@zhushanwen/subagent-core 0.8.0 → 0.9.0

package/src/execution/__tests__/manifest-store-tmp-recovery.test.ts

@@ -1,8 +1,14 @@
 // src/execution/__tests__/manifest-store-tmp-recovery.test.ts
 //
-// [u-svc / T5④ / PS-13] recoverTmpFiles 循环内 per-file 容错：
-// 单个 tmp 文件操作失败（ENOENT——并发回收/外部清理抢先）只 warn + 跳过，
-// 不再中断整轮——剩余 tmp 继续处理；返回值形态不变（跳过者不计数）。
+// [U4c / G3] tmp 恢复退役（D6）：sweepTmpFiles 语义 = 全部 tmp **静默删除**——
+// manifest 已是可丢可重建缓存（权威 = `.state`，重建 = RecordStore.rebuildIndexes），
+// promote 半写 tmp 的恢复语义失效。断言面：
+//   - 合法 JSON 的 tmp（旧 promote 分支 2 形态）也删——promote 退役的核心锚点；
+//   - manifest 已存在时的陈旧 tmp（旧分支 1 形态）删；
+//   - 非法 JSON 的 tmp（旧分支 3 形态）删；
+//   - 返回删除计数（promote 退役后无恢复形态；公开转发链 recoverManifestTmpFiles 签名不变）；
+//   - [T5④ / PS-13] per-file 容错保留：单个 tmp 删除失败（ENOENT——并发回收/外部
+//     清理抢先）只 warn + 跳过，不再中断整轮。
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
@@ -36,7 +42,7 @@ const VALID_MANIFEST = {
   status: "running",
 };
 
