@platless/axom-cli 0.1.0 → 0.3.13

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

@@ -0,0 +1,30 @@
+# Qoder 原生 ACP 插话
+
+Qoder 1.1.61 的原生 ACP 将运行中的 `session/prompt` 排队，没有声明或实现
+`_session/steering`。只在实验 SDK adapter 中支持插话，不能让普通 `qoder` 入口出现按钮。
+
+`qoder-steering.json` 在 `qoder-subagent-origin.json` 之后应用，逐步核验官方 npm
+包的 SHA-256。只修改 Axom 拥有的不可变副本，不改用户安装的 CLI 或 npm 缓存。
+原生 ACP 的 new/load/resume、模型、权限、MCP、工具和子任务归属继续由 Qoder 处理。
+
+补丁在 initialize 顶层声明 `_meta.steering={supported:true,timings:["now"]}`，
+并实现 `_session/steering`。文本通过校验后加入当前会话的专用插话队列，调用原生
+QueryEngine.abort 中断当前执行；原有平台 prompt 保持待完成。原生执行收束后，在
+同一个 QueryEngine、历史、配置与平台回合内处理插话，新的回复完成才返回 prompt。
+这会中断尚未完成的工具；不承诺撤销已经完成的文件或命令副作用。
+
+没有运行回合时返回 `promptRequired`，不自行启动无人跟踪的回合。当前仅支持文本和
+`now`；无效输入不打断执行。Stop 与关闭会话优先于插话，真实执行错误继续上报。
+消息队列限 32 条、每条文本限 128 KiB；每次 prompt 收束清理专用队列。它不增加
+数据库字段或第二份 transcript。通用 ACP、服务端和 UI 不增加 Qoder 判断。
+
+目前只认证 npm 1.1.61 这份原文件。新包必须重新核验源文件和运行时语义，不按版本号
+猜兼容。显式 command 覆盖继续尊重用户设置，不偷偷把本地 CLI 换成 managed 包。
+
+当无补丁的原生 Qoder ACP 自己声明并实现相同插话协议，且普通入口的运行中工具、
+消息落点、Stop、load/resume、模型/权限、子任务与完整基线验收通过时，可移除这份
+配方、runtime 引用和台账项；单独 SDK 探针或版本升级不构成移除依据。
+
+验证包括 CLI 的 `nativeSteeringPatch.test.ts`、对官方补丁包执行
+`node axom-patch/cli/probes/qoder-steering.mjs <package>`，以及测试环境普通 `qoder`
+入口的真实模型、REST 和 canvas 界面验收。测试入口名称及具体会话必须写入验收记录。

package/dist/axom-patch/cli/qoder-subagent-origin.json

