@platless/axom-cli 0.5.9 → 0.6.36

package/dist/axom-patch/cli/kimi-subagents.mjs

@@ -0,0 +1,173 @@
+import {readdir, readFile} from 'node:fs/promises';
+import {homedir} from 'node:os';
+import {join} from 'node:path';
+
+const record = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const text = value => typeof value === 'string' ? value : '';
+const terminalStates = new Map([['completed', 'completed'], ['failed', 'failed'], ['killed', 'cancelled'], ['aborted', 'cancelled'], ['lost', 'disconnected'], ['cancelled', 'cancelled']]);
+const terminal = value => terminalStates.get(value);
+const field = (body, name) => body.split('\n\n', 1)[0].match(new RegExp(`^${name}: ([^\\r\\n]+)$`, 'm'))?.[1];
+const notification = (sessionId, update) => ({jsonrpc: '2.0', method: 'session/update', params: {sessionId, update}});
+const outputText = update => typeof update.rawOutput === 'string' ? update.rawOutput : (update.content ?? [])
+  .filter(block => block.type === 'content' && block.content?.type === 'text').map(block => block.content.text).join('\n');
+
+export class KimiSubagents {
+  constructor(emit, {home = process.env.KIMI_CODE_HOME ?? join(homedir(), '.kimi-code')} = {}) {
+    this.emit = emit;
+    this.home = home;
+    this.enabled = false;
+    this.requests = new Map();
+    this.sessions = new Map();
+  }
+
+  fromClient(message) {
+    if (!record(message)) return;
+    if (message.method === 'initialize') {
+      const capabilities = message.params?.clientCapabilities;
+      this.enabled = record(capabilities?.subagents) || capabilities?._meta?.jetbrains?.air?.capabilities?.includes('nativeSubagentSessions') === true;
+    }
+    if (message.id !== undefined && ['initialize', 'session/prompt', 'session/delete', 'session/close'].includes(message.method)) this.requests.set(message.id, {method: message.method, sessionId: message.params?.sessionId});
+    if (message.method === 'session/load') this.sessions.delete(message.params?.sessionId);
+  }
+
+  session(id) {
+    let session = this.sessions.get(id);
+    if (!session) {
+      session = {calls: new Map(), agents: new Map()};
+      this.sessions.set(id, session);
+    }
+    return session;
+  }
+
+  send(sessionId, update) {
+    this.emit(notification(sessionId, update));
+  }
+
+  spawn(sessionId, session, callId, spec, index) {
+    const known = spec.resume && session.agents.get(spec.resume);
+    const nativeCallId = callId.replace(/^\d+:/, '');
+    const child = {id: known?.id ?? `kimi-agent:${sessionId}:${nativeCallId}:${index}`, name: spec.name, task: spec.task, callId, done: false};
+    if (!known) this.send(sessionId, {sessionUpdate: 'subagent_spawned', subagentSessionId: child.id, name: child.name, task: child.task, capabilities: {}});
+    else this.send(sessionId, {sessionUpdate: 'subagent_state_update', subagentSessionId: child.id, _meta: {axom: {state: 'running'}}});
+    return child;
+  }
+
+  start(sessionId, session, call, update) {
+    const args = update.rawInput;
+    if (!record(args) || call.children.length) return;
+    const name = text(args.subagent_type) || 'coder';
+    const specs = call.kind === 'AgentSwarm'
+      ? [...Object.entries(record(args.resume_agent_ids) ? args.resume_agent_ids : {}).map(([resume, task]) => ({resume, task: text(task), name})),
+        ...(Array.isArray(args.items) ? args.items : []).filter(item => typeof item === 'string').map(item => ({name: `${name}: ${item}`, task: text(args.prompt_template).replaceAll('{{item}}', item), item}))]
+      : [{name, task: text(args.prompt), resume: text(args.resume)}];
+    call.args = args;
+    call.children = specs.slice(0, 128).map((spec, index) => ({...this.spawn(sessionId, session, call.id, spec, index), item: spec.item}));
+  }
+
+  finish(sessionId, child, state, body) {
+    if (child.done) return;
+    child.done = true;
+    if (body) this.send(child.id, {sessionUpdate: 'agent_message_chunk', content: {type: 'text', text: body}});
+    this.send(sessionId, {sessionUpdate: 'subagent_state_update', subagentSessionId: child.id, state});
+  }
+
+  complete(sessionId, session, call, update) {
+    if (!call.children.length) {
+      call.children = [this.spawn(sessionId, session, call.id, {name: call.kind, task: ''}, 0)];
+    }
+    const body = outputText(update);
+    if (call.kind === 'AgentSwarm') {
+      const results = [...body.matchAll(/<subagent\b([^>]*)>([\s\S]*?)<\/subagent>/g)];
+      const attribute = (attributes, name) => attributes.match(new RegExp(`(?:^| )${name}="([^"]*)"`))?.[1];
+      for (const [index, child] of call.children.entries()) {
+        const result = results[index];
+        const agentId = result && attribute(result[1], 'agent_id');
+        if (agentId) session.agents.set(agentId, child);
+        this.finish(sessionId, child, result ? terminal(attribute(result[1], 'outcome')) ?? 'failed' : 'failed', result?.[2] ?? body);
+      }
+      return;
+    }
+    const child = call.children[0];
+    const agentId = field(body, 'agent_id');
+    if (agentId) session.agents.set(agentId, child);
+    const taskId = field(body, 'task_id');
+    if (field(body, 'status') === 'running' && taskId && /^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-z]{8}$/.test(taskId)) {
+      child.background = {taskId, agentId};
+      return;
+    }
+    const state = field(body, 'stop_reason') === 'cancelled' ? 'cancelled' : terminal(field(body, 'status')) ?? (update.status === 'failed' ? 'failed' : 'completed');
+    const summary = body.match(/\n\[summary\]\n([\s\S]*?)(?:\n\nresume_hint:|$)/)?.[1];
+    this.finish(sessionId, child, state, summary ?? body);
+  }
+
+  fromAgent(message) {
+    if (!record(message)) return false;
+    if (!message.method && message.id !== undefined) {
+      const request = this.requests.get(message.id);
+      this.requests.delete(message.id);
+      if (['session/delete', 'session/close'].includes(request?.method) && !message.error) this.sessions.delete(request.sessionId);
+      if (this.enabled && request?.method === 'initialize' && message.result?.agentCapabilities) {
+        if (record(message.result.agentCapabilities.sessionCapabilities?.subagents)) {
+          this.enabled = false;
+          return false;
+        }
+        message.result.agentCapabilities.sessionCapabilities ??= {};
+        message.result.agentCapabilities.sessionCapabilities.subagents = {};
+      }
+      if (request?.method === 'session/prompt' && (message.error || message.result?.stopReason === 'cancelled')) {
+        const session = this.sessions.get(request.sessionId);
+        for (const call of session?.calls.values() ?? []) for (const child of call.children) {
+          if (!child.background) this.finish(request.sessionId, child, message.error ? 'failed' : 'cancelled', '');
+        }
+      }
+    }
+    if (!this.enabled || message.method !== 'session/update') return false;
+    const {sessionId, update} = message.params ?? {};
+    if (!sessionId || !record(update) || !['tool_call', 'tool_call_update'].includes(update.sessionUpdate)) return false;
+    if (typeof update.toolCallId !== 'string' || !update.toolCallId) return false;
+    const session = this.session(sessionId);
+    const id = update.toolCallId;
+    let call = session.calls.get(id);
+    if (!call) {
+      const title = text(update.name) || text(update.title);
+      const kind = title === 'AgentSwarm' || title.startsWith('Launching agent swarm:') ? 'AgentSwarm'
+        : title === 'Agent' || /^Launching (?:background )?.+ agent:/.test(title) ? 'Agent' : undefined;
+      if (!kind) return false;
+      call = {id, kind, children: []};
+      session.calls.set(id, call);
+    }
+    this.start(sessionId, session, call, update);
+    if (['completed', 'failed'].includes(update.status)) this.complete(sessionId, session, call, update);
+    return true;
+  }
+
+  async poll() {
+    if (this.polling) return;
+    this.polling = true;
+    try {
+      for (const [sessionId, session] of this.sessions) {
+        const children = [...session.calls.values()].flatMap(call => call.children).filter(child => child.background && !child.done);
+        if (!children.length || !/^session_[a-zA-Z0-9-]+$/.test(sessionId)) continue;
+        if (!session.directory) {
+          for (const workspace of await readdir(join(this.home, 'sessions'), {withFileTypes: true}).catch(() => [])) {
+            if (!workspace.isDirectory()) continue;
+            const directory = join(this.home, 'sessions', workspace.name, sessionId);
+            const state = await readFile(join(directory, 'state.json'), 'utf8').then(JSON.parse).catch(() => null);
+            if (state?.id === sessionId) {session.directory = directory; break;}
+          }
+        }
+        if (!session.directory) continue;
+        for (const child of children) {
+          const {taskId, agentId} = child.background;
+          const directory = join(session.directory, 'agents', 'main', 'tasks');
+          const task = await readFile(join(directory, `${taskId}.json`), 'utf8').then(JSON.parse).catch(() => null);
+          if (task?.taskId !== taskId || task.kind !== 'agent' || task.agentId !== agentId) continue;
+          const state = terminal(task.status);
+          if (!state) continue;
+          const body = await readFile(join(directory, taskId, 'output.log'), 'utf8').catch(() => text(task.stopReason));
+          if (this.sessions.get(sessionId) === session) this.finish(sessionId, child, state, body);
+        }
+      }
+    } finally {this.polling = false;}
+  }
+}

