@platless/axom-cli 0.1.0 → 0.3.13

package/README.md

@@ -61,4 +61,4 @@ Non-secret CLI auth state is stored in `~/.axom/config.json` with mode `0600`. T
 
 ## Learn more
 
-This README is a front page, not the manual. For the full command reference (arguments, exit codes, examples) and architecture notes, see `docs/modules/cli.md` and `guide/en/agent-integration/axom-cli/` in the Axomwork monorepo this package is built from.
+This README is a front page, not the manual. For the full command reference (arguments, exit codes, examples) and architecture notes, see `docs/guide/modules/cli.md` and `guide/en/agent-integration/axom-cli/` in the Axomwork monorepo this package is built from.

package/dist/authScopes.js

@@ -0,0 +1,19 @@
+export const DEFAULT_CLI_SCOPES = ['record_query', 'record_write', 'execute', 'task', 'workstation'];
+/**
+ * Requested by `axom auth` but left unchecked on the consent page (the server preselects only
+ * the client's defaults). app_studio and setting_platform are shown locked for non-admins.
+ */
+export const OPTIONAL_CLI_SCOPES = ['app_studio', 'setting_user', 'setting_platform'];
+export function cliRequestedScopes(cowork = false) {
+    return [...DEFAULT_CLI_SCOPES, ...OPTIONAL_CLI_SCOPES, ...(cowork ? ['cowork'] : [])];
+}
+export function grantedCliScopes(scope, requested) {
+    if (typeof scope !== 'string' || !scope.trim()) {
+        throw new Error('Server does not report granted scopes; upgrade the server before authorizing this CLI.');
+    }
+    const granted = [...new Set(scope.trim().split(/ +/))];
+    if (granted.some((value) => !requested.includes(value))) {
+        throw new Error('Server returned unsupported or unrequested scopes; upgrade the server and authorize again.');
+    }
+    return granted;
+}

package/dist/axom-patch/cli/README.md