@@ -0,0 +1,73 @@
+{
+  "id": "qoder-subagent-origin",
+  "package": "@qoder-ai/qodercli",
+  "versions": [
+    "1.1.61"
+  ],
+  "edits": [
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "34875088fd8af9c97e88446cbbfa11bca24c1b6558cec048ac1152bd5486f4e9",
+      "after_sha256": "b29a975245a7194ef2ac4f2a742090d9e0d8f64ba3471bae475a564ee96600c1",
+      "before": "toolCallNames=new Map;",
+      "after": "toolCallNames=new Map;axomQoderToolOrigins=new Map;"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "b29a975245a7194ef2ac4f2a742090d9e0d8f64ba3471bae475a564ee96600c1",
+      "after_sha256": "8d6dac333c191312ffdd5180554279dc168405cffc3720833f21139f9242d5fe",
+      "before": "async sendUpdate(A){let e={sessionId:this.id,update:A};await this.connection.sessionUpdate(e)}",
+      "after": "axomQoderId(value){return typeof value === \"string\" && value.length > 0 && value.length <= 256 && !/[\\x00-\\x1f\\x7f]/.test(value)}\naxomQoderObserveSdk(message){\n  if(message.type !== \"assistant\" || !Array.isArray(message.message?.content)) return;\n  const parent=message.parent_tool_use_id;\n  if(parent !== null && !this.axomQoderId(parent)) return;\n  for(const block of message.message.content){\n    if(block?.type !== \"tool_use\" || !this.axomQoderId(block.id) || !this.axomQoderId(block.name)) continue;\n    const prior=this.axomQoderToolOrigins.get(block.id);\n    if(this.axomQoderToolOrigins.has(block.id)){\n      if(prior && (prior.parent !== parent || prior.name !== block.name)) this.axomQoderToolOrigins.set(block.id,null);\n      continue;\n    }\n    if(this.axomQoderToolOrigins.size >= 4096) continue;\n    this.axomQoderToolOrigins.set(block.id,{parent,name:block.name});\n  }\n}\naxomQoderSdkUpdate(message,update){\n  if(this.axomQoderId(message.parent_tool_use_id)) update={...update,_meta:{...update._meta,qoder:{...update._meta?.qoder,version:1,source:\"native-acp-patch\",parentToolUseId:message.parent_tool_use_id,route:\"child\"}}};\n  return this.sendUpdate(update);\n}\nasync sendUpdate(A){\n  if(A.sessionUpdate === \"tool_call\" || A.sessionUpdate === \"tool_call_update\"){\n    const origin=this.axomQoderToolOrigins.get(A.toolCallId);\n    if(origin) A={...A,_meta:{...A._meta,qoder:{...A._meta?.qoder,version:1,source:\"native-acp-patch\",toolName:origin.name,...(origin.parent ? {parentToolUseId:origin.parent,route:\"child\"} : {})}}};\n  }\n  let e={sessionId:this.id,update:A};await this.connection.sessionUpdate(e)\n}"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "8d6dac333c191312ffdd5180554279dc168405cffc3720833f21139f9242d5fe",
+      "after_sha256": "c606c209aa5c89afacb411c68acc071817de29dc31fe0978e7c22e713eaba5cd",
+      "before": "async dispatchSDKMessage(A){switch(A.type){",
+      "after": "async dispatchSDKMessage(A){this.axomQoderObserveSdk(A);switch(A.type){"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "c606c209aa5c89afacb411c68acc071817de29dc31fe0978e7c22e713eaba5cd",
+      "after_sha256": "fa8a112848de34c682943d97a6f59c3eb6c882d388c9478c7edf2c7ae6597973",
+      "before": "await this.sendUpdate({sessionUpdate:\"agent_message_chunk\",content:{type:\"text\",text:e.delta.text}})",
+      "after": "await this.axomQoderSdkUpdate(A,{sessionUpdate:\"agent_message_chunk\",content:{type:\"text\",text:e.delta.text}})"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "fa8a112848de34c682943d97a6f59c3eb6c882d388c9478c7edf2c7ae6597973",
+      "after_sha256": "9b0bce311b17ac72f1bcdda18bc587d7cc5383994ca56893085e1568b57f5940",
+      "before": "await this.sendUpdate({sessionUpdate:\"agent_thought_chunk\",content:{type:\"text\",text:e.delta.thinking}})",
+      "after": "await this.axomQoderSdkUpdate(A,{sessionUpdate:\"agent_thought_chunk\",content:{type:\"text\",text:e.delta.thinking}})"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "9b0bce311b17ac72f1bcdda18bc587d7cc5383994ca56893085e1568b57f5940",
+      "after_sha256": "c5af49f3d42a8f525af8813b97b93078fa0bc3433e7331b47b55cd9a13b7b0d9",
+      "before": "async streamHistory(A){let e=gnd(A);for(let t of A){",
+      "after": "async streamHistory(A){let e=gnd(A);for(let t of A){this.axomQoderObserveSdk(t);"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "c5af49f3d42a8f525af8813b97b93078fa0bc3433e7331b47b55cd9a13b7b0d9",
+      "after_sha256": "5a4a47e3812f5cef51847852b400bab9d74acfd4932c890d9072c0ec58a552a9",
+      "before": "await this.sendUpdate({sessionUpdate:\"user_message_chunk\",content:{type:\"text\",text:A},messageId:t.uuid})",
+      "after": "await this.axomQoderSdkUpdate(t,{sessionUpdate:\"user_message_chunk\",content:{type:\"text\",text:A},messageId:t.uuid})"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "5a4a47e3812f5cef51847852b400bab9d74acfd4932c890d9072c0ec58a552a9",
+      "after_sha256": "0041e7a85e0ed7a8a811c7fd5b2cc7f7df710b529e087af319411a8cbd5a481d",
+      "before": "await this.sendUpdate({sessionUpdate:\"agent_message_chunk\",content:{type:\"text\",text:A},messageId:t.uuid})",
+      "after": "await this.axomQoderSdkUpdate(t,{sessionUpdate:\"agent_message_chunk\",content:{type:\"text\",text:A},messageId:t.uuid})"
+    },
+    {
+      "file": "bundle/qodercli.js",
+      "before_sha256": "0041e7a85e0ed7a8a811c7fd5b2cc7f7df710b529e087af319411a8cbd5a481d",
+      "after_sha256": "88829cdc00f1d435d6b9fb4cd8088d678731a99e8c414cb02159a770ddedc32d",
+      "before": "await this.sendUpdate({sessionUpdate:\"agent_thought_chunk\",content:{type:\"text\",text:A.thinking},messageId:t.uuid})",
+      "after": "await this.axomQoderSdkUpdate(t,{sessionUpdate:\"agent_thought_chunk\",content:{type:\"text\",text:A.thinking},messageId:t.uuid})"
+    }
+  ],
+  "bin": "qodercli"
+}

package/dist/axom-patch/cli/qoder-subagent-subwork.md

