@platless/axom-cli 0.1.0 → 0.5.9

package/dist/axom-patch/cli/probes/claude-late-async-terminal.mjs

@@ -0,0 +1,38 @@
+// Runs the actual installed adapter runtime classes, without launching Claude or accessing auth.
+// node <probe> <package-directory> [--expect-bug]
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const directory = process.argv[2];
+if (!directory) throw new Error('Supply the adapter package directory');
+const { NativeSubagentRuntime } = await import(pathToFileURL(path.resolve(directory, 'dist/native-subagents.js')));
+const { AsyncTaskRuntime } = await import(pathToFileURL(path.resolve(directory, 'dist/async-tasks.js')));
+const expectBug = process.argv.includes('--expect-bug');
+for (const state of ['completed', 'failed', 'stopped']) {
+  for (const closing of ['terminalState', 'terminalPromise']) {
+    const events = [];
+    const publish = async (notification) => { events.push(notification); };
+    // "air", not `true`: 0.90.0 renamed the first argument from `enabled` to `form` ("air" | "rfd"),
+    // and in the rfd form a finished child keeps receiving its own late updates by design. Axom
+    // declares the AIR extension meta, so "air" is the form it gets; on pre-0.90 versions the
+    // string is still truthy, so `enabled` behaves as before.
+    const native = new NativeSubagentRuntime('air', 'root', {}, publish, { log() {} });
+    const child = { sessionId: 'child', parentSessionId: 'root' };
+    native.childByToolCall.set('call', child);
+    const tasks = new AsyncTaskRuntime(true, 'root', publish, { routeOf: (call) => native.routeOfToolCall(call) });
+    await tasks.taskBackgrounded({ task_id: 'task', tool_use_id: 'call', task_type: 'shell', description: 'background shell' });
+    assert.ok(events.some((event) => event.update.sessionUpdate === 'async_task_spawned'));
+    child[closing] = closing === 'terminalState' ? 'completed' : Promise.resolve();
+    await tasks.taskNotification('task', state, 'done');
+    const terminal = events.filter((event) => event.update.sessionUpdate === 'async_task_state_update');
+    assert.equal(terminal.length, expectBug ? 0 : 1, `${closing}/${state}`);
+    if (!expectBug) {
+      assert.equal(terminal[0].sessionId, 'child');
+      assert.equal(terminal[0].update.state, state);
+    }
+    const lateText = { sessionId: 'root', update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'late' } } };
+    assert.equal(native.routeOfToolCall('call')(lateText), null, 'ordinary late transcript must remain filtered');
+  }
+}
+console.log(expectBug ? 'Reproduced all 6 upstream late-terminal losses' : 'Passed all 6 late-terminal cases; ordinary late transcript stays filtered');

package/dist/axom-patch/cli/probes/pi-steering.mjs