@@ -0,0 +1,110 @@
+# CLI / adapter 补丁说明
+
+## 自动应用与交付
+
+`runtime.json` 是随 CLI 发布的可信补丁策略，不从 agent 响应或网络下载补丁代码。
+`npm run build` 编译 CLI 后自动复制本目录到 `dist/axom-patch/cli`；打包前检查内容一致。
+Gradle 将带补丁的 npm 包、size/SHA-512 与自动分发标记封装为 Server 的 Client release。
+Workstation Docker 同样携带这份策略；普通 CLI 安装/Server 下发更新不依赖 npm postinstall。
+
+覆盖与发布包补丁都用同一套版本条件选择生效范围，二选一，加载时校验：
+
+| | 覆盖（读 registry 版本） | 发布包补丁（读被改的包版本） |
+|---|---|---|
+| when：只在列出的版本 | `when_registry_version: ["0.86.0"]` | `versions: ["0.84.0"]`；原文件哈希不符即报错 |
+| until：低于某版本 | `until_registry_version: "0.86.1"`，registry 读不懂时照样生效 | `until_version: "0.86.1"`；原文件哈希不符的版本按上游启动并告警 |
+| 都不写 | 一直生效，直到删除 | 不允许 |
+
+when 用于「这个版本有问题、已有修复版」，registry 一换版本就不再生效；until 用于「等上游发某个版本」，
+钉住的版本必须排在界限之前。两种都不需要为让位再发 CLI。
+
+用户按正常界面安装/更新适配器即可：补充条目（Kimi Code、Command Code、ZCode）、分发源覆盖和启动环境变量通过 catalog 应用，
+roster、Install、Update、启动统一读取同一来源。
+发布包代码补丁由 `managedPatches.ts` 在 Install/Update 和首次真实启动时应用。
+历史安装也会补齐，配置显式 command 的用户自有启动程序按其配置执行。
+
+发布包补丁步骤：
+
+1. 按包名与精确版本选择已验证补丁；不支持的版本按上游启动，并在维护日志提示复核。
+2. 缓存缺包时走现有 npm 安装机制；原文件身份与 SHA-256 不符合时安装/启动失败，不能声称补丁已生效。
+3. 复制完整 adapter 及其依赖到 Axom 管理的临时目录，检查修改前/后哈希。
+4. 写 `axom-patches.json` 收据，原子发布副本，从包声明的入口启动。
+5. 缓存身份为「包名、版本、补丁内容哈希」；并发复用并保留各次启动参数/环境。
+
+副本位于 Workstation config dir 的 `acp-adapters/patched-npm/`。
+npm 原缓存保持原样；已有旧副本保留给仍运行的会话。后续 CLI 移除配方后，新启动自动改走原发布包。
+用户无需运行 patch、修改 npm 缓存或单独配置补丁目录。
+
+## Agent catalog（`registry/catalog.ts`）
+
+catalog 是 Axom 对官方 ACP registry 的本地扩展层，随 CLI 发布：条目在 catalog 里 = 真机验证过
+（roster 的 `curated`），设置页展开区只放 catalog 条目，其余官方条目折叠在 "Unverified Agents"。
+它能做的事：静态推荐（`recommended`：claude、codex、pi）、补充/取代官方条目（`supplement` /
+`supersedes`）、钉版本与启动环境（`distribution` / `launchEnv`，临时的放 `runtime.json`）、
+前置依赖（`prerequisite`）、本地检测（`detect`）。
+
+**托管与检测分工**：Axom 启动的一律是自己托管、钉版本的那份（npx 缓存、`uv tool dir`、
+`acp-adapters/` 下的二进制），roster 的 `adapterInstalled` 只说这一份。`detect` 只看用户自己的安装
+（PATH 命令或固定文件，不起进程）：检测到就报 `detected`，设置页因"In use on this machine"把它排进推荐位，
+但不算 Axom 已安装、也不拿来启动。前置依赖同样靠 `detect` 判断；缺了且没有 `install`
+（ZCode）时 roster 报 `missingPrerequisite`，设置页不给 Install、只显示 catalog 的提示。
+
+## 当前补丁
+
+| 台账 ID | 状态/应用入口 | AI 核验与下线重点 |
+|---|---|---|
+| kimi-code-distribution | active；catalog.ts 补充条目 `kimi-code`（Kimi Code 2.1.1 官方二进制，六平台 tar.gz + sha256），隐藏已归档的 `kimi` | registry#458 合入后补充条目自动让位、版本由 registry 跟进；验证 Install/Update、复用登录后删除 supplement |
+| command-code-distribution | active；catalog.ts 补充条目 `command-code`（npx `command-code@1.74.3 acp`） | registry 收录后自动让位；确认 registry 版本带 `acp` 子命令后删除 supplement |
+| zcode-acp-distribution | active；catalog.ts 补充条目 `zcode-acp`（npx `zcode-acp-server@0.63.0`），前置依赖 ZCode 本体 | registry#566/#650 合入后自动让位；删除 supplement 时保留 prerequisite |
+| claude-plan-tools | active；启动任务清单工具变量 | 无变量真实 ACP 会话能发布 plan 后下线 |
+| codex-plan-tools | active；CODEX_CONFIG 的 update_plan 开关 | 无覆盖真实 ACP 会话能发布 plan；保留显式用户配置优先级 |
+| claude-async-task-preview | active；registry 为 0.86.0 时钉 0.86.1-preview.2（`when_registry_version`） | 上游 #1249：不再从前台 Bash 文本猜后台任务、已结束 child 的 async 终态照常送达。registry 换成其他版本即不生效，确认正式版含修复后删除本条 |
+| claude-late-async-terminal | retired；0.84.0/0.85.0 配方已删除 | 修复由上游 #1249 带入预览版并被采用；探针在无补丁预览版 6/6 通过 |
+| acp-sdk-draft-variants | active；draftInterceptor / draftSubagents | 发布 SDK 接收 subagent/async 变体后，验证真实通知流，再替换对应边界 |
+| acp-sdk-foreign-session | active；draftInterceptor | SDK 能路由不是当前客户端主动打开的子会话；仅支持 draft 类型不足以下线 |
+| acp-sdk-capability-fields | active；acpClient / draftSubagents | 无兼容桥 initialize 能保留 subagents，且 AIR vendor 能力协商仍有效 |
+| qoder-subagent-origin / qoder-subagent-subwork | active；原生 Qoder 1.1.61 包补丁保留 `_meta.qoder`，适配器归一到 subwork | 无补丁版本的并发过程、终态、load/resume/重连全部通过后，删除包配方与边界；core/App 不加 Qoder 分支 |
+| acp-registry-etarget | active；版本不存在时单次回退 | 上游版本可安装时自然不触发；删除整个策略要检查 registry 契约 |
+| claude-steering | draft；steering/ 的两份旧版 diff | 0.76/0.77 草案未经完整运行时验证，不自动应用；重新测 E1–E3 |
+| codex-steering | draft；steering/ 的旧版 diff | 1.10/1.11 草案不适用于当前新版，不自动应用；重新测 E1–E3 |
+
+每条完整路径、版本哈希、上游链接、删除条件与验证项见 [台账](../manifest.json)。
+steering diff 原样来自历史 notes；维护本目录文件及台账哈希，历史归档保留实验上下文。
+
+## 验证
+
+```bash
+cd axom-cli
+npm run build
+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
+```
+
+Claude 的真实 runtime 回归（不启动 Claude 模型、不读取凭据）：
+
+```bash
+node axom-patch/cli/probes/claude-late-async-terminal.mjs /path/to/pristine/claude-agent-acp --expect-bug
+node axom-patch/cli/probes/claude-late-async-terminal.mjs /path/to/fixed/claude-agent-acp   # 例如原版 0.86.1-preview.2
+```
+
+覆盖 completed/failed/stopped × terminalState/terminalPromise 六种晚到终态，同时要求普通 late transcript 仍被过滤。
+下线时必须在**无补丁的新发布包**上跑第二条命令，不要用当前带补丁副本证明上游修复。
+
+Pi 的发布包运行时探针（使用真实 adapter 类，不启动模型、不读取凭据）：
+
+```bash
+node axom-patch/cli/probes/pi-steering.mjs /path/to/pristine/pi-acp --expect-unsupported
+node axom-patch/cli/probes/pi-steering.mjs /path/to/patched/pi-acp
+```
+
+仅已核验的原生 Pi 0.87.1 声明 `supported: true, timings: ["next"]`。其他原生版本不声明能力。
+运行中普通消息因此走既有 NEXT 自动投递；已排队消息仍可手动插话。当前工具先完成，再处理插话。
+空闲、取消中、压缩中返回 `promptRequired`，不提交原生消息。传输异常继续使用现有平台处置。
+队列插话、取消、出队共享独立互斥锁；成功回执后的历史物化和队列删除不可被请求取消打断。
+
+## AI 新增/下线操作
+
+- 新增发布包补丁：提交本目录的 JSON 配方（包名、精确版本、每个文件的原/产物哈希与唯一替换段），
+  加入 runtime.package_patches 和台账，跑原包/补丁对照、安装启动测试与 Client release 打包校验。
+- 新增来源/环境覆盖：修改 runtime.overrides、台账和 catalog 回归，保留 registry/用户显式 env 优先级。
+- 下线：先按统一证据门槛核验，从 runtime 移除策略或替换 SDK 边界，保留回归；台账标 retired 并记录证据。
+- CLI 补丁变化必须 bump CLI npm version。相同版本不会触发 Server 自动升级，不能只改 Server 镜像 tag。