package/dist/axom-patch/cli/nightly-task.md

@@ -1,6 +1,9 @@
 # Nightly 任务：catalog agent 版本升级
 
-供 AI 周期执行的任务说明。**默认产出是把 catalog / runtime.json 的钉版本升到上游最新**：
+> 流程总入口与全部经验教训见 **[`../DAILY_UPGRADE_CHECK.md`](../DAILY_UPGRADE_CHECK.md)**（唯一权威
+> runbook）。本文件保留 Qoder 原生 ACP 的候选认证门槛细节；两文冲突时以 runbook 为准。
+
+供 AI 周期执行的任务说明。Qoder 原生 ACP 候选优先遵循下面的完整认证门槛；发现新版本身不授权改钉版本。**默认产出是把 catalog / runtime.json 的钉版本升到上游最新**：
 对每个有新版本的 agent，判定新版本是否已解决补丁问题（或官方提供了可替代方案），已解决走下线，
 没解决就把补丁移植到新版本并把钉版本升上去。「只分析不升级」是例外，只允许用在判定不了、
 且报告里写明了缺什么证据/设备的情况。
@@ -8,6 +11,42 @@
 与每周一 09:00 的 [`scripts/check-upstream-patches.py`](../../scripts/check-upstream-patches.py)
 （launchd，覆盖全部组件、只产报告）互补：本任务只管 **CLI catalog / adapter 补丁层**，但执行升级。
 
