@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/src/index.ts

@@ -24,7 +24,7 @@
 // 0.4.0 = 首个公开发布的收敛收口面（0.3.0 为 2026-08-30 裁决的跳号占位，永不单独
 // 发布；+ minor changeset 收口面落本号）；与 package.json version 的一致性由
 // src/__tests__/smoke.test.ts 动态守护，改版本须两处同步。
-export const CORE_PACKAGE_VERSION = "0.8.0";
+export const CORE_PACKAGE_VERSION = "0.9.0";
 
 // ── 宿主端口接线面（core/）────────────────────────────────────
 // HostServices：dataRoot / log / discoveryRoots 端口 + configureCore 注入；
@@ -66,8 +66,6 @@ export type {
   EngineCapabilities,
   EngineHandle,
   EngineHandleData,
-  InteractAction,
-  InteractResult,
   ProbeReport,
   ReplayedTurn,
   SessionView,
@@ -212,13 +210,16 @@ export {
 // globalThis[Symbol.for] slot 防 jiti 多实例分裂，/resume /fork 复用既有实例
 // （SR-3/SR-4 语义）。createSubagentService / SubagentServiceInit 为构造依赖参数
 // 注入形态（modelService 等，无全局查找，@experimental U10 / D6）。
+// [H3/R6] 单例访问器 + Init 接口外移支撑文件 service/service-bootstrap.ts，本
+// barrel 直接改指向该文件（导出符号面不变；壳对 bootstrap 零 re-export——防壳↔
+// bootstrap 值环，设计 v4 import 纪律）。对外消费方零感知。
+export { SubagentService } from "./execution/subagent-service.ts";
 export {
-  SubagentService,
   getSubagentService,
   setSubagentService,
   createSubagentService,
   type SubagentServiceInit,
-} from "./execution/subagent-service.ts";
+} from "./execution/service/service-bootstrap.ts";
 // notifyGateAllowsDelivery：closedReason → 投递许可判定（通知门）——
 // 投递内核与壳侧 notify 链的共同语义锚点（execution 生产域消费，A2a）。
 export { notifyGateAllowsDelivery } from "./execution/subagent-service.ts";

package/src/orchestration/__tests__/agent-call-catch-fallback.test.ts

@@ -135,13 +135,12 @@ describe("U7a: catch 分支兜底回发 agent-result（非 Abort 异常）", ()
       expect(posted.result.error).toBe("runner exploded");
       expect(posted.result.content).toBe("");
 
-      // state 一致性三件套（review should_fix）：
+      // state 一致性三件套（review should_fix；[H2 W3] trace.live 字段已删除，
+      // 「live 清除」由类型层面收敛——节点无运行期附属对象）：
       // trace node 标 failed（不遗留 running 幽灵节点）
       const traceNode = run.state.trace.find(2);
       expect(traceNode?.status).toBe("failed");
       expect(traceNode?.result?.error).toBe("runner exploded");
-      // node.live 清除（防内存泄漏）
-      expect(traceNode?.live).toBeUndefined();
       // 持久化（catch 是最需留证的场景）
       expect(deps.store.save).toHaveBeenCalled();
     } finally {

package/src/orchestration/__tests__/agent-call-stream.test.ts

@@ -1,10 +1,18 @@
 // src/orchestration/__tests__/agent-call-stream.test.ts
 //
-// U4: dispatchAgentCall 创建 SubagentStream 并在 agent call 结束后 dispose
-// U5: dispatchAgentCall widgetKey 格式 = subagent-stream-<runId>-<stepIndex>
-// U6: streamSink 为 undefined 时 dispatchAgentCall 不创建 stream 不报错
+// [H2 W3] 原 U4/U5（dispatchAgentCall 创建 SubagentStream + widgetKey 格式）与
+// U6（streamSink undefined 降级）锁定的是 pump 旁路 streaming 通道——该族随设计
+// subagent-workflow-record-unification.md D2「stream 通道承接」退役：pump 不再
+// 构造 SubagentStream（streaming 由 service 派发路径既有通道承载）。
 //
-// 通过 handleWorkerMessage 触发 dispatchAgentCall（内部函数不 export）。
+// [R2-5] streamSink 注入面已彻底删除（LifecycleDeps 死字段清理）：U4' 的运行时
+// 负向断言（「streamSink 已注入 → setWidget 零调用」）前提消失，改为**编译期结构
+// 断言**（下方 HasStreamSink）——字段若被重新引入，keyof LifecycleDeps 重新出现
+// "streamSink"，类型断言立即编译红；比运行时负向用例更强的永久护栏。
+//
+// 本文件现锁定：
+// - U4'（编译期）：LifecycleDeps 不再有 streamSink 注入面
+// - U6（运行时）：最简 deps（无 stream 通道）下 runner.run 仍被调用，无异常
 
 import { describe, expect, it, vi } from "vitest";
 
@@ -52,9 +60,8 @@ function makeRunningRun(runId: string): WorkflowRun {
   } as unknown as WorkflowRun;
 }
 
-/** LifecycleDeps mock，runner.run 可控制返回值，streamSink 可配置 */
+/** LifecycleDeps mock（runner.run 可控制返回值；streamSink 注入面已随 [R2-5] 删除） */
 function makeDeps(opts: {
-  streamSink?: { setWidget: ReturnType<typeof vi.fn> };
   runnerResult?: AgentResult;
 } = {}): LifecycleDeps {
   return {
@@ -65,7 +72,6 @@ function makeDeps(opts: {
     eventBus: { emit: vi.fn() },
     onRunDone: vi.fn(),
     log: vi.fn(),
-    streamSink: opts.streamSink,
   } as unknown as LifecycleDeps;
 }
 
@@ -87,50 +93,20 @@ function makeAgentCallMsg(callId: number): unknown {
   };
 }
 
-// ── U4: dispatchAgentCall 创建 SubagentStream 并 dispose ──
-
-describe("U4: dispatchAgentCall stream dispose", () => {
-  it("agent call 结束后 stream.dispose 被调用（setWidget 末次 lines=undefined）", async () => {
-    const setWidget = vi.fn();
-    const deps = makeDeps({ streamSink: { setWidget } });
-    const run = makeRunningRun("wf-test-123");
-    const handlers = makeHandlers();
-
-    await handleWorkerMessage(run, makeAgentCallMsg(0), deps, handlers);
-    // dispatchAgentCall 内部 void withSlot(...)（fire-and-forget），需等 microtask 完成
-    await vi.waitFor(() => {
-      expect(setWidget.mock.calls.length).toBeGreaterThanOrEqual(1);
-    });
-
-    const calls = setWidget.mock.calls;
-    const lastCall = calls[calls.length - 1];
-    expect(lastCall[1]).toBeUndefined();
-  });
-});
-
-// ── U5: widgetKey 格式 ──
-
-describe("U5: widgetKey 格式", () => {
-  it("widgetKey = subagent-stream-<runId>-<stepIndex>", async () => {
-    const setWidget = vi.fn();
-    const deps = makeDeps({ streamSink: { setWidget } });
-    const run = makeRunningRun("wf-test-123");
-    const handlers = makeHandlers();
+// ── U4': stream 通道退役（编译期结构断言，[R2-5]） ──
 
-    await handleWorkerMessage(run, makeAgentCallMsg(2), deps, handlers);
-    await vi.waitFor(() => {
-      expect(setWidget.mock.calls.length).toBeGreaterThanOrEqual(1);
-    });
-
-    const widgetKey = setWidget.mock.calls[0]![0] as string;
-    expect(widgetKey).toBe("subagent-stream-wf-test-123-2");
-  });
-});
+/** "streamSink" ∈ keyof LifecycleDeps 时为 true——与下方显式 false 标注冲突即编译红。 */
+type HasStreamSink = "streamSink" extends keyof LifecycleDeps ? true : false;
+// 结构断言本体：字段已删 = false。若有人重新引入 streamSink 字段，本行类型错误，
+// tsc / vue-tsc 拦截（vitest 转译不做类型检查；类型门由 pre-commit/CI 的 tsc 面
+// 覆盖——比运行时负向用例更强的注入面消失护栏）。
+const assertNoStreamSinkField: HasStreamSink = false;
+void assertNoStreamSinkField;
 
-// ── U6: streamSink 为 undefined 时不报错 ──
+// ── U6: 最简 deps 下派发不报错 ──
 
-describe("U6: streamSink undefined 降级", () => {
-  it("streamSink=undefined → runner.run 仍被调用，无异常", async () => {
+describe("U6: 最简 deps（无 stream 通道）→ runner.run 仍被调用，无异常", () => {
+  it("dispatchAgentCall 不依赖 stream 注入面 → runner.run 正常派发", async () => {
     const runnerRun = vi.fn(async () => makeMockResult());
     const deps = {
       store: { save: vi.fn(async () => {}) },
@@ -140,7 +116,6 @@ describe("U6: streamSink undefined 降级", () => {
       eventBus: { emit: vi.fn() },
       onRunDone: vi.fn(),
       log: vi.fn(),
-      // streamSink 不设 = undefined
     } as unknown as LifecycleDeps;
     const run = makeRunningRun("wf-test-456");
     const handlers = makeHandlers();

package/src/orchestration/__tests__/error-recovery-terminal-hardening.test.ts

@@ -10,8 +10,9 @@
  * - OR-6 主线程半边：{type:"log"} 计入 errorLogs + deps.log debug 留痕（含上限裁剪）；
  *   未知 type warn 留痕（协议漂移防线）
  * - OR-8：脚本 return 时残留 fire-and-forget in-flight call 收口为取消终态
- *   （call done + trace failed + Cancelled 文案 + completedAt + live 清除），
- *   先收口再落盘——done 快照不含 running 节点
+ *   （call done + trace failed + Cancelled 文案 + completedAt；[H2 W3] trace.live
+ *   字段已删除——节点无运行期附属对象可滞留），先收口再落盘——done 快照不含
+ *   running 节点
  */
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
@@ -320,12 +321,11 @@ describe("[OR-8] run done 时残留 in-flight call 收口 cancelled", () => {
     // call 收口为 done + 取消文案（不删除条目——保留调用痕迹）
     expect(call?.status).toBe("done");
     expect(call?.result?.error).toContain("Cancelled");
-    // trace 节点 failed + completedAt + live 清除（快照/GUI 不再显示 running 步骤）
+    // trace 节点 failed + completedAt（快照/GUI 不再显示 running 步骤）
     const node = run.state.trace.find(1);
     expect(node?.status).toBe("failed");
     expect(node?.error).toContain("Cancelled");
     expect(node?.completedAt).toBeDefined();
-    expect(node?.live).toBeUndefined();
     // 持久化快照（收口先于 save）不含 running 形态
     const snap = toRunSnapshot(run);
     expect(snap.state.calls.map((c) => c.status)).toEqual(["done"]);

package/src/orchestration/__tests__/file-run-store.test.ts

@@ -298,13 +298,15 @@ describe("FileRunStore — 版本衔接与 live-strip（U8 / ⛔5，D4 裁决）
     expect(JSON.parse(raw).v).toBe("wf-run-v2");
 
     // 存量行宽容读 → 再 save：落盘行升级为带 v 当前版本（不做自动迁移的
-    // 渐进收敛——D4 裁决②「写入时补 v」）
+    // 渐进收敛——D4 裁决②「写入时补 v」）。[H2 W3] live 字段退役后 codec 不再
+    // 承担键清洗（strip 分支随字段删除退役）——存量行的多余键原样透传（类型
+    // 层面已无写点，新写行不可能再产生 live 键；真实存量行经旧 codec strip 也不带）。
     writeStateFile("wf-legacy-2.jsonl", LEGACY_LINE + "\n");
     const legacy = (await store.loadAll()).find((r) => r.runId === "wf-legacy-1")!;
     await store.save(legacy);
     const migrated = readFileSync(store.stateFilePath("wf-legacy-1"), "utf8").trim();
     expect(JSON.parse(migrated).v).toBe("wf-run-v2");
-    expect(migrated.includes('"live"')).toBe(false);
+    expect(JSON.parse(migrated).state.status).toBe("running");
   });
 
   it("⛔5 未知更高版本行跳过 + warn（消息含实际版本值，可定位）", async () => {
@@ -326,7 +328,7 @@ describe("FileRunStore — 版本衔接与 live-strip（U8 / ⛔5，D4 裁决）
     expect(warnMessages().some((m) => m.includes("unsupported version") && m.includes("wf-run-v3"))).toBe(true);
   });
 
-  it("⛔5 live 字段 strip 后落盘（落盘行无 live 键，内存 run 不受影响）", async () => {
+  it("⛔5 [H2 W3] live 字段退役：落盘行无 live 键（类型层面收敛的端到端回归）", async () => {
     const run = makeRun("wf-livestrip-1");
     const node: import("../models/types.ts").ExecutionTraceNode = {
       stepIndex: 0,
@@ -334,20 +336,16 @@ describe("FileRunStore — 版本衔接与 live-strip（U8 / ⛔5，D4 裁决）
       task: "do work",
       model: "test-model",
       status: "running",
-      live: undefined,
     };
     run.state.trace.append(node);
     const AgentCallMod = await import("../models/agent-call.ts");
     const call = new AgentCallMod.AgentCall(0, { prompt: "do work" }, node);
     run.state.calls.set(0, call);
-    node.live = { id: "run-0", turns: [] } as unknown as import("../../execution/types.ts").ExecutionRecord;
 
     await store.save(run);
 
     const raw = readFileSync(store.stateFilePath("wf-livestrip-1"), "utf8");
     expect(raw.includes('"live"')).toBe(false);
-    // strip 产出快照副本：内存中 run 的 live 保留（save 后 run 可继续跑）
-    expect(node.live).toBeDefined();
   });
 
   it("pi 现网形态行（带 v）经 store 端到端恢复", async () => {

package/src/orchestration/__tests__/lifecycle-abort-broadcast-signal.test.ts

@@ -160,14 +160,13 @@ describe("[OR-3] abort 广播（abortRun / terminateRunningRuns）", () => {
     const deps = makeDeps();
     const runId = await runWorkflow(makeSpec(), deps);
     const run = deps.runs.get(runId)!;
-    // 注入 in-flight call（真实 AgentCall 实例：running + live record）
+    // 注入 in-flight call（真实 AgentCall 实例：running）
     const node: ExecutionTraceNode = {
       stepIndex: 1,
       agent: "a",
       task: "t",
       model: "m",
       status: "running",
-      live: { turns: [] } as never,
     };
     run.state.trace.append(node);
     const call = new AgentCall(1, { prompt: "t" }, node);
@@ -176,7 +175,7 @@ describe("[OR-3] abort 广播（abortRun / terminateRunningRuns）", () => {
 
     await abortRun(runId, deps, "mid-flight abort");
 
-    // 收口：call done + trace failed（Cancelled 文案）+ live 清除
+    // 收口：call done + trace failed（Cancelled 文案；[H2 W3] trace.live 已删除）
     expect(call.status).toBe("done");
     expect(call.result?.error).toContain("Cancelled");
     expect(run.state.trace.find(1)?.status).toBe("failed");

package/src/orchestration/__tests__/run-snapshot.test.ts

@@ -3,7 +3,8 @@
 // 四视角：
 // ①使用者——toRunSnapshot/fromRunSnapshot 往返等值（含 pi 壳 jsonl-run-store
 //   serializeRun 现网形态样本：键序/v 字段/无 live 的快照行，⛔5 往返逐字节一致）；
-// ②隔离者——live-strip 产出新对象，不 mutate 内存中的 run（save 后 run 可继续跑）；
+// ②隔离者——[H2 W3] ExecutionTraceNode.live 字段退役后节点无运行期附属对象，
+//   序列化直出无 live 键（strip 分支随字段删除退役，防御回归锁定）；
 // ③幸存者——版本 guard（D4 裁决③：v 不匹配即拒，字符串无大小序）+ 形状校验
 //   全分支不抛（返回 undefined）；
 // ④接线者——「缺 v 宽容」不内聚进 codec（D4 裁决②归属：store 层预处理职责，
@@ -47,33 +48,10 @@ function makeRun(runId: string, opts: { status?: "running" | "done" } = {}): Wor
   );
 }
 
-/** 最小 live 执行进度对象（strip 逻辑只解构键名，值形态不可达——对齐
- *  lifecycle-predicates.test.ts 的 partial + as ExecutionRecord 先例）。 */
-function makeLiveRecord(id: string): ExecutionRecord {
-  return {
-    id,
-    agent: "coder",
-    model: "test-model",
-    thinkingLevel: undefined,
-    mode: "background",
-    task: "do work",
-    slug: "do-work",
-    startedAt: 0,
-    rootSessionId: undefined,
-    parentRecordId: undefined,
-    depth: 0,
-    status: "running",
-    turns: [],
-    turnCount: 0,
-    totalTokens: 0,
-    lastError: undefined,
-    round: 0,
-    endedAt: undefined,
-    result: undefined,
-    error: undefined,
-    agentResult: undefined,
-    controller: undefined,
-  } as ExecutionRecord;
+/** 最小多余键载体（[H2 W3] live 字段退役后的防御样本——模拟旧版本运行期对象
+ *  残留的多余键，重水合链路的丢弃行为回归用）。 */
+function makeStaleExtraKey(): Record<string, unknown> {
+  return { stale: "legacy-key" };
 }
 
 /**
@@ -204,49 +182,55 @@ describe("run-snapshot — toRunSnapshot/fromRunSnapshot 往返等值", () => {
   });
 });
 
-describe("run-snapshot — live-strip 防御内聚", () => {
-  it("trace 节点与 calls[].traceNode 带 live → 序列化输出无 live 键", () => {
-    const run = makeRun("wf-live-1");
+describe("run-snapshot — [H2 W3] live 字段退役后的序列化行为", () => {
+  it("running 节点（类型已无 live 字段）全量直出：序列化无 live 键且往返保真", () => {
+    const run = makeRun("wf-nolive-1");
     const node: ExecutionTraceNode = {
       stepIndex: 0,
       agent: "coder",
       task: "do work",
       model: "test-model",
       status: "running",
-      live: undefined,
     };
     run.state.trace.append(node);
     const call = new AgentCall(0, { prompt: "do work" }, node);
     run.state.calls.set(0, call);
-    // D-10：call.traceNode 与 trace 节点共享引用，live 挂节点上（running 态常态）
-    node.live = makeLiveRecord("run-0");
 
     const snap = toRunSnapshot(run);
     const serialized = JSON.stringify(snap);
 
+    // strip 分支随 ExecutionTraceNode.live 字段删除退役——节点不再携带运行期对象，
+    // 序列化直出即无 live 键（类型层面收敛的行为回归锁定）
     expect(serialized.includes('"live"')).toBe(false);
     expect(snap.state.trace[0]).not.toHaveProperty("live");
     expect(snap.state.calls[0].traceNode).not.toHaveProperty("live");
+
+    const back = fromRunSnapshot(JSON.parse(serialized))!;
+    expect(back.state.trace.toArray()[0]?.status).toBe("running");
+    expect(back.state.trace.toArray()[0]?.task).toBe("do work");
   });
 
-  it("strip 产出新对象，不 mutate 内存 run（save 后 run 可继续跑）", () => {
-    const run = makeRun("wf-live-2");
+  it("运行期多余键残留不进重水合快照的往返链（防御回归）", () => {
+    const run = makeRun("wf-stale-1");
     const node: ExecutionTraceNode = {
       stepIndex: 0,
       agent: "coder",
       task: "do work",
       model: "test-model",
       status: "running",
-      live: undefined,
     };
-    run.state.trace.append(node);
-    node.live = makeLiveRecord("run-0");
+    // 模拟旧版本运行期对象残留的多余键（类型外 attach）
+    const withStale = Object.assign(node, makeStaleExtraKey()) as ExecutionTraceNode;
+    run.state.trace.append(withStale);
 
-    toRunSnapshot(run);
+    const snap = toRunSnapshot(run);
+    // trace 直出拷贝会带多余键（codec 不再承担键清洗——多余键是调用方脏数据，
+    // 正常路径类型层面已无写点）；但 JSON 往返后重水合按 Trace.fromArray 拷贝，
+    // 快照行保持可解析、状态保真
+    expect(JSON.parse(JSON.stringify(snap)).state.trace[0].status).toBe("running");
 
-    // 原节点 live 保留（运行期消费面——TUI 事件流投影——不受落盘影响）
-    expect(node.live).toBeDefined();
-    expect(node.live!.id).toBe("run-0");
+    const back = fromRunSnapshot(JSON.parse(JSON.stringify(snap)))!;
+    expect(back.state.trace.toArray()[0]?.status).toBe("running");
   });
 });