package/dist/axom-patch/cli/pi-steering.json

@@ -0,0 +1,37 @@
+{
+  "id": "pi-steering",
+  "package": "pi-acp",
+  "versions": [
+    "0.0.34"
+  ],
+  "edits": [
+    {
+      "file": "dist/index.js",
+      "before_sha256": "324aeb8bba1228937e16b1326fb3e014e2a625b2dea549dbcd49b006cd5df6a2",
+      "after_sha256": "a4e110853ca8ebbd2ab02cb8d6851df42b606b3b1a68832b8e61a5f6d5611574",
+      "before": "var PiAcpSession = class {",
+      "after": "// Injected into pi-acp 0.0.34. Uses its existing RPC process and ACP prompt ownership.\n// Pi 0.87.1 accepts prompt(streamingBehavior=steer) before streaming events finish.\n// Holding the ACP prompt open also tracks a native continuation admitted at the idle boundary.\nclass AxomPiSteering {\n  constructor(session) {\n    this.session = session;\n    this.tail = Promise.resolve();\n    this.pending = 0;\n    this.requested = false;\n    this.finishing = false;\n    this.settling = null;\n    this.revision = 0;\n  }\n  steer(message, images) {\n    const session = this.session;\n    if (!session.pendingTurn || session.cancelRequested || this.finishing) {\n      return Promise.resolve({ outcome: \"promptRequired\" });\n    }\n    const turn = session.pendingTurn;\n    this.pending++;\n    const operation = this.tail.then(async () => {\n      if (session.pendingTurn !== turn || session.cancelRequested) return { outcome: \"promptRequired\" };\n      const state = await session.proc.getState();\n      if (state?.isStreaming !== true || state?.isCompacting === true) return { outcome: \"promptRequired\" };\n      // No await between checking ACP ownership and starting the native request.\n      if (session.pendingTurn !== turn || session.cancelRequested) return { outcome: \"promptRequired\" };\n      const result = await session.proc.request({ type: \"prompt\", message, images, streamingBehavior: \"steer\" });\n      if (!result.success) return { outcome: \"promptRequired\" };\n      return { outcome: \"injected\" };\n    });\n    this.tail = operation.catch(() => {});\n    return operation.finally(() => {\n      this.pending--;\n      if (!this.pending && this.requested) this.settle();\n    });\n  }\n  settle() {\n    this.requested = true;\n    this.revision++;\n    if (this.pending || this.settling || this.finishing) return this.settling;\n    const session = this.session;\n    const turn = session.pendingTurn;\n    if (!turn) return;\n    const revision = this.revision;\n    this.settling = (async () => {\n      const state = await session.proc.getState();\n      // An old agent_settled notification may arrive during admission of a new native loop.\n      if (this.pending || session.pendingTurn !== turn || state?.isStreaming === true || state?.isCompacting === true) return;\n      this.finishing = true;\n      this.requested = false;\n      try { await session.axomFinishTurn(); }\n      finally { this.finishing = false; }\n    })().catch(error => {\n      if (session.pendingTurn === turn) {\n        session.pendingTurn = null;\n        turn.reject(error);\n      }\n    }).finally(() => {\n      this.settling = null;\n      if (!this.pending && this.requested && this.revision !== revision) this.settle();\n    });\n    return this.settling;\n  }\n}\n\nasync function axomPiSupportsSteering() {\n  const command = getPiCommand(process.env.PI_ACP_PI_COMMAND);\n  const launch = shouldUseShellForPiCommand(command) ? crossSpawn : spawn;\n  return new Promise(resolve => {\n    let output = \"\";\n    let child;\n    try { child = launch(command, [\"--version\"], { stdio: [\"ignore\", \"pipe\", \"ignore\"], env: process.env }); }\n    catch { resolve(false); return; }\n    const timeout = setTimeout(() => { child.kill(); resolve(false); }, 5000);\n    child.stdout.on(\"data\", data => { output += data; });\n    child.on(\"error\", () => { clearTimeout(timeout); resolve(false); });\n    child.on(\"close\", code => { clearTimeout(timeout); resolve(code === 0 && output.trim() === \"0.87.1\"); });\n  });\n}\n\nvar PiAcpSession = class {\n  axomSteering = new AxomPiSteering(this);"
+    },
+    {
+      "file": "dist/index.js",
+      "before_sha256": "a4e110853ca8ebbd2ab02cb8d6851df42b606b3b1a68832b8e61a5f6d5611574",
+      "after_sha256": "4cc9687bd28fda78978b91976d7e9ce968d30e7385be17780d40787be684861e",
+      "before": "  async settleTurn() {\n    await this.publishContextUsage();",
+      "after": "  async settleTurn() {\n    return this.axomSteering.settle();\n  }\n  async axomFinishTurn() {\n    await this.publishContextUsage();"
+    },
+    {
+      "file": "dist/index.js",
+      "before_sha256": "4cc9687bd28fda78978b91976d7e9ce968d30e7385be17780d40787be684861e",
+      "after_sha256": "9257e9ffd319f7605fbac8dab11ba8e83bb0975345f0eb62cec6cf236a58daa0",
+      "before": "  async initialize(params) {\n    const supportedVersion = 1;",
+      "after": "  axomSteeringSupported = false;\n  async extMethod(method, params) {\n    if (method !== \"_session/steering\" || !this.axomSteeringSupported) throw RequestError3.methodNotFound(method);\n    if (!params || typeof params.sessionId !== \"string\" || !Array.isArray(params.prompt)) {\n      throw RequestError3.invalidParams(undefined, \"Invalid steering request\");\n    }\n    const steering = params._meta?.steering;\n    if (steering?.idleBehavior !== undefined && steering.idleBehavior !== \"promptRequired\") {\n      throw RequestError3.invalidParams(undefined, \"Unsupported steering idleBehavior\");\n    }\n    if (steering?.priority !== undefined && steering.priority !== \"next\") {\n      throw RequestError3.invalidParams(undefined, \"Pi steering accepts only next\");\n    }\n    if (params.prompt.some(block => !block || ![\"text\", \"image\", \"resource\", \"resource_link\"].includes(block.type))) {\n      throw RequestError3.invalidParams(undefined, \"Unsupported steering content\");\n    }\n    const session = this.sessions.maybeGet(params.sessionId);\n    if (!session) return { outcome: \"promptRequired\" };\n    const { message, images } = promptToPiMessage(params.prompt);\n    return session.axomSteering.steer(message, images);\n  }\n  async initialize(params) {\n    this.axomSteeringSupported = await axomPiSupportsSteering();\n    const supportedVersion = 1;"
+    },
+    {
+      "file": "dist/index.js",
+      "before_sha256": "9257e9ffd319f7605fbac8dab11ba8e83bb0975345f0eb62cec6cf236a58daa0",
+      "after_sha256": "1ee621825b7e02d74312336fc0f820046bd41fe26455143f6f6e5078a727fa79",
+      "before": "      agentInfo: {\n        name: pkg.name ?? \"pi-acp\",",
+      "after": "      ...(this.axomSteeringSupported ? { _meta: { steering: { supported: true, timings: [\"next\"] } } } : {}),\n      agentInfo: {\n        name: pkg.name ?? \"pi-acp\","
+    }
+  ]
+}

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