+
+## Qoder 原生 ACP 候选认证门槛
+
+本节覆盖其他段落对 Qoder 的自动升钉建议。先发现官方精确版本，再使用
+`qoder/scripts/build.mjs` 和 `generate.mjs` 生成独立候选；始终运行 `bin.qodercli`
+并记录 `bin.args:["--acp"]`、完整主包文件哈希、现有 ordered recipe `patchDigest`、
+所需平台原生工具身份与哈希。新版本如果无法通过结构化钩子生成，应报告并停止。
+
+在 authoring checkout 上执行（Node 必须满足候选策略；不安装定时任务）：
+
+```bash
+export EV=/home/admin/agent-artifacts/qoder-nightly-YYYYMMDD
+export TMPDIR="$EV/tmp"
+mkdir -p "$TMPDIR"
+# beaver 外部 npm 下载前加载 ~/.config/vpn/proxy.env。
+# CANDIDATE 为生成的主包目录，其同级 .release.json / .recipe.json 是输入。
+# EVIDENCE 必须位于同一隔离 npm install 的祖先 node_modules 可解析的位置。
+node axom-patch/cli/qoder/scripts/certify.mjs   --candidate "$CANDIDATE" --evidence "$EVIDENCE"   --platform linux --arch x64 --auth-home "$AUTH_SOURCE_HOME"
+```
+
+`--auth-home` 只把允许的认证文件复制到新 HOME，不复用原始配置或历史。省略时仅跑
+真实 initialize。工具的依赖须用隔离 npm install --ignore-scripts 安装；需要的原生
+helper 只能在新 staging 中设置执行位。认证工具从实际 Node、候选和依赖重算绑定，
+错误平台标签、缺项、重复、陈旧摘要、失败、坏工件或 synthetic 证据均不能通过。
+每次输出新 `run-*` 目录，`result.json` 与 `result.sha256` 禁止覆盖旧结果。
+
+后续真实 UI、legacy migration、安装及各平台检查的记录放入 `$EVIDENCE/records/`；
+按 README 的 schema 绑定同一候选、suite、Node、平台、工具和依赖。执行同一命令加
+`--collect-only` 重新验证字节和工件再归并；它不会运行模型或信任旧 PASS 标签。
+不要同时导入一个检查的多次记录，重复即拒绝。直接 ACP next 不等于 insert-button。
+
+只有 15 个必需检查在目标平台全部真实 PASS，才可提出钉版本变更。实际 UI、Windows
+或迁移缺失必须报告 NOT_PASS，保留当前钉版本；合成 fixture 只验证 schema。
+不自动发布、升钉、安装 cron、推送或部署。候选/release/historyVersions/suite 变更后
+旧证据作废，必须对最终字节重新执行。
+
 ## 钉版本规则（本任务的前提）
 
 - **Axom 给适配器打了补丁（package_patches 配方 / native_extensions 包装）⇒ 必须钉版本**。
