@platless/axom-cli 0.3.13 → 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

@@ -0,0 +1,194 @@
+# Nightly 任务：catalog agent 版本升级
+
+> 流程总入口与全部经验教训见 **[`../DAILY_UPGRADE_CHECK.md`](../DAILY_UPGRADE_CHECK.md)**（唯一权威
+> runbook）。本文件保留 Qoder 原生 ACP 的候选认证门槛细节；两文冲突时以 runbook 为准。
+
+供 AI 周期执行的任务说明。Qoder 原生 ACP 候选优先遵循下面的完整认证门槛；发现新版本身不授权改钉版本。**默认产出是把 catalog / runtime.json 的钉版本升到上游最新**：
+对每个有新版本的 agent，判定新版本是否已解决补丁问题（或官方提供了可替代方案），已解决走下线，
+没解决就把补丁移植到新版本并把钉版本升上去。「只分析不升级」是例外，只允许用在判定不了、
+且报告里写明了缺什么证据/设备的情况。
+
+与每周一 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 包装）⇒ 必须钉版本**。
+  不钉的话 registry/npm 一发新版，Install/Update 就装上一个补丁不生效的包。
+- **没打补丁 ⇒ 不钉**，版本跟 registry 走（用户自己的 Update 决定）。
+- **例外：registry 没有这个 agent**（supplement：kimi-code、command-code、zcode-acp、hermes）⇒
+  版本天然由我们的 catalog 决定，永远钉着。
+- scan/Update 的比对语义：roster 上报的 `version`/`registryVersion` 对钉住条目就是**生效（钉住）
+  版本**，设置页 `updatable` 因此永远对着 catalog 钉版本比，不对着官方 registry 比——这是特性，
+  不要"修"。
+- `catalog.test.ts > patched agents stay pinned` 是机械守卫：新增补丁不补钉会红；本任务改版本后
+  它也负责防止「钉了一个配方不覆盖的版本」。
+
+## 产物
+
+每次运行（无论动作多少）写报告到 `docs/superpowers/nightly-reports/YYYY-MM-DD-cli-catalog.md`：
+每个 agent 的结论（已解决/仍需要/无法判定）、证据、动作、遗留。报告不写本目录——整个
+`axom-patch/cli/` 随 CLI 打包进 dist。
+
+## 第 0 步：边界（每次都要读）
+
+- 永不自动 git push、发版、发 issue/PR；改动仅限第 4 步编辑集。
+- 补丁**下线**必须满足 [`docs/handbook/upstream-patches.md`](../../docs/handbook/upstream-patches.md)
+  的五条证据（修复链接、`fixed_release`、`adopted_version`、无补丁回归、`removal_commit`）。
+  「上游发了新版本」不是「已修复」；探针通过才是。
+- 钉版本只升不降；配方与钉版本一起动，不允许钉着一个配方不生效的版本。
+- 改了任何随 CLI 发布的内容**必须 bump `axom-cli/package.json` npm version**——相同版本不触发
+  Server 自动升级。
+
+## 第 1 步：数据收集
+
+```bash
+cd <repo>
+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 收录
+gh pr view 566  -R agentclientprotocol/registry --json state,title   # zcode-acp 收录
+gh pr view 650  -R agentclientprotocol/registry --json state,title
+python3 -c "import json;d=json.load(open('$HOME/.axom/workstation/acp-adapters/builds.json'));print({k:v['current'] for k,v in d['agents'].items()})"
+```
+
+对照表（钉版本与配方以文件为准，本表是索引；升级后同步更新本表）：
+
+| agent id | 来源 | 钉在哪 | 配方 |
+|---|---|---|---|
+| 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@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 |
+| antigravity-acp | registry binary .par（dl.google.com） | catalog.ts `distribution` | native extension antigravity-proxy |
+
+## 第 2 步：逐 agent 判定（三选一，必须给结论）
+
+对每个「npm latest / registry 版本 > 当前钉版本」的 agent：
+
+1. **上游已解决，或官方有替代方案** → 走下线证据门槛（第 0 步），按台账 remove_when 退休补丁，
+   删钉版本，版本交还 registry。证据：探针在无补丁新版本上通过，或上游实现了等价能力
+   （如 adapter 原生暴露配额、原生发出 subagent 变体）。
+2. **仍需要补丁**（默认预期）→ 第 3 步移植配方，第 4 步升钉版本。**当天完成**。
+3. **判定不了** → 保持钉住，报告写明缺什么（哪个探针不存在、哪步需要真机/凭据）。这是唯一
+   允许不升级的出口。
+
+另查两件让位事件：
+
+- registry 收录了 supplement 的 id → supplement 让位前确认让位目标版本有配方覆盖；没有就先把
+  supplement 换成显式 `distribution` 钉 + 移植配方，再让位。
+- 条件 override 到界（qoder until_registry_version）→ 让位目标高于配方版本时同样先移植再放行。
+
+## 第 3 步：移植补丁到新版本
+
+1. **取 pristine**：`mkdir -p "$EV/pristine" && cd "$EV/pristine" && npm pack <pkg>@<ver>` 解包
+   （antigravity 用 curl 拉 darwin-arm64 zip）。
+2. **先问「还需要吗」**：
+   - 配额类：grep 新版本有无原生 `accountRateLimits` / 等价能力；没有 → 仍需要。
+   - 行为类（steering / subagent）：查 initialize 有无 `_meta.steering`、有无 `subagent_spawned`
+     等原生实现；没有 → 仍需要。
+3. **account-limits 类配方**（claude/codex/commandcode/zcode）：改 `account-limits/generate.py`
+   里的版本号与锚点串（`count==1` 断言失败 = 上游改了形状，对照新 pristine 修锚点），指向新
+   pristine 目录重跑，生成新配方 JSON。
+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；
+   - 需要行为证据的候选可运行 `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 步：升钉版本（编辑集，同一提交改完）
+
+1. `axom-cli/src/workstation/acp/registry/catalog.ts`：bump `distribution.version` /
+   `supplement.version` 与来源（npx spec / 六平台归档 URL）；binary 条目换 URL 时逐平台 HEAD
+   确认，能拿 sha256 就补。**diff registry 现条目的 args/env**——钉住来源整个替换 registry 的
+   distribution，registry 新加的要并进来。
+2. `axom-patch/cli/runtime.json`：override 钉版本与 `until_registry_version` 同步；配方文件的
+   `versions`（字节一致可双版本并存，如 zcode 0.69.3+0.69.4；锚点变了就只留新版本）；native
+   extension `versions` 加新版本（旧的保留，过渡期安装仍被包住）。
+3. `axom-patch/manifest.json`：`dependencies.<pkg>.reviewed_version` = 本次核验的版本；
+   `patches[].artifacts` 的 sha256 全部重算（copy-patches.mjs 会校验，漏了 build 直接红）。
+4. `axom-cli/package.json` bump npm version（相对上一个已发布版本）。
+5. 文档：`axom-patch/cli/README.md` 当前补丁表、本文件对照表。
+
+## 第 5 步：验证
+
+```bash
+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
+```
+
+main 上有一批与本任务无关的既有失败（daemon 接线、浏览器 keeper、journal 时序、migrate 的
+claude 旧 override 用例）；与 `git stash` 前后对照失败集一致即可，不要顺手修。
+
+真机冒烟（可选；涉及启动行为变化时做）：dev 实例 Install/Update 一次，scan 确认版本行收敛到
+新钉版本；`reconcileCertifiedBuilds` 会在 CLI 发出后自动把已装工作站前移。
+
+## 第 6 步：报告
+
+写入 `docs/superpowers/nightly-reports/`：对照表快照、每个 agent 的三选一结论与证据、动作清单、
+遗留（只属于出口 3）。发版走既有 Client release 流程，本任务不触碰。
+
+## 快照（2026-10-14 首跑，全部完成升级）
+
+| agent | 旧钉 | 新钉 | registry/npm 当时 | 结论 |
+|---|---|---|---|---|
+| claude-acp | —（补钉） | 0.90.0 | 0.90.0 | 上游无原生配额 → 补钉；配方经 generate.py 重生成（normalize.mjs 对齐） |
+| codex-acp | —（补钉） | 2.2.2 | 2.2.2 | 同上 |
+| pi-acp | —（补钉） | 0.0.34 | 0.0.34 | 上游无 steering/subagent 变体 → 补钉 |
+| 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.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/pi-subagent-subwork.json

@@ -0,0 +1,23 @@
+{
+  "id": "pi-subagent-subwork",
+  "package": "pi-acp",
+  "versions": [
+    "0.0.34"
+  ],
+  "edits": [
+    {
+      "file": "dist/index.js",
+      "before_sha256": "1ee621825b7e02d74312336fc0f820046bd41fe26455143f6f6e5078a727fa79",
+      "after_sha256": "228205f547edccd553d873a5f5c5dea6795ab6d33f989f14067e239153bbb2ef",
+      "before": "var PiAcpSession = class {\n  axomSteering = new AxomPiSteering(this);",
+      "after": "// Injected into pi-acp 0.0.34 after pi-steering. Normalizes pi-subagents children into\n// draft ACP subagent variants (RFD #1992), the same contract claude-agent-acp ships\n// natively. All ids are derived from the root session id plus toolCallId/runId, never\n// random, so a keeper raw-log replay re-derives identical frames. Frames ride the\n// session's existing lastEmit chain so they keep one total order with every other frame.\nconst VOLATILE_PROGRESS_KEYS = /* @__PURE__ */ new Set([\n  \"durationMs\",\n  \"lastActivityAt\",\n  \"recentOutput\",\n  \"inputTokens\",\n  \"outputTokens\",\n  \"cacheRead\",\n  \"cacheWrite\",\n  \"tokens\",\n  \"cost\",\n  \"window\",\n  \"windowPeak\",\n  \"usage\"\n]);\nclass AxomPiSubagents {\n  constructor(session) {\n    this.session = session;\n    this.children = /* @__PURE__ */ new Map();\n    this.runs = /* @__PURE__ */ new Map();\n  }\n  emitTo(sessionId, update) {\n    const session = this.session;\n    session.lastEmit = session.lastEmit.then(\n      () => session.conn.sessionUpdate({ sessionId, update })\n    ).catch(() => {\n    });\n  }\n  isLaunch(args) {\n    return args && typeof args === \"object\" && typeof args.agent === \"string\" && args.agent && !args.action && (typeof args.task === \"string\" || args.workflow !== undefined);\n  }\n  textOf(content, cap) {\n    if (!Array.isArray(content)) return \"\";\n    let text = \"\";\n    for (const block of content) {\n      if (block && typeof block === \"object\" && block.type === \"text\" && typeof block.text === \"string\") text += (text ? \"\\n\" : \"\") + block.text;\n      if (text.length >= cap) break;\n    }\n    return text.slice(0, cap);\n  }\n  spawn(childId, name, task, meta) {\n    this.emitTo(this.session.sessionId, {\n      sessionUpdate: \"subagent_spawned\",\n      subagentSessionId: childId,\n      name,\n      task,\n      capabilities: {},\n      _meta: { pi: meta }\n    });\n  }\n  onToolStart(ev) {\n    if (ev.toolName !== \"subagent\" || !this.isLaunch(ev.args)) return;\n    const toolCallId = String(ev.toolCallId ?? \"\");\n    if (!toolCallId || this.children.has(toolCallId)) return;\n    const args = ev.args;\n    const childId = `pi-agent:${this.session.sessionId}:${toolCallId}`;\n    const task = typeof args.task === \"string\" && args.task ? args.task : `workflow: ${String(args.workflow)}`;\n    const child = { childId, terminal: false, lastUpdate: undefined };\n    this.children.set(toolCallId, child);\n    this.spawn(childId, args.agent, task, { toolCallId });\n  }\n  // pi-subagents resends the full foreground progress snapshot on a timer; measured on real\n  // genius runs, frame-to-frame deltas are timers (durationMs/lastActivityAt), a rolling output\n  // tail (recentOutput[] — the child's content, which must not stream into the parent session\n  // anyway) and token/cost/window telemetry that ticks on every model step. Strip all of those\n  // recursively and drop an update whose fingerprint did not change. Discrete signals — status\n  // text, turnCount, recentTools[] and toolCalls[] growth — still pass, and the terminal frames\n  // (with the final usage) arrive on tool_execution_end, which is never deduplicated.\n  stripVolatile(value) {\n    if (Array.isArray(value)) return value.map((item) => this.stripVolatile(item));\n    if (value && typeof value === \"object\") {\n      const out = {};\n      for (const key of Object.keys(value).sort()) {\n        if (VOLATILE_PROGRESS_KEYS.has(key)) continue;\n        out[key] = this.stripVolatile(value[key]);\n      }\n      return out;\n    }\n    return value;\n  }\n  pruneEmpty(value) {\n    if (Array.isArray(value)) {\n      const kept = value.map((item) => this.pruneEmpty(item)).filter((item) => item !== void 0);\n      return kept.length ? kept : void 0;\n    }\n    if (value && typeof value === \"object\") {\n      const out = {};\n      for (const key of Object.keys(value)) {\n        const pruned = this.pruneEmpty(value[key]);\n        if (pruned !== void 0) out[key] = pruned;\n      }\n      return Object.keys(out).length ? out : void 0;\n    }\n    return value;\n  }\n  onToolUpdate(ev) {\n    const child = this.children.get(String(ev.toolCallId ?? \"\"));\n    if (!child) return false;\n    const fingerprint = JSON.stringify(this.pruneEmpty(this.stripVolatile(ev.partialResult)));\n    if (fingerprint === child.lastUpdate) return true;\n    child.lastUpdate = fingerprint;\n    return false;\n  }\n  onToolEnd(ev) {\n    const toolCallId = String(ev.toolCallId ?? \"\");\n    const child = this.children.get(toolCallId);\n    if (!child || child.terminal) return;\n    const details = ev.result && typeof ev.result === \"object\" && ev.result.details && typeof ev.result.details === \"object\" ? ev.result.details : {};\n    const runId = typeof details.runId === \"string\" ? details.runId : typeof details.asyncId === \"string\" ? details.asyncId : undefined;\n    if (runId && !this.runs.has(runId)) this.runs.set(runId, child);\n    if (details.asyncId !== undefined || details.asyncDir !== undefined) return;\n    child.terminal = true;\n    const preview = this.textOf(ev.result && ev.result.content, 2000);\n    if (preview) this.emitTo(child.childId, { sessionUpdate: \"agent_message_chunk\", content: { type: \"text\", text: preview } });\n    this.emitTo(this.session.sessionId, {\n      sessionUpdate: \"subagent_state_update\",\n      subagentSessionId: child.childId,\n      state: ev.isError === true ? \"failed\" : \"completed\",\n      _meta: { pi: { toolCallId } }\n    });\n  }\n  onNotify(entry) {\n    const details = entry.details && typeof entry.details === \"object\" ? entry.details : {};\n    const runs = Array.isArray(details.runs) ? details.runs : [];\n    for (const run of runs) {\n      if (!run || typeof run !== \"object\") continue;\n      const runId = typeof run.runId === \"string\" ? run.runId : typeof run.id === \"string\" ? run.id : undefined;\n      if (!runId) continue;\n      let child = this.runs.get(runId);\n      if (!child) {\n        child = { childId: `pi-agent:${this.session.sessionId}:run:${runId}`, terminal: false };\n        this.runs.set(runId, child);\n        this.spawn(child.childId, typeof run.agent === \"string\" && run.agent ? run.agent : \"subagent\", typeof run.summary === \"string\" ? run.summary : \"\", { adopted: true, runId });\n      }\n      if (child.terminal) continue;\n      const status = typeof run.status === \"string\" ? run.status : \"\";\n      const state = status === \"completed\" ? \"completed\" : status === \"failed\" ? \"failed\" : status === \"stopped\" ? \"cancelled\" : undefined;\n      if (!state) continue;\n      child.terminal = true;\n      const meta = { pi: { runId } };\n      for (const key of [\"session\", \"resultPath\", \"asyncDir\"]) {\n        if (typeof run[key] === \"string\" && run[key]) meta.pi[key] = run[key];\n      }\n      if (typeof run.summary === \"string\" && run.summary) {\n        this.emitTo(child.childId, { sessionUpdate: \"agent_message_chunk\", content: { type: \"text\", text: run.summary.slice(0, 2000) } });\n      }\n      this.emitTo(this.session.sessionId, { sessionUpdate: \"subagent_state_update\", subagentSessionId: child.childId, state, _meta: meta });\n    }\n  }\n  observe(ev) {\n    const type = String(ev.type ?? \"\");\n    if (type === \"tool_execution_start\") this.onToolStart(ev);\n    else if (type === \"tool_execution_end\") this.onToolEnd(ev);\n    else if (type === \"tool_execution_update\") return this.onToolUpdate(ev);\n    else if (type === \"message_end\") {\n      // pi delivers extension custom messages (pi.sendMessage) as message_start/message_end\n      // pairs with role \"custom\"; pi-acp 0.0.34 has no case for them and drops them.\n      const message = ev.message;\n      if (message && typeof message === \"object\" && message.role === \"custom\" && message.customType === \"subagent-notify\") this.onNotify(message);\n    }\n    return false;\n  }\n}\n\nvar PiAcpSession = class {\n  axomSteering = new AxomPiSteering(this);\n  axomSubagents = new AxomPiSubagents(this);"
+    },
+    {
+      "file": "dist/index.js",
+      "before_sha256": "228205f547edccd553d873a5f5c5dea6795ab6d33f989f14067e239153bbb2ef",
+      "after_sha256": "41e76175c97e4d0e042e6fa7cfabca0eb0fea757a4fcfec39d8d238fc2e9088e",
+      "before": "  handlePiEvent(ev) {\n    const type = String(ev.type ?? \"\");",
+      "after": "  handlePiEvent(ev) {\n    if (this.axomSubagents && this.axomSubagents.observe(ev)) return;\n    const type = String(ev.type ?? \"\");"
+    }
+  ]
+}

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

@@ -13,7 +13,11 @@ for (const state of ['completed', 'failed', 'stopped']) {
   for (const closing of ['terminalState', 'terminalPromise']) {
     const events = [];
     const publish = async (notification) => { events.push(notification); };
-    const native = new NativeSubagentRuntime(true, 'root', {}, publish, { log() {} });
+    // "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) });

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();
+}