@@ -0,0 +1,34 @@
+// 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); };
+    const native = new NativeSubagentRuntime(true, '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/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.61');
+  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,49 @@
+// 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.61');
+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(){');
+const Session = new Function('brr', 'kRs', 'PRs', 'xc', 'Qze', `return class {
+  axomQoderToolOrigins=new Map;toolCallNames=new Map;permissionToolCallIds=new Set;
+  constructor(connection){this.connection=connection;this.id='root';this.context={toolRegistry:{getTool:()=>({kind:'read'})},config:{isTasksEnabled:()=>false}}}
+  supportsTerminalOutput(){return false} async sendPlanUpdate(){}
+  ${helper} ${dispatch}
+}`)(v => ({ toolCallId: v.toolCallId, kind: 'read', rawInput: v.input, status: v.status,
+  _meta: { qoder: { toolName: v.name } } }), () => null,
+  v => ({ toolCallId: v.toolCallId, status: v.isError ? 'failed' : 'completed', rawOutput: v.content }), 'Plan', new Set());
+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);
+await session.dispatchSDKMessage(tool('read-a', 'wrong-agent'));
+assert.equal(events.at(-1).update._meta.qoder.parentToolUseId, undefined);
+console.log('Official Qoder 1.1.61 ACP dispatch: parallel tool/result, child text, root and conflict checks passed');