@@ -41,7 +80,7 @@
 
 ```bash
 cd <repo>
-curl -s --max-time 30 https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json -o /tmp/acp-registry.json
+curl -s --max-time 30 https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json -o $EV/acp-registry.json
 for p in pi-acp @agentclientprotocol/claude-agent-acp @agentclientprotocol/codex-acp \
          command-code zcode-acp-server @qoder-ai/qodercli; do npm view "$p" version; done
 gh pr view 458  -R agentclientprotocol/registry --json state,title   # kimi-code 收录
@@ -57,7 +96,7 @@ python3 -c "import json;d=json.load(open('$HOME/.axom/workstation/acp-adapters/b
 | claude-acp | npm @agentclientprotocol/claude-agent-acp | catalog.ts `distribution` | claude-account-limits + launchEnv |
 | codex-acp | npm @agentclientprotocol/codex-acp | catalog.ts `distribution` | codex-account-limits + launchEnv |
 | pi-acp | npm pi-acp | catalog.ts `distribution` | pi-steering、pi-subagent-subwork |
-| qoder | npm @qoder-ai/qodercli | runtime.json override（追赶钉，until registry 同版） | qoder-steering、qoder-subagent-origin |
+| qoder | npm @qoder-ai/qodercli@1.1.75 | catalog.ts 固定 `--acp` + `qoder-native-acp` package patch；runtime.json `install_policies` 禁用 npm scripts | qoder-native-acp |
 | kimi-code | GitHub release 二进制 | catalog.ts `supplement` | native extension kimi-proxy |
 | command-code | npm command-code | catalog.ts `supplement` | commandcode-account-limits |
 | zcode-acp | npm zcode-acp-server | catalog.ts `supplement` | zcode-account-limits、zcode-models、zcode-subagent-subwork |
@@ -82,7 +121,7 @@ python3 -c "import json;d=json.load(open('$HOME/.axom/workstation/acp-adapters/b
 
 ## 第 3 步：移植补丁到新版本
 
-1. **取 pristine**：`mkdir /tmp/axom-nightly && cd /tmp/axom-nightly && npm pack <pkg>@<ver>` 解包
+1. **取 pristine**：`mkdir -p "$EV/pristine" && cd "$EV/pristine" && npm pack <pkg>@<ver>` 解包
    （antigravity 用 curl 拉 darwin-arm64 zip）。
 2. **先问「还需要吗」**：
    - 配额类：grep 新版本有无原生 `accountRateLimits` / 等价能力；没有 → 仍需要。
@@ -91,16 +130,18 @@ python3 -c "import json;d=json.load(open('$HOME/.axom/workstation/acp-adapters/b
 3. **account-limits 类配方**（claude/codex/commandcode/zcode）：改 `account-limits/generate.py`
    里的版本号与锚点串（`count==1` 断言失败 = 上游改了形状，对照新 pristine 修锚点），指向新
    pristine 目录重跑，生成新配方 JSON。
-4. **手工配方**（zcode-models、zcode-subagent-subwork、qoder-*）：对每个 edit 检查 `before` 在新
-   pristine 里是否仍唯一存在；压缩标识符改名（如 `gnd`→`Ocd`、`as`→`cs`）就同步改锚点；然后按
-   **配方在 runtime.json `package_patches` 里的顺序链式重算哈希**——第二个配方的 before 哈希
-   基准是第一个配方打完之后的文件（qoder-subagent-origin 在 qoder-steering 之前）。
+4. **手工配方**（zcode-models、zcode-subagent-subwork）：对每个 edit 检查 `before` 在新
+   pristine 里是否仍唯一存在；压缩标识符改名（如 `gnd`→`Ocd`、`as`→`cs`）就**同步改锚点和载荷**。
+   Qoder 使用官方 1.1.75 的 `qoder-native-acp.json`，不再维护旧 steering/subagent 配方；
+   `patchDigest` 必须由生成器按完整 recipe（含 asset）重算。Qoder 与其他包补丁一样，
+   安装和启动只依赖 Catalog 钉版本、配方锚点和哈希；行为/平台认证仅用于升级或退休判断，
+   不得成为普通安装的前置条件。
 5. **验证**（缺一不可）：
    - 顺序应用配方到 pristine 副本，逐 edit 核对 before/after sha256；
-   - 有探针的包跑探针：补丁副本必须通过，pristine 必须**复现缺失**（证明补丁仍需要）——
-     `node axom-patch/cli/probes/<pkg-*>.mjs <patched-dir>`（探针内钉了版本断言，随移植更新）；
-   - 探针桩跟不上上游新代码路径（新解引用/新自由变量）时，更新探针桩而不是删断言；断言意图
-     不变，措辞跟上新行为（参考 2026-10-14 qoder-subagent-origin 的 toolCallPublisher 桩）。
+   - 需要行为证据的候选可运行 `node axom-patch/cli/qoder/scripts/certify.mjs`，并保存每个
+     check 的原始记录、候选 digest、Node/tool identity 和平台信息；这些记录只用于升级/退休判断；
+   - `manifest.json` 的 `compatible_versions` 与配方 `versions` 同步（`acp/qoderPatches.test.ts` 会断言）；
+   - 生成器/认证器结构变化时修复对应断言并重新生成 release，不通过手工修改 certification 绕过 gate。
 
 ## 第 4 步：升钉版本（编辑集，同一提交改完）
 
@@ -123,6 +164,7 @@ cd axom-cli
 npx vitest run src/workstation/acp/patchAssets.test.ts src/workstation/acp/managedPatches.test.ts \
   src/workstation/acp/registry/catalog.test.ts src/workstation/acp/acpAgents.test.ts
 npm run build            # 含 copy-patches 的台账工件校验
+npm run test:qoder-patch # Qoder 补丁模块与生成器（npm test 也会跑）
 cd ..
 python3 scripts/check-upstream-patches.py --offline
 ```