@@ -0,0 +1,73 @@
+# qoder-subagent-origin / qoder-subagent-subwork
+
+## 为什么需要
+
+Qoder CLI 1.1.61 的内部运行流已经带 `parent_tool_use_id`，但它自己的 ACP
+`dispatchSDKMessage` / `streamHistory` 在生成文字、思考和工具事件时丢掉了这个字段。
+因此原生 `qodercli --acp` 的子任务 Read / Bash 出现在主会话。ACP 上层无法从时间、
+标题或返回顺序补出可靠关系，尤其不能拆解并发任务。
+
+此前只在 Axom 的 SDK adapter 里加 `_meta.qoder`，没有覆盖用户正在用的原生入口。
+那个实验能证明 SDK 归属信息存在，但不能证明原生入口已经修好。
+
+## 补丁的位置与行为
+
+1. `qoder-subagent-origin.json` 对官方 npm `@qoder-ai/qodercli@1.1.61` 的
+   `bundle/qodercli.js` 做精确版本、原文件及每一步产物 SHA-256 校验。
+   在 Qoder 原生 ACP 转换层保留每个工具的父 ID，在文字/思考及历史事件上写
+   `_meta.qoder={version:1,source:"native-acp-patch",parentToolUseId,route:"child"}`。
+   根工具保留工具名和补丁版本，但不伪造父 ID。冲突和容量不足不猜归属。
+2. `qoderAdapter/subwork.ts` 消费该元数据，生成已有的 ACP
+   `subagent_spawned` / `subagent_state_update`，并给 child item 填确定性地址：
+   `qoder-agent:<root native sessionId>:<Agent toolCallId>`。
+   解析器仍在根进程；任务正文、执行工具、结果和带身份的文字/思考落在 subwork。
+3. Agent 工具调用被归一为同一个 subwork 派发与结果，不再额外产生委派摘要卡。
+   后台 `async_launched` 只是启动回执，不能据此结束子工作；已存在的后台真实终态修补
+   走同一归一入口。权限回调保持原生根会话的请求/回答路径，不启用独立子任务控制。
+
+服务端、数据库、公共工作模型及 App 不新增 Qoder 判断；此次新增的核心 Qoder
+元数据分支已经撤回。通用 ACP 会话只接线到 Qoder 自己的边界。
+
+## 分发和版本门槛
+
+`runtime.json` 引用补丁配方。`managedPatches.ts` 在 Install/Update/首次 managed
+launch 时复制完整 npm 包及依赖，校验并写收据，启动不可变副本。npm 原缓存和用户
+原有 Qoder 二进制保持原样。Qoder 包同时发布 `qodercli` 和 dispatcher 两个 bin，
+配方显式选择 `bin:"qodercli"`；通用补丁加载器只增加可信配方的 bin 选择能力。
+没有显式 bin 的其他补丁仍执行原来的单入口检查。
+
+- 只认证原生 Qoder CLI 1.1.61 的这份发布包，不把 1.1.64 当作兼容版本。
+- CLI 版本 bump 到 0.3.7，补丁跟随正常 Client release 分发。
+- 显式自定义 command 按用户配置运行，不会偷偷替换用户二进制。要启用原生补丁，
+  工作站 Qoder 项使用 catalog 管理的原生 npm ACP 入口（清除旧二进制 command/args）。
+- 继续走 Qoder 原生 ACP 的 new/load/resume、模型和权限模式；不把原生会话切换到
+  不支持恢复的 SDK adapter。已有历史不追溯猜分或改写；修复后的新事件才按证据分流。
+- SDK adapter 的既有实验同样可经过本边界，但不是原生入口验收的替代品。
+
+## 什么时候可以移除
+
+当无补丁的 Qoder ACP 能发送稳定的派生关系、每帧子任务归属、真实终态以及可回放
+的同一关系，并通过并发乱序、失败/取消、后台迟到、load/resume/重连验收后：删除
+配方、runtime 引用、Qoder subwork 归一器和接线，台账标 retired。继续保留通用
+ACP/Claude/Codex 基线。不以升级版本号或主 Agent 返回成功作为移除依据。
+
+## 验证
+
+```bash
+cd axom-cli
+npm test
+cd ..
+node axom-patch/cli/probes/qoder-subagent-origin.mjs /path/to/patched/qoder-package
+AXOM_BASELINE_SQLITE_BIN=/path/to/new-sqlite/bin \
+AXOM_BASELINE_PYTHON_BIN=/path/to/new-python/bin scripts/test-acp-baseline.sh
+```
+
+运行时探针执行官方 bundle 里实际的 ACP dispatch 方法，验证并发 child 的工具与
+结果、文字、根输出和冲突边界；不启动模型、不读取凭据。真实功能验收必须另经
+测试工作站、服务端、数据库、REST 和页面，记录具体会话。fixture 通过不等于上线验收。
+
+## 原生后台过程补齐
+
+Qoder 1.1.61 不向主 ACP 流转发后台子任务的 SDK 消息。`backgroundProcess.ts` 只读轮询经过原生启动回执确认的 `agent-<agentId>.jsonl`；每行必须同时匹配 native session、cwd、agentId、parent_tool_use_id、isSidechain 与版本。只发出实际记录的工具调用、结果、思考和回复，经 `_meta.qoder` 进入同一 subwork 边界。父会话空闲后仍可接收这些项；完成状态继续采用原生 task-notification，不从最后一条文本推断完成。
+
+解析有单行、单轮字节与行数上限，拒绝符号链接、未知工具结果与不完整行，并按原生 uuid 去重。这一补齐针对本次已观察的后台调用；历史未观察任务不会被猜测迁移。上游转发后台消息后应移除 transcript 轮询，并保留并行归属和晚到事件验收。

