@zhushanwen/subagent-core 0.2.0 → 0.4.0

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

@@ -0,0 +1,159 @@
+// src/execution/__tests__/record-store-orphan-revive.test.ts
+//
+// [PS-10/T6④] revive() 复位 orphanJudged——落实 recoverOrphanRecords 注释承诺
+// 「IO 恢复后重开可重判」。
+//
+// 缺陷（设计 §4.3 PS-10）：resumable 形态（IO-error 保守分支）无 .finalized sidecar
+// 锚，重判资格完全由 orphanJudged 实例级缓存承载；dispose 有 clear 但 /new 复活路径
+// revive() 此前不复位 → 同进程内曾经的 IO 失败记录永久停留 resumable。
+//
+// 覆盖（验收④：IO 恢复记录 revive 后再次扫描会重新判定，不再停留 resumable）：
+//   阶段 1  IO 失败（openSync EACCES 注入）→ 判定落 resumable entry（保守分支真实触发）
+//   阶段 2  IO 恢复 + revive() → 再次 recoverOrphanRecords 重新判定收敛 closed+gc
+//           （未修复时 orphanJudged 残留 → 605 行 continue 零 entry，本用例红）
+//
+// fs mock：只劫持 openSync 的读模式（"r"）按目标路径计数放行——扫描侧
+// readIdentityHeader（session-reconstructor）与判定侧 readLastJsonlLine（record-store
+// 私有）走同一原语，放行计数 = 让扫描成功、判定失败的最小注入面；写模式（sidecar）
+// 与其余 fs 全部透传 actual。
+
+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";
+
+const { openSyncMock, fsActualHolder, loggerMock } = vi.hoisted(() => ({
+  openSyncMock: vi.fn(),
+  fsActualHolder: {} as { fs?: typeof import("node:fs") },
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("node:fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("node:fs")>();
+  fsActualHolder.fs = actual;
+  return { ...actual, openSync: openSyncMock };
+});
+vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
+
+import { RecordStore } from "../record-store.ts";
+
+let tmpDir = "";
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "rs-revive-"));
+  loggerMock.debug.mockClear();
+  loggerMock.warn.mockClear();
+  loggerMock.error.mockClear();
+});
+
+afterEach(() => {
+  fs.rmSync(tmpDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  openSyncMock.mockReset();
+});
+
+/** 最小合法 session.jsonl：session header + subagent-identity + 完整 assistant 末行。 */
+function writeOrphanSession(filePath: string, id: string): void {
+  const header = JSON.stringify({
+    type: "session", version: 3, id: "sess-uuid", timestamp: "2026-01-01T00:00:00.000Z", cwd: "/tmp",
+  });
+  const identityEntry = JSON.stringify({
+    type: "custom", id: "id-1", parentId: null,
+    timestamp: "2026-01-01T00:00:01.000Z", customType: "subagent-identity",
+    data: { id, agent: "worker", mode: "background", task: "orphan revive", startedAt: 1000, rootSessionId: "sess-orphan" },
+  });
+  const assistantMsg = JSON.stringify({
+    type: "message", id: "msg-1", parentId: "id-1",
+    timestamp: "2026-01-01T00:00:02.000Z",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: "result" }],
+      usage: { input: 10, output: 20, cacheRead: 0, cacheWrite: 0, totalTokens: 30, cost: { total: 0 } },
+      stopReason: "stop", timestamp: 2000,
+    },
+  });
+  fs.writeFileSync(filePath, `${header}\n${identityEntry}\n${assistantMsg}\n`, "utf-8");
+}
+
+function makeStore(): { store: RecordStore; appended: Array<{ customType: string; data: Record<string, unknown> }> } {
+  const appended: Array<{ customType: string; data: Record<string, unknown> }> = [];
+  const store = new RecordStore(tmpDir, undefined, {
+    appendEntry: (customType: string, data: unknown) => {
+      appended.push({ customType, data: data as Record<string, unknown> });
+    },
+  } as never);
+  return { store, appended };
+}
+
+describe("[PS-10] revive() 复位 orphanJudged（IO 恢复后重开可重判）", () => {
+  it("IO 失败落 resumable → revive 后 IO 恢复，再次扫描重新判定收敛 closed+gc", () => {
+    const sessionFile = path.join(tmpDir, "orphan-revive.jsonl");
+    writeOrphanSession(sessionFile, "sa-revive-1");
+    const realOpenSync = fsActualHolder.fs!.openSync;
+
+    // 目标路径读模式 open 的放行计数：阶段 1 只放行 1 次（扫描侧 readIdentityHeader），
+    // 判定侧 readLastJsonlLine 的 open 注入 EACCES（IO 暂时失败的保守形态）。
+    let allowReads = Infinity;
+    openSyncMock.mockImplementation((p: unknown, flags: unknown) => {
+      if (p === sessionFile && typeof flags === "string" && flags.includes("r")) {
+        if (allowReads <= 0) {
+          const err = new Error(`EACCES: permission denied, open '${sessionFile}'`) as NodeJS.ErrnoException;
+          err.code = "EACCES";
+          throw err;
+        }
+        allowReads--;
+      }
+      return realOpenSync(p as Parameters<typeof realOpenSync>[0], flags as Parameters<typeof realOpenSync>[1]);
+    });
+
+    // ── 阶段 1：IO 失败 → 保守落 resumable（注释承诺的形态）──
+    allowReads = 1;
+    const { store, appended } = makeStore();
+    store.recoverOrphanRecords("sess-orphan");
+
+    expect(appended).toHaveLength(1);
+    expect(appended[0]?.customType).toBe("subagent-record");
+    expect(appended[0]?.data.status).toBe("running");
+    expect(appended[0]?.data.resumable).toBe(true);
+    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(false); // 保守分支无 sidecar 锚
+
+    // ── 阶段 2：IO 恢复 + /new 复活（revive 复位 orphanJudged）→ 重判收敛终态 ──
+    allowReads = Infinity;
+    store.revive();
+    store.recoverOrphanRecords("sess-orphan");
+
+    expect(appended).toHaveLength(2); // 未修复时 orphanJudged 残留 → 零新 entry，此处红
+    const rejudged = appended[1];
+    expect(rejudged?.data.status).toBe("closed");
+    expect(rejudged?.data.closedReason).toBe("gc");
+    expect(rejudged?.data.resumable).toBeUndefined(); // 不再停留 resumable
+    expect(fs.existsSync(`${sessionFile}.finalized`)).toBe(true); // 终态防重锚落盘
+  });
+
+  it("未 revive 时重判资格保持（防重缓存语义不回归）：重复 recover 零新 entry", () => {
+    const sessionFile = path.join(tmpDir, "orphan-norevive.jsonl");
+    writeOrphanSession(sessionFile, "sa-revive-2");
+    const realOpenSync = fsActualHolder.fs!.openSync;
+    let allowReads = Infinity;
+    openSyncMock.mockImplementation((p: unknown, flags: unknown) => {
+      if (p === sessionFile && typeof flags === "string" && flags.includes("r")) {
+        if (allowReads <= 0) {
+          const err = new Error(`EACCES: permission denied, open '${sessionFile}'`) as NodeJS.ErrnoException;
+          err.code = "EACCES";
+          throw err;
+        }
+        allowReads--;
+      }
+      return realOpenSync(p as Parameters<typeof realOpenSync>[0], flags as Parameters<typeof realOpenSync>[1]);
+    });
+
+    allowReads = 1;
+    const { store, appended } = makeStore();
+    store.recoverOrphanRecords("sess-orphan");
+    expect(appended).toHaveLength(1);
+
+    // 同进程内不经历 revive（未重开）：IO 已恢复也不重判——同 session 防重语义保持
+    allowReads = Infinity;
+    store.recoverOrphanRecords("sess-orphan");
+    expect(appended).toHaveLength(1);
+  });
+});

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