@@ -148,5 +190,5 @@ claude 旧 override 用例）；与 `git stash` 前后对照失败集一致即
 | antigravity-acp | —（补钉 1.3.0 后升） | **1.4.0** | registry 1.4.0 | 真实 1.4.0 .par 经 proxy 实测：透传无损、能力注入成功；配额 READ 留真机 |
 | command-code | 1.74.3 | **1.82.1** | npm 1.82.1 | 上游仍无配额能力；handler map 改名（u/dn→m/hn）锚点已跟，generate.py 移植 |
 | zcode-acp | 0.69.3 | **0.69.4** | npm 0.69.4 | 三份配方目标文件字节一致（versions 双版本）；subagent 探针补丁副本过、pristine 复现缺失 |
-| qoder | 1.1.61 | **1.1.71** | npm 1.1.71 | 仍无 ACP steering；三处锚点改名已移植，哈希链按 origin→steering 重算，双探针通过、pristine 复现缺失 |
+| qoder | 1.1.74 adapter | **1.1.75 native ACP** | npm `@qoder-ai/qodercli@1.1.75` | `qoder-native-acp` recipe 已生成；真实行为/平台 evidence 只作为后续升级或退休依据，不阻塞当前安装 |
 | kimi-code | 2.1.1 | 2.1.1 | registry 未收录 | 无新版（GitHub release 同版） |

