@zhushanwen/subagent-core 0.6.0 → 0.7.0

package/src/execution/__tests__/idle-gc.test.ts

@@ -0,0 +1,200 @@
+// src/execution/__tests__/idle-gc.test.ts
+//
+// [W4] idle-gc 扩展单测：startedAt 锚归档（无 idleSince 的 resumable record）、
+// 只归档不补注销（archive 不发 pending:unregister——注销统一交对账 sweep）、
+// WorkflowRun store 纳入（startedAt 锚终态化 + save）。fake timers 推进 GC
+// interval；RecordStore 用 mkdtemp 自建目录 + pi=null（archive 纯内存，零磁盘写）。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createRecord } from "../execution-record.ts";
+import { startIdleGc } from "../idle-gc.ts";
+import { RecordStore } from "../record-store.ts";
+import type { ExecutionRecord } from "../types.ts";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+const GC_INTERVAL_MS = 60 * 60 * 1000;
+
+let tmpDir: string;
+let stop: (() => void) | undefined;
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "idle-gc-"));
+});
+
+afterEach(() => {
+  stop?.();
+  stop = undefined;
+  fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  vi.useRealTimers();
+});
+
+function makeStore(): RecordStore {
+  return new RecordStore(path.join(tmpDir, "sessions"));
+}
+
+function makeRecord(id: string, overrides: Partial<ExecutionRecord> = {}): ExecutionRecord {
+  const record = createRecord(id, {
+    agent: "worker",
+    model: "m",
+    mode: "background",
+    task: "t",
+    slug: "s",
+    startedAt: Date.now(),
+    rootSessionId: "sess-root",
+  });
+  record.resumable = true;
+  Object.assign(record, overrides);
+  return record;
+}
+
+describe("idle-gc record 锚扩展（W4）", () => {
+  it("无 idleSince 的 resumable record 以 startedAt 为锚：超 30 天归档", async () => {
+    const store = makeStore();
+    const stale = makeRecord("bg-old", { startedAt: Date.now() - 31 * DAY_MS });
+    store.register(stale);
+    const fresh = makeRecord("bg-new", { startedAt: Date.now() - 1 * DAY_MS });
+    store.register(fresh);
+    const unregisterEmit = vi.fn();
+    stop = startIdleGc(store, undefined);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+    expect(store.getMutable("bg-old")).toBeUndefined(); // 已归档（内存移除）
+    expect(store.getMutable("bg-new")).toBeDefined();
+    expect(unregisterEmit).not.toHaveBeenCalled();
+  });
+
+  it("有 idleSince 的 resumable record 仍以 idleSince 为锚（现状语义保持）", async () => {
+    const store = makeStore();
+    const rec = makeRecord("bg-1", {
+      startedAt: Date.now() - 1 * DAY_MS,
+      idleSince: Date.now() - 31 * DAY_MS,
+    });
+    store.register(rec);
+    stop = startIdleGc(store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+    expect(store.getMutable("bg-1")).toBeUndefined();
+  });
+
+  it("锚窗内（30 天量级以内）不归档", async () => {
+    const store = makeStore();
+    const rec = makeRecord("bg-1", { startedAt: Date.now() - 29 * DAY_MS });
+    store.register(rec);
+    stop = startIdleGc(store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+    expect(store.getMutable("bg-1")).toBeDefined();
+  });
+
+  it("只归档不补注销：archive 不发 pending:unregister（store pi=null 且不注入 emit 通道）", async () => {
+    const store = makeStore();
+    let appendCalls = 0;
+    // pi=null 构造后再注入 spy 形态的 pi——archive 的唯一出站面是 pi.appendEntry
+    //（reportSubagentRecord）。归档必须零注销发射（发射点枚举 5 处不含 GC）。
+    const rec = makeRecord("bg-1", { startedAt: Date.now() - 31 * DAY_MS });
+    store.register(rec);
+    store.setPi({ appendEntry: () => { appendCalls += 1; } });
+    stop = startIdleGc(store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+    expect(store.getMutable("bg-1")).toBeUndefined();
+    // archive 自身的 subagent-record entry 上报不构成注销；断言无 pending:unregister
+    // 形态调用由「startIdleGc 签名不持有 pi/emit 通道」结构性保证（类型层）。
+    expect(appendCalls).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe("idle-gc WorkflowRun store 纳入（W4）", () => {
+  function makeWorkflowStore(runs: Array<{
+    runId: string;
+    status: string;
+    startedAt: string;
+  }>) {
+    const transitions: Array<{ runId: string; reason?: string }> = [];
+    const saved: string[] = [];
+    return {
+      store: {
+        loadAll: async () =>
+          runs.map((r) => ({
+            runId: r.runId,
+            state: { status: r.status },
+            meta: { startedAt: r.startedAt },
+            transition: (_target: "done", reason?: string) => {
+              transitions.push({ runId: r.runId, reason });
+            },
+          })),
+        save: async (run: { runId: string }) => {
+          saved.push(run.runId);
+        },
+      },
+      transitions,
+      saved,
+    };
+  }
+
+  it("running 且 startedAt 超 30 天 → transition(done, time_limited) + save", async () => {
+    const { store, transitions, saved } = makeWorkflowStore([
+      { runId: "wf-old", status: "running", startedAt: new Date(Date.now() - 31 * DAY_MS).toISOString() },
+    ]);
+    const recordStore = makeStore();
+    stop = startIdleGc(recordStore, store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+    expect(transitions).toEqual([{ runId: "wf-old", reason: "time_limited" }]);
+    expect(saved).toEqual(["wf-old"]);
+  });
+
+  it("窗内 running / 已终态 run 不动", async () => {
+    const { store, transitions, saved } = makeWorkflowStore([
+      { runId: "wf-new", status: "running", startedAt: new Date(Date.now() - 1 * DAY_MS).toISOString() },
+      { runId: "wf-done", status: "done", startedAt: new Date(Date.now() - 40 * DAY_MS).toISOString() },
+    ]);
+    stop = startIdleGc(makeStore(), store);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+    expect(transitions).toEqual([]);
+    expect(saved).toEqual([]);
+  });
+
+  it("loadAll 抛错（宿主未 configureCore）→ 单轮跳过不炸 interval", async () => {
+    const failing = {
+      loadAll: async () => {
+        throw new Error("core_host_not_configured");
+      },
+      save: async () => {},
+    };
+    stop = startIdleGc(makeStore(), failing);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS * 2 + 1);
+    // 两次扫描周期都存活（未抛出即通过）。
+  });
+
+  it("save 抛错 → 吞错留痕，不阻断其余 run", async () => {
+    const transitions: Array<{ runId: string; reason?: string }> = [];
+    const failing = {
+      loadAll: async () => [
+        {
+          runId: "wf-a",
+          state: { status: "running" },
+          meta: { startedAt: new Date(Date.now() - 31 * DAY_MS).toISOString() },
+          transition: (_t: "done", reason?: string) => {
+            transitions.push({ runId: "wf-a", reason });
+          },
+        },
+        {
+          runId: "wf-b",
+          state: { status: "running" },
+          meta: { startedAt: new Date(Date.now() - 32 * DAY_MS).toISOString() },
+          transition: (_t: "done", reason?: string) => {
+            transitions.push({ runId: "wf-b", reason });
+          },
+        },
+      ],
+      save: async (run: { runId: string }) => {
+        if (run.runId === "wf-a") throw new Error("EIO");
+      },
+    };
+    stop = startIdleGc(makeStore(), failing);
+    await vi.advanceTimersByTimeAsync(GC_INTERVAL_MS + 1);
+    expect(transitions.map((t) => t.runId).sort()).toEqual(["wf-a", "wf-b"]);
+  });
+});

package/src/execution/__tests__/lifecycle-predicates.test.ts

@@ -1,7 +1,9 @@
-// lifecycle-predicates 单测（v4 B-1）。
+// lifecycle-predicates 单测（v4 B-1；W6 随拆依赖改写：读点改 core 侧状态镜像）。
 // 验证 isIdle/isResumable/hasLiveProcessHandle 在两态收敛后的判定逻辑。
-// 依赖 lifecycle-manager 模块级 idleTimers 与 session-runner.spawnedChildren（单例 Map），
-// beforeEach 重置隔离。
+// 依赖 lifecycle-manager 模块级 idleTimers 与 core 侧 spawnedChildren 镜像
+// （engine/host/spawned-children.ts），beforeEach 重置隔离。
+// [W3 改写] inproc 过渡桥并读用例随 inproc pi 引擎目录 删除消亡——镜像成为唯一数据源
+// （host/childSpawned 上报 + 终止意图置死位），等价性用例的「并读」语义不再存在。
 
 import { describe, it, expect, beforeEach } from "vitest";
 
@@ -10,8 +12,10 @@ import {
   disarmIdleTimer,
   _resetLifecycleState,
 } from "../lifecycle-manager.ts";
-import { spawnedChildren } from "../engine/engines/pi/session-runner.ts";
-import type { ChildProcess } from "node:child_process";
+import {
+  coreSpawnedChildrenMirror,
+  _resetCoreSpawnedChildrenMirrorForTest,
+} from "../engine/host/spawned-children.ts";
 import type { ExecutionRecord } from "../types.ts";
 
 import { hasLiveProcessHandle, isIdle, isResumable } from "../lifecycle-predicates.ts";
@@ -44,16 +48,10 @@ function makeRecord(overrides: Partial<ExecutionRecord> = {}): ExecutionRecord {
   } as ExecutionRecord;
 }
 
-/** 构造最小 ChildProcess fake（hasLiveProcessHandle 只读 .killed）。 */
-function fakeChild(killed: boolean): ChildProcess {
-  // 测试 fake：被测代码仅读 .killed，其余字段不可达，用 unknown 中转满足 Map 类型。
-  return { killed } as unknown as ChildProcess;
-}
-
 describe("lifecycle-predicates (v4 B-1)", () => {
   beforeEach(() => {
     _resetLifecycleState();
-    spawnedChildren.clear();
+    _resetCoreSpawnedChildrenMirrorForTest();
   });
 
   describe("isIdle (= hasIdleTimer)", () => {
@@ -75,20 +73,27 @@ describe("lifecycle-predicates (v4 B-1)", () => {
     });
   });
 
-  describe("hasLiveProcessHandle", () => {
-    it("no child in map → false", () => {
+  describe("hasLiveProcessHandle（W6 改读镜像）", () => {
+    it("no mirror entry → false", () => {
       expect(hasLiveProcessHandle("sa-test")).toBe(false);
     });
 
-    it("child present and not killed → true", () => {
-      spawnedChildren.set("sa-test", fakeChild(false));
+    it("mirror entry running (not killed) → true", () => {
+      coreSpawnedChildrenMirror().register("sa-test", { pid: 1, killed: false });
       expect(hasLiveProcessHandle("sa-test")).toBe(true);
     });
 
-    it("child present but killed → false", () => {
-      spawnedChildren.set("sa-test", fakeChild(true));
+    it("mirror entry killed → false", () => {
+      coreSpawnedChildrenMirror().register("sa-test", { pid: 1, killed: true });
       expect(hasLiveProcessHandle("sa-test")).toBe(false);
     });
+
+    it("mirror markKilled 置死后 → false", () => {
+      coreSpawnedChildrenMirror().register("sa-test", { pid: 1, killed: false });
+      coreSpawnedChildrenMirror().markKilled("sa-test");
+      expect(hasLiveProcessHandle("sa-test")).toBe(false);
+    });
+
   });
 
   describe("isResumable (= running && !hasLiveProcessHandle)", () => {
@@ -96,9 +101,9 @@ describe("lifecycle-predicates (v4 B-1)", () => {
       expect(isResumable(makeRecord({ status: "running" }))).toBe(true);
     });
 
-    it("running + live process → false (Path A 保活 / 正在执行)", () => {
+    it("running + live process (镜像) → false (Path A 保活 / 正在执行)", () => {
       const rec = makeRecord({ status: "running" });
-      spawnedChildren.set(rec.id, fakeChild(false));
+      coreSpawnedChildrenMirror().register(rec.id, { pid: 1, killed: false });
       expect(isResumable(rec)).toBe(false);
     });
 
@@ -108,7 +113,7 @@ describe("lifecycle-predicates (v4 B-1)", () => {
 
     it("closed + live process → false (终态优先)", () => {
       const rec = makeRecord({ status: "closed" });
-      spawnedChildren.set(rec.id, fakeChild(false));
+      coreSpawnedChildrenMirror().register(rec.id, { pid: 1, killed: false });
       expect(isResumable(rec)).toBe(false);
     });
   });

package/src/execution/__tests__/nested-visibility-env-propagation.test.ts

@@ -20,8 +20,9 @@ import {
   finalizedMarkerModule,
   fsSyncModule,
   manifestStoreModule,
-  tempPromptModule,
 } from "./helpers/subagent-service-mocks.ts";
+import { registerFakePiEngine } from "./helpers/fake-engine-port.ts";
+import { clearEngines } from "../engine/registry.ts";
 
 // ── mock modules ──
 
@@ -30,7 +31,6 @@ vi.mock("node:fs", async (importOriginal) => fsSyncModule(await importOriginal<t
 vi.mock("../alive-store.ts", async (importOriginal) => aliveStoreModule(await importOriginal<typeof import("../alive-store.ts")>()));
 vi.mock("../finalized-marker.ts", () => finalizedMarkerModule());
 vi.mock("../manifest-store.ts", () => manifestStoreModule());
-vi.mock("../engine/engines/pi/temp-prompt.ts", () => tempPromptModule());
 
 import { spawn } from "node:child_process";
 
@@ -132,6 +132,9 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
   });
 
   it("TC-3d: 子进程 execute 创建的 record.rootSessionId = env 贯穿的真 ROOT", async () => {
+    // [W3] 协议替身挂起（engine.run 不 settle）——record 保持 running 在 store 可观察
+    clearEngines();
+    registerFakePiEngine();
     process.env[ENV_ROOT_SESSION_ID] = "root-main-session";
     process.env[ENV_SELF_RECORD_ID] = "sa-parent";
     process.env[ENV_DEPTH] = "1";

package/src/execution/__tests__/reconcile-sweep.test.ts

@@ -0,0 +1,200 @@
+// src/execution/__tests__/reconcile-sweep.test.ts
+//
+// [W4] 注册对账 sweep 单测：差集判据（record 终态 ∪ 已归档/不存在 → 补发；
+// active → 跳过）、类型分流（[F2]：workflow/畸形走 workflow run 判据——终态 ∪
+// store 查不到 → 补注销，running → 跳过；bash 无收口通道保守跳过——显式偏差；
+// 未注入 workflow 判据时保守跳过）、写法（appendEntry 权威落盘 + 尽力 emit；
+// appendEntry 抛错不计入且不 emit）。差集输入 session 文件用
+// mkdtempSync 自建自删（禁触真实数据目录）。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { runReconcileSweep, type SupervisedRecordState } from "../round-supervisor/reconcile-sweep.ts";
+
+let tmpDir: string;
+let sessionFile: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "round-sweep-"));
+  sessionFile = path.join(tmpDir, "session.jsonl");
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  vi.restoreAllMocks();
+});
+
+function writeSessionFile(lines: unknown[]): void {
+  fs.writeFileSync(sessionFile, lines.map((l) => JSON.stringify(l)).join("\n") + "\n", "utf-8");
+}
+
+function reg(id: string, type = "subagent"): unknown {
+  return { customType: "pending:register", data: { id, type, name: id, registeredAt: 1, sessionId: "sess" } };
+}
+
+function unreg(id: string): unknown {
+  return { customType: "pending:unregister", data: { id, reason: "completed" } };
+}
+
+function makeDeps(overrides: {
+  states?: Map<string, SupervisedRecordState>;
+  workflowStates?: Map<string, SupervisedRecordState>;
+  injectWorkflowLookup?: boolean;
+  appendEntry?: (customType: string, data: unknown) => void;
+  emit?: (channel: string, data: unknown) => void;
+  sessionFile?: string;
+} = {}) {
+  const states = overrides.states ?? new Map<string, SupervisedRecordState>();
+  const workflowStates = overrides.workflowStates;
+  const appended: Array<{ customType: string; data: unknown }> = [];
+  const emitted: Array<{ channel: string; data: unknown }> = [];
+  const deps = {
+    sessionFile: overrides.sessionFile ?? sessionFile,
+    lookupRecordState: (id: string): SupervisedRecordState => states.get(id) ?? "missing",
+    // [F2] workflow 判据：显式注入（injectWorkflowLookup !== false 或给了
+    // workflowStates）时按 Map 查；否则缺席（向后兼容形态）。
+    ...(overrides.injectWorkflowLookup === false && workflowStates === undefined
+      ? {}
+      : {
+          lookupWorkflowRunState: (id: string): SupervisedRecordState =>
+            workflowStates?.get(id) ?? "missing",
+        }),
+    appendEntry: overrides.appendEntry ?? ((customType: string, data: unknown) => appended.push({ customType, data })),
+    emit: overrides.emit ?? ((channel: string, data: unknown) => emitted.push({ channel, data })),
+  };
+  return { deps, appended, emitted };
+}
+
+describe("runReconcileSweep 差集补发", () => {
+  it("register(subagent) × record 终态 → 补发 unregister（appendEntry 权威 + 尽力 emit），reason 取 closedReason", () => {
+    writeSessionFile([reg("bg-1")]);
+    const { deps, appended, emitted } = makeDeps({
+      states: new Map([["bg-1", { terminal: true, closedReason: "cancelled" }]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-1"]);
+    expect(appended).toEqual([
+      { customType: "pending:unregister", data: { id: "bg-1", reason: "cancelled", status: "cancelled" } },
+    ]);
+    expect(emitted).toHaveLength(1);
+  });
+
+  it("record 已归档/不存在（查不到）→ 视同终态补注销（reason=expired）", () => {
+    writeSessionFile([reg("bg-gone")]);
+    const { deps, appended } = makeDeps({ states: new Map() }); // lookup 恒 missing
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-gone"]);
+    expect(appended[0].data).toEqual({ id: "bg-gone", reason: "expired", status: "expired" });
+  });
+
+  it("record 活跃 → 保守跳过（不写不 emit）", () => {
+    writeSessionFile([reg("bg-live")]);
+    const { deps, appended, emitted } = makeDeps({ states: new Map([["bg-live", "active"]]) });
+    const result = runReconcileSweep(deps);
+    expect(result.skippedActive).toEqual(["bg-live"]);
+    expect(appended).toHaveLength(0);
+    expect(emitted).toHaveLength(0);
+  });
+
+  it("[F2] type=workflow × workflow run 终态 → 补注销（reason 取 run state reason）", () => {
+    writeSessionFile([reg("wf-1", "workflow")]);
+    const { deps, appended, emitted } = makeDeps({
+      workflowStates: new Map([["wf-1", { terminal: true, closedReason: "aborted" }]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["wf-1"]);
+    expect(appended).toEqual([
+      { customType: "pending:unregister", data: { id: "wf-1", reason: "aborted", status: "aborted" } },
+    ]);
+    expect(emitted).toHaveLength(1);
+  });
+
+  it("[F2] type=workflow × workflow run running → 保守跳过（宁挂账不误注销活跃 run）", () => {
+    writeSessionFile([reg("wf-live", "workflow")]);
+    const { deps, appended } = makeDeps({
+      workflowStates: new Map([["wf-live", "active"]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.skippedActive).toEqual(["wf-live"]);
+    expect(result.reconciled).toEqual([]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("[F2] 畸形条目（type 缺失/未知，normalizePendingType 归 workflow）× store 查不到 → 视同终态补注销", () => {
+    writeSessionFile([reg("bad-1", "mystery")]);
+    const { deps, appended } = makeDeps({}); // workflowStates 缺省 = 恒 missing
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bad-1"]);
+    expect(appended[0].data).toEqual({ id: "bad-1", reason: "expired", status: "expired" });
+  });
+
+  it("[F2] type=bash → 保守跳过（无 record/store 可查，显式偏差——宁挂账不失明）", () => {
+    writeSessionFile([reg("bt-1", "bash")]);
+    const { deps, appended } = makeDeps({});
+    const result = runReconcileSweep(deps);
+    expect(result.skippedNonSubagent).toEqual(["bt-1"]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("[F2] deps 未注入 workflow 判据 → workflow/未知类型保守跳过（判据缺席 ≠ 可注销）", () => {
+    writeSessionFile([reg("wf-1", "workflow"), reg("bad-1", "mystery")]);
+    const { deps, appended } = makeDeps({ injectWorkflowLookup: false });
+    const result = runReconcileSweep(deps);
+    expect(result.skippedNonSubagent.sort()).toEqual(["bad-1", "wf-1"]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("已注销的 id 不出现在差集 → 不补发", () => {
+    writeSessionFile([reg("bg-1"), unreg("bg-1")]);
+    const { deps, appended } = makeDeps();
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual([]);
+    expect(appended).toHaveLength(0);
+  });
+
+  it("unregister 之后的重注册重新进差集（同 id 重 register = 后写胜出）", () => {
+    writeSessionFile([reg("bg-1"), unreg("bg-1"), reg("bg-1")]);
+    const { deps, appended } = makeDeps();
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-1"]);
+    expect(appended).toHaveLength(1);
+  });
+
+  it("sessionFile 缺失 → 空跑（不抛）", () => {
+    const { deps } = makeDeps({ sessionFile: undefined });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual([]);
+  });
+
+  it("session 文件不可读（未 flush/被删）→ 空跑", () => {
+    const { deps } = makeDeps({ sessionFile: path.join(tmpDir, "nope.jsonl") });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual([]);
+  });
+
+  it("appendEntry 抛错 → 不计 reconciled、不 emit（差集残留交下次 sweep 重试）", () => {
+    writeSessionFile([reg("bg-1"), reg("bg-2")]);
+    const { deps, emitted } = makeDeps({
+      appendEntry: (customType, data) => {
+        if ((data as { id: string }).id === "bg-1") throw new Error("EACCES");
+      },
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-2"]);
+    expect(emitted.map((e) => (e.data as { id: string }).id)).toEqual(["bg-2"]);
+  });
+
+  it("坏行（截断 JSON）跳过不拖垮其余条目", () => {
+    fs.writeFileSync(sessionFile, [JSON.stringify(reg("bg-1")), '{"customType":"pending:regis'].join("\n"), "utf-8");
+    const { deps, appended } = makeDeps({
+      states: new Map([["bg-1", { terminal: true, closedReason: "gc" }]]),
+    });
+    const result = runReconcileSweep(deps);
+    expect(result.reconciled).toEqual(["bg-1"]);
+    expect(appended).toHaveLength(1);
+  });
+});

package/src/execution/__tests__/record-store.test.ts

@@ -36,7 +36,7 @@ vi.mock("../sessions-index.ts", async (importOriginal) => {
 });
 
 import { writeAliveMarker } from "../alive-store.ts";
-import { completeRecord, createRecord, tryTransition } from "../execution-record.ts";
+import { completeRecord, createRecord, projectOutcome, tryTransition } from "../execution-record.ts";
 import { writeFinalized } from "../finalized-marker.ts";
 import type { ManifestRecord } from "../manifest-store.ts";
 import { ManifestStore } from "../manifest-store.ts";
@@ -817,7 +817,7 @@ describe("RecordStore", () => {
       return { store, appended };
     }
 
-    it("末行完整 → closed 终态 entry + .finalized sidecar（防重锚）", () => {
+    it("末行完整（in-flight，无 resumable）→ closed + 重启中断 error，投影 failed（[F3] 表 3 行 2）", () => {
       const sessionFile = path.join(tmpDir, "orphan-done.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-orphan-1", agent: "worker", mode: "background", task: "orphan done",
@@ -831,7 +831,14 @@ describe("RecordStore", () => {
       expect(entry?.data.status).toBe("closed");
       expect(entry?.data.closedReason).toBe("gc");
       expect(entry?.data.endedAt).toEqual(expect.any(Number));
-      expect(entry?.data.error).toBeUndefined();
+      // [F3] in-flight 直断 = boot 直断 failed 语义：任务因宿主重启中断，不得投影
+      // completed（事故环 3 残留）。error 载体 → deriveOutcome("gc", error) = failed。
+      expect(entry?.data.error).toContain("host restart");
+      expect(projectOutcome({
+        status: "closed",
+        closedReason: entry?.data.closedReason as never,
+        error: entry?.data.error as string | undefined,
+      })).toBe("failed");
       expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
       // 防重：sidecar 使下次重建走分支 2（closed），不再进判定
       const again = [...appended];
@@ -841,7 +848,51 @@ describe("RecordStore", () => {
       expect(found?.status).toBe("closed");
     });
 
-    it("末行截断 → closed + error（保守方向）", () => {
+    it("SP-5 完成态（resumable + result 有值）→ completed 无 error（不误标重启失败，[F3] 不回归）", () => {
+      const sessionFile = path.join(tmpDir, "orphan-sp5.jsonl");
+      writeSessionJsonl(sessionFile, {
+        id: "sa-orphan-sp5", agent: "worker", mode: "background", task: "sp5 done",
+        startedAt: 6000, rootSessionId: "sess-orphan",
+      });
+      // 主 session 末条 entry（v2 D3 merge 数据源）携 resumable+result——W4 起轮终
+      // 执行态信号随 entry 保留，子文件侧重建不带该信号。data 需过 rebuildEntryRecord
+      // 形状守卫（agent/task/startedAt 必带）。
+      const mainFile = writeMainSession([
+        { id: "sa-orphan-sp5", agent: "worker", task: "sp5 done", startedAt: 6000, status: "running", resumable: true, result: "final answer text" },
+      ]);
+      const { store, appended } = makeRecoveryStore();
+      store.recoverOrphanRecords("sess-orphan", mainFile);
+
+      const entry = appended.find((c) => c.data.id === "sa-orphan-sp5");
+      expect(entry?.data.status).toBe("closed");
+      expect(entry?.data.error).toBeUndefined();
+      expect(projectOutcome({
+        status: "closed",
+        closedReason: entry?.data.closedReason as never,
+        error: entry?.data.error as string | undefined,
+      })).toBe("completed");
+    });
+
+    it("resumable 无产出 → 保持 running 落 resumable entry（W4 死亡纳管态跨重启，boot 重认领源，不直断）", () => {
+      const sessionFile = path.join(tmpDir, "orphan-resumable.jsonl");
+      writeSessionJsonl(sessionFile, {
+        id: "sa-orphan-res", agent: "worker", mode: "background", task: "resumable orphan",
+        startedAt: 7000, rootSessionId: "sess-orphan",
+      });
+      const mainFile = writeMainSession([
+        { id: "sa-orphan-res", agent: "worker", task: "resumable orphan", startedAt: 7000, status: "running", resumable: true },
+      ]);
+      const { store, appended } = makeRecoveryStore();
+      store.recoverOrphanRecords("sess-orphan", mainFile);
+
+      const entry = appended.find((c) => c.data.id === "sa-orphan-res");
+      expect(entry?.data.status).toBe("running");
+      expect(entry?.data.resumable).toBe(true);
+      // 保留分支不写终态 sidecar
+      expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false);
+    });
+
+    it("末行截断 → closed + error（保守方向；[F3] in-flight 同时携重启中断语义）", () => {
       const sessionFile = path.join(tmpDir, "orphan-truncated.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-orphan-2", agent: "worker", mode: "background", task: "orphan truncated",
@@ -855,10 +906,11 @@ describe("RecordStore", () => {
       const entry = appended.find((c) => c.data.id === "sa-orphan-2");
       expect(entry?.data.status).toBe("closed");
       expect(entry?.data.error).toContain("truncated");
+      expect(entry?.data.error).toContain("host restart");
       expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
     });
 
-    it("末行 >64KB 完整 JSON → 不误判截断，判 done（V1 探针实测回归）", () => {
+    it("末行 >64KB 完整 JSON → 不误判截断，[F3] in-flight 携重启中断 error（无 truncated）", () => {
       const sessionFile = path.join(tmpDir, "orphan-longline.jsonl");
       writeSessionJsonl(sessionFile, {
         id: "sa-orphan-5", agent: "worker", mode: "background", task: "orphan long line",
@@ -877,7 +929,9 @@ describe("RecordStore", () => {
 
       const entry = appended.find((c) => c.data.id === "sa-orphan-5");
       expect(entry?.data.status).toBe("closed");
-      expect(entry?.data.error).toBeUndefined();
+      // [F3] in-flight 重启中断 error 必有；「不误判截断」= error 不含 truncated 标记
+      expect(entry?.data.error).toContain("host restart");
+      expect(entry?.data.error).not.toContain("truncated");
       expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true);
     });