package/dist/axom-patch/cli/runtime.json

@@ -0,0 +1,37 @@
+{
+  "schema_version": 1,
+  "overrides": [
+    {
+      "id": "claude-async-task-preview",
+      "agent": "claude-acp",
+      "distribution": {
+        "version": "0.86.1-preview.2",
+        "npx": {
+          "package": "@agentclientprotocol/claude-agent-acp@0.86.1-preview.2"
+        }
+      },
+      "when_registry_version": [
+        "0.86.0"
+      ]
+    },
+    {
+      "id": "claude-plan-tools",
+      "agent": "claude-acp",
+      "env": {
+        "CLAUDE_CODE_ENABLE_TODO_TOOLS": "1"
+      }
+    },
+    {
+      "id": "codex-plan-tools",
+      "agent": "codex-acp",
+      "env": {
+        "CODEX_CONFIG": "{\"tools\":{\"update_plan\":{\"enabled\":true}}}"
+      }
+    }
+  ],
+  "package_patches": [
+    "pi-steering.json",
+    "qoder-subagent-origin.json",
+    "qoder-steering.json"
+  ]
+}

package/dist/axom-patch/cli/steering/claude-steering-js.patch

@@ -0,0 +1,89 @@
+--- a/dist/acp-agent.js
++++ b/dist/acp-agent.js
+@@ -180,12 +180,29 @@
+     return { sessionId, asyncTaskId };
+ }
+ /** How urgently the SDK delivers a steered message relative to the running
+- *  turn — an internal Claude implementation detail, not part of the wire
+- *  contract. `now` pre-empts the current generation, while `later` waits for a
+- *  pending permission/elicitation callback to settle instead of cancelling its
+- *  ACP request and hiding the client's user-input card (IJAI-1191). */
++ *  turn. `now` pre-empts the current generation, `next` waits for the next
++ *  natural boundary without aborting, and `later` waits for a pending
++ *  permission/elicitation callback to settle instead of cancelling its ACP
++ *  request and hiding the client's user-input card (IJAI-1191).
++ *
++ *  This is both the agent's own default choice and — since the
++ *  `_session/steering` response is identical whichever timing was used, so a
++ *  Host cannot discover the difference by trying — the vocabulary a Host may
++ *  name explicitly through `_meta.steering.priority`. The set is advertised on
++ *  `InitializeResponse._meta.steering.timings` so the capability is declared
++ *  rather than probed. */
+ const STEER_PRIORITY_NOW = "now";
++const STEER_PRIORITY_NEXT = "next";
+ const STEER_PRIORITY_LATER = "later";
++/** The delivery timings this agent accepts on `_meta.steering.priority`, and the
++ *  value advertised as `InitializeResponse._meta.steering.timings`. Both reads
++ *  come from this one array so the accepted set and the advertised set cannot
++ *  drift apart. */
++const STEER_TIMINGS = [
++    STEER_PRIORITY_NOW,
++    STEER_PRIORITY_NEXT,
++    STEER_PRIORITY_LATER,
++];
+ /** Validate raw JSON-RPC params into a {@link SteerRequest}. Kept minimal — the
+  *  content blocks are handed to `promptToClaude`, which tolerates unknown block
+  *  types — but `sessionId` and a non-empty `prompt` array are required. */
+@@ -206,6 +223,16 @@
+         : undefined;
+     if (idleBehavior !== undefined && idleBehavior !== "promptRequired") {
+         throw RequestError.invalidParams(undefined, "unsupported steering idleBehavior");
++    }
++    const priority = steering && typeof steering === "object"
++        ? steering.priority
++        : undefined;
++    // Rejected rather than ignored: a silently dropped priority is
++    // indistinguishable from an honoured one on the response, so a Host that
++    // asked for `next` and got `now` would only find out by losing the running
++    // turn's remaining work.
++    if (priority !== undefined && !STEER_TIMINGS.includes(priority)) {
++        throw RequestError.invalidParams(undefined, "unsupported steering priority");
+     }
+     return {
+         sessionId,
+@@ -947,6 +974,10 @@
+                 ...airSessionFailureCapabilityMeta(AGENT_FILE_CHANGE_REPORT_CAPABILITY, AIR_NATIVE_SUBAGENT_SESSIONS_CAPABILITY, AIR_ASYNC_TASKS_CAPABILITY, AIR_RECOMMENDED_CONFIG_VALUE_CAPABILITY),
+                 steering: {
+                     supported: true,
++                    // The timings a Host may name on `_meta.steering.priority`
++                    // (see STEER_TIMINGS). Declared, not probed: the response to
++                    // `_session/steering` is the same whichever timing was used.
++                    timings: [...STEER_TIMINGS],
+                 },
+                 goal: {
+                     version: GOAL_EXTENSION_VERSION,
+@@ -1758,9 +1789,22 @@
+         const steeredUuid = randomUUID();
+         userMessage.uuid = steeredUuid;
+         // Deliver into the running turn rather than queuing behind it as a fresh
+-        // prompt would.
++        // prompt would. With no priority in `_meta` this is byte-for-byte the
++        // established behavior: `now`, held back to `later` only while a
++        // permission/elicitation callback is awaiting input.
++        const defaultPriority = (session.pendingUserInputCount ?? 0) > 0
++            ? STEER_PRIORITY_LATER
++            : STEER_PRIORITY_NOW;
++        // A Host that named a timing gets it, with one exception: an explicit
++        // `now` is still held back while a callback is awaiting input, because
++        // pre-empting ABORTS the cycle, which cancels that ACP request and can
++        // strand the prompt (IJAI-1191). `next` and `later` never pre-empt, so
++        // they carry no such hazard and are honoured verbatim.
++        const requestedPriority = params._meta?.steering?.priority;
+         userMessage.priority =
+-            (session.pendingUserInputCount ?? 0) > 0 ? STEER_PRIORITY_LATER : STEER_PRIORITY_NOW;
++            requestedPriority === undefined || requestedPriority === STEER_PRIORITY_NOW
++                ? defaultPriority
++                : requestedPriority;
+         // Mark before the push and in the same synchronous section as the in-flight
+         // check: the interrupt can have the CLI finalizing the aborted cycle by the
+         // time the consumer next runs, and an unmarked result would settle the turn

package/dist/axom-patch/cli/steering/claude-steering-types.patch

@@ -0,0 +1,28 @@
+--- a/dist/acp-agent.d.ts
++++ b/dist/acp-agent.d.ts
+@@ -47,17 +47,22 @@
+     stopped: boolean;
+ };
+ /** Request-level steering options. `promptRequired` is opt-in so existing Hosts
+- *  keep the established idle fallback behavior. */
++ *  keep the established idle fallback behavior, and `priority` is optional so a
++ *  Host that names none keeps the agent's established default. */
+ type SteerMeta = {
+     [key: string]: unknown;
+     steering?: {
+         idleBehavior?: "promptRequired";
++        priority?: SteerTiming;
+     };
+ };
++/** A delivery timing a Host may name on {@link SteerMeta}, and a member of the
++ *  set advertised as `InitializeResponse._meta.steering.timings`. */
++export type SteerTiming = "now" | "next" | "later";
+ /** Params of a {@link STEER_METHOD} request. Shaped like the relevant subset of
+  *  a `PromptRequest` so the same `promptToClaude` conversion applies. Delivery
+- *  priority is deliberately NOT exposed here — it's an internal detail the agent
+- *  chooses (see {@link STEER_PRIORITY}). */
++ *  priority is the agent's own choice (see {@link STEER_TIMINGS}) unless the
++ *  Host names one it advertised. */
+ export type SteerRequest = {
+     sessionId: string;
+     prompt: PromptRequest["prompt"];

package/dist/axom-patch/cli/steering/codex-steering.patch

@@ -0,0 +1,57 @@
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -31723,6 +31723,20 @@
+ // src/AcpExtensions.ts
+ var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
+ var SESSION_STEERING_METHOD = "_session/steering";
++/**
++ * The delivery timings this agent accepts on a `_session/steering` request's
++ * `_meta.steering.priority`, and the value advertised as
++ * `InitializeResponse._meta.steering.timings`. Both reads come from this one
++ * array so the accepted set and the advertised set cannot drift apart.
++ *
++ * `now` is the only entry because injecting into the live turn is the only
++ * thing this adapter can ask the app-server for: `turn/steer` carries no timing
++ * field. A Host that needs `next` (deliver at a boundary without discarding the
++ * running turn's remaining work) must hold the message itself; declaring the
++ * set is what lets it know that without having to try and lose work finding
++ * out.
++ */
++var SESSION_STEERING_TIMINGS = ["now"];
+ function isExtMethodRequest(request) {
+   return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === LEGACY_GOAL_CONTROL_METHOD || request.method === SESSION_STEERING_METHOD || request.method === ASYNC_TASK_STOP_METHOD;
+ }
+@@ -32334,7 +32348,11 @@
+       authMethods: getCodexAuthMethods(_params.clientCapabilities),
+       _meta: {
+         steering: {
+-          supported: true
++          supported: true,
++          // Declared, not probed: `_session/steering` answers the same
++          // `{outcome}` whichever timing was used, so a Host cannot discover
++          // this by trying. See SESSION_STEERING_TIMINGS.
++          timings: [...SESSION_STEERING_TIMINGS]
+         },
+         goal: {
+           version: GOAL_EXTENSION_VERSION,
+@@ -33502,6 +33520,20 @@
+     const prompt = params["prompt"];
+     if (typeof sessionId !== "string" || !Array.isArray(prompt)) {
+       throw RequestError.invalidParams();
++    }
++    // `_meta` reaches us because sessionSteerParamsParser passes unknown keys
++    // through. A priority outside the advertised set is REJECTED rather than
++    // ignored: the `{outcome}` this method answers is identical either way, so
++    // a Host that asked for a timing we cannot honour would otherwise learn it
++    // only by losing the running turn's remaining work.
++    const meta = params["_meta"];
++    const steering = meta && typeof meta === "object" ? meta["steering"] : void 0;
++    const priority = steering && typeof steering === "object" ? steering["priority"] : void 0;
++    if (priority !== void 0 && !SESSION_STEERING_TIMINGS.includes(priority)) {
++      throw RequestError.invalidParams(
++        void 0,
++        `Unsupported steering priority; this agent accepts ${SESSION_STEERING_TIMINGS.join(", ")}`
++      );
+     }
+     return {
+       sessionId,

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

@@ -0,0 +1,79 @@
+// Injected into pi-acp 0.0.34. Uses its existing RPC process and ACP prompt ownership.
+// Pi 0.87.1 accepts prompt(streamingBehavior=steer) before streaming events finish.
+// Holding the ACP prompt open also tracks a native continuation admitted at the idle boundary.
+class AxomPiSteering {
+  constructor(session) {
+    this.session = session;
+    this.tail = Promise.resolve();
+    this.pending = 0;
+    this.requested = false;
+    this.finishing = false;
+    this.settling = null;
+    this.revision = 0;
+  }
+  steer(message, images) {
+    const session = this.session;
+    if (!session.pendingTurn || session.cancelRequested || this.finishing) {
+      return Promise.resolve({ outcome: "promptRequired" });
+    }
+    const turn = session.pendingTurn;
+    this.pending++;
+    const operation = this.tail.then(async () => {
+      if (session.pendingTurn !== turn || session.cancelRequested) return { outcome: "promptRequired" };
+      const state = await session.proc.getState();
+      if (state?.isStreaming !== true || state?.isCompacting === true) return { outcome: "promptRequired" };
+      // No await between checking ACP ownership and starting the native request.
+      if (session.pendingTurn !== turn || session.cancelRequested) return { outcome: "promptRequired" };
+      const result = await session.proc.request({ type: "prompt", message, images, streamingBehavior: "steer" });
+      if (!result.success) return { outcome: "promptRequired" };
+      return { outcome: "injected" };
+    });
+    this.tail = operation.catch(() => {});
+    return operation.finally(() => {
+      this.pending--;
+      if (!this.pending && this.requested) this.settle();
+    });
+  }
+  settle() {
+    this.requested = true;
+    this.revision++;
+    if (this.pending || this.settling || this.finishing) return this.settling;
+    const session = this.session;
+    const turn = session.pendingTurn;
+    if (!turn) return;
+    const revision = this.revision;
+    this.settling = (async () => {
+      const state = await session.proc.getState();
+      // An old agent_settled notification may arrive during admission of a new native loop.
+      if (this.pending || session.pendingTurn !== turn || state?.isStreaming === true || state?.isCompacting === true) return;
+      this.finishing = true;
+      this.requested = false;
+      try { await session.axomFinishTurn(); }
+      finally { this.finishing = false; }
+    })().catch(error => {
+      if (session.pendingTurn === turn) {
+        session.pendingTurn = null;
+        turn.reject(error);
+      }
+    }).finally(() => {
+      this.settling = null;
+      if (!this.pending && this.requested && this.revision !== revision) this.settle();
+    });
+    return this.settling;
+  }
+}
+
+async function axomPiSupportsSteering() {
+  const command = getPiCommand(process.env.PI_ACP_PI_COMMAND);
+  const launch = shouldUseShellForPiCommand(command) ? crossSpawn : spawn;
+  return new Promise(resolve => {
+    let output = "";
+    let child;
+    try { child = launch(command, ["--version"], { stdio: ["ignore", "pipe", "ignore"], env: process.env }); }
+    catch { resolve(false); return; }
+    const timeout = setTimeout(() => { child.kill(); resolve(false); }, 5000);
+    child.stdout.on("data", data => { output += data; });
+    child.on("error", () => { clearTimeout(timeout); resolve(false); });
+    child.on("close", code => { clearTimeout(timeout); resolve(code === 0 && output.trim() === "0.87.1"); });
+  });
+}

package/dist/cli.js

@@ -25,7 +25,8 @@ export function buildProgram() {
         .command('auth')
         .description('Authorize axom-cli with an Axomwork server')
         .option('--server <url>', 'Axomwork server URL')
-        .action((options) => runCommand(() => authAction({ server: options.server ?? serverOption() })));
+        .option('--cowork', 'Request delegated cowork session access')
+        .action((options) => runCommand(() => authAction({ server: options.server ?? serverOption(), cowork: options.cowork })));
     program
         .command('whoami')
         .description('Print the authenticated Axomwork user')
@@ -38,6 +39,13 @@ export function buildProgram() {
     program
         .command('__credential-broker', { hidden: true })
         .action(() => runCredentialBroker());
+    program.command('qoder-acp')
+        .description('Run the Qoder SDK ACP adapter over stdio')
+        .requiredOption('--qodercli <path>', 'Explicit Qoder CLI executable')
+        .action(async (options) => {
+        const { runQoderAdapter } = await import('./workstation/qoderAdapter/main.js');
+        await runQoderAdapter(options.qodercli);
+    });
     registerStructCommands(program);
     registerRecordCommands(program);
     registerExecuteCommand(program);

package/dist/commands/auth.js

@@ -2,13 +2,14 @@ import { hostname } from 'node:os';
 import { loadConfig, resolveServer, saveConfig } from '../config.js';
 import { callAxomTool } from '../mcp.js';
 import { authorizeDevice } from '../workstation/oauth/deviceAuthorization.js';
-import { revokeAndClearTokens, saveTokens } from '../credentials.js';
+import { revokeAndClearTokens, revokeRefreshToken, saveTokens } from '../credentials.js';
+import { cliRequestedScopes } from '../authScopes.js';
 export const DEFAULT_SERVER_URL = 'http://localhost:8080';
 export async function authAction(options, deps = {}) {
     const config = await loadConfig();
     const server = resolveServer(config, options.server ?? config.defaultServer ?? DEFAULT_SERVER_URL);
     const host = hostname();
-    const { accessToken, refreshToken, expiresInSeconds } = await authorizeDevice(server, `Axomwork CLI (${host})`, host, deps);
+    const { accessToken, refreshToken, expiresInSeconds, scopes } = await authorizeDevice(server, `Axomwork CLI (${host})`, host, deps, cliRequestedScopes(options.cowork));
     const updated = await loadConfig();
     try {
         await saveTokens(server, { accessToken, refreshToken, expiresAt: new Date(Date.now() + expiresInSeconds * 1000).toISOString() });
@@ -22,6 +23,7 @@ export async function authAction(options, deps = {}) {
         updated.defaultServer = server;
     }
     await saveConfig(updated);
+    console.log(`Authorized scopes: ${scopes.join(', ')}`);
     const outcome = await callAxomTool(server, 'axom__system__whoami', {});
     if (outcome.isError) {
         throw new Error(outcome.text);
@@ -39,14 +41,3 @@ export async function logoutAction(options) {
     await saveConfig(config);
     console.log(`Logged out from ${server}`);
 }
-async function revokeRefreshToken(server, refreshToken) {
-    await fetch(`${server}/oauth/revoke`, {
-        method: 'POST',
-        headers: { 'content-type': 'application/x-www-form-urlencoded' },
-        body: new URLSearchParams({
-            token: refreshToken,
-            token_type_hint: 'refresh_token',
-            client_id: 'axom-cli',
-        }),
-    }).catch(() => undefined);
-}

package/dist/commands/execute.js

@@ -20,9 +20,9 @@ export async function executeAction(options) {
     if (parts.length === 3) {
         const [applicationName, modelName, operationName] = parts;
         printOutcome(
-        // 同步是 axom__*__execute 的固有语义；awaitResult 参数已随 InvocationMode 重构移除，
+        // 同步是 axom__execute__run_* 的固有语义；awaitResult 参数已随 InvocationMode 重构移除，
         // 继续传会被工具的封闭 inputSchema 直接拒掉。
-        await callAxomTool(server, 'axom__operation__execute', {
+        await callAxomTool(server, 'axom__execute__run_operation', {
             applicationName,
             modelName,
             operationName,
@@ -32,9 +32,9 @@ export async function executeAction(options) {
     }
     if (parts.length === 2) {
         const [applicationName, serviceName] = parts;
-        printOutcome(await callAxomTool(server, 'axom__service__execute', { applicationName, serviceName, input }));
+        printOutcome(await callAxomTool(server, 'axom__execute__run_service', { applicationName, serviceName, input }));
         return;
     }
     const [serviceName] = parts;
-    printOutcome(await callAxomTool(server, 'axom__service__execute', { serviceName, input }));
+    printOutcome(await callAxomTool(server, 'axom__execute__run_service', { serviceName, input }));
 }

package/dist/commands/record.js

@@ -45,24 +45,24 @@ export function registerRecordCommands(program) {
 export async function recordGetAction(options) {
     const server = await resolveActionServer(options.server);
     const [applicationName, modelName] = splitPath(options.path, 2, '<app>/<model>');
-    printOutcome(await callAxomTool(server, 'axom__record__get', { applicationName, modelName, id: options.id }));
+    printOutcome(await callAxomTool(server, 'axom__record_query__get_record', { applicationName, modelName, id: options.id }));
 }
 export async function recordCreateAction(options) {
     const server = await resolveActionServer(options.server);
     const [applicationName, modelName] = splitPath(options.path, 2, '<app>/<model>');
     const record = parseJsonArg(options.json, 'record', recordExample);
-    printOutcome(await callAxomTool(server, 'axom__record__create', { applicationName, modelName, record }));
+    printOutcome(await callAxomTool(server, 'axom__record_write__create_record', { applicationName, modelName, record }));
 }
 export async function recordUpdateAction(options) {
     const server = await resolveActionServer(options.server);
     const [applicationName, modelName] = splitPath(options.path, 2, '<app>/<model>');
     const changes = parseJsonArg(options.json, 'record update changes', recordExample);
-    printOutcome(await callAxomTool(server, 'axom__record__update', { applicationName, modelName, id: options.id, changes }));
+    printOutcome(await callAxomTool(server, 'axom__record_write__update_record', { applicationName, modelName, id: options.id, changes }));
 }
 export async function recordUpsertAction(options) {
     const server = await resolveActionServer(options.server);
     const record = parseJsonArg(options.record, 'record', recordExample);
-    printOutcome(await callAxomTool(server, 'axom__record__upsert', {
+    printOutcome(await callAxomTool(server, 'axom__record_write__upsert_record', {
         applicationName: options.applicationName,
         modelName: options.modelName,
         identityField: options.identityField,
@@ -72,7 +72,7 @@ export async function recordUpsertAction(options) {
 export async function recordDeleteAction(options) {
     const server = await resolveActionServer(options.server);
     const [applicationName, modelName] = splitPath(options.path, 2, '<app>/<model>');
-    printOutcome(await callAxomTool(server, 'axom__record__delete', { applicationName, modelName, id: options.id }));
+    printOutcome(await callAxomTool(server, 'axom__record_write__delete_record', { applicationName, modelName, id: options.id }));
 }
 export async function recordQueryAction(options) {
     const server = await resolveActionServer(options.server);
@@ -92,7 +92,7 @@ export async function recordQueryAction(options) {
         args.criteria = queryCriteria;
     if ('page' in criteria)
         args.page = criteria.page;
-    printOutcome(await callAxomTool(server, 'axom__record__query', args));
+    printOutcome(await callAxomTool(server, 'axom__record_query__query_records', args));
 }
 async function resolveActionServer(server) {
     return resolveServer(await loadConfig(), server);

package/dist/commands/struct.js

@@ -23,22 +23,22 @@ export async function structListAction(options) {
         if (options.target !== undefined) {
             throw new UsageError('Expected axom struct list app with no target.');
         }
-        printOutcome(await callAxomTool(server, 'axom__struct__list_applications', {}));
+        printOutcome(await callAxomTool(server, 'axom__app_struct__list_applications', {}));
         return;
     }
     const [applicationName] = splitPath(options.target ?? '', 1, '<applicationName>');
-    printOutcome(await callAxomTool(server, 'axom__struct__list_models', { applicationName }));
+    printOutcome(await callAxomTool(server, 'axom__app_struct__list_models', { applicationName }));
 }
 export async function structGetAction(options) {
     const server = await resolveActionServer(options.server);
     const kind = requireStructKind(options.kind);
     if (kind === 'app') {
         const [applicationName] = splitPath(options.target ?? '', 1, '<applicationName>');
-        printOutcome(await callAxomTool(server, 'axom__struct__get_application', { applicationName }));
+        printOutcome(await callAxomTool(server, 'axom__app_struct__get_application', { applicationName }));
         return;
     }
     const [applicationName, modelName] = splitPath(options.target ?? '', 2, '<applicationName>/<modelName>');
-    printOutcome(await callAxomTool(server, 'axom__struct__get_model', { applicationName, modelName }));
+    printOutcome(await callAxomTool(server, 'axom__app_struct__get_model', { applicationName, modelName }));
 }
 async function resolveActionServer(server) {
     return resolveServer(await loadConfig(), server);