package/dist/axom-patch/cli/probes/codex-terminal-output.mjs

@@ -0,0 +1,33 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+
+const packageRoot = process.argv[2];
+assert.ok(packageRoot, 'Pass the codex-acp package directory');
+const source = readFileSync(path.join(packageRoot, 'dist/index.js'), 'utf8');
+const helpers = source.slice(source.indexOf('function usesTerminal(item)'), source.indexOf('function startFacts(item)')) +
+  source.slice(source.indexOf('function completionFacts(item,'), source.indexOf('function searchTitle(')) +
+  source.slice(source.indexOf('function toTerminalToolStatus(status)'), source.indexOf('// src/tool-calls/reporters/CommandReporter.ts'));
+const context = vm.createContext({});
+vm.runInContext(helpers, context);
+for (const streamed of [false, true]) {
+  for (const status of ['completed', 'failed']) {
+    context.item = {
+      id: 'terminal-output-probe', source: 'unifiedExec', commandActions: [],
+      status, exitCode: status === 'completed' ? 0 : 7,
+      aggregatedOutput: 'BEGIN\nEND\n',
+    };
+    context.streamed = streamed;
+    const facts = vm.runInContext('completionFacts(item, streamed, false)', context);
+    if (process.argv.includes('--expect-bug')) {
+      assert.equal(facts.opaqueResult, undefined);
+    } else {
+      assert.equal(facts.opaqueResult.formatted_output, context.item.aggregatedOutput);
+      assert.equal(facts.opaqueResult.exit_code, context.item.exitCode);
+    }
+    assert.equal(facts.status, status);
+    assert.equal(facts.terminalExit.exitCode, context.item.exitCode);
+  }
+}
+console.log(process.argv.includes('--expect-bug') ? 'Confirmed missing complete terminal result' : 'Complete terminal results pass: streamed/unstreamed and completed/failed');

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