@@ -0,0 +1,80 @@
+// Execute the real published adapter classes, without models or credentials.
+// node <probe> <pi-acp-package-directory> [--expect-unsupported]
+import assert from 'node:assert/strict';
+import { readFile, writeFile, mkdtemp, rm, chmod } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+const directory = path.resolve(process.argv[2]);
+const require = createRequire(path.join(directory, 'package.json'));
+const scratch = await mkdtemp(path.join(tmpdir(), 'axom-pi-runtime-'));
+const previousCommand = process.env.PI_ACP_PI_COMMAND;
+try {
+  const original = await readFile(path.join(directory, 'dist/index.js'), 'utf8');
+  let source = original.slice(0, original.lastIndexOf('// src/index.ts')).replace(/^#![^\n]*\n/, '');
+  source = source.replace(/from "([^"\n]+)"/g, (whole, specifier) => specifier.startsWith('@') || specifier === 'cross-spawn'
+    ? `from ${JSON.stringify(pathToFileURL(require.resolve(specifier)).href)}` : whole);
+  source += '\nexport { PiAcpAgent, PiAcpSession };\n';
+  await writeFile(path.join(scratch, 'package.json'), await readFile(path.join(directory, 'package.json')));
+  await writeFile(path.join(scratch, 'runtime.mjs'), source);
+  const { PiAcpAgent, PiAcpSession } = await import(pathToFileURL(path.join(scratch, 'runtime.mjs')));
+  const command = path.join(scratch, 'native-version');
+  await writeFile(command, '#!/bin/sh\nprintf "0.87.1\\n"\n');
+  await chmod(command, 0o700);
+  process.env.PI_ACP_PI_COMMAND = command;
+  const agent = Object.create(PiAcpAgent.prototype);
+  const initialized = await agent.initialize({ protocolVersion: 1, clientCapabilities: {} });
+  if (process.argv.includes('--expect-unsupported')) {
+    assert.equal(initialized._meta?.steering?.supported, undefined);
+    console.log('PASS pristine pi-acp has no steering extension');
+  } else {
+    assert.deepEqual(initialized._meta.steering, { supported: true, timings: ['next'] });
+    await writeFile(command, '#!/bin/sh\nprintf "0.70.6\\n"\n');
+    assert.equal((await agent.initialize({ protocolVersion: 1, clientCapabilities: {} }))._meta?.steering, undefined);
+    await writeFile(command, '#!/bin/sh\nprintf "0.87.1\\n"\n');
+    await agent.initialize({ protocolVersion: 1, clientCapabilities: {} });
+    console.log('PASS native version gating and next capability');
+    let streaming = false, nativeEvent, releaseReceipt;
+    const requests = [], updates = [];
+    const proc = {
+      onEvent(handler) { nativeEvent = handler; },
+      async getState() { return { isStreaming: streaming }; },
+      async prompt(message, images) { requests.push({ type: 'original', message, images }); streaming = true; },
+      async request(cmd) { requests.push(cmd); return new Promise(resolve => { releaseReceipt = resolve; }); },
+    };
+    const session = new PiAcpSession({ sessionId: 'fixture', cwd: scratch, mcpServers: [], proc,
+      conn: { async sessionUpdate(event) { updates.push(event); } } });
+    agent.sessions = { maybeGet(id) { return id === 'fixture' ? session : undefined; } };
+    const params = { sessionId: 'fixture', prompt: [{ type: 'text', text: 'inspect this' },
+      { type: 'image', mimeType: 'image/png', data: 'fixture-image' }], _meta: { steering: { idleBehavior: 'promptRequired', priority: 'next' } } };
+    assert.deepEqual(await agent.extMethod('_session/steering', params), { outcome: 'promptRequired' });
+    for (const priority of ['now', 'later']) {
+      await assert.rejects(agent.extMethod('_session/steering', { ...params, _meta: { steering: { priority } } }));
+    }
+    assert.equal(requests.length, 0);
+    let finished = false;
+    const originalTurn = session.prompt('original').then(reason => { finished = true; return reason; });
+    const injected = agent.extMethod('_session/steering', params);
+    while (!releaseReceipt) await new Promise(resolve => setTimeout(resolve, 1));
+    assert.deepEqual(requests[1], { type: 'prompt', message: 'inspect this',
+      images: [{ type: 'image', mimeType: 'image/png', data: 'fixture-image' }], streamingBehavior: 'steer' });
+    nativeEvent({ type: 'agent_settled' });
+    await new Promise(resolve => setTimeout(resolve, 5));
+    assert.equal(finished, false);
+    releaseReceipt({ success: true });
+    assert.deepEqual(await injected, { outcome: 'injected' });
+    await new Promise(resolve => setTimeout(resolve, 5));
+    assert.equal(finished, false, 'native continuation remains owned by original ACP prompt');
+    streaming = false;
+    nativeEvent({ type: 'agent_settled' });
+    assert.equal(await originalTurn, 'end_turn');
+    assert.equal(requests.length, 2, 'exactly one native submission for the inserted message');
+    assert.equal(updates.filter(event => event.update?._meta?.piAcp?.running === false).length, 1);
+    console.log('PASS real adapter content conversion, idle refusal, priority validation and tracked continuation');
+  }
+} finally {
+  if (previousCommand === undefined) delete process.env.PI_ACP_PI_COMMAND;
+  else process.env.PI_ACP_PI_COMMAND = previousCommand;
+  await rm(scratch, { recursive: true, force: true });
+}

package/dist/axom-patch/cli/probes/pi-subagent-subwork.mjs

