@zhushanwen/pi-subagent-workflow 9.3.0 → 9.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhushanwen/pi-subagent-workflow",
-  "version": "9.3.0",
+  "version": "9.4.0",
   "type": "module",
   "main": "index.ts",
   "description": "Unified subagent execution and multi-agent workflow orchestration for Pi — spawned-process agent runtime with sync/background modes, stateful workflow management with persistence, state machine, and execution tracing.",
@@ -58,22 +58,22 @@
     ]
   },
   "dependencies": {
-    "@zhushanwen/extension-protocol": "0.18.0",
+    "@zhushanwen/extension-protocol": "0.19.0",
     "@zhushanwen/session-delivery": "1.1.0",
     "@zhushanwen/pi-ext-guards": "0.4.3",
     "@zhushanwen/pi-extension-logger": "0.6.2",
-    "@zhushanwen/pi-notify-ledger-host": "0.3.0",
-    "@zhushanwen/subagent-core": "1.3.0",
-    "@zhushanwen/pi-subagent-cli": "0.6.0",
-    "@zhushanwen/zcode-subagent-cli": "0.5.0"
+    "@zhushanwen/pi-notify-ledger-host": "0.3.1",
+    "@zhushanwen/pi-subagent-cli": "0.7.0",
+    "@zhushanwen/zcode-subagent-cli": "0.6.0",
+    "@zhushanwen/subagent-core": "1.4.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^1.0.0",
     "@earendil-works/pi-coding-agent": "^1.0.0",
     "@earendil-works/pi-tui": "^1.0.0",
     "typebox": "1.3.27",
-    "@zhushanwen/pi-pending-notifications": "0.8.2",
-    "@zhushanwen/pi-structured-output": "6.1.0"
+    "@zhushanwen/pi-structured-output": "6.1.0",
+    "@zhushanwen/pi-pending-notifications": "0.8.3"
   },
   "peerDependenciesMeta": {
     "@earendil-works/pi-coding-agent": {
@@ -87,7 +87,7 @@
     "@types/node": "^24.0.0",
     "@vitest/coverage-v8": "^4.1.9",
     "vitest": "^4.1.8",
-    "@zhushanwen/subagent-engine-sdk": "0.9.0"
+    "@zhushanwen/subagent-engine-sdk": "0.10.0"
   },
   "scripts": {
     "typecheck": "npx tsc --noEmit",

package/src/index.ts

@@ -2,7 +2,7 @@
  * subagent-workflow Extension — Factory（extension 装配点）
  *
  * 合并 @zhushanwen/pi-subagents + @zhushanwen/pi-workflow 为统一包。
- * 注册项：4 tool（subagent + subagents + workflow + workflow-script）+ 2 command（subagents + workflows）
+ * 注册项：4 tool（subagent + subagents + workflow + workflow-script）+ 3 command（subagents + workflows + subagent-model）
  * + messageRenderer（subagent-bg-notify）+ session 事件。
  *
  * 包内结构（执行运行时已迁 packages/subagent-core，本包只留注册面与宿主适配）：
@@ -52,6 +52,8 @@ import { registerWorkflowsCommand } from "./interface/command/commands.ts";
 import { registerSubagentTool } from "./interface/tool/subagent-tool.ts";
 // ═══ interface/ 层（tools/commands/tui 合并） ═══
 import { registerSubagentsCommand } from "./interface/command/subagents.ts";
+// [subagent-model-switch U6] 模型切换 RPC 通道消费端（§7.1.1，runtime 出站点 prompt 触达）
+import { registerSubagentModelCommand } from "./interface/command/subagent-model.ts";
 import { registerSubagentsTool } from "./interface/tool/tool-subagents.ts";
 import { registerWorkflowTool } from "./interface/tool/tool-workflow.ts";
 import { registerWorkflowScriptTool } from "./interface/tool/tool-workflow-script.ts";
@@ -143,6 +145,7 @@ export default function subagentsWorkflowExtension(pi: ExtensionAPI): void {
   // ════════════════════════════════════════════════════════════
   registerSubagentTool(pi);
   registerSubagentsCommand(pi);
+  registerSubagentModelCommand(pi);
   pi.registerMessageRenderer(SUBAGENT_BG_NOTIFY_CUSTOM_TYPE, renderBgNotifyMessage);
 
   // ════════════════════════════════════════════════════════════
@@ -226,7 +229,7 @@ export default function subagentsWorkflowExtension(pi: ExtensionAPI): void {
   process.on("beforeExit", reapSpawnedChildrenOnShutdown);
 
   // ════════════════════════════════════════════════════════════
-  //  Tools（3 个）+ Commands（2 个）—— 注册面
+  //  Tools（3 个）+ Commands（3 个）—— 注册面
   //
   //  lazyDeps / isScriptRunning / registry 由 workflow-events.ts 装配结果提供。
   //  guard：workflow tool 与 subagents（批量派发入口）共用同一 guard——两者是同一条

package/src/interface/command/__tests__/commands-resume.test.ts

@@ -1,13 +1,13 @@
 /**
- * /workflows 命令的 resume 通道契约（workflow-run-resume-revision U3）。
+ * /workflows 命令的 resume 通道契约（workflow-run-resume-revision U3 + F1-26 后续项）。
  *
- * 覆盖面（TUI 模式）：/workflows resume <runId> → 执行断点续跑后 notify，不打开
- * 面板；缺 runId → Usage 提示；resumeRun 拒绝 → warning notify 透出恢复指引文案。
+ * 覆盖面（TUI 模式）：/workflows resume <runId> [model] → 执行断点续跑后 notify，
+ * 不打开面板；缺 runId → Usage 提示（含可选 [model]）；resumeRun 拒绝 → warning
+ * notify 透出恢复指引文案；显式 model 的 handler 透传（第三参 { model } / 无 model
+ * 不落键）与目录预检拒单（与 tool 通道同款 D8 语义）。
  *
- * RPC 模式（taiji GUI）的 resume verb 接线未随 U3 落地：解析词表在
- * command-actions.ts（领地外，resume verb 现仍解析为 lifecycle-removed），其
- * dispatch 断言由 src/__tests__/rpc-command-handling.test.ts 原样锁定——词表
- * 适配归编排层（见 commands.ts handleRpcMode 注释）。workflow tool 通道
+ * RPC 模式（taiji GUI）的 resume verb 接线与 model 透传由
+ * src/__tests__/rpc-command-handling.test.ts 覆盖；workflow tool 通道
  * （action:"resume"，含 D14 args 校验）由 tool-workflow-resume.test.ts 覆盖。
  *
  * mock 策略：resume-run 深路径 stub（对齐 tool-workflow-resume.test.ts）；命令
@@ -19,6 +19,7 @@ import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 
 // 被 mock 的模块——import 路径与被测源文件的等值实例（对齐 tool-workflow-resume.test.ts）
 import { resumeRun } from "@zhushanwen/subagent-core/orchestration/resume-run.ts";
+import { setModelConfigService, GLOBAL_SLOT_KEYS } from "@zhushanwen/subagent-core";
 
 import { registerWorkflowsCommand } from "../commands.ts";
 
@@ -66,9 +67,26 @@ function makeCtx(mode: "rpc" | "tui"): { ctx: ExtensionCommandContext; notifies:
   return { ctx: ctx as never, notifies };
 }
 
+/** 重置进程级 ModelConfigService 单例槽（model catalog 预检用例的注入/清理，
+ *  Symbol 直写——key 与生产 getModelServiceSlot 的 MODEL_SERVICE_SLOT_KEY 一致）。 */
+function resetModelServiceSlot(): void {
+  const slot = Reflect.get(globalThis, Symbol.for(GLOBAL_SLOT_KEYS.modelService)) as
+    | { current: unknown }
+    | undefined;
+  if (slot) slot.current = null;
+}
+
+/** 注入目录为 entries 的最小 ModelConfigService fake（duck-typed getAvailable）。 */
+function injectModelServiceWith(entries: Array<{ provider: string; id: string }>): void {
+  setModelConfigService({
+    getModelRegistry: () => ({ getAvailable: () => entries }),
+  } as never);
+}
+
 beforeEach(() => {
   vi.mocked(resumeRun).mockReset();
   vi.mocked(resumeRun).mockResolvedValue("wf-x");
+  resetModelServiceSlot();
 });
 
 // ── TUI 模式 ─────────────────────────────────────────────────
@@ -79,17 +97,44 @@ describe("/workflows TUI resume", () => {
     const { ctx, notifies } = makeCtx("tui");
     await cmd.handler("resume wf-x", ctx);
     expect(vi.mocked(resumeRun)).toHaveBeenCalledWith("wf-x", expect.anything());
+    // 无 model 不落键：调用恰为 (runId, deps) 两参（spread 条件反写不会静默通过）
+    expect(vi.mocked(resumeRun).mock.calls[0]).toHaveLength(2);
     expect(notifies).toHaveLength(1);
     expect(notifies[0]!.msg).toContain("resuming");
     expect(notifies[0]!.level).toBe("info");
   });
 
+  it("resume <runId> <model> → resumeRun 第三参 { model } 透传 + notify 带模型", async () => {
+    injectModelServiceWith([{ provider: "p2", id: "m2" }]);
+    const cmd = captureCommand();
+    const { ctx, notifies } = makeCtx("tui");
+    await cmd.handler("resume wf-x p2/m2:high", ctx);
+    expect(vi.mocked(resumeRun)).toHaveBeenCalledWith("wf-x", expect.anything(), {
+      model: "p2/m2:high",
+    });
+    expect(notifies[0]!.msg).toContain("resuming with model p2/m2:high");
+    expect(notifies[0]!.level).toBe("info");
+  });
+
+  it("resume 显式 model 目录查无 → 同步拒单 warning（tool 通道同款 D8 语义，不落覆盖记账）", async () => {
+    injectModelServiceWith([{ provider: "p1", id: "m1" }]);
+    const cmd = captureCommand();
+    const { ctx, notifies } = makeCtx("tui");
+    await cmd.handler("resume wf-x pX/nope", ctx);
+    // 目录查无在 resumeRun 之前拒绝——不产生假成功 notify
+    expect(vi.mocked(resumeRun)).not.toHaveBeenCalled();
+    expect(notifies).toHaveLength(1);
+    expect(notifies[0]!.msg).toContain("Failed to resume workflow wf-x:");
+    expect(notifies[0]!.msg).toContain("pX/nope");
+    expect(notifies[0]!.level).toBe("warning");
+  });
+
   it("resume 缺 runId → Usage warning", async () => {
     const cmd = captureCommand();
     const { ctx, notifies } = makeCtx("tui");
     await cmd.handler("resume", ctx);
     expect(vi.mocked(resumeRun)).not.toHaveBeenCalled();
-    expect(notifies[0]).toMatchObject({ msg: "Usage: /workflows resume <runId>", level: "warning" });
+    expect(notifies[0]).toMatchObject({ msg: "Usage: /workflows resume <runId> [model]", level: "warning" });
   });
 
   it("resumeRun 拒绝 → warning notify（TUI 同款透出）", async () => {

package/src/interface/command/__tests__/subagent-model.test.ts

@@ -0,0 +1,242 @@
+/**
+ * /subagent-model 命令 handler 测试（subagent-model-switch §7.1.1，U6）。
+ *
+ * 覆盖（通道契约：全程不抛 + 一切结果落结果文件）：
+ * - 合法 payload → service.setModel 桩 → 结果文件内容 = 应答（core SetModelReply 原样）；
+ * - service.setModel 抛错 → 错误 envelope 文件且 handler 不抛；
+ * - 非法 JSON（无 requestId）→ 零文件 + handler 不抛（runtime 超时路径承接）；
+ * - 字段校验失败（requestId 在场）→ invalid_payload envelope；
+ * - service 未就绪 → subagent_runtime_not_ready envelope；
+ * - 注册形态：命令名 / TUI 模式指引（内部 RPC 通道，无 TUI 分支）。
+ *
+ * mock 策略：runSubagentModelRpc 依赖注入面直驱（不 mock barrel）；落盘全在 mkdtemp tmp。
+ * 运行：cd extensions/universal/subagent-workflow && npx vitest run src/interface/command/__tests__/subagent-model.test.ts
+ */
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import { registerSubagentModelCommand, runSubagentModelRpc } from "../subagent-model.ts";
+import type { SubagentModelCommandDeps } from "../subagent-model.ts";
+
+// ── fixture ──────────────────────────────────────────────────
+
+let root: string;
+
+beforeEach(() => {
+  root = mkdtempSync(join(tmpdir(), "subagent-model-cmd-"));
+});
+
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+});
+
+interface StubService { // oe-exempt:20261006:test:测试专用服务桩装配单实现为常态
+  setModel: ReturnType<typeof vi.fn>;
+  chatActions: { getRecordForAction: ReturnType<typeof vi.fn> };
+}
+
+function stubService(): StubService {
+  return {
+    setModel: vi.fn(async () => ({
+      scope: "chat",
+      reply: { kind: "recorded", notice: "已记录，下次执行生效。" },
+    })),
+    chatActions: {
+      getRecordForAction: vi.fn(() => ({ id: "sa-1" }) as never),
+    },
+  };
+}
+
+function deps(service: StubService | null): { deps: SubagentModelCommandDeps; resultsDir: string } {
+  const resultsDir = join(root, "results");
+  return {
+    deps: {
+      getService: () => service as never,
+      resolveAgentDir: () => join(root, "agent"),
+      // rootCwd 作为 enc 编码键——结果目录 = <agentDir>/subagents/<enc(cwd)>/model-switch
+      resolveRootCwd: () => join(root, "proj"),
+    },
+    resultsDir,
+  };
+}
+
+function rpcCtx(mode: "rpc" | "tui" = "rpc"): { ctx: ExtensionCommandContext; notifies: Array<{ msg: string; level: string }> } {
+  const notifies: Array<{ msg: string; level: string }> = [];
+  const ctx = {
+    mode,
+    ui: { notify: (msg: string, level: string) => notifies.push({ msg, level }) },
+    cwd: join(root, "proj"),
+  };
+  return { ctx: ctx as never, notifies };
+}
+
+const VALID_ARGS = JSON.stringify({
+  requestId: "req-abc",
+  recordId: "sa-1",
+  provider: "zai-coding-cn",
+  modelId: "glm-5.3-flash",
+  thinkingLevel: "high",
+});
+
+function resultFile(requestId: string): string {
+  // enc 段镜像 core encodeCwd（布局单源在 path-encoding.ts，测试只按同式派生锚）。
+  const enc = "--" + join(root, "proj").replace(/^[/\\]/, "").replace(/[/\\:]/g, "-") + "--";
+  return join(root, "agent", "subagents", enc, "model-switch", `${requestId}.json`);
+}
+
+// ── 成功路 ───────────────────────────────────────────────────
+
+describe("/subagent-model — 成功路（payload → setModel → 结果文件）", () => {
+  it("合法 payload：setModel 桩收到 target/model/thinkingLevel，结果文件 = 应答原样", async () => {
+    const service = stubService();
+    const { deps: d } = deps(service);
+    const { ctx } = rpcCtx();
+
+    await runSubagentModelRpc(d, VALID_ARGS, ctx);
+
+    expect(service.chatActions.getRecordForAction).toHaveBeenCalledWith("sa-1");
+    expect(service.setModel).toHaveBeenCalledWith(
+      { domain: "chat", record: { id: "sa-1" } },
+      { provider: "zai-coding-cn", modelId: "glm-5.3-flash" },
+      "high",
+    );
+    const raw = readFileSync(resultFile("req-abc"), "utf8");
+    expect(JSON.parse(raw)).toEqual({ scope: "chat", reply: { kind: "recorded", notice: "已记录，下次执行生效。" } });
+  });
+
+  it("runId 目标：workflow-run 域分流（不触 getRecordForAction）", async () => {
+    const service = stubService();
+    const { deps: d } = deps(service);
+    const { ctx } = rpcCtx();
+
+    const args = JSON.stringify({ requestId: "req-run", runId: "wf-1", provider: "p", modelId: "m" });
+    await runSubagentModelRpc(d, args, ctx);
+
+    expect(service.chatActions.getRecordForAction).not.toHaveBeenCalled();
+    expect(service.setModel).toHaveBeenCalledWith({ domain: "workflow-run", runId: "wf-1" }, { provider: "p", modelId: "m" }, undefined);
+  });
+
+  it("handler 不抛（即使 setModel 桩 resolve 失败也不向上传播）", async () => {
+    const service = stubService();
+    service.setModel.mockResolvedValue({ scope: "error", message: "目录无此模型（最接近的候选：X）" });
+    const { deps: d } = deps(service);
+    const { ctx } = rpcCtx();
+
+    await expect(runSubagentModelRpc(d, VALID_ARGS, ctx)).resolves.toBeUndefined();
+    const envelope = JSON.parse(readFileSync(resultFile("req-abc"), "utf8")) as { scope: string };
+    expect(envelope.scope).toBe("error");
+  });
+});
+
+// ── 失败路：envelope 且不抛 ──────────────────────────────────
+
+describe("/subagent-model — 失败路（envelope 落盘 + 全程不抛）", () => {
+  it("service.setModel 抛错：错误 envelope 文件 + handler 不抛", async () => {
+    const service = stubService();
+    service.setModel.mockRejectedValue(Object.assign(new Error("thinking 档位 max 在模型 X 上不可用"), { code: "thinking_level_unavailable" }));
+    const { deps: d } = deps(service);
+    const { ctx } = rpcCtx();
+
+    await expect(runSubagentModelRpc(d, VALID_ARGS, ctx)).resolves.toBeUndefined();
+
+    const envelope = JSON.parse(readFileSync(resultFile("req-abc"), "utf8")) as {
+      error: { code: string; message: string; recovery: string };
+    };
+    expect(envelope.error.code).toBe("thinking_level_unavailable");
+    expect(envelope.error.message).toContain("不可用");
+    expect(envelope.error.recovery).toContain("重试切换");
+  });
+
+  it("getRecordForAction 抛错（目标不存在）：envelope + handler 不抛", async () => {
+    const service = stubService();
+    service.chatActions.getRecordForAction.mockImplementation(() => {
+      throw new Error("record sa-ghost not found");
+    });
+    const { deps: d } = deps(service);
+    const { ctx } = rpcCtx();
+
+    await expect(runSubagentModelRpc(d, VALID_ARGS, ctx)).resolves.toBeUndefined();
+
+    const envelope = JSON.parse(readFileSync(resultFile("req-abc"), "utf8")) as { error: { code: string } };
+    expect(envelope.error.code).toBe("subagent_model_switch_failed");
+  });
+
+  it("非法 JSON（无 requestId）：零文件 + handler 不抛 + warning notify", async () => {
+    const { deps: d } = deps(stubService());
+    const { ctx, notifies } = rpcCtx();
+
+    await expect(runSubagentModelRpc(d, "not-json{", ctx)).resolves.toBeUndefined();
+    expect(existsSync(resultFile("req-abc"))).toBe(false);
+    expect(notifies[0]?.level).toBe("warning");
+  });
+
+  it("字段校验失败（缺 provider）：invalid_payload envelope", async () => {
+    const { deps: d } = deps(stubService());
+    const { ctx } = rpcCtx();
+
+    const args = JSON.stringify({ requestId: "req-bad", recordId: "sa-1", modelId: "m" });
+    await runSubagentModelRpc(d, args, ctx);
+
+    const envelope = JSON.parse(readFileSync(resultFile("req-bad"), "utf8")) as {
+      error: { code: string; message: string };
+    };
+    expect(envelope.error.code).toBe("invalid_payload");
+    expect(envelope.error.message).toContain("provider");
+  });
+
+  it("recordId 与 runId 双给：invalid_payload envelope（wire 契约二选一）", async () => {
+    const { deps: d } = deps(stubService());
+    const { ctx } = rpcCtx();
+
+    const args = JSON.stringify({ requestId: "req-both", recordId: "sa-1", runId: "wf-1", provider: "p", modelId: "m" });
+    await runSubagentModelRpc(d, args, ctx);
+
+    const envelope = JSON.parse(readFileSync(resultFile("req-both"), "utf8")) as { error: { code: string } };
+    expect(envelope.error.code).toBe("invalid_payload");
+  });
+
+  it("service 未就绪（session_start 前）：subagent_runtime_not_ready envelope", async () => {
+    const { deps: d } = deps(null);
+    const { ctx } = rpcCtx();
+
+    await runSubagentModelRpc(d, VALID_ARGS, ctx);
+
+    const envelope = JSON.parse(readFileSync(resultFile("req-abc"), "utf8")) as { error: { code: string } };
+    expect(envelope.error.code).toBe("subagent_runtime_not_ready");
+  });
+});
+
+// ── 注册形态 ─────────────────────────────────────────────────
+
+describe("registerSubagentModelCommand — 注册形态", () => {
+  interface CapturedCommand { // oe-exempt:20261006:test:测试专用命令捕获结构单实现为常态（同 commands-resume.test.ts 先例）
+    name: string;
+    description: string;
+    handler: (args: string, ctx: ExtensionCommandContext) => Promise<void>;
+  }
+
+  function captureCommand(): CapturedCommand {
+    const commands: CapturedCommand[] = [];
+    const api = {
+      registerCommand: (name: string, def: Omit<CapturedCommand, "name">) => {
+        commands.push({ name, ...def });
+      },
+    };
+    registerSubagentModelCommand(api as never);
+    expect(commands).toHaveLength(1);
+    return commands[0]!;
+  }
+
+  it("命令名 = subagent-model；TUI 模式 = 指引提示（内部 RPC 通道无 TUI 分支）", async () => {
+    const cmd = captureCommand();
+    expect(cmd.name).toBe("subagent-model");
+    const { ctx, notifies } = rpcCtx("tui");
+    await cmd.handler(VALID_ARGS, ctx);
+    expect(notifies[0]?.level).toBe("warning");
+    expect(notifies[0]?.msg).toContain("internal taiji GUI channel");
+  });
+});

package/src/interface/command/command-actions.ts

@@ -22,7 +22,7 @@ export type SubagentRpcAction =
 /** /workflows RPC action 判别联合。 */
 export type WorkflowRpcAction =
   | { action: "abort"; runId: string }
-  | { action: "resume"; runId: string }
+  | { action: "resume"; runId: string; model?: string }
   | { action: "lifecycle-missing-id"; verb: "abort" | "resume" }
   | { action: "lifecycle-removed"; verb: "pause" }
   | { action: "noop" };
@@ -128,8 +128,9 @@ export function parseSubagentRpcCommand(argsStr: string): SubagentRpcAction {
  * 支持格式：
  * - `abort <runId>` → { action: "abort", runId }
  * - `abort`（无 runId）→ { action: "lifecycle-missing-id", verb: "abort" }
- * - `resume <runId>` → { action: "resume", runId }（断点续跑——与 TUI verb、
- *   workflow tool action:"resume" 三通道同语义）
+ * - `resume <runId> [model]` → { action: "resume", runId, model? }（断点续跑——与
+ *   TUI verb、workflow tool action:"resume" 三通道同语义；model 可选 canonical ref
+ *   'provider/modelId[:thinkingLevel]'，落统一覆盖记账——F1-26 后续项）
  * - `resume`（无 runId）→ { action: "lifecycle-missing-id", verb: "resume" }
  * - `pause ...`（已移除的 lifecycle verb，带或不带 runId 均同）→
  *   { action: "lifecycle-removed", verb: "pause" }——removed verb 优先于 missing-id 判定
@@ -140,7 +141,7 @@ export function parseWorkflowRpcCommand(argsStr: string): WorkflowRpcAction {
   const args = argsStr.trim().split(/\s+/).filter(Boolean);
   if (args.length === 0) return { action: "noop" };
 
-  const [verb, runId] = args;
+  const [verb, runId, model] = args;
   if (isRemovedLifecycleVerb(verb)) {
     return { action: "lifecycle-removed", verb };
   }
@@ -149,7 +150,7 @@ export function parseWorkflowRpcCommand(argsStr: string): WorkflowRpcAction {
     if (!runId) return { action: "lifecycle-missing-id", verb };
     return verb === "abort"
       ? { action: "abort", runId }
-      : { action: "resume", runId };
+      : { action: "resume", runId, ...(model !== undefined ? { model } : {}) };
   }
   return { action: "noop" };
 }

package/src/interface/command/commands.ts

@@ -24,7 +24,13 @@ import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-wor
 import { getLogger } from "@zhushanwen/pi-extension-logger";
 
 import type { LauncherDeps } from "@zhushanwen/subagent-core";
-import { abortRun, getSubagentService, resumeRun } from "@zhushanwen/subagent-core";
+import {
+  abortRun,
+  assertModelInCatalog,
+  getModelConfigService,
+  getSubagentService,
+  resumeRun,
+} from "@zhushanwen/subagent-core";
 import type { WorkflowRun } from "@zhushanwen/subagent-core";
 import { parseWorkflowRpcCommand, type WorkflowRpcAction } from "./command-actions.ts";
 import { createWorkflowsView, type ViewActions } from "../tui/views/WorkflowsView.ts";
@@ -130,13 +136,17 @@ export function registerWorkflowsCommand(
       if (verb === "resume") {
         const runId = rest[0];
         if (!runId) {
-          ctx.ui.notify("Usage: /workflows resume <runId>", "warning");
+          ctx.ui.notify("Usage: /workflows resume <runId> [model]", "warning");
           return;
         }
+        // 可选第二参数 = 显式模型 canonical ref（'provider/modelId[:thinkingLevel]'）——
+        // 落统一覆盖记账（F1-26 后续项：与 setModel 补切同通道，resume 合一步表达）。
+        const model = rest[1];
         try {
-          await resumeRun(runId, deps);
+          if (model !== undefined) assertResumeModelInCatalog(model);
+          await resumeRun(runId, deps, ...(model !== undefined ? [{ model }] : []));
           ctx.ui.notify(
-            `Workflow ${runId}: resuming — completed calls replay at zero token cost, unfinished calls re-dispatched`,
+            `Workflow ${runId}: resuming${model !== undefined ? ` with model ${model}` : ""} — completed calls replay at zero token cost, unfinished calls re-dispatched`,
             "info",
           );
         } catch (err) {
@@ -192,9 +202,10 @@ async function handleRpcMode(
     }
     case "resume": {
       try {
-        await resumeRun(parsed.runId, deps);
+        if (parsed.model !== undefined) assertResumeModelInCatalog(parsed.model);
+        await resumeRun(parsed.runId, deps, ...(parsed.model !== undefined ? [{ model: parsed.model }] : []));
         ctx.ui.notify(
-          `Workflow ${parsed.runId}: resuming — completed calls replay at zero token cost, unfinished calls re-dispatched`,
+          `Workflow ${parsed.runId}: resuming${parsed.model !== undefined ? ` with model ${parsed.model}` : ""} — completed calls replay at zero token cost, unfinished calls re-dispatched`,
           "info",
         );
       } catch (err) {
@@ -210,7 +221,14 @@ async function handleRpcMode(
       );
       return;
     case "lifecycle-missing-id":
-      ctx.ui.notify(`Usage: /workflows ${parsed.verb} <runId>`, "warning");
+      // Usage 按 verb 区分（与 TUI verb 分支同文案——两模式统一）：resume 的可选
+      // [model] 参数要出现在提示里，GUI 侧缺 runId 时得到的指引不指向旧用法。
+      ctx.ui.notify(
+        parsed.verb === "resume"
+          ? "Usage: /workflows resume <runId> [model]"
+          : `Usage: /workflows ${parsed.verb} <runId>`,
+        "warning",
+      );
       return;
     case "noop":
       ctx.ui.notify("View workflows in the composer task tray", "info");
@@ -223,6 +241,28 @@ async function handleRpcMode(
   }
 }
 
+/**
+ * 命令通道显式 model 的目录预检（D8 拒单语义，与 tool 通道 run/resume action 同款
+ * ——isModelRef 语法闸在 core resumeRun，此处补目录存在性：语法合法但目录查无
+ * （如 provider 段拼写错）在写覆盖记账之前同步拒绝，不延迟到派发期，避免「记账已
+ * 落盘 + 命令已 notify 成功」的假成功形态；三通道（TUI verb / RPC verb / tool）对称）。
+ * throw 落调用方 try/catch，分类化错误文案（含可用模型清单 + 修复指引）经 notify
+ * 直达用户。单例缺席（session_start 前不可达）降级跳过 + warn 留痕——派发期
+ * identity 解析仍是权威裁决（与 tool 通道降级语义一致）。
+ */
+function assertResumeModelInCatalog(model: string): void {
+  const modelService = getModelConfigService();
+  if (modelService === null) {
+    getLogger("subagent-workflow").warn(
+      "[commands] model catalog unavailable (model service not initialized) — resume model catalog check skipped; dispatch-time identity resolution remains authoritative",
+    );
+    return;
+  }
+  assertModelInCatalog(model, modelService.getModelRegistry(), {
+    source: "resume model override",
+  });
+}
+
 /**
  * TUI 模式：按 runId 直接打开对应 run 的 view（精确匹配优先，前缀唯一匹配次之）。
  * 均未命中 → error notify。

package/src/interface/command/subagent-model.ts

@@ -0,0 +1,268 @@
+// src/interface/command/subagent-model.ts
+//
+// /subagent-model 命令——subagent/workflow run 执行模型切换的宿主触达通道消费端
+// （subagent-model-switch §7.1.1 通道，U6）。内部 RPC 命令：runtime 网关适配器经
+// client.prompt("/subagent-model <单行JSON>") 短路本 handler（不经主 agent LLM，
+// pi _tryExecuteExtensionCommand 主路径对 / 前缀先行执行）。
+//
+// 通道契约（§7.1.1 四要素）：
+// - 载荷 = 单行 JSON {requestId, recordId?|runId?, provider, modelId, thinkingLevel?}；
+// - 执行 = 本进程直调宿主 setModel 编排（service.setModel，§7.2 单一三步）；
+// - 回执 = 一切结果（SetModelReply 三 scope / 错误 envelope）写结果文件
+//   `<subagent 数据根>/model-switch/<requestId>.json` 后正常返回——**全程不抛**；
+//   runtime 出站点在 handler 返回后读文件一次（写后读，无轮询无监视）。
+// - 结果文件承载 core SetModelReply 形状（scope 判别）——extension 不依赖
+//   @taiji/shared，wire 三形态映射归 runtime 适配器（依赖方向的唯一合法位置）。
+//
+// TUI 分支不存在：本命令是 GUI 通道专用内部命令，非交互入口（照 /subagents RPC
+// verb 的 GUI 屏蔽先例，TUI 手敲仅得指引提示）。
+
+import * as path from "node:path";
+
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+import {
+  ENV_ROOT_CWD,
+  getSubagentModelSwitchResultsDir,
+  getSubagentService,
+  writeAtomicFileSync,
+} from "@zhushanwen/subagent-core";
+import type { ModelSwitchTarget, SetModelReply } from "@zhushanwen/subagent-core";
+import { getLogger } from "@zhushanwen/pi-extension-logger";
+import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
+
+const logger = getLogger("subagents");
+
+/**
+ * requestId 文件名白名单：`[\w-]{1,128}`（与 core record id 白名单同式——防路径穿越；
+ * 生产源 = runtime randomUUID，字符集 ⊆ 白名单，本式仅防御畸形通道输入）。
+ */
+const REQUEST_ID_PATTERN = /^[\w-]{1,128}$/;
+
+/** 错误 envelope 形状（结果文件内的失败承载；code 值域 = 本文件错误分型常量族）。
+ *  scope: "error" = 网关 mapResultFileToWireReply 的分派判别键（D3-A4 缺陷修复：
+ *  缺 scope 时域内失败被「scope 未知」通道错误吞掉，真实 code/recovery 丢失）。 */
+interface SubagentModelEnvelope { // oe-exempt:20261006:framework:通道结果信封契约形状（单命令单载体，单实现常态）
+  scope: "error";
+  error: { code: string; message: string; recovery: string };
+}
+
+/** /subagent-model 命令的依赖注入面（注册点装配生产实现，单测注入桩）。 */
+export interface SubagentModelCommandDeps { // oe-exempt:20261006:framework:命令 handler 依赖注入面（注册点装配，单实现常态）
+  /** 宿主 setModel 编排单例（session_start 前 null——envelope 分型承接）。 */
+  getService: () => ReturnType<typeof getSubagentService>;
+  /** agentDir 锚（pi SDK 活源，与 session-lifecycle 装配同源）。 */
+  resolveAgentDir: () => string;
+  /** 树根主 cwd（session-baselines rootCwd 同式推导，见 registerSubagentModelCommand）。 */
+  resolveRootCwd: () => string;
+}
+
+/** 载荷解析三态（显式判别：无 requestId = 无法命名结果文件，与字段校验失败分流）。 */
+type ParsedPayload =
+  | { ok: true; requestId: string; payload: SubagentModelPayload }
+  | { ok: false; requestIdMissing: true }
+  | { ok: false; requestIdMissing: false; requestId: string; validationMessage: string };
+
+/** 载荷结构（wire 契约 §7.1.1：recordId/runId 二选一，provider/modelId 必填）。
+ *  字段经逐项 typeof 抽取组装（JSON 边界不落地 unknown 断言）。 */
+interface SubagentModelPayload { // oe-exempt:20261006:framework:通道载荷契约形状（单命令单载体，单实现常态）
+  requestId: string;
+  recordId?: string;
+  runId?: string;
+  provider?: string;
+  modelId?: string;
+  thinkingLevel?: string;
+}
+
+/** 非空字符串字段抽取（undefined = 缺失或类型不符，二者同判缺失）。 */
+function nonEmptyString(v: unknown): string | undefined {
+  return typeof v === "string" && v !== "" ? v : undefined;
+}
+
+/**
+ * 解析单行 JSON 载荷（§7.1.1 要素 1）。requestId 缺失/非法 → requestIdMissing（无法
+ * 命名结果文件，本侧零回执——runtime 出站点超时路径承接通道失败，仅日志留痕）；
+ * 其余字段校验失败在 requestId 在场时落 envelope（invalid_payload 分型）。
+ */
+function parsePayload(argsStr: string): ParsedPayload {
+  let raw: unknown;
+  try {
+    raw = JSON.parse(argsStr.trim());
+  } catch {
+    return { ok: false, requestIdMissing: true };
+  }
+  if (typeof raw !== "object" || raw === null) return { ok: false, requestIdMissing: true };
+  const obj = raw as Record<string, unknown>;
+  const requestId = nonEmptyString(obj.requestId);
+  if (requestId === undefined || !REQUEST_ID_PATTERN.test(requestId)) {
+    return { ok: false, requestIdMissing: true };
+  }
+  const payload: SubagentModelPayload = {
+    requestId,
+    recordId: nonEmptyString(obj.recordId),
+    runId: nonEmptyString(obj.runId),
+    provider: nonEmptyString(obj.provider),
+    modelId: nonEmptyString(obj.modelId),
+    thinkingLevel: nonEmptyString(obj.thinkingLevel),
+  };
+  const validationMessage = validatePayload(payload);
+  if (validationMessage !== undefined) {
+    return { ok: false, requestIdMissing: false, requestId, validationMessage };
+  }
+  return { ok: true, requestId, payload };
+}
+
+/** 载荷字段校验（requestId 之外的域内畸形 → envelope invalid_payload 的 message 文案）。 */
+function validatePayload(payload: SubagentModelPayload): string | undefined {
+  if ((payload.recordId !== undefined) === (payload.runId !== undefined)) {
+    return "payload 需要 recordId（chat 域）或 runId（workflow run 级）二选一";
+  }
+  if (payload.provider === undefined) {
+    return "payload 缺 provider（canonical ref 的 provider 段）";
+  }
+  if (payload.modelId === undefined) {
+    return "payload 缺 modelId（canonical ref 的 modelId 段）";
+  }
+  return undefined;
+}
+
+/**
+ * 结果文件写入（唯一出站原语，永不抛）：writeAtomicFileSync（tmp+rename，防 runtime
+ * 读到半文件）+ 目录递归建。写失败 = 通道回执丢失（runtime 超时路径承接），日志留痕。
+ */
+function writeResultFile(resultsFile: string, content: string): void {
+  try {
+    writeAtomicFileSync(resultsFile, content);
+  } catch (err) {
+    logger.warn(`[subagent-model] result file write failed (runtime will report channel timeout): ${toErrorMessage(err)}`, {
+      resultsFile,
+    });
+  }
+}
+
+/** 提取引擎分型错误码（EngineError 载荷 .code——分型值域校验交由 runtime 侧）。 */
+function errorCodeOf(err: unknown): string | undefined {
+  // `in` 收窄（TS 4.9+）：Error & Record<"code", unknown>，零断言读载荷。
+  if (!(err instanceof Error) || !("code" in err)) return undefined;
+  const code: unknown = err.code;
+  return typeof code === "string" && code !== "" ? code : undefined;
+}
+
+/**
+ * RPC 执行体（§7.1.1 要素 2）：payload 校验 → 宿主 setModel → 结果文件。
+ * **全程不抛**——一切异常 catch 后落错误 envelope；校验失败同落 envelope。
+ */
+export async function runSubagentModelRpc(
+  deps: SubagentModelCommandDeps,
+  argsStr: string,
+  ctx: ExtensionCommandContext,
+): Promise<void> {
+  const parsed = parsePayload(argsStr);
+  if (!parsed.ok) {
+    if (parsed.requestIdMissing) {
+      // requestId 不可用 = 无关联回执面：日志留痕即可，runtime 超时按通道失败应答
+      //（结果文件名 = requestId，载荷缺失时本侧无从落文件）。
+      logger.warn("[subagent-model] payload unparseable or requestId missing — no result file, runtime timeout path will report");
+      ctx.ui.notify("/subagent-model payload requires requestId — request dropped", "warning");
+      return;
+    }
+    // requestId 在场 + 字段校验失败：envelope 落盘（invalid_payload 分型）。
+    const invalidFile = path.join(
+      getSubagentModelSwitchResultsDir(deps.resolveAgentDir(), deps.resolveRootCwd()),
+      `${parsed.requestId}.json`,
+    );
+    writeResultFile(
+      invalidFile,
+      JSON.stringify({
+        scope: "error",
+        error: {
+          code: "invalid_payload",
+          message: parsed.validationMessage,
+          recovery: "修正 subagent.setModel 载荷后重试（runtime 协议面问题，正常使用不可达）",
+        },
+      } satisfies SubagentModelEnvelope),
+    );
+    return;
+  }
+  const { requestId, payload } = parsed;
+  const resultsFile = path.join(
+    getSubagentModelSwitchResultsDir(deps.resolveAgentDir(), deps.resolveRootCwd()),
+    `${requestId}.json`,
+  );
+
+  try {
+    const service = deps.getService();
+    if (!service) {
+      writeResultFile(
+        resultsFile,
+        JSON.stringify({
+          scope: "error",
+          error: {
+            code: "subagent_runtime_not_ready",
+            message: "subagent 执行运行时未就绪（session 未启动或已 dispose）",
+            recovery: "先在该会话派发一条消息启动 subagent 运行时，再重试切换",
+          },
+        } satisfies SubagentModelEnvelope),
+      );
+      return;
+    }
+
+    // 目标组装（§6.1 作用域分流）：recordId → chat 域（getRecordForAction 同 message/close
+    // 的统一入口——含归属校验与冷查）；runId → run 级（终局/成员清单校验在编排步骤①）。
+    let target: ModelSwitchTarget;
+    if (typeof payload.recordId === "string") {
+      target = { domain: "chat", record: service.chatActions.getRecordForAction(payload.recordId) };
+    } else {
+      target = { domain: "workflow-run", runId: payload.runId as string };
+    }
+
+    const thinkingLevel = payload.thinkingLevel as string | undefined;
+    const reply: SetModelReply = await service.setModel(
+      target,
+      { provider: payload.provider as string, modelId: payload.modelId as string },
+      thinkingLevel,
+    );
+    // 应答三 scope 原样落文件（scope 判别由 runtime 适配器消费——core 形状是唯一权威）。
+    writeResultFile(resultsFile, JSON.stringify(reply));
+  } catch (err) {
+    // §7.5 通道行同族语义：handler 域内失败如实落 envelope（生效状态未知不虚构——
+    // 消息携带宿主编排错误原文，恢复动作照通道行）。
+    writeResultFile(
+      resultsFile,
+      JSON.stringify({
+        scope: "error",
+        error: {
+          code: errorCodeOf(err) ?? "subagent_model_switch_failed",
+          message: toErrorMessage(err),
+          recovery: "重试切换（覆盖替换幂等）；当前生效状态以面板与记录链为准",
+        },
+      } satisfies SubagentModelEnvelope),
+    );
+  }
+}
+
+/** 注册 /subagent-model 命令（内部 RPC 通道，taiji GUI 专用）。 */
+export function registerSubagentModelCommand(pi: ExtensionAPI): void {
+  pi.registerCommand("subagent-model", {
+    description: "Internal RPC: switch subagent/workflow-run model (single-line JSON payload)",
+    handler: async (argsStr: string, ctx: ExtensionCommandContext) => {
+      if (ctx.mode !== "rpc") {
+        ctx.ui.notify("/subagent-model is an internal taiji GUI channel — switch models from the subagent panel", "warning");
+        return;
+      }
+      // rootCwd 与 session-baselines 构造推导同式（env PI_SUBAGENT_ROOT_CWD 贯穿 ||
+      // ctx.cwd）——保证结果目录与 records 落同一 enc 段（enc 段不变量，path-encoding
+      // 头注同族约束）。本命令只在主进程执行（子进程无 / 命令通道），env 恒缺省。
+      await runSubagentModelRpc(
+        {
+          getService: getSubagentService,
+          resolveAgentDir: getAgentDir,
+          resolveRootCwd: () => process.env[ENV_ROOT_CWD] || ctx.cwd,
+        },
+        argsStr,
+        ctx,
+      );
+    },
+  });
+}

package/src/interface/tool/__tests__/tool-workflow-resume.test.ts

@@ -130,6 +130,26 @@ describe("actionResume", () => {
     expect(options.budgetTokens).toBe(50_000);
   });
 
+  it("model 形参透传（F1-26 后续项：core 落统一覆盖记账——补切 + 无参 resume 合一步）", async () => {
+    const recordPath = writeRecordStream([runCreatedFrame('{"a":1}')]);
+    await actionResume(
+      { action: "resume", runId: "wf-test", args: { a: 1 }, model: "p2/m2" } as never,
+      makeDeps(recordPath) as never,
+    );
+    const options = vi.mocked(resumeRun).mock.calls[0]![2] as { model?: string };
+    expect(options.model).toBe("p2/m2");
+  });
+
+  it("model 缺省 → options 不带 model 键（无参 resume 不写覆盖记账）", async () => {
+    const recordPath = writeRecordStream([runCreatedFrame('{"a":1}')]);
+    await actionResume(
+      { action: "resume", runId: "wf-test", args: { a: 1 } } as never,
+      makeDeps(recordPath) as never,
+    );
+    const options = vi.mocked(resumeRun).mock.calls[0]![2] as { model?: string };
+    expect("model" in options).toBe(false);
+  });
+
   it("tokens 缺省 → options 不带 budgetTokens 键（core 侧跳过覆盖、走三档回落）", async () => {
     await actionResume(
       { action: "resume", runId: "wf-test" } as never,

package/src/interface/tool/tool-workflow.ts

@@ -114,7 +114,11 @@ const WorkflowParams = Type.Object({
     Type.String({ description: "Error/reason message (optional, used with abort)" }),
   ),
   model: Type.Optional(Type.String({
-    description: "Run-level model override in 'provider/modelId' format. When set, all agents spawned by this run inherit it by default (unless a per-call agent() opts.model is set). Omit to inherit the main agent's model.",
+    description:
+      "Run-level model override in 'provider/modelId' format. When set, all agents spawned by this run inherit it by default (unless a per-call agent() opts.model is set). " +
+      "Also accepted on action:\"resume\" — recorded as the run's user override (same channel as a panel switch) and drives all re-dispatched steps. " +
+      "A user-issued runtime model override (panel model switch / /subagent-model command) takes precedence over this parameter — user override wins over any explicitly scripted model. " +
+      "Omit to inherit the main agent's model.",
   })),
   thinkingLevel: Type.Optional(StringEnum(THINKING_ORDER, {
     description: "Run-level thinkingLevel override (off/minimal/low/medium/high/xhigh/max). All agents in this run inherit it by default. Omit to default each agent to its model's highest available level.",
@@ -232,14 +236,21 @@ export function registerWorkflowTool(
       "completed calls from the record at zero token cost and continues where the run stopped. " +
       "Do NOT resume a settled (done/failed/cancelled) run — start a new run instead.",
       "resume: pass the SAME args as the original run (they are verified field-by-field; a mismatch is rejected " +
-      "with the differing fields listed). Omit args to reuse the original ones. Changed args = different intent = new run.",
+      "with the differing fields listed). Omit args to reuse the original ones. Changed args = different intent = new run. " +
+      "To resume with a specific model: pass model ('provider/modelId') on the resume itself — it is recorded as the " +
+      "run's user override (same channel as a panel switch), drives all re-dispatched steps, and persists for later " +
+      "resumes without the parameter. Alternatively switch the run's model first (panel selector or /subagent-model) " +
+      "then resume without model — both are the same override channel.",
       "Call shapes (JSON): " +
       "- run: {\"action\":\"run\",\"name\":\"<script>\",\"args\":{...},\"tokens\":N,\"time\":N,\"model\":\"<provider/modelId>\",\"thinkingLevel\":\"<level>\"}. " +
       "- status: {\"action\":\"status\"}. " +
       "- abort: {\"action\":\"abort\",\"runId\":\"<id>\"} (optional: {\"error\":\"<reason>\"}). " +
-      "- resume: {\"action\":\"resume\",\"runId\":\"<id>\",\"args\":{...},\"tokens\":N,\"time\":N} — args/tokens/time optional.",
+      "- resume: {\"action\":\"resume\",\"runId\":\"<id>\",\"args\":{...},\"tokens\":N,\"time\":N,\"model\":\"<provider/modelId>\"} — args/tokens/time/model optional.",
       "Budget: Do NOT set tokens/time unless the user explicitly requests a limit. Built-in workflows run unlimited by default.",
-      "Model/thinkingLevel: omit by default (inherit main agent's model). Only set model/thinkingLevel when the user explicitly requests a specific model or thinking depth for this run.",
+      "Model/thinkingLevel: omit by default (inherit main agent's model). Only set model/thinkingLevel when the user explicitly requests a specific model or thinking depth for this run. " +
+      "Note: a user-issued runtime model override (panel switch / /subagent-model) takes precedence over the model parameter — an explicitly scripted thinkingLevel still applies " +
+      "(explicit levels outrank the override's inline level). If a run's explicitly scripted model seems ignored, " +
+      "check for an active user override (run journal model-override frame) before assuming a resolution bug.",
       "Anti-patterns: Flattening args sub-fields (task/items/...) to the top level — they belong inside args. Calling {\"action\":\"run\"} without name.",
       "CRITICAL: For orchestration patterns, ALWAYS use action:run with the <location> absolute " +
       "path of the matching listed workflow — NEVER use workflow-script action:generate to recreate patterns " +
@@ -565,10 +576,28 @@ export async function actionResume(
   assertEntryTimeBudget(params.time);
   assertEntryTokenBudget(params.tokens);
 
+  // 显式 model 参数的目录预检（run action 同款 D8 拒单语义——查无同步 throw 零写，
+  // 单例缺席降级跳过 + warn，派发期 identity 解析仍是权威裁决）。
+  if (params.model !== undefined) {
+    const modelService = getModelConfigService();
+    if (modelService === null) {
+      logger.warn(
+        "[tool-workflow] model catalog unavailable (model service not initialized) — resume model catalog check skipped; dispatch-time identity resolution remains authoritative",
+      );
+    } else {
+      assertModelInCatalog(params.model, modelService.getModelRegistry(), {
+        source: "resume model override",
+      });
+    }
+  }
+
   const options: ResumeRunOptions = {
     ...(params.time !== undefined ? { budgetTimeMs: params.time } : {}),
     // token 预算显式覆盖（与 time 同款通道；三档回落与落盘归 core 单点）
     ...(params.tokens !== undefined ? { budgetTokens: params.tokens } : {}),
+    // [F1-26 后续项] 显式 model 透传（core 落统一覆盖记账——「补切 + 无参 resume」
+    // 的合一步；格式与目录已在本入口预检，记账落盘归 core 锁段单点）
+    ...(params.model !== undefined ? { model: params.model } : {}),
     // [§2.5] args 原样下传由 core 判定（D14 单源）；journalDir 传壳的 store 同源目录，
     // 否则 core 会按模块锚解析 record 路径——多 session 场景会静默读成「无记录」
     //（D14 静默放行 = 安全语义反转；core 锚点与壳 store 锚点必须同源）。

package/src/jsonl-run-store.ts

@@ -76,7 +76,7 @@ import {
   type WorkflowRunEvent,
 } from "@zhushanwen/subagent-core";
 import { WorkflowRun } from "@zhushanwen/subagent-core";
-import { errorLogsFromEvents, rebuildBudget, runAccountingFromEvents } from "@zhushanwen/subagent-core";
+import { errorLogsFromEvents, latestModelOverride, rebuildBudget, runAccountingFromEvents } from "@zhushanwen/subagent-core";
 import { guardStaleCtx, isEnoentError, toErrorMessage } from "@zhushanwen/pi-ext-guards";
 
 // ── [W1 / D1] v2 条目读面（注册定界 + 终态条目抑制）────────────────
@@ -283,7 +283,7 @@ interface CallDraft {
 /**
  * record 事件流 → WorkflowRun 聚合重建（纯函数，零 IO）。
  *
- * fold 语义（词表 = run-events.ts [D4] 对齐后 9 事件）：
+ * fold 语义（词表 = run-events.ts 事件词表，单源）：
  * - `run-created`：spec.scriptSource（全文，[D1]）+ args（全文，设计 §3.1 载荷表；
  *   旧格式帧回落 argsSummary 尽力恢复——parseLegacyArgsSummary）+ startedAt 锚点
  *   （帧 ts 优先，回落注册条目 startedAt）；
@@ -294,7 +294,10 @@ interface CallDraft {
  *   形态建占位行——同 journal fold 兜底）；sessionFile/sessionId 从 result 透传
  *   （对齐 finalizeCall 的 call 字段填充纪律）；
  * - `run-settled`：终局（status=done + reason 映射 + completedAt=帧 ts）；无帧 =
- *   running（交恢复链收编）。
+ *   running（交恢复链收编）；
+ * - `model-override`：latestModelOverride 折叠 → meta.modelOverride（最新一条生效，
+ *   覆盖旧覆盖值不叠加；无覆盖不造键——详见 foldRecordStreamToRun 内
+ *   [subagent-model-switch §6.6①/§7.4] 注释，不在此重复展开）。
  *
  * record 流不承载的字段（budget 计数/errorLogs/trace 完整面）按恢复语义最小形态
  * 缺省——步骤级详情的恢复读面 = record 流直读（session-reader 家族链），不经本聚合。
@@ -506,6 +509,11 @@ function foldRecordStreamToRun(
   const calls = draftsToAgentCalls(drafts, sharedNodes, nodes);
 
   const settledEvent = lastRunSettledEvent(events);
+  // [subagent-model-switch §6.6①/§7.4] 覆盖记账折叠（派生视图半边）：生效覆盖值 =
+  // 最新一条（latestModelOverride core 单点——覆盖旧覆盖值不叠加，不变量 2）；
+  // 无覆盖 undefined 不造键。fold 未跟时本行缺失 = 覆盖状态静默丢行——
+  // jsonl-run-store-loadall 的 fold 消费用例是此丢行风险的机器防线（P8 第五道）。
+  const modelOverride = latestModelOverride(events);
   if (settledEvent === undefined) {
     const interruptedAt = lastInterruptedAt(events);
     return WorkflowRun.reconstruct(
@@ -524,6 +532,7 @@ function foldRecordStreamToRun(
         //（CLI/TUI 不显示僵尸「运行中」；resume 资格判据在 core fold lifecycle，
         // 不受本投影影响）。
         ...(interruptedAt !== undefined ? { interruptedAt } : {}),
+        ...(modelOverride !== undefined ? { modelOverride } : {}),
       },
     );
   }
@@ -543,6 +552,7 @@ function foldRecordStreamToRun(
     {
       startedAt: startedAtIso,
       completedAt: new Date(settledEvent.ts).toISOString(),
+      ...(modelOverride !== undefined ? { modelOverride } : {}),
     },
   );
 }

package/src/workflow-events.ts

@@ -402,6 +402,28 @@ export function setupWorkflowDomain(
         }
         return service.executeWorkflowAgent(opts, parentRunId, signal, undefined, undefined, stepIndex);
       },
+      // [F1-18 修复] resume 显式 model 落账后的宿主投影同步（生产接线——单例现读
+      // 同 workflowAgentDispatch 形态）。实现 = SubagentService.applyRunOverrideProjection
+      // （覆盖内存表写值 + 重建负缓存作废）；throw 走 resume 侧回滚围栏（run 回
+      // interrupted 可重试），service 缺席文案同款 [C2] 闭环。
+      onResumeModelOverrideCommitted: (runId, override) => {
+        const service = getSubagentService();
+        if (!service) {
+          throw new Error(
+            "resume model override projection unavailable: subagent service not initialized " +
+              "(session_start assembly failed). Recovery: retry the resume once the session " +
+              "is initialized; the override frame is already persisted in the run journal.",
+          );
+        }
+        service.applyRunOverrideProjection(runId, override);
+      },
+      // [dmg-r2-5] 宿主会话锚现读口（run-created 帧 rootSessionId 载荷源）：与
+      // workflowAgentDispatch 同款 service 单例现读形态——sessionRootId 根进程语义
+      // 与 record 域 rootSessionId 同源（根进程 = 本 session id，嵌套 = env ROOT）。
+      // 同 cwd 多会话共享 workflow-state 目录，runtime 网关 runId 路由靠该字段精确
+      // 判归属；service 缺席返回 null（帧不落字段，读侧旧格式行放行——不抛，创建
+      // 主链不因锚缺席失败）。
+      getSessionRootId: () => getSubagentService()?.getSessionRootId() ?? null,
       log,
     };
     return deps;
@@ -702,6 +724,20 @@ export function setupWorkflowDomain(
     // "sar-unattached" → armed 回执落账键错 → fold 出 created 态 → IllegalTransitionError
     // 让位，run journal 恒缺 armed 帧（真机 wf-1790034646281-w7tp4f 实证链，R2 裁决）。
     get workflowAgentDispatch() { return createLazy(resolveDeps, "workflowAgentDispatch"); },
+    // [dmg-r2-5] 宿主会话锚必须随 lazyDeps 转发（workflowAgentDispatch 同款先例）：
+    // workflow tool / subagents tool 的 run action 以 lazyDeps 为 deps 启动 run，漏本
+    // 成员则 run-created 帧不落 rootSessionId（可选成员静默放行）——同 cwd 多会话下
+    // runtime 网关 runId 路由恒回落目录存在性弱锚，精确归属形同虚设。
+    get getSessionRootId() { return createLazy(resolveDeps, "getSessionRootId"); },
+    // [dmg-r1-1] resume 显式 model 落账回调必须随 lazyDeps 转发（getSessionRootId
+    // 同款先例，同族第三例）：三个生产入口（registerWorkflowTool / registerSubagentsTool /
+    // registerWorkflowsCommand）都以 lazyDeps 为 deps 启动 run，resume with model 的
+    // 落账点（resume-run appendResumeModelOverride）落完 journal B 帧后经本回调同步
+    // 宿主投影——漏本成员则可选链静默短路（可选成员静默放行）：覆盖内存表 /
+    // 负缓存 stale 不失效，重派被旧投影遮蔽（旧 model 命中或覆盖丢失按 run-created.model
+    // 解析），pi 仍 notify「resuming with model B」成功文案。转发清单对账测试防第四处
+    // 漏转发（workflow-events.test.ts lazyDeps 转发清单对账 describe）。
+    get onResumeModelOverrideCommitted() { return createLazy(resolveDeps, "onResumeModelOverrideCommitted"); },
     // scheduleTimeBudget / appendEntry 不可缺席（ports.ts D-12 regression fix 同族）：
     // rebuildRuntime 重排 run 级墙钟预算计时器、finalizeRun 的 pending:unregister
     // 直落都经这两个成员消费——lazyDeps 缺席会让消费点拿到 undefined（可选属性