n

1// mods-jit — throwaway. Design (c): register a callsign just in time inside agent.spawn,
2// keep it out of the model's agent listing via agent.offer, dispatch to it.
3// mode.txt (plugin root) selects:  show  = no offer filter (baseline listing cost)
4//                                  hide  = isOffered:false for every JIT name, always
5//                                  gate  = isOffered:false unless a spawn for that name is in flight
6//                                  call  = isOffered:false unless an Agent tool.call is in progress
7//                                          (tool.call runs before the dispatch-time offer batch,
8//                                          never during the per-turn listing)
9//                                  tight = isOffered:true only for the ONE type an in-progress Agent
10//                                          call reserved (picked in tool.call, keyed by tool_use_id)
11//   pre-<m>[-N] = same offer rule, but the names are registered up front at session.start (JIT inside
12//             spawn is refused: the call's dispatchable set is fixed before the hook runs).
13// Witness: every fire appends a JSONL line to markers.jsonl via $.fs.
14import type { Register, EngineInterface } from 'claude-code';
15type Json = Record<string, unknown>;
16const POOL = ['Hopper', 'Lovelace', 'Noether', 'Shackleton', 'Tereshkova', 'Amundsen', 'Kovalevskaya', 'Ibn_Battuta'];
17const jit = new Set<string>();      // full registered type names
18const inflight = new Set<string>(); // types a spawn is dispatching right now
19let calls = 0; // Agent tool.calls in progress
20const reserved = new Map<string, string>(); // tool_use_id -> type (tight mode)
21let cursor = 0;
22let n = 0; let mode: string | undefined;
23let chain: Promise<void> = Promise.resolve();
24function mark($: EngineInterface, hook: string, data: Json): Promise<void> {
25  const path = `${$.plugin.root}/markers.jsonl`;
26  const line = JSON.stringify({ ts: new Date().toISOString(), hook, ...data }) + '\n';
27  chain = chain.then(async () => {
28    const prev = (await $.fs.exists(path)) ? await $.fs.read(path) : '';
29    await $.fs.write(path, prev + line);
30  }).catch(() => undefined); // audit-allow: fail-loud — probe telemetry
31  return chain;
32}
33async function getMode($: EngineInterface): Promise<string> {
34  if (mode === undefined) {
35    const p = `${$.plugin.root}/mode.txt`;
36    mode = (await $.fs.exists(p)) ? String(await $.fs.read(p)).trim() : 'show';
37  }
38  return mode;
39}
40async function reg($: EngineInterface, name: string): Promise<string | undefined> {
41  // @ts-expect-error — $.agent.register is in the 2.1.283 binary, not the 2.1.273 typings
42  const r: unknown = await $.agent.register({
43    name, description: `callsign ${name}`,
44    prompt: `You are ${name}. Begin your final reply with the exact line [${name}]. You are a capable general agent; complete the task.`,
45  });
46  return (r as { agent?: string } | undefined)?.agent;
47}
48const pre: string[] = [];
49export const register: Register = (on) => {
50  on('session.start', async ($, e, next) => {
51    const r = await next(e);
52    const m = await getMode($);
53    const poolAll: string[] = JSON.parse(String(await $.fs.read(`${$.plugin.root}/pool.json`)));
54    if (m.startsWith('pre-')) {
55      const t0 = Date.now();
56      const count = Number(m.split('-')[2] ?? POOL.length);
57      for (let i = 0; i < count; i++) {
58        const name = count <= POOL.length ? POOL[i]! : poolAll[i]!;
59        try { const t = await reg($, name); if (t) { pre.push(t); jit.add(t); } }
60        catch (err) { await mark($, 'agent.register', { name, error: String(err) }); }
61      }
62      await mark($, 'session.start', { mode: m, registered: pre.length, first: pre.slice(0, 3), ms: Date.now() - t0 });
63    }
64    return r;
65  });
66  on('agent.offer', async ($, e, next) => {
67    const r = await next(e);
68    const m = await getMode($);
69    let isOffered = r.isOffered;
70    const base = m.replace(/^pre-/, '').split('-')[0];
71    if (jit.has(e.agent) && base === 'hide') isOffered = false;
72    if (jit.has(e.agent) && base === 'gate') isOffered = inflight.has(e.agent);
73    if (jit.has(e.agent) && base === 'call') isOffered = calls > 0;
74    if (jit.has(e.agent) && base === 'tight') isOffered = [...reserved.values()].includes(e.agent);
75    if (pre.slice(0, 2).includes(e.agent) || e.agent === 'general-purpose') await mark($, 'agent.offer', { mode: m, agent: e.agent, isOffered });
76    return { isOffered };
77  });
78  on('tool.call', { tool: 'Agent' }, async ($, e, next) => {
79    const id = (e as unknown as Json).tool_use_id as string;
80    const input = e as unknown as Json;
81    const st = (input.subagent_type ?? 'general-purpose') as string;
82    if (pre.length > 0 && st === 'general-purpose') reserved.set(id, pre[cursor++ % pre.length]!);
83    calls++;
84    try { return await next(e); } finally { calls--; reserved.delete(id); }
85  });
86  on('agent.spawn', async ($, e, next) => {
87    const m = await getMode($);
88    const k = n++;
89    if (e.subagentType !== 'general-purpose') return next(e);
90    if (m.startsWith('pre-')) {
91      const type = reserved.get(e.tool_use_id) ?? pre[k % Math.max(pre.length, 1)];
92      if (type === undefined) return next(e);
93      const name = type.split(':')[1]!;
94      inflight.add(type);
95      try {
96        const r = await next({ ...e, subagentType: type, description: `${name} · ${e.description}` });
97        await mark($, 'agent.spawn.result', { mode: m, k, type, result: r as Json });
98        return r;
99      } catch (err) {
100        await mark($, 'agent.spawn.error', { mode: m, k, type, error: String(err) });
101        throw err;
102      } finally { inflight.delete(type); }
103    }
104    const name = POOL[k % POOL.length]!;
105    let type: string | undefined;
106    try {
107      // @ts-expect-error — $.agent.register is in the 2.1.283 binary, not the 2.1.273 typings
108      const r: unknown = await $.agent.register({
109        name, description: `callsign ${name}`,
110        prompt: `You are ${name}. Begin your final reply with the exact line [${name}]. You are a capable general agent; complete the task.`,
111      });
112      type = (r as { agent?: string } | undefined)?.agent;
113      await mark($, 'agent.register', { mode: m, k, name, returned: r as Json });
114    } catch (err) {
115      await mark($, 'agent.register', { mode: m, k, name, error: String(err) });
116      return next(e);
117    }
118    if (type === undefined) return next(e);
119    jit.add(type); inflight.add(type);
120    try {
121      const r = await next({ ...e, subagentType: type, description: `${name} · ${e.description}` });
122      await mark($, 'agent.spawn.result', { mode: m, k, type, result: r as Json });
123      return r;
124    } catch (err) {
125      await mark($, 'agent.spawn.error', { mode: m, k, type, error: String(err) });
126      throw err;
127    } finally { inflight.delete(type); }
128  });
129  on('turn.complete', async ($, e, next) => {
130    if (e.agentId !== undefined) await mark($, 'turn.complete', { agentId: e.agentId, answer: typeof e.answer === 'string' ? e.answer.slice(0, 80) : e.answer });
131    return next(e);
132  });
133};
134