@@ -0,0 +1,211 @@
+// Execute the real published adapter classes, without models or credentials.
+// node <probe> <pi-acp-package-directory> [--expect-no-subagents]
+//
+// Pristine pi-acp emits no subagent variants and drops custom messages; the patched
+// adapter normalizes pi-subagents children into draft ACP subagent variants with
+// ids derived only from the root session id and toolCallId/runId, so the same input
+// always produces byte-identical frames.
+import assert from 'node:assert/strict';
+import { readFile, writeFile, mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+
+const directory = path.resolve(process.argv[2]);
+const expectNone = process.argv.includes('--expect-no-subagents');
+const require = createRequire(path.join(directory, 'package.json'));
+const scratch = await mkdtemp(path.join(tmpdir(), 'axom-pi-subagents-'));
+try {
+  const original = await readFile(path.join(directory, 'dist/index.js'), 'utf8');
+  let source = original.slice(0, original.lastIndexOf('// src/index.ts')).replace(/^#![^\n]*\n/, '');
+  source = source.replace(/from "([^"\n]+)"/g, (whole, specifier) => specifier.startsWith('@') || specifier === 'cross-spawn'
+    ? `from ${JSON.stringify(pathToFileURL(require.resolve(specifier)).href)}` : whole);
+  source += '\nexport { PiAcpAgent, PiAcpSession };\n';
+  await writeFile(path.join(scratch, 'package.json'), await readFile(path.join(directory, 'package.json')));
+  await writeFile(path.join(scratch, 'runtime.mjs'), source);
+  const { PiAcpSession } = await import(pathToFileURL(path.join(scratch, 'runtime.mjs')));
+
+  const COLLECT = () => {
+    const updates = [];
+    return { updates, conn: { async sessionUpdate(event) { updates.push(event); } } };
+  };
+  const newSession = () => {
+    const collect = COLLECT();
+    let events;
+    const proc = { onEvent(handler) { events = handler; } };
+    const session = new PiAcpSession({ sessionId: 'fixture', cwd: scratch, mcpServers: [], proc, conn: collect.conn });
+    return { session, collect, fire: ev => { events(ev); return session.flushEmits(); } };
+  };
+
+  // One full drive; every awaited fire drains the ordered emit chain first.
+  // verify=false collects the frames without the per-step assertions, for the pristine run.
+  const drive = async (verify = true) => {
+    const { session, collect, fire } = newSession();
+    const updates = collect.updates;
+    const names = () => updates.map(u => `${u.sessionId}:${u.update.sessionUpdate}`);
+
+    // Foreground launch: spawned precedes the adapter's own tool_call frame.
+    await fire({ type: 'tool_execution_start', toolCallId: 't1', toolName: 'subagent',
+      args: { agent: 'scout', task: 'map the repo' } });
+    if (verify) {
+      assert.deepEqual(updates[0].update, { sessionUpdate: 'subagent_spawned', subagentSessionId: 'pi-agent:fixture:t1',
+        name: 'scout', task: 'map the repo', capabilities: {}, _meta: { pi: { toolCallId: 't1' } } });
+      assert.equal(updates[0].sessionId, 'fixture');
+      assert.equal(updates[1].update.sessionUpdate, 'tool_call');
+    }
+
+    // Foreground completion: child preview then terminal state, then the adapter's frame.
+    await fire({ type: 'tool_execution_end', toolCallId: 't1', isError: false,
+      result: { content: [{ type: 'text', text: 'all clear' }], details: { mode: 'single', runId: 'fg1' } } });
+    if (verify) {
+      const afterEnd = names();
+      assert.deepEqual(afterEnd.slice(2, 4), ['pi-agent:fixture:t1:agent_message_chunk', 'fixture:subagent_state_update']);
+      assert.equal(updates[3].update.state, 'completed');
+    }
+
+    // Management and steering calls are not launches.
+    await fire({ type: 'tool_execution_start', toolCallId: 't2', toolName: 'subagent', args: { action: 'list' } });
+    await fire({ type: 'tool_execution_end', toolCallId: 't2', isError: false,
+      result: { content: [{ type: 'text', text: 'agents: ...' }], details: {} } });
+    await fire({ type: 'tool_execution_start', toolCallId: 't3', toolName: 'subagent',
+      args: { id: 'x', message: 'steer' } });
+    await fire({ type: 'tool_execution_end', toolCallId: 't3', isError: false,
+      result: { content: [{ type: 'text', text: 'queued' }], details: {} } });
+    if (verify) assert.ok(!updates.some(u => u.update.sessionUpdate === 'subagent_spawned' && u.update.name !== 'scout'));
+
+    // Async launch: the receipt is not a terminal state.
+    await fire({ type: 'tool_execution_start', toolCallId: 't4', toolName: 'subagent',
+      args: { agent: 'researcher', task: 'study', async: true } });
+    if (verify) assert.equal(updates.find(u => u.update.sessionUpdate === 'subagent_spawned' && u.update._meta?.pi?.toolCallId === 't4')?.update.subagentSessionId, 'pi-agent:fixture:t4');
+    await fire({ type: 'tool_execution_end', toolCallId: 't4', isError: false,
+      result: { content: [{ type: 'text', text: 'Async single: researcher [r9]' }],
+        details: { mode: 'single', runId: 'r9', asyncId: 'r9', asyncDir: '/tmp/async' } } });
+    if (verify) assert.ok(!updates.some(u => u.update.sessionUpdate === 'subagent_state_update' && u.update.subagentSessionId === 'pi-agent:fixture:t4'));
+
+    // The completion notice closes the async child by run id.
+    await fire({ type: 'message_end', message: { role: 'custom', customType: 'subagent-notify',
+      content: 'researcher finished', details: { runs: [{ runId: 'r9', agent: 'researcher', status: 'completed',
+        summary: 'study done', resultPath: '/tmp/async/r9/result.json' }] } } });
+    await fire({ type: 'message_start', message: { role: 'custom', customType: 'subagent-notify',
+      content: 'duplicate pair member', details: { runs: [{ runId: 'r9', agent: 'researcher', status: 'completed' }] } } });
+    if (verify) {
+      const closed = updates.find(u => u.update.sessionUpdate === 'subagent_state_update' && u.update.subagentSessionId === 'pi-agent:fixture:t4');
+      assert.equal(closed.update.state, 'completed');
+      assert.equal(closed.update._meta.pi.runId, 'r9');
+      assert.equal(closed.update._meta.pi.resultPath, '/tmp/async/r9/result.json');
+    }
+
+    // A repeated notice is idempotent.
+    const countBefore = updates.length;
+    if (verify) {
+      const beforePair = updates.length;
+      await fire({ type: 'message_start', message: { role: 'custom', customType: 'subagent-notify',
+        content: 'pair member', details: { runs: [{ runId: 'r9', agent: 'researcher', status: 'completed' }] } } });
+      assert.equal(updates.length, beforePair);
+    }
+    await fire({ type: 'message_end', message: { role: 'custom', customType: 'subagent-notify',
+      content: 'researcher finished', details: { runs: [{ runId: 'r9', agent: 'researcher', status: 'completed' }] } } });
+    if (verify) assert.equal(updates.length, countBefore + 0);
+
+    // Unknown runs (adapter restart) get an adopted spawn plus their state.
+    await fire({ type: 'message_end', message: { role: 'custom', customType: 'subagent-notify',
+      content: 'worker stopped', details: { runs: [{ runId: 'zz', agent: 'worker', status: 'stopped', summary: '' }] } } });
+    if (verify) {
+      const adopted = updates.find(u => u.update.sessionUpdate === 'subagent_spawned' && u.update._meta?.pi?.adopted);
+      assert.equal(adopted.update.subagentSessionId, 'pi-agent:fixture:run:zz');
+      assert.equal(adopted.update.name, 'worker');
+      assert.equal(updates.find(u => u.update.sessionUpdate === 'subagent_state_update' && u.update.subagentSessionId === 'pi-agent:fixture:run:zz').update.state, 'cancelled');
+    }
+
+    // Paused is not terminal; other custom messages are ignored.
+    await fire({ type: 'message_end', message: { role: 'custom', customType: 'subagent-notify',
+      content: 'paused', details: { runs: [{ runId: 'pp', agent: 'worker', status: 'paused' }] } } });
+    if (verify) {
+      assert.ok(updates.some(u => u.update.sessionUpdate === 'subagent_spawned' && u.update.subagentSessionId === 'pi-agent:fixture:run:pp'));
+      assert.ok(!updates.some(u => u.update.sessionUpdate === 'subagent_state_update' && u.update.subagentSessionId === 'pi-agent:fixture:run:pp'));
+    }
+    const beforeOther = updates.length;
+    await fire({ type: 'message_end', message: { role: 'custom', customType: 'something-else',
+      content: 'x', details: {} } });
+    await fire({ type: 'message_end', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } });
+    assert.equal(updates.length, beforeOther);
+
+    // Progress dedup: identical-heartbeat tool_execution_update frames are dropped, real
+    // changes pass, other tools are never deduplicated.
+    await fire({ type: 'tool_execution_start', toolCallId: 't5', toolName: 'subagent',
+      args: { agent: 'worker', task: 'long job', async: false } });
+    await fire({ type: 'tool_execution_update', toolCallId: 't5', toolName: 'subagent',
+      partialResult: { content: [{ type: 'text', text: '(running...)' }],
+        details: { progress: [{ agent: 'worker', durationMs: 1000, lastActivityAt: 1791891393036, status: 'running tool bash' }] } } });
+    const afterFirstUpdate = updates.filter(u => u.update.sessionUpdate === 'tool_call_update').length;
+    await fire({ type: 'tool_execution_update', toolCallId: 't5', toolName: 'subagent',
+      partialResult: { content: [{ type: 'text', text: '(running...)' }],
+        details: { progress: [{ agent: 'worker', durationMs: 2000, lastActivityAt: 1791891394047,
+          recentOutput: ['(no output)', '(no output)'], status: 'running tool bash' }] } } });
+    await fire({ type: 'tool_execution_update', toolCallId: 't5', toolName: 'subagent',
+      partialResult: { content: [{ type: 'text', text: '(running...)' }],
+        details: { progress: [{ agent: 'worker', durationMs: 3000, lastActivityAt: 1791891395047,
+          recentOutput: ['(no output)', '(no output)', '(no output)'], status: 'running tool bash' }] } } });
+    await fire({ type: 'tool_execution_update', toolCallId: 't5', toolName: 'subagent',
+      partialResult: { content: [{ type: 'text', text: '(running...)' }],
+        details: { progress: [{ agent: 'worker', durationMs: 3100, lastActivityAt: 1791891396047,
+          recentOutput: ['(no output)', '(no output)', '(no output)'], status: 'running tool bash',
+          inputTokens: 2730, outputTokens: 69, cacheRead: 160, tokens: 2799, window: 2890, windowPeak: 2890 }],
+          results: [{ usage: { input: 2730, output: 69, cost: 0.0009, turns: 1 } }] } } });
+    await fire({ type: 'tool_execution_update', toolCallId: 't5', toolName: 'subagent',
+      partialResult: { content: [{ type: 'text', text: '(running...)' }],
+        details: { progress: [{ agent: 'worker', durationMs: 3200, lastActivityAt: 1791891397047,
+          recentOutput: ['(no output)', '(no output)', '(no output)'], status: 'running tool bash',
+          inputTokens: 5483, outputTokens: 1852, cacheRead: 3049, tokens: 7335, window: 5642, windowPeak: 5642 }],
+          results: [{ usage: { input: 5483, output: 1852, cost: 0.0040, turns: 1 } }] } } });
+    if (verify) {
+      assert.equal(updates.filter(u => u.update.sessionUpdate === 'tool_call_update').length, afterFirstUpdate,
+        'heartbeat frames differing only in timers/recentOutput/token telemetry are dropped');
+    }
+    await fire({ type: 'tool_execution_update', toolCallId: 't5', toolName: 'subagent',
+      partialResult: { content: [{ type: 'text', text: '(running...)' }],
+        details: { progress: [{ agent: 'worker', durationMs: 3500, lastActivityAt: 1791891396047,
+          recentOutput: ['(no output)', '(no output)', '(no output)'], status: 'running tool bash',
+          recentTools: [{ tool: 'bash', args: 'ls', endMs: 1 }] }] } } });
+    if (verify) {
+      assert.equal(updates.filter(u => u.update.sessionUpdate === 'tool_call_update').length, afterFirstUpdate + 1,
+        'a real milestone (recentTools growth / status change) still passes');
+    }
+    const updatesBeforeOther = updates.length;
+    await fire({ type: 'tool_execution_update', toolCallId: 'tx', toolName: 'read',
+      partialResult: { content: [{ type: 'text', text: 'x' }] } });
+    await fire({ type: 'tool_execution_update', toolCallId: 'tx', toolName: 'read',
+      partialResult: { content: [{ type: 'text', text: 'x' }] } });
+    if (verify) assert.equal(updates.length, updatesBeforeOther + 2, 'other tools are never deduplicated');
+    await fire({ type: 'tool_execution_end', toolCallId: 't5', isError: false,
+      result: { content: [{ type: 'text', text: 'long job done' }], details: { mode: 'single', runId: 'fg5' } } });
+    if (verify) {
+      assert.equal(updates.find(u => u.update.sessionUpdate === 'subagent_state_update' && u.update.subagentSessionId === 'pi-agent:fixture:t5')?.update.state, 'completed',
+        'a deduplicated run still closes normally');
+    }
+
+    return updates;
+  };
+
+  if (expectNone) {
+    const first = await drive(false);
+    const spawns = first.filter(u => u.update.sessionUpdate === 'subagent_spawned').length;
+    const states = first.filter(u => u.update.sessionUpdate === 'subagent_state_update').length;
+    assert.equal(spawns, 0);
+    assert.equal(states, 0);
+    assert.ok(first.some(u => u.update.sessionUpdate === 'tool_call'), 'adapter still maps tool calls');
+    console.log('PASS pristine pi-acp emits no subagent variants and ignores custom messages');
+  } else {
+    const first = await drive();
+    const spawns = first.filter(u => u.update.sessionUpdate === 'subagent_spawned').length;
+    const states = first.filter(u => u.update.sessionUpdate === 'subagent_state_update').length;
+    assert.equal(spawns, 5);           // t1, t4, adopted zz, paused pp, t5
+    assert.equal(states, 4);           // t1, r9(t4), zz, t5
+    const second = await drive();
+    assert.deepEqual(second, first);   // deterministic: no ids beyond the inputs
+    console.log('PASS subagent variants, ordering, idempotence and determinism');
+  }
+} finally {
+  await rm(scratch, { recursive: true, force: true });
+}