@@ -0,0 +1,82 @@
+import assert from 'node:assert/strict';
+import {spawn} from 'node:child_process';
+import {createInterface} from 'node:readline';
+import {fileURLToPath} from 'node:url';
+
+const binary = process.argv[2];
+assert.ok(binary, 'Usage: node kimi-subagent-subwork.mjs /path/to/managed/kimi');
+const child = spawn(process.execPath, [fileURLToPath(new URL('../account-limits/kimi-proxy.mjs', import.meta.url)), binary, 'acp'], {stdio: ['pipe', 'pipe', 'inherit']});
+const pending = new Map();
+const updates = [];
+const sessions = [];
+let nextId = 1;
+const write = message => child.stdin.write(JSON.stringify(message) + '\n');
+const request = (method, params) => new Promise((resolve, reject) => {
+  const id = nextId++;
+  const timer = setTimeout(() => {pending.delete(id); reject(new Error(`Timeout: ${method}`));}, 90000);
+  pending.set(id, {resolve, reject, timer});
+  write({jsonrpc: '2.0', id, method, params});
+});
+createInterface({input: child.stdout}).on('line', line => {
+  let message;
+  try {message = JSON.parse(line);} catch {return;}
+  if (message.method === 'session/update') updates.push(message.params);
+  if (message.method === 'session/request_permission') {
+    const option = message.params.options.find(option => option.kind === 'allow_once');
+    write({jsonrpc: '2.0', id: message.id, result: {outcome: option ? {outcome: 'selected', optionId: option.optionId} : {outcome: 'cancelled'}}});
+  }
+  const waiter = !message.method && pending.get(message.id);
+  if (!waiter) return;
+  pending.delete(message.id);
+  clearTimeout(waiter.timer);
+  if (message.error) waiter.reject(new Error(JSON.stringify(message.error)));
+  else waiter.resolve(message.result);
+});
+child.on('exit', code => {
+  for (const waiter of pending.values()) {clearTimeout(waiter.timer); waiter.reject(new Error(`Kimi exited: ${code}`));}
+  pending.clear();
+});
+const prompt = (sessionId, text) => request('session/prompt', {sessionId, prompt: [{type: 'text', text}]});
+const create = async () => {
+  const session = await request('session/new', {cwd: '/tmp', mcpServers: []});
+  sessions.push(session.sessionId);
+  return session.sessionId;
+};
+const states = () => updates.filter(({update}) => update.sessionUpdate === 'subagent_state_update' && update.state);
+try {
+  const initialized = await request('initialize', {protocolVersion: 1, clientCapabilities: {subagents: {}, _meta: {jetbrains: {air: {version: 1, capabilities: ['nativeSubagentSessions', 'asyncTasks']}}}}, clientInfo: {name: 'axom-kimi-subagent-probe', version: '1.0.0'}});
+  assert.ok(initialized.agentCapabilities.sessionCapabilities.subagents);
+  assert.ok(initialized.agentCapabilities._meta['axom/accountRateLimits']);
+  console.log('agent', JSON.stringify(initialized.agentInfo));
+  const foreground = await create();
+  await prompt(foreground, 'ACP rendering verification. Use Agent exactly once, subagent_type explore, prompt "Return the exact literal KIMI_FOREGROUND_OK; do not use tools, read files or run commands." Wait for its result, then repeat the literal. Do not use any other tools or modify files.');
+  const spawn = updates.find(({sessionId, update}) => sessionId === foreground && update.sessionUpdate === 'subagent_spawned');
+  assert.ok(spawn, 'Foreground dispatch');
+  assert.ok(states().some(({sessionId, update}) => sessionId === foreground && update.state === 'completed'));
+  assert.ok(updates.some(({sessionId, update}) => sessionId === spawn.update.subagentSessionId && update.content?.text.includes('KIMI_FOREGROUND_OK')));
+  assert.ok(!updates.some(({update}) => update.title === 'Agent' || update.title?.startsWith('Launching explore agent:')), 'No duplicate Agent tool card');
+  const beforeResume = updates.length;
+  await prompt(foreground, 'Use Agent exactly once with resume="agent-0" and prompt="Return KIMI_RESUME_OK without tools." Do not set subagent_type. Wait for its result, then repeat it. No other tools or file changes.');
+  assert.ok(updates.slice(beforeResume).some(({update}) => update.sessionUpdate === 'subagent_state_update' && update.subagentSessionId === spawn.update.subagentSessionId && update.state === 'completed'), 'Resume reuses child identity');
+  assert.ok(!updates.slice(beforeResume).some(({update}) => update.sessionUpdate === 'subagent_spawned'));
+  console.log('PASS foreground + resume');
+
+  const background = await create();
+  await prompt(background, 'ACP background rendering verification. Use Agent exactly once with run_in_background=true, subagent_type explore, prompt="Return the exact literal KIMI_BACKGROUND_OK without tools, file access or commands." After the launch receipt say launched and finish your turn. Do not wait, poll or call any other tools.');
+  const deadline = Date.now() + 45000;
+  while (!states().some(({sessionId, update}) => sessionId === background && update.state === 'completed') && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100));
+  assert.ok(states().some(({sessionId, update}) => sessionId === background && update.state === 'completed'), 'Background terminal after launch receipt');
+  const backgroundChild = updates.find(({sessionId, update}) => sessionId === background && update.sessionUpdate === 'subagent_spawned')?.update.subagentSessionId;
+  assert.ok(updates.some(({sessionId, update}) => sessionId === backgroundChild && update.content?.text.includes('KIMI_BACKGROUND_OK')), 'Background output');
+  console.log('PASS background late output + terminal');
+
+  const beforeLoad = updates.length;
+  await request('session/load', {sessionId: foreground, cwd: '/tmp', mcpServers: []});
+  assert.ok(updates.slice(beforeLoad).some(({update}) => update.sessionUpdate === 'subagent_spawned' && update.subagentSessionId === spawn.update.subagentSessionId), 'Load reconstructs stable child identity');
+  console.log('PASS load replay');
+  console.log(JSON.stringify({sessions: sessions.length, children: updates.filter(({update}) => update.sessionUpdate === 'subagent_spawned').length, terminals: states().map(({update}) => update.state)}));
+} finally {
+  for (const sessionId of sessions) await request('session/delete', {sessionId}).catch(error => console.error('cleanup', error.message));
+  child.stdin.end();
+  child.kill();
+}