package/dist/axom-patch/cli/qoder-background-terminal.md

@@ -0,0 +1,81 @@
+# qoder-background-terminal
+
+## 为什么需要
+
+测试环境 Qoder CLI 1.1.61 的后台 Agent 调用在 ACP 中只返回 `async_launched`。
+原生根会话 JSONL 随后收到 `origin.kind=task-notification` 的系统完成通知，但 live ACP
+和 `session/load` 均未提供可供平台确认任务终态的更新。因此任务实际完成，Activity 仍显示
+Waiting / Task result unconfirmed。不是根据主 Agent 的自然语言回答判断完成。
+
+## 补丁边界
+
+实现位于 Workstation 的 ACP 会话边界；不修改 Qoder 二进制，不引入 SDK、数据库表或平台委派。
+仅 initialize 身份 `qoder-cli@1.1.61` 的真实托管会话启用，配置探测不启用。
+按进程有效 HOME、cwd、native session ID 定位 `~/.qoder/projects/<encoded-cwd>/<session>.jsonl`。
+只读当前根会话历史，逐行校验精确 session ID / cwd / 非 sidechain；不打开 `tasks/*.output`
+或其他子任务完整日志。路径中的叶子文件不跟随 symlink。
+
+同时满足以下三项，才沿原有 WireEvent / journal / seq / ack 发出同一 Agent 工具的
+`rawOutput.kind=agent-result` 更新：
+
+1. ACP 已观测到该根会话的后台 Agent 调用，且工具调用返回；cached resume 不重放
+   opening 时，从精确匹配的根 JSONL Agent tool_use 与结构化启动回执恢复相同关系。
+2. 原生结构化启动回执的 tool-use-id 对应该调用，并提供 agentId。
+3. 原生系统 task-notification 的 tool-use-id 对应该调用，含明确终态及结果。
+
+原生 ACP 已提供结构化终态时优先使用它。普通用户文字、其他会话、未知版本/格式不能触发补回。
+不根据标题、消息顺序、主 Agent 回答或超时推测完成。成功、失败、取消按明确通知状态处理；
+失败/取消格式当前由确定性用例验证，真机覆盖以验收报告为准。
+
+每次最多增量读取 4 MiB，读取块 64 KiB，单行上限 2 MiB；最多保存 512 个关联，单个结果
+128 KiB，全部结果 4 MiB，超过限制维持原始状态。当前没有待确认调用时不读文件。
+关闭、连接 abort、读取循环终止即停止定时器。没有文件、格式未知或读取失败不阻塞 ACP。
+重复轮询和同一文件重读不重复发布；重建运行时可重新确认同一工具，但不会创建第二个任务。
+历史补回走正常会话恢复路径，不直接修改数据库。
+
+2026-10-03 真机验收补充：默认 Agent 的输入可不带 `subagent_type`。它只是可选的类型
+文案，不能作为识别任务或跟踪完成通知的必填条件。识别仍要求 Qoder 的工具元数据、
+`kind=think`、prompt 和明确后台标记；非字符串类型仍拒绝。服务端的 Qoder 专用摘要
+投影同步允许该字段缺失，不推测子会话身份。升级验收必须覆盖默认 Agent（省略类型）
+和显式类型两种调用，避免测试只覆盖手工指定 `subagent_type` 的请求。
+
+## 上游升级后如何判断是否保留
+
+版本增加不会自动证明修复。新版本默认不启用此补丁，先使用无补丁 CLI 抓取原始 ACP：
+
+- 后台成功、失败、取消均有可对应 toolCallId 的明确终态及结果；启动回执不是任务终态。
+- 两个同时运行的后台任务乱序完成，状态和结果不会串任务。
+- 主轮次结束后迟到的后台完成仍会发送。
+- 重开旧会话的 session/load 能恢复相同终态，断线恢复不创建重复任务。
+
+全部通过后登记修复版本、原始抓包、无补丁回归和删除提交，再删除模块、调用接线及测试。
+只解决 live 而不解决 load 时不能整体退役。需要对新版本继续兼容时，先重新核验目录编码、
+JSONL 字段及通知格式，再显式扩充版本 gate；不对未知版本自动尝试。
+
+## 本地回归
+
+`npx vitest run src/workstation/qoderAdapter/backgroundTerminal.test.ts src/workstation/acp/acpSession.test.ts`
+以及 CLI 全量测试、typecheck/build/补丁台账校验。此次随 CLI 0.3.2（整合主干 0.3.1）交付，无 npm 发布操作。
+
+## 旧会话详情配套投影
+
+真实 session/load 把同一个 Qoder opening 再次导入为无 turnId 的记录，原调用有唯一 turnId。
+详情原先要求恰好一个 opening，所以即使终态补回也会报 identity ambiguous。
+配套 `qoder-native-replay-detail` 只在 UI 折叠一个有 turn 的原调用及其更晚、无 turn、
+同 owner/call/input/title/locations 和完整 Qoder metadata 的精确副本。数据原样保留，
+多个真实 opening、跨 turn 的重复创建、任何输入或 vendor identity 冲突、其他 provider 的 opening 副本继续拒绝。
+待平台历史导入不再制造重复 opening 且无例外回归通过，再删除这个单独的投影兼容分支。
+此配套修改需要构建并部署 Web / Server，与仅 CLI 的终态修复分开核验。
+
+Cached resume 的补充规则与限制见 [qoder-foreground-output.md](qoder-foreground-output.md)。
+
+
+## 后台结果的到达轮次
+
+2026-10-04 真机复验：session/resume 后按旧 toolCallId 补回两个已完成后台结果，
+不产生重复 opening，但详情控制器曾把更新的到达轮次也当作另一份调用身份，报 ambiguous。
+配套通用详情校验仅允许完整历史中唯一、明确 run_in_background=true 的原调用接收更晚更新；
+更新须同 owner/call/name，kind 不冲突、输入缺省或与原输入完全相等。
+真实重复 opening、前台跨轮复用、修改输入、未知/截断身份与更新早于创建仍拒绝。
+不新增厂商分支，不改任何 provider 的路由或执行控制。新增两个红绿功能测试并真机检查详情。
+这是后台异步结果的正常生命周期校验，独立于 Qoder 补丁，不应随上游补丁退役一并删除。