package/dist/axom-patch/cli/probes/qoder-steering.mjs

@@ -0,0 +1,89 @@
+// Exercise the real native ACP methods, without model calls or credentials.
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+export async function verifyQoderSteering(bundle) {
+  const slice = (start, end) => {
+    const from = bundle.indexOf(start), to = bundle.indexOf(end, from);
+    assert(from >= 0 && to > from, `Native Qoder lacks ${start}`);
+    return bundle.slice(from, to);
+  };
+  class RequestError extends Error {
+    static invalidParams(_data, message) { return new this(message); }
+  }
+  const methods = slice('axomQoderSteer(A){', 'async axomQoderPromptOnce(A,e,t,i,n){');
+  const Session = new Function('as', 'mte', `return class {
+    axomQoderSteeringMessages=[];active=true;disposed=false;promptRunning=true;
+    pendingPrompt=new AbortController;queryEngine={activeAbortController:{},abort:()=>{this.aborts++}};aborts=0;
+    ${methods}
+  }`)(RequestError, () => 'generated-id');
+  const request = text => ({ prompt: [{ type: 'text', text }],
+    _meta: { steering: { idleBehavior: 'promptRequired', priority: 'now' } } });
+  const session = new Session();
+  let finishFirst, finishSecond;
+  const inputs = [];
+  session.axomQoderPromptOnce = async (prompt, signal) => {
+    inputs.push(prompt);
+    assert.equal(signal, session.pendingPrompt.signal);
+    return new Promise(resolve => {
+      if (inputs.length === 1) finishFirst = resolve; else finishSecond = resolve;
+    });
+  };
+  let completed = false;
+  const pending = session.promptViaQueryEngine([{ type: 'text', text: 'original' }],
+    session.pendingPrompt.signal, 'prompt-id', 'user-id').then(value => { completed = true; return value; });
+  assert.deepEqual(session.axomQoderSteer(request('changed')), { outcome: 'injected' });
+  assert.equal(session.aborts, 1);
+  assert.equal(session.pendingPrompt.signal.aborted, false, 'steering must not cancel the host prompt');
+  finishFirst({ stopReason: 'cancelled' });
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(completed, false, 'the interrupted native result must not finish the host turn');
+  assert.deepEqual(inputs[1], [{ type: 'text', text: 'changed' }]);
+  finishSecond({ stopReason: 'end_turn' });
+  assert.equal((await pending).stopReason, 'end_turn');
+  assert.equal(session.axomQoderSteeringMessages.length, 0);
+
+  // Native promptRunning remains true for a microtask after its query iterator finishes.
+  // Accepting a message there would report delivery after the wrapper already stopped draining.
+  const finished = new Session(); finished.queryEngine.activeAbortController = undefined;
+  assert.deepEqual(finished.axomQoderSteer(request('arrived at completion')),
+    { outcome: 'promptRequired', reason: 'noRunningTurn' });
+  assert.equal(finished.axomQoderSteeringMessages.length, 0);
+
+  for (const key of ['active', 'promptRunning']) {
+    const idle = new Session(); idle[key] = false;
+    assert.deepEqual(idle.axomQoderSteer(request('idle')), { outcome: 'promptRequired', reason: 'noRunningTurn' });
+    assert.equal(idle.aborts, 0);
+  }
+  const invalid = new Session();
+  for (const value of [request(' '), request('x'.repeat(131073)),
+    { ...request('x'), prompt: [{ type: 'image', data: 'x', mimeType: 'image/png' }] },
+    { ...request('x'), _meta: { steering: { priority: 'next' } } }]) {
+    assert.throws(() => invalid.axomQoderSteer(value));
+  }
+  assert.equal(invalid.aborts, 0);
+  assert.equal(invalid.axomQoderSteeringMessages.length, 0);
+
+  const stopped = new Session();
+  stopped.axomQoderPromptOnce = async () => { stopped.pendingPrompt.abort(); return { stopReason: 'cancelled' }; };
+  stopped.axomQoderSteer(request('must not run after Stop'));
+  assert.equal((await stopped.promptViaQueryEngine([], stopped.pendingPrompt.signal, 'p', 'u')).stopReason, 'cancelled');
+  assert.equal(stopped.axomQoderSteeringMessages.length, 0);
+
+  const broken = new Session();
+  broken.axomQoderPromptOnce = async () => { throw new Error('real failure'); };
+  broken.axomQoderSteer(request('cannot hide a failure'));
+  await assert.rejects(broken.promptViaQueryEngine([], broken.pendingPrompt.signal, 'p', 'u'), /real failure/);
+  assert.equal(broken.axomQoderSteeringMessages.length, 0);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const directory = process.argv[2];
+  if (!directory) throw new Error('Usage: node qoder-steering.mjs <patched-qoder-package>');
+  const metadata = JSON.parse(await readFile(join(directory, 'package.json'), 'utf8'));
+  assert.equal(metadata.name, '@qoder-ai/qodercli'); assert.equal(metadata.version, '1.1.71');
+  await verifyQoderSteering(await readFile(join(directory, 'bundle/qodercli.js'), 'utf8'));
+  console.log('Native Qoder steering: host-turn lifetime, interruption, idle, validation, Stop and failure checks passed');
+}