@@ -17,6 +17,24 @@ import * as path from "node:path";
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+// [PS-14/T7③ / LC-9 等 T7 可观测性] Mock 共享 logger：sessions-index 写失败的
+// warn 留痕可被断言（对齐 channel-registry-handshake.test.ts 模式）。
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
+// [PS-14] saveIndex 可注入失败（默认 resolve，零影响既有用例；loadIndex/常量保留 actual）。
+const { saveIndexMock } = vi.hoisted(() => ({
+  saveIndexMock: vi.fn(() => Promise.resolve()),
+}));
+vi.mock("../sessions-index.ts", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../sessions-index.ts")>();
+  return { ...actual, saveIndex: saveIndexMock };
+});
+
 import { writeAliveMarker } from "../alive-store.ts";
 import { completeRecord, createRecord, tryTransition } from "../execution-record.ts";
 import { writeFinalized } from "../finalized-marker.ts";
@@ -106,6 +124,12 @@ describe("RecordStore", () => {
   afterEach(() => {
     // maxRetries：fire-and-forget 的 sessions-index 写可能与删除并发（ENOTEMPTY 竞态）
     fs.rmSync(rootDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+    // [PS-14] 恢复 saveIndex 默认 resolve 实现 + 清 logger 断言（用例间隔离）
+    saveIndexMock.mockReset();
+    saveIndexMock.mockImplementation(() => Promise.resolve());
+    loggerMock.debug.mockClear();
+    loggerMock.warn.mockClear();
+    loggerMock.error.mockClear();
   });
 
   // ============================================================
@@ -1054,4 +1078,63 @@ describe("RecordStore", () => {
       expect(() => store.reportRecordTransition(r)).not.toThrow();
     });
   });
+
+  // ============================================================
+  // [PS-14/T7③] sessions-index 写失败可观测（warn 而非仅 debug）
+  // ============================================================
+  // flushIndexAfterScan 触发链：collectRecords 全量扫描（首扫 dirStamp===null）→
+  // scanFile 探测置 indexDirty → 扫描尾 flush（lastIndexWriteAt=0 天然过 60s 节流窗）
+  // → saveIndex（mock reject）→ .catch 恢复 dirty + warn。
+  describe("PS-14: sessions-index 写失败可观测", () => {
+    it("saveIndex reject → warn（不再仅 debug），detail 含 dir 与 error", async () => {
+      saveIndexMock.mockRejectedValueOnce(new Error("EACCES: permission denied"));
+      writeSessionJsonl(path.join(tmpDir, "sa-ps14.jsonl"), {
+        id: "ps14",
+        agent: "worker",
+        mode: "sync",
+        task: "t",
+        startedAt: 1000,
+      });
+
+      const store = new RecordStore(tmpDir);
+      const records = store.collectRecords();
+      expect(records).toHaveLength(1); // 扫描本身不受索引写失败影响
+
+      // fire-and-forget saveIndex：等 .catch 执行
+      await vi.waitFor(() => {
+        expect(loggerMock.warn).toHaveBeenCalledWith(
+          expect.stringContaining("sessions-index write failed"),
+          expect.objectContaining({
+            detail: expect.objectContaining({
+              error: expect.stringContaining("EACCES: permission denied"),
+            }),
+          }),
+        );
+      });
+      // 升级语义：warn 而非 debug（debug 层不再承载该信号）
+      const debugIndexMsgs = loggerMock.debug.mock.calls.filter((c) =>
+        String(c[0]).includes("sessions-index write failed"),
+      );
+      expect(debugIndexMsgs).toHaveLength(0);
+    });
+
+    it("saveIndex 成功 → 零 warn（正常路径不制造噪音）", async () => {
+      writeSessionJsonl(path.join(tmpDir, "sa-ps14-ok.jsonl"), {
+        id: "ps14ok",
+        agent: "worker",
+        mode: "sync",
+        task: "t",
+        startedAt: 1000,
+      });
+
+      const store = new RecordStore(tmpDir);
+      store.collectRecords();
+      await vi.waitFor(() => expect(saveIndexMock).toHaveBeenCalled());
+
+      const warnIndexMsgs = loggerMock.warn.mock.calls.filter((c) =>
+        String(c[0]).includes("sessions-index write failed"),
+      );
+      expect(warnIndexMsgs).toHaveLength(0);
+    });
+  });
 });

package/src/execution/__tests__/run-and-finalize-chatmode.test.ts

@@ -28,6 +28,10 @@ vi.mock("../../core/logger.ts", () => ({ getLogger: () => loggerMock }));
 vi.mock("../session-runner.ts", () => ({
   runSpawn: vi.fn(),
   killAllSpawnedChildren: vi.fn(),
+  getChildByRecord: vi.fn(() => undefined),
+  registerSpawnedChildForRecord: vi.fn(),
+  killRecordChildWithEscalation: vi.fn(),
+  spawnedChildren: new Map(),
 }));
 
 import { runSpawn } from "../session-runner.ts";

package/src/execution/__tests__/run-spawn-chatmode-settled.test.ts

@@ -60,6 +60,7 @@ vi.mock("../alive-store.ts", () => ({
 // 非 chatMode 用例 ④ 的 agent_end 走正常 kill 分支（count=0 → SIGTERM）。
 vi.mock("../session-pending.ts", () => ({
   readActivePendingFromSessionFile: vi.fn(() => ({ count: 0 })),
+  prunePendingCursor: vi.fn(),
 }));
 
 vi.mock("../temp-prompt.ts", () => ({