package/dist/axom-patch/cli/qoder-foreground-output.md

@@ -0,0 +1,41 @@
+# qoder-foreground-output / qoder-cached-resume
+
+## 为什么需要
+
+2026-10-03 原生 Qoder CLI 1.1.61 抓包证实：两个前台 Agent 同时运行时，子任务
+文字/思考全部以根 sessionId 发送，没有 messageId 或归属 metadata。字符串在 ACP
+上线已交错，不能按标题、完成顺序或时间可靠拆回。每个 Agent 的工具最终结果却完整。
+另一个独立问题是 session/load 可能迟到重放历史，平台把它写到新轮次，制造重复 opening。
+本补丁不恢复暂存表，也不把未知来源的文字猜成子会话。
+
+## 行为与限制
+
+只启用 initialize 明确报告 qoder-cli@1.1.61 的进程；Claude、Codex、未知版本原样通过。
+实现位于 qoderAdapter/foregroundOutput.ts，ACP 层只接线。
+
+- 根会话明确发出 Agent 前台调用（background=false 或省略）至所有前台调用终止期间，
+  不投递没有 messageId/metadata 的根文字和思考。工具调用、命令、完整工具结果、权限、
+  配置和有身份的子会话事件原样保留。任务完成后的主回答正常展示。
+- 这是结果优先的降级：无法辨别的实时文字（包括此时可能出现的主 Agent 插话）不会展示；
+  **不宣称恢复完整子任务过程，也不宣称能独立操作这些摘要任务的 Stop/Resume**。
+  出错、取消、轮次结束会解除过滤；不会因 unfinished Agent 永久屏蔽下一轮。
+- 已有平台历史的普通 reconnect 使用官方 session/resume，保留同一个 native sessionId，
+  模型/权限配置来自恢复响应。拒绝恢复时直接报错，不偷偷新建另一段会话。
+- 真正历史接管/backfill、显式 settings load、无 resume 能力继续旧路径。本补丁不以模糊
+  文本去重掩盖这些路径的迟到历史；没有证据声称所有 session/load 都已彻底解决。
+- resume 不回放 opening，故 backgroundTerminalRepair 可从只读根 JSONL 恢复精确后台
+  Agent 输入与启动关系，继续按 tool-use-id 补回明确通知。只发送同一个工具的终态更新，
+  不发送历史 opening、不生成子会话。既有通知可能重新确认相同任务；不是重复执行任务。
+  初次增量扫描完成后，没有待确认任务即停止文件轮询读操作。原有读限制/身份校验仍适用。
+
+## 回归与退役
+
+qoderForegroundBaseline.test.ts 使用真实 ACP transport、原始交错抓包和三前台任务边界；
+覆盖省略类型、失败/取消后续轮、完整结果、主回答、已标识文字、background 不过滤。
+acpAgents.test.ts 覆盖 cached resume / 真正 backfill / settings load 与其他 provider 边界；
+backgroundTerminal.test.ts 覆盖无 opening 回放的后台精确结果恢复。
+
+上游升级后默认不启用。先裸 ACP 测并行前台长文字：必须提供稳定的来源/session/message
+标识，且终态与实际结果正确；再测 reconnect 不产生旧 opening，backfill 仍能取全历史，
+迟到后台通知仍能补全。通过原始抓包、无补丁回归及平台真机后记录版本再删除补丁。
+仅增加 CLI 版本号或最终任务成功不能证明可以退役。