package/dist/axom-patch/cli/probes/qoder-subagent-origin.mjs

@@ -0,0 +1,61 @@
+// Run against the hash-verified patched official bundle. Exercises its actual ACP dispatch methods
+// without starting a model or reading credentials. Real model acceptance is separate.
+import { readFile } from 'node:fs/promises';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+const directory = process.argv[2];
+if (!directory) throw new Error('Usage: node qoder-subagent-origin.mjs <patched-package-directory>');
+const metadata = JSON.parse(await readFile(join(directory, 'package.json'), 'utf8'));
+assert.equal(metadata.name, '@qoder-ai/qodercli'); assert.equal(metadata.version, '1.1.71');
+const bundle = await readFile(join(directory, 'bundle/qodercli.js'), 'utf8');
+const method = (start, end) => {
+  const from = bundle.indexOf(start), to = bundle.indexOf(end, from);
+  assert(from >= 0 && to > from, `Missing real ACP method ${start}`);
+  return bundle.slice(from, to);
+};
+const helper = method('axomQoderId(value)', 'supportsTerminalOutput(){');
+const dispatch = method('async dispatchSDKMessage(A)', 'createAcpSlashCommandHandler(){');
+// 1.1.71 moved tool-call emission behind a `toolCallPublisher` whose constructor callback is
+// `A => this.sendUpdate(A)` — still the patched sendUpdate, so the meta injection survives; the
+// stub reproduces that wiring. `dkA`/`Fc`/`CtA`/`Y9` are the slice's free variables.
+const Session = new Function('dkA', 'Fc', 'CtA', 'Y9', `return class {
+  axomQoderToolOrigins=new Map;toolCallNames=new Map;permissionToolCallIds=new Set;
+  toolCallPublisher;
+  constructor(connection){this.connection=connection;this.id='root';this.context={toolRegistry:{getTool:()=>({kind:'read'})},config:{isTasksEnabled:()=>false}};
+    this.toolCallPublisher={
+      declare: async u => this.sendUpdate(u),
+      result: async u => this.sendUpdate({ sessionUpdate: 'tool_call_update', toolCallId: u.toolCallId, content: u.content, isError: u.isError }),
+    }}
+  supportsTerminalOutput(){return false} async sendPlanUpdate(){}
+  ${helper} ${dispatch}
+}`)(v => ({ sessionUpdate: 'tool_call', toolCallId: v.toolCallId, kind: v.kind, rawInput: v.input, status: v.status }),
+  'Plan', new Set(), () => false);
+const events = [];
+const session = new Session({ sessionUpdate: async value => events.push(value) });
+const tool = (id, parent) => ({ type: 'assistant', parent_tool_use_id: parent,
+  message: { content: [{ type: 'tool_use', id, name: 'Read', input: { path: '/probe' } }] } });
+await session.dispatchSDKMessage(tool('read-a', 'agent-a'));
+await session.dispatchSDKMessage(tool('read-b', 'agent-b'));
+await session.dispatchSDKMessage({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'read-b', content: 'B' }] } });
+await session.dispatchSDKMessage({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'read-a', content: 'A' }] } });
+for (const [id, parent] of [['read-a', 'agent-a'], ['read-b', 'agent-b']]) {
+  const owned = events.filter(v => v.update.toolCallId === id);
+  assert.equal(owned.length, 2);
+  for (const event of owned) assert.equal(event.update._meta.qoder.parentToolUseId, parent);
+}
+await session.dispatchSDKMessage({ type: 'stream_event', parent_tool_use_id: 'agent-b',
+  event: { type: 'content_block_delta', delta: { type: 'text_delta', text: 'child B' } } });
+assert.equal(events.at(-1).update._meta.qoder.parentToolUseId, 'agent-b');
+await session.dispatchSDKMessage({ type: 'stream_event', parent_tool_use_id: null,
+  event: { type: 'content_block_delta', delta: { type: 'text_delta', text: 'root' } } });
+assert.equal(events.at(-1).update._meta, undefined);
+await session.dispatchSDKMessage(tool('root-read', null));
+assert.equal(events.at(-1).update._meta.qoder.parentToolUseId, undefined);
+// 1.1.61 skipped a re-declared tool id entirely; 1.1.71 re-declares it, so the conflict shows up
+// as a freshly emitted tool_call whose origin was invalidated — the intent (a conflicting parent
+// must not tag the tool as a child) is asserted on whatever the conflict emitted.
+await session.dispatchSDKMessage(tool('read-a', 'wrong-agent'));
+const conflict = events.at(-1).update;
+assert.equal(conflict.toolCallId, 'read-a');
+assert.ok(!conflict._meta?.qoder?.parentToolUseId, 'conflicting re-declare must not carry a parent');
+console.log('Official Qoder 1.1.71 ACP dispatch: parallel tool/result, child text, root and conflict checks passed');