-describe("T5④ recoverTmpFiles per-file tolerance", () => {
+describe("[U4c/G3] sweepTmpFiles 静默删除（promote 语义失效；H4/U5 更名收口）", () => {
   let dir: string;
   let store: ManifestStore;
 
@@ -57,15 +63,32 @@ describe("T5④ recoverTmpFiles per-file tolerance", () => {
     fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   });
 
-  it("processes remaining tmp files when one unlink fails mid-loop", async () => {
-    const actualFs = await vi.importActual<typeof import("node:fs")>("node:fs");
-    // 三个 tmp：good（合法 → promote）、stale（manifest sa-stale.json 已存在 → 删）、
-    // doomed（unlink ENOENT）
+  it("合法 tmp + manifest 缺失（旧 promote 形态）→ 删而非提升（promote 退役锚点）", async () => {
     fs.writeFileSync(path.join(dir, "sa-good.json.tmp.111"), JSON.stringify(VALID_MANIFEST));
+    const result = await store.sweepTmpFiles();
+    // 重建源 = `.state` + rebuildIndexes——半写 tmp 不再被复活成「看似权威」的索引
+    expect(result).toBe(1);
+    expect(fs.existsSync(path.join(dir, "sa-good.json"))).toBe(false);
+    expect(fs.existsSync(path.join(dir, "sa-good.json.tmp.111"))).toBe(false);
+    expect(loggerMock.warn).not.toHaveBeenCalled();
+  });
+
+  it("manifest 已存在 + 非法 JSON tmp → 全删，幸存 manifest 不动", async () => {
     fs.writeFileSync(path.join(dir, "sa-stale.json"), JSON.stringify(VALID_MANIFEST));
     fs.writeFileSync(path.join(dir, "sa-stale.json.tmp.222"), "{}");
-    fs.writeFileSync(path.join(dir, "sa-doomed.json.tmp.333"), "not json");
-    const doomedPath = path.join(dir, "sa-doomed.json.tmp.333");
+    fs.writeFileSync(path.join(dir, "sa-junk.json.tmp.333"), "not json");
+    const result = await store.sweepTmpFiles();
+    expect(result).toBe(2);
+    expect(fs.existsSync(path.join(dir, "sa-stale.json"))).toBe(true);
+    expect(fs.existsSync(path.join(dir, "sa-stale.json.tmp.222"))).toBe(false);
+    expect(fs.existsSync(path.join(dir, "sa-junk.json.tmp.333"))).toBe(false);
+  });
+
+  it("per-file 容错保留：单个 unlink ENOENT 只 warn 跳过，不中断整轮", async () => {
+    const actualFs = await vi.importActual<typeof import("node:fs")>("node:fs");
+    fs.writeFileSync(path.join(dir, "sa-a.json.tmp.444"), "not json");
+    fs.writeFileSync(path.join(dir, "sa-doomed.json.tmp.555"), "not json");
+    const doomedPath = path.join(dir, "sa-doomed.json.tmp.555");
     unlinkSyncMock.mockImplementation((p: fs.PathLike) => {
       if (String(p) === doomedPath) {
         const err = new Error("ENOENT: file vanished") as NodeJS.ErrnoException;
@@ -75,25 +98,23 @@ describe("T5④ recoverTmpFiles per-file tolerance", () => {
       return actualFs.unlinkSync(p);
     });
 
-    const result = await store.recoverTmpFiles();
+    const result = await store.sweepTmpFiles();
 
-    // 整轮不中断：doomed 之外的 tmp 全部处理完
-    expect(result.recovered).toBe(1); // good promote
-    expect(result.deleted).toBe(1); // stale 删
-    // good 被提升为正式 manifest
-    expect(fs.existsSync(path.join(dir, "sa-good.json"))).toBe(true);
+    // 整轮不中断：doomed 之外的 tmp 处理完
+    expect(result).toBe(1);
+    expect(fs.existsSync(path.join(dir, "sa-a.json.tmp.444"))).toBe(false);
     // 失败留痕（warn 级，含文件名）
     expect(loggerMock.warn).toHaveBeenCalledWith(
-      expect.stringContaining("sa-doomed.json.tmp.333"),
+      expect.stringContaining("sa-doomed.json.tmp.555"),
       expect.objectContaining({ detail: expect.stringContaining("ENOENT") }),
     );
-    expect(loggerMock.warn).toHaveBeenCalledWith(expect.stringContaining("1 of 3 tmp file(s)"));
+    expect(loggerMock.warn).toHaveBeenCalledWith(expect.stringContaining("1 of 2 tmp file(s)"));
   });
 
-  it("returns counts unchanged and no warnings when all tmp files succeed", async () => {
-    fs.writeFileSync(path.join(dir, "sa-ok.json.tmp.444"), JSON.stringify(VALID_MANIFEST));
-    const result = await store.recoverTmpFiles();
-    expect(result).toEqual({ deleted: 0, recovered: 1 });
+  it("无 tmp 残留 → 零副作用零告警", async () => {
+    fs.writeFileSync(path.join(dir, "sa-quiescent.json"), JSON.stringify(VALID_MANIFEST));
+    const result = await store.sweepTmpFiles();
+    expect(result).toBe(0);
     expect(loggerMock.warn).not.toHaveBeenCalled();
   });
 });

package/src/execution/__tests__/model-config-service.test.ts

@@ -0,0 +1,111 @@
+// src/execution/__tests__/model-config-service.test.ts
+//
+// [H3/R5 测试归位] ModelConfigService 自有域测试文件。本文件用例自
+// subagent-service.test.ts「ModelConfigService ctxModel 缓存」describe 整块迁入
+//（用例名与断言零改动，纯移动——被测主体是 ModelConfigService 模块而非
+// SubagentService，按被测主体归属原则从 God-class 级测试文件拆出）。
+//
+// ============================================================
+// ModelConfigService ctxModel 缓存(renderCall 标题行 model 显示的核心)
+// ============================================================
+//
+// [HISTORICAL] 99f20da1e 后 renderCall 拿不到主 agent model(ToolRenderContext 无 model),
+// resolveModel 第三层拗错→降级不显示 model。修复:session_start 缓存 ctxModel,
+// resolveModel 第三参默认用缓存。此测试验证该透传链路。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import { ModelConfigService } from "../model-config-service.ts";
+import type { ModelInfo, ModelRegistryLike } from "../model-resolver.ts";
+
+// ── 工具:建临时 agentDir + 真实 ModelConfigService（自 subagent-service.test.ts 迁移段自持副本）──
+
+function makeTmpAgentDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "subagents-test-"));
+  return dir;
+}
+
+function makeModelService(agentDir: string): ModelConfigService {
+  return new ModelConfigService({ agentDir, cwd: agentDir });
+}
+
+describe("ModelConfigService ctxModel 缓存", () => {
+  let agentDir: string;
+
+  beforeEach(() => {
+    agentDir = makeTmpAgentDir();
+  });
+  afterEach(() => {
+    fs.rmSync(agentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  /** 最小 mock registry:空可用列表(ctxModel 路径不需要 lookup)。 */
+  function makeEmptyRegistry(): ModelRegistryLike {
+    return {
+      getAvailable: () => [],
+      find: () => undefined,
+      hasConfiguredAuth: () => false,
+    };
+  }
+
+  it("initModel 传 ctxModel 后,resolveModel 不传第三参返回缓存 model", () => {
+    const svc = makeModelService(agentDir);
+    const mainModel: ModelInfo = {
+      id: "main-model",
+      name: "Main",
+      provider: "anthropic",
+      reasoning: false,
+    };
+    svc.initModel({
+      modelRegistry: makeEmptyRegistry(),
+      sessionId: "sess-1",
+      ctxModel: mainModel,
+    });
+
+    // agent 无 model 声明 + 无 override → 走第三层 ctxModel 缓存
+    const r = svc.resolveModel("general-purpose");
+    expect(r.model).toBe(mainModel);
+    expect(r.model.provider).toBe("anthropic");
+  });
+
+  it("显式 ctxModel 参数优先于缓存(execute 路径覆盖 renderCall 缓存)", () => {
+    const svc = makeModelService(agentDir);
+    const cached: ModelInfo = { id: "cached", name: "C", provider: "p1", reasoning: false };
+    const explicit: ModelInfo = { id: "explicit", name: "E", provider: "p2", reasoning: false };
+    svc.initModel({
+      modelRegistry: makeEmptyRegistry(),
+      sessionId: "sess-1",
+      ctxModel: cached,
+    });
+
+    // execute 传显式 ctxModel → 用显式,不用缓存
+    const r = svc.resolveModel("general-purpose", undefined, explicit);
+    expect(r.model).toBe(explicit);
+  });
+
+  it("setCtxModel 刷新缓存(model_select 后 renderCall 能看到新 model)", () => {
+    const svc = makeModelService(agentDir);
+    const m1: ModelInfo = { id: "m1", name: "1", provider: "p", reasoning: false };
+    const m2: ModelInfo = { id: "m2", name: "2", provider: "p", reasoning: false };
+    svc.initModel({ modelRegistry: makeEmptyRegistry(), sessionId: "s", ctxModel: m1 });
+
+    expect(svc.resolveModel("general-purpose").model).toBe(m1);
+    svc.setCtxModel(m2); // 模拟 model_select 刷新
+    expect(svc.resolveModel("general-purpose").model).toBe(m2);
+  });
+
+  it("缓存为空且无 override/agentConfig.model → 拗错(不静默降级)", () => {
+    const svc = makeModelService(agentDir);
+    svc.initModel({
+      modelRegistry: makeEmptyRegistry(),
+      sessionId: "s",
+      // ctxModel 不传 → 缓存为空
+    });
+    // 空 registry + 空 ctxModel → 第三层不可用 → 拗错
+    expect(() => svc.resolveModel("general-purpose")).toThrow(/No available model/);
+  });
+});

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

@@ -17,7 +17,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
   aliveStoreModule,
   childProcessModule,
-  finalizedMarkerModule,
+  stateMarkerModule,
   fsSyncModule,
   manifestStoreModule,
 } from "./helpers/subagent-service-mocks.ts";
@@ -29,7 +29,7 @@ import { clearEngines } from "../engine/registry.ts";
 vi.mock("node:child_process", () => childProcessModule());
 vi.mock("node:fs", async (importOriginal) => fsSyncModule(await importOriginal<typeof import("node:fs")>()));
 vi.mock("../alive-store.ts", async (importOriginal) => aliveStoreModule(await importOriginal<typeof import("../alive-store.ts")>()));
-vi.mock("../finalized-marker.ts", () => finalizedMarkerModule());
+vi.mock("../state-marker.ts", () => stateMarkerModule());
 vi.mock("../manifest-store.ts", () => manifestStoreModule());
 
 import { spawn } from "node:child_process";
@@ -101,7 +101,9 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
 
   it("TC-3a: 根进程 initSession：无 env → sessionRootId = sessionId（自己是 ROOT）", () => {
     const service = setupService("root-it");
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
+    // [R1 深绑改写] sessionRootId 随域 #2 聚合迁入 SessionBaselines，深绑路径改为
+    // service → baselines 聚合实例（断言对象与强度不变，路径对齐终态结构）。
+    const sessionRootId = (Reflect.get(service, "baselines") as { sessionRootId: string | null }).sessionRootId as string;
     expect(sessionRootId).toBe("root-it");
   });
 
@@ -109,7 +111,8 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
     process.env[ENV_ROOT_SESSION_ID] = "real-root-session";
     const service = setupService("child-session");
 
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
+    // [R1 深绑改写] 同上：sessionRootId 经 baselines 聚合路径读取。
+    const sessionRootId = (Reflect.get(service, "baselines") as { sessionRootId: string | null }).sessionRootId as string;
     expect(sessionRootId).toBe("real-root-session"); // env 贯穿，不是 child-session
   });
 
@@ -122,11 +125,12 @@ describe("TC-3: PI_SUBAGENT_ROOT_SESSION_ID env 贯穿正确", () => {
     const service = setupService("b-session");
 
     // B 的 sessionRootId 仍为 ROOT（env 贯穿，不被 B 自己的 sessionId 覆盖）
-    const sessionRootId = Reflect.get(service, "sessionRootId") as string;
+    // [R1 深绑改写] 同上：sessionRootId / execNesting 经 baselines 聚合路径读取。
+    const sessionRootId = (Reflect.get(service, "baselines") as { sessionRootId: string | null }).sessionRootId as string;
     expect(sessionRootId).toBe("root-main-session");
 
     // B 的嵌套基线记录了 B 自己的身份（recordId + depth；[D3-⑤] execNesting 公共层）
-    const baseline = (Reflect.get(service, "execNesting") as { baseline(): { recordId: string; depth: number } | null }).baseline()!;
+    const baseline = ((Reflect.get(service, "baselines") as { execNesting: { baseline(): { recordId: string; depth: number } | null } }).execNesting).baseline()!;
     expect(baseline.recordId).toBe("sa-a-record");
     expect(baseline.depth).toBe(1);
   });

package/src/execution/__tests__/notify-ledger.test.ts

@@ -917,6 +917,47 @@ describe("createNotifier — ledger 四步接线（U2）", () => {
     notifier.dispose();
   });
 
+  it("dedupKey 显式覆盖 notifyId（drain 丢弃通知独立身份）：同轮失败通知 key 不互吞，同 key 重放仍幂等；缺省回退 `id` / `id:round` 不变", () => {
+    const ledgerMock = makeLedgerHost();
+    const notifierHost = makeNotifierHost();
+    // 桥接：ledger sendDelivery → notifier host.sendMessage（模拟 index.ts 装配）
+    ledgerMock.host.sendDelivery = (message) => {
+      notifierHost.sendMessage(message, { triggerTurn: true });
+      if (ledgerMock.deliverPersists.value) {
+        ledgerMock.sessionEntries.push({
+          type: "custom_message",
+          customType: message.customType,
+          content: message.content,
+          display: message.display,
+          details: message.details,
+        });
+      }
+    };
+    bindNotifyLedgerHost(ledgerMock.host);
+
+    const notifier = createNotifier(notifierHost);
+    // 场景复刻（conversation-continuation drain 丢弃修复）：同 id 同轮——失败单发缺省
+    // key `id:round`，丢弃通知 dedupKey `id:round:drain-drop` → 两条都写账送达（修复
+    // 前丢弃通知沿用缺省 key 被幂等吞，「队列消息被丢」反馈永不可达）。
+    const failedRound = { id: "sa-drain", status: "closed" as const, outcome: "failed" as const, agent: "w", round: 1, startedAt: 1, endedAt: 2 };
+    notifier.notify({ ...failedRound, error: "round did not complete: crash" });
+    notifier.notify({ ...failedRound, error: "queued message could not be dispatched", dedupKey: "sa-drain:1:drain-drop" });
+    // 同 dedupKey 重放 = 同一显式反馈 → 幂等吞（去重语义保留，非全量放行）
+    notifier.notify({ ...failedRound, error: "dropped again", dedupKey: "sa-drain:1:drain-drop" });
+
+    expect(notifierHost.sentMessages).toHaveLength(2);
+    expect(notifierHost.sentMessages[0]?.details).toMatchObject({ notifyId: "sa-drain:1" });
+    expect(notifierHost.sentMessages[1]?.details).toMatchObject({ notifyId: "sa-drain:1:drain-drop" });
+
+    // 缺省回退（dedupKey 未设）：无 round → 裸 id（notifyClosed 终态通知消费形态），
+    // 与 `id:round` / `id:round:drain-drop` 互不吞——key 空间三形态互斥
+    notifier.notify({ ...failedRound, round: undefined, error: "closed" });
+    expect(notifierHost.sentMessages).toHaveLength(3);
+    expect(notifierHost.sentMessages[2]?.details).toMatchObject({ notifyId: "sa-drain" });
+
+    notifier.dispose();
+  });
+
   it("ledger 未 bind 时退回内核路径（向后兼容，options 仍单通道 triggerTurn）", () => {
     const notifierHost = makeNotifierHost();
     const notifier = createNotifier(notifierHost);
@@ -982,7 +1023,7 @@ describe("createNotifier — ledger 四步接线（U2）", () => {
 // ─── MF-5: settled 监听单例化 ──────────────────────────────
 //
 // 回归背景：index.ts:428-430 每次 session_start 注册新 pi.on("agent_settled")
-// handler，旧实例 dispose 只置标志不移除物理监听（pi 0.84.1 on() 无 off）——
+// handler，旧实例 dispose 只置标志不移除物理监听（pi 0.84.4 on() 无 off）——
 // 长会话 N 次切换累积 N 个死 handler。修复：bind 路径首次注册模块级单例
 // handler（settledEdgeDispatch），后续 bind 只换 boundLedger 引用。
 

package/src/execution/__tests__/rebuild-indexes.test.ts

@@ -0,0 +1,329 @@
+// src/execution/__tests__/rebuild-indexes.test.ts
+//
+// [U4c / G1+G2+G4-S5] 缓存降级三锚点：
+//   - S5① 手动删 manifest/sessions-index → 重建照常无错误静默吞（boot 全量通道
+//     rebuildIndexes + 查询面惰性通道 mergedRecords 双通道各自可独立触发）；
+//   - 失败降级：无 identity 的损坏/异构文件不在扫描集 → 不重建不抛（sessions-index
+//     「损坏静默回退全扫」同款先例）；幸存 manifest 不覆写（幂等补缺）；
+//   - G2 词汇双写：四 manifest 写面（markFinalized/markCancelled/markBatchFinalized/
+//     markIdleArchived）旧 status 三态投影 + executionStatus/closedReason 并存。
+
+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 { RecordStore } from "../record-store.ts";
+import { INDEX_FILENAME } from "../sessions-index.ts";
+import { writeCancelledState, writeFinalizedState } from "../state-marker.ts";
+import type { ExecutionRecord, SubagentRecord } from "../types.ts";
+
+/** 最小合法子 session 文件（session header + identity custom entry + assistant msg）。 */
+function writeSessionJsonl(
+  filePath: string,
+  identity: { id: string; task: string; startedAt: number; rootSessionId?: string },
+): void {
+  const header = JSON.stringify({
+    type: "session", version: 3, id: `sess-${identity.id}`, timestamp: new Date(identity.startedAt).toISOString(), cwd: "/tmp",
+  });
+  const identityData: Record<string, unknown> = {
+    id: identity.id,
+    agent: "worker",
+    mode: "background",
+    task: identity.task,
+    slug: "rebuild",
+    startedAt: identity.startedAt,
+  };
+  if (identity.rootSessionId !== undefined) identityData.rootSessionId = identity.rootSessionId;
+  const identityEntry = JSON.stringify({
+    type: "custom",
+    id: "id-1",
+    parentId: null,
+    timestamp: new Date(identity.startedAt).toISOString(),
+    customType: "subagent-identity",
+    data: identityData,
+  });
+  const assistantMsg = JSON.stringify({
+    type: "message",
+    id: "msg-1",
+    parentId: "id-1",
+    timestamp: new Date(identity.startedAt + 1000).toISOString(),
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: "result text" }],
+      usage: { input: 10, output: 20, cacheRead: 0, cacheWrite: 0, totalTokens: 30, cost: { total: 0 } },
+      stopReason: "stop",
+      timestamp: identity.startedAt + 1000,
+    },
+  });
+  fs.writeFileSync(filePath, `${header}\n${identityEntry}\n${assistantMsg}\n`, "utf-8");
+}
+
+function makeRecord(id: string, overrides: Partial<ExecutionRecord> = {}): ExecutionRecord {
+  const r = createRecord(id, {
+    agent: "worker",
+    model: "test/model",
+    mode: "background",
+    task: "rebuild task",
+    slug: "rebuild",
+    startedAt: 1000,
+    rootSessionId: "root-session",
+    chatMode: false,
+    controller: new AbortController(),
+  });
+  Object.assign(r, overrides);
+  return r;
+}
+
+/** markBatchFinalized 入参的最小 SubagentRecord。 */
+function makeSubagentRecord(id: string, sessionFile?: string): SubagentRecord {
+  return {
+    id,
+    agent: "worker",
+    task: "batch task",
+    slug: "batch",
+    status: "running",
+    mode: "background",
+    startedAt: 1000,
+    rootSessionId: "root-session",
+    parentRecordId: undefined,
+    depth: 0,
+    endedAt: undefined,
+    turns: 0,
+    totalTokens: 0,
+    model: "test/model",
+    thinkingLevel: undefined,
+    eventLog: [],
+    displayItems: [],
+    result: undefined,
+    error: undefined,
+    sessionFile,
+  };
+}
+
+describe("[U4c/G1] rebuildIndexes 双通道 + S5 缓存可丢锚点", () => {
+  let rootDir: string;
+  let sessionsDir: string;
+  let recordsDir: string;
+
+  beforeEach(() => {
+    rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "rebuild-indexes-"));
+    sessionsDir = path.join(rootDir, "sessions");
+    recordsDir = path.join(rootDir, "records");
+    fs.mkdirSync(sessionsDir);
+    fs.mkdirSync(recordsDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("S5①: 手动删 manifest/sessions-index → boot 全量重建照常，无错误静默吞", async () => {
+    const fileA = path.join(sessionsDir, "20260912T000000_a.jsonl");
+    const fileB = path.join(sessionsDir, "20260912T000001_b.jsonl");
+    writeSessionJsonl(fileA, { id: "sa-closed", task: "closed task", startedAt: 1000, rootSessionId: "root-session" });
+    writeSessionJsonl(fileB, { id: "sa-running", task: "running task", startedAt: 2000, rootSessionId: "root-session" });
+    // 权威终态位（重建源 = `.state` 优先）
+    writeFinalizedState(fileA, "gc");
+    // 损坏/异构文件（无 identity 无绑定）：不在扫描集，重建面必须静默跳过
+    fs.writeFileSync(path.join(sessionsDir, "junk.jsonl"), "not a session at all\n", "utf-8");
+    // 「缓存曾存在」的现场：manifest + sessions-index 各留一份后人为删除（S5 场景步骤）
+    fs.writeFileSync(path.join(recordsDir, "sa-closed.json"), "{}", "utf-8");
+    fs.writeFileSync(path.join(rootDir, INDEX_FILENAME), "{corrupted", "utf-8");
+    fs.rmSync(path.join(recordsDir, "sa-closed.json"));
+    fs.rmSync(path.join(rootDir, INDEX_FILENAME));
+
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    let rebuilt = -1;
+    expect(() => {
+      rebuilt = store.rebuildIndexes();
+    }).not.toThrow();
+    // 幂等补缺面 = 扫描集内全部 record（closed + running 两种形态都补）
+    expect(rebuilt).toBe(2);
+
+    // manifest 重建产物：词汇双写（旧三态 + executionStatus）+ identity 富字段
+    const closed = JSON.parse(fs.readFileSync(path.join(recordsDir, "sa-closed.json"), "utf-8")) as Record<string, unknown>;
+    expect(closed.status).toBe("closed");
+    expect(closed.executionStatus).toBe("closed");
+    expect(closed.closedReason).toBe("gc");
+    expect(closed.agentName).toBe("worker");
+    expect(closed.task).toBe("closed task");
+    expect(closed.sessionFile).toBe(fileA);
+    const running = JSON.parse(fs.readFileSync(path.join(recordsDir, "sa-running.json"), "utf-8")) as Record<string, unknown>;
+    expect(running.status).toBe("running");
+    expect(running.executionStatus).toBe("running");
+    expect(running.completedAt).toBeUndefined();
+
+    // junk 文件不产生 manifest（扫描集外静默跳过）
+    expect(fs.readdirSync(recordsDir).sort()).toEqual(["sa-closed.json", "sa-running.json"]);
+
+    // sessions-index 经首扫自愈重写（fire-and-forget，等待落盘）
+    await vi.waitFor(() => expect(fs.existsSync(path.join(rootDir, INDEX_FILENAME))).toBe(true));
+    const index = JSON.parse(fs.readFileSync(path.join(rootDir, INDEX_FILENAME), "utf-8")) as {
+      version: number;
+      entries: Record<string, unknown>;
+    };
+    expect(index.version).toBe(1);
+    expect(Object.keys(index.entries)).toContain("20260912T000000_a.jsonl");
+    expect(Object.keys(index.entries)).toContain("20260912T000001_b.jsonl");
+
+    // 列表/详情照常（S5 通过标准）
+    const ids = store.collectRecords(100).map((r) => r.id);
+    expect(ids).toContain("sa-closed");
+    expect(ids).toContain("sa-running");
+    store.dispose();
+  });
+
+  it("幸存 manifest 不覆写（重建是补缺不是刷新——防用尽力数据降级幸存快照）", () => {
+    const fileA = path.join(sessionsDir, "20260912T000002_survivor.jsonl");
+    writeSessionJsonl(fileA, { id: "sa-survivor", task: "disk task", startedAt: 1000, rootSessionId: "root-session" });
+    // 幸存 manifest 的 task 比 disk 重建源「新鲜」（终态写点真实值）
+    fs.writeFileSync(
+      path.join(recordsDir, "sa-survivor.json"),
+      JSON.stringify({ id: "sa-survivor", rootSessionId: "root-session", agentName: "worker", status: "closed", task: "survivor task", createdAt: 1000 }),
+      "utf-8",
+    );
+
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    expect(store.rebuildIndexes()).toBe(0);
+    const manifest = JSON.parse(fs.readFileSync(path.join(recordsDir, "sa-survivor.json"), "utf-8")) as Record<string, unknown>;
+    expect(manifest.task).toBe("survivor task");
+    store.dispose();
+  });
+
+  it("惰性通道: 查询面（collectRecords）补建缺员 manifest；在途 record 不建（创建时不写契约保持）", () => {
+    const fileA = path.join(sessionsDir, "20260912T000003_lazy.jsonl");
+    const fileLive = path.join(sessionsDir, "20260912T000004_live.jsonl");
+    writeSessionJsonl(fileA, { id: "sa-lazy", task: "lazy task", startedAt: 1000, rootSessionId: "root-session" });
+    writeSessionJsonl(fileLive, { id: "sa-live", task: "live task", startedAt: 2000, rootSessionId: "root-session" });
+
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    // 在途 record（内存持有）——终态写点会落 manifest，惰性通道不得提前建
+    store.register(makeRecord("sa-live", { sessionFile: fileLive }));
+
+    const ids = store.collectRecords(100).map((r) => r.id);
+    expect(ids).toContain("sa-lazy");
+    expect(ids).toContain("sa-live");
+
+    // 惰性补建只发生在外源 record
+    expect(fs.existsSync(path.join(recordsDir, "sa-lazy.json"))).toBe(true);
+    expect(fs.existsSync(path.join(recordsDir, "sa-live.json"))).toBe(false);
+    store.dispose();
+  });
+
+  it("每 id 每进程一次守卫 + revive 复位（防高频查询放大磁盘写）", () => {
+    const fileA = path.join(sessionsDir, "20260912T000005_guard.jsonl");
+    writeSessionJsonl(fileA, { id: "sa-guard", task: "guard task", startedAt: 1000, rootSessionId: "root-session" });
+
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    store.collectRecords(100);
+    expect(fs.existsSync(path.join(recordsDir, "sa-guard.json"))).toBe(true);
+
+    // 再次删除 + 查询：本进程已尝试过，不重复补写（boot 全量轮/下次进程承接）
+    fs.rmSync(path.join(recordsDir, "sa-guard.json"));
+    store.collectRecords(100);
+    expect(fs.existsSync(path.join(recordsDir, "sa-guard.json"))).toBe(false);
+
+    // /new /resume 复活（revive）复位守卫——「重开重判」语义
+    store.revive();
+    store.collectRecords(100);
+    expect(fs.existsSync(path.join(recordsDir, "sa-guard.json"))).toBe(true);
+    store.dispose();
+  });
+});
+
+describe("[U4c/G2] manifest 词汇双写——四写面旧三态投影 + executionStatus/closedReason 并存", () => {
+  let rootDir: string;
+  let sessionsDir: string;
+  let recordsDir: string;
+
+  beforeEach(() => {
+    rootDir = fs.mkdtempSync(path.join(os.tmpdir(), "rebuild-dualwrite-"));
+    sessionsDir = path.join(rootDir, "sessions");
+    recordsDir = path.join(rootDir, "records");
+    fs.mkdirSync(sessionsDir);
+    fs.mkdirSync(recordsDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  function readManifest(id: string): Record<string, unknown> {
+    return JSON.parse(fs.readFileSync(path.join(recordsDir, `${id}.json`), "utf-8")) as Record<string, unknown>;
+  }
+
+  it("markFinalized：status closed（旧三态）+ executionStatus closed + closedReason 随写", () => {
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    const sessionFile = path.join(sessionsDir, "20260912T000006_fin.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    const record = makeRecord("sa-fin", { sessionFile, status: "closed", closedReason: "parent-shutdown", endedAt: 2000 });
+
+    expect(store.markFinalized(record, "parent-shutdown")).toBe(true);
+    const manifest = readManifest("sa-fin");
+    expect(manifest.status).toBe("closed");
+    expect(manifest.executionStatus).toBe("closed");
+    expect(manifest.closedReason).toBe("parent-shutdown");
+    store.dispose();
+  });
+
+  it("markCancelled：终态投影同 markFinalized（双写字段齐）", () => {
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    const sessionFile = path.join(sessionsDir, "20260912T000007_cx.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    const record = makeRecord("sa-cx2", { sessionFile, endedAt: 2000 });
+
+    expect(store.markCancelled(record)).toBe(true);
+    const manifest = readManifest("sa-cx2");
+    expect(manifest.status).toBe("closed");
+    expect(manifest.executionStatus).toBe("closed");
+    store.dispose();
+  });
+
+  it("markIdleArchived：归档点补写 running 投影（非终态化语义——磁盘仍 running 可接管）", () => {
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    const sessionFile = path.join(sessionsDir, "20260912T000008_idle.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+    const record = makeRecord("sa-idle", { sessionFile, resumable: true });
+
+    store.markIdleArchived(record);
+    const manifest = readManifest("sa-idle");
+    expect(manifest.status).toBe("running");
+    expect(manifest.executionStatus).toBe("running");
+    expect(manifest.completedAt).toBeUndefined();
+    // 非终态化：不写 .state（归档 ≠ 放弃可重连性）
+    expect(fs.existsSync(`${sessionFile}.state`)).toBe(false);
+    store.dispose();
+  });
+
+  it("markBatchFinalized：批成员 running 投影双写（barrier 面词汇一致）", async () => {
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    const sessionFile = path.join(sessionsDir, "20260912T000009_batch.jsonl");
+    fs.writeFileSync(sessionFile, "{}\n", "utf-8");
+
+    await store.markBatchFinalized([makeSubagentRecord("sa-batch", sessionFile)]);
+    const manifest = readManifest("sa-batch");
+    expect(manifest.status).toBe("running");
+    expect(manifest.executionStatus).toBe("running");
+    expect(manifest.closedReason).toBeUndefined();
+    store.dispose();
+  });
+
+  it("重建投影的旧三态 cancelled 派生：`.state` cancelled → status cancelled + closedReason cancelled", () => {
+    // markCancelled 终态位的磁盘重建形态（buildRecord 分支 1）：重建 manifest 的旧
+    // 词汇须能区分 cancelled（session-reader 投影消费三态）。
+    const fileA = path.join(sessionsDir, "20260912T000010_cxl.jsonl");
+    writeSessionJsonl(fileA, { id: "sa-cxl", task: "cancelled task", startedAt: 1000, rootSessionId: "root-session" });
+    writeCancelledState(fileA, 3000);
+
+    const store = new RecordStore(sessionsDir, undefined, undefined, recordsDir);
+    store.rebuildIndexes();
+    const manifest = readManifest("sa-cxl");
+    expect(manifest.status).toBe("cancelled");
+    expect(manifest.executionStatus).toBe("closed");
+    expect(manifest.closedReason).toBe("cancelled");
+    store.dispose();
+  });
+});