package/dist/axom-patch/cli/qoder-steering.json

@@ -0,0 +1,52 @@
+{
+  "id": "qoder-steering",
+  "package": "@qoder-ai/qodercli",
+  "versions": [
+    "1.1.61"
+  ],
+  "bin": "qodercli",
+  "edits": [
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "88829cdc00f1d435d6b9fb4cd8088d678731a99e8c414cb02159a770ddedc32d",
+      "after_sha256": "b2401c8cae2370a486eae2d14f0d8a39826887886f558982b73ba2c839a9d9a3",
+      "before": "protocolVersion:xbs,authMethods:e,agentInfo:{name:HQ,title:Hn,version:t},agentCapabilities:",
+      "after": "protocolVersion:xbs,authMethods:e,agentInfo:{name:HQ,title:Hn,version:t},_meta:{steering:{supported:true,timings:[\"now\"]}},agentCapabilities:"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "b2401c8cae2370a486eae2d14f0d8a39826887886f558982b73ba2c839a9d9a3",
+      "after_sha256": "d2725132d0ff3bb9a234f7d3a782e463bc6c2637a9e995569c5702ce50130dd4",
+      "before": "async prompt(A){await this.ensureAuthenticated();let e=this.sessions.get(A.sessionId);",
+      "after": "async extMethod(method,params){\n  if(method !== \"_session/steering\") throw as.methodNotFound(method);\n  await this.ensureAuthenticated();\n  if(!params || typeof params.sessionId !== \"string\" || !params.sessionId) throw as.invalidParams(undefined,\"Missing sessionId\");\n  const session=this.sessions.get(params.sessionId);\n  if(!session) throw as.invalidParams(undefined,\"Unknown sessionId\");\n  return session.axomQoderSteer(params);\n}\nasync prompt(A){await this.ensureAuthenticated();let e=this.sessions.get(A.sessionId);"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "d2725132d0ff3bb9a234f7d3a782e463bc6c2637a9e995569c5702ce50130dd4",
+      "after_sha256": "c3fc2dae248e7e9105417fabe289b52609daea7512ca770e4dc9cbd3d2cfdb61",
+      "before": "promptRunning=!1;pendingMessages=[];",
+      "after": "promptRunning=!1;pendingMessages=[];axomQoderSteeringMessages=[];"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "c3fc2dae248e7e9105417fabe289b52609daea7512ca770e4dc9cbd3d2cfdb61",
+      "after_sha256": "88dd0b3900897e3d9737ac63e5261711aa7aa277e4ca4d38ee59bdb987584eb5",
+      "before": "async promptViaQueryEngine(A,e,t,i,n){",
+      "after": "axomQoderSteer(A){\n  const steering=A._meta?.steering;\n  if(steering?.priority !== undefined && steering.priority !== \"now\") throw as.invalidParams(undefined,\"Qoder supports only now steering\");\n  if(steering?.idleBehavior !== undefined && steering.idleBehavior !== \"promptRequired\") throw as.invalidParams(undefined,\"Unsupported steering idleBehavior\");\n  if(!Array.isArray(A.prompt) || !A.prompt.length || A.prompt.some(block=>!block || block.type !== \"text\" || typeof block.text !== \"string\")) throw as.invalidParams(undefined,\"Qoder steering requires text blocks\");\n  const text=A.prompt.map(block=>block.text).join(\"\\n\");\n  if(!text.trim() || text.length > 131072) throw as.invalidParams(undefined,\"Invalid steering text length\");\n  if(this.disposed || !this.active || !this.promptRunning || !this.queryEngine?.activeAbortController || !this.pendingPrompt || this.pendingPrompt.signal.aborted) return {outcome:\"promptRequired\",reason:\"noRunningTurn\"};\n  if(this.axomQoderSteeringMessages.length >= 32) throw as.invalidParams(undefined,\"Too many pending steering messages\");\n  const message={prompt:A.prompt.map(block=>({type:\"text\",text:block.text})),id:mte()};\n  this.axomQoderSteeringMessages.push(message);\n  try{this.queryEngine.abort({source:\"sdk_interrupt\",origin:\"user\"});}\n  catch(error){this.axomQoderSteeringMessages.pop();throw error;}\n  return {outcome:\"injected\"};\n}\nasync promptViaQueryEngine(A,e,t,i,n){\n  let result;\n  try{\n    result=await this.axomQoderPromptOnce(A,e,t,i,n);\n    const originalId=result.userMessageId;\n    while(!e.aborted && !this.disposed && this.active && this.axomQoderSteeringMessages.length){\n      const message=this.axomQoderSteeringMessages.shift();\n      const next=await this.axomQoderPromptOnce(message.prompt,e,mte(),message.id);\n      if(result.usage && next.usage){\n        const inputTokens=result.usage.inputTokens+next.usage.inputTokens;\n        const outputTokens=result.usage.outputTokens+next.usage.outputTokens;\n        next.usage={inputTokens,outputTokens,totalTokens:inputTokens+outputTokens};\n        const models=new Map;\n        for(const item of [...result._meta?.quota?.model_usage??[],...next._meta?.quota?.model_usage??[]]){\n          const prior=models.get(item.model)??{input_tokens:0,output_tokens:0};\n          models.set(item.model,{input_tokens:prior.input_tokens+item.token_count.input_tokens,output_tokens:prior.output_tokens+item.token_count.output_tokens});\n        }\n        next._meta={...next._meta,quota:{token_count:{input_tokens:inputTokens,output_tokens:outputTokens},model_usage:Array.from(models,([model,token_count])=>({model,token_count}))}};\n      }\n      result=next;\n    }\n    return {...result,...(originalId?{userMessageId:originalId}:{})};\n  }finally{this.axomQoderSteeringMessages.length=0;}\n}\nasync axomQoderPromptOnce(A,e,t,i,n){"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "88dd0b3900897e3d9737ac63e5261711aa7aa277e4ca4d38ee59bdb987584eb5",
+      "after_sha256": "e45ea5a46d85285a41739fe391fe83dae491e1de3ba1882452b34e5b1453fab4",
+      "before": "if(!A.includes(\"Operation aborted\"))throw new as(500,A);",
+      "after": "if(!A.includes(\"Operation aborted\")&&!(this.axomQoderSteeringMessages.length&&[\"aborted_tools\",\"aborted_streaming\"].includes(c.terminal_reason)))throw new as(500,A);"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "e45ea5a46d85285a41739fe391fe83dae491e1de3ba1882452b34e5b1453fab4",
+      "after_sha256": "a776c9f78e10cb1231229efebf3364ba0259f40b43bb09de77e2a0fb890f7199",
+      "before": "else if(\"error_during_execution\"===A.subtype&&\"refusal\"!==A.stop_reason){let e=A.errors??[];",
+      "after": "else if(\"error_during_execution\"===A.subtype&&\"refusal\"!==A.stop_reason&&!(this.axomQoderSteeringMessages.length&&[\"aborted_tools\",\"aborted_streaming\"].includes(A.terminal_reason))){let e=A.errors??[];"
+    }
+  ]
+}