@zhushanwen/subagent-core 0.2.0 → 0.5.1

package/src/execution/__tests__/output-collector.test.ts

@@ -5,8 +5,17 @@
 // （usage 收口进 getTotalUsage，text 收口进 getFullText，均在 execution-record.test 测）。
 import { describe, expect, it } from "vitest";
 
-import { isStaleContextErrorMsg, DETERMINISTIC_SCHEMA_FAILURE_PREFIX, isDeterministicSchemaFailureMsg, STALE_CONTEXT_PATTERNS } from "../../orchestration/execute-agent-call.ts";
-import { collectResult, describeMissingParsedOutput, extractParsedOutput, neutralizeStalePatterns } from "../output-collector.ts";
+import {
+  classifyFailureKind,
+  collectResult,
+  describeMissingParsedOutput,
+  DETERMINISTIC_SCHEMA_FAILURE_PREFIX,
+  extractParsedOutput,
+  isDeterministicSchemaFailureMsg,
+  isStaleContextErrorMsg,
+  neutralizeStalePatterns,
+  STALE_CONTEXT_PATTERNS,
+} from "../engine/engines/pi/output-collector.ts";
 import type { ExecutionRecord, ToolCall } from "../types.ts";
 
 // ============================================================
@@ -162,9 +171,9 @@ describe("describeMissingParsedOutput", () => {
   // ── [F-R1] 态2（isError 分支）错误摘要拼接段中和 ──
   //
   // 动态错误文本（模型/provider 原始错误）可能携带 "aborted"/"ctx is stale" 等
-  // STALE_CONTEXT_PATTERNS 词；不中和则归因 error 经 collectResult → result.error
-  // 流到 execute-agent-call 的 isStaleContextErrorMsg 分诊，被误诊为 stale-context
-  // 跳过重试。固定前缀静态无命中（上一用例锁定），中和只针对动态段。
+  // STALE_CONTEXT_PATTERNS 词；不中和则归因 error 经 collectResult 的
+  // classifyFailureKind 分诊被误标 stale_context（归因语义被污染）。
+  // 固定前缀静态无命中（上一用例锁定），中和只针对动态段。
   describe("F-R1: 态2 错误摘要 STALE_CONTEXT_PATTERNS 中和", () => {
     function failedSoCallsWith(text: string): ToolCall[] {
       return [
@@ -233,7 +242,7 @@ describe("describeMissingParsedOutput", () => {
 // ============================================================
 
 describe("MF-1: 三态可重试性矩阵（确定性失败标记）", () => {
-  // 矩阵（SSOT 注释在 execute-agent-call DETERMINISTIC_SCHEMA_FAILURE_PREFIX 与
+  // 矩阵（SSOT 注释在本模块 DETERMINISTIC_SCHEMA_FAILURE_PREFIX 与
   // describeMissingParsedOutput JSDoc，本 describe 是执行面锁定）：
   //   态① 从未调用 SO            → 带标记 → 不可重试（环境确定性，C1 安装盲区）
   //   态② SO isError（gate 终止/不可满足 schema）→ 带标记 → 不可重试（同 schema 重试必同结果）
@@ -356,3 +365,105 @@ describe("collectResult — F-1 schemaExpected 失败标注", () => {
     expect(isDeterministicSchemaFailureMsg(result.error)).toBe(true);
   });
 });
+
+// ============================================================
+// D5-③: failureKind 分类（产出侧单点识别）
+// ============================================================
+
+describe("classifyFailureKind（词表 → 结构化标签）", () => {
+  it("pi 真实 stale 文案 → stale_context", () => {
+    const piRealStale =
+      "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession().";
+    expect(classifyFailureKind(piRealStale)).toBe("stale_context");
+  });
+
+  it("abort 族（context canceled / aborted）→ stale_context", () => {
+    expect(classifyFailureKind("Request context canceled by provider")).toBe("stale_context");
+    expect(classifyFailureKind("Subprocess aborted by runtime shutdown")).toBe("stale_context");
+  });
+
+  it("确定性 schema 失败标记前缀 → schema_deterministic", () => {
+    expect(classifyFailureKind(
+      `${DETERMINISTIC_SCHEMA_FAILURE_PREFIX} Agent finished without producing a structured output`,
+    )).toBe("schema_deterministic");
+  });
+
+  it("未知文案（词表零命中，pi 升级改写文案后的形态）→ unknown（安全默认，可重试）", () => {
+    expect(classifyFailureKind("provider 503 service unavailable")).toBe("unknown");
+    expect(classifyFailureKind("spawn EAGAIN")).toBe("unknown");
+    expect(classifyFailureKind("extension runtime was superseded by a newer orchestration epoch")).toBe("unknown");
+  });
+
+  it("undefined（成功路径）→ undefined（不落失败分诊）", () => {
+    expect(classifyFailureKind(undefined)).toBeUndefined();
+  });
+
+  it("标记词与 stale 词表零交集（分诊优先级无歧义）", () => {
+    expect(classifyFailureKind(DETERMINISTIC_SCHEMA_FAILURE_PREFIX)).toBe("schema_deterministic");
+  });
+});
+
+describe("collectResult — D5-③ failureKind 产出", () => {
+  /** 最小 ExecutionRecord stub（collectResult 只读 turns/toolCalls 派生面）。 */
+  function makeRecordWithCalls(calls: ToolCall[]): ExecutionRecord {
+    return {
+      id: "rec-fk",
+      turns: [{ toolCalls: calls, text: "done", turnCount: 1, closed: true }],
+      turnCount: 1,
+    } as unknown as ExecutionRecord;
+  }
+
+  const baseArgs = {
+    startTime: Date.now(),
+    sessionId: "s-fk",
+    sessionFile: undefined,
+  };
+
+  it("error 命中 stale 词表 → failureKind=stale_context", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, {
+      ...baseArgs,
+      success: false,
+      error: "This extension ctx is stale after session replacement or reload.",
+    });
+    expect(result.failureKind).toBe("stale_context");
+  });
+
+  it("F-1 归因覆写（态①②确定性标记）→ failureKind=schema_deterministic", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.error).toBeDefined();
+    expect(result.failureKind).toBe("schema_deterministic");
+  });
+
+  it("态③归因（调用过但无 details，无标记）→ failureKind=unknown（可重试，矩阵保留）", () => {
+    const record = makeRecordWithCalls([
+      { toolName: "structured-output", result: { content: [] } },
+    ]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.error).toBeDefined();
+    expect(result.failureKind).toBe("unknown");
+  });
+
+  it("普通 provider 错误 → failureKind=unknown", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, { ...baseArgs, success: false, error: "provider boom 5xx" });
+    expect(result.failureKind).toBe("unknown");
+  });
+
+  it("成功路径（error undefined）→ failureKind 不写（缺省 = unknown = 可重试，消费侧语义）", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined });
+    expect(result.failureKind).toBeUndefined();
+  });
+
+  it("词表漂移失效模式：未知文案（未来 pi 形态）→ failureKind=unknown（保守重试，非静默漏诊）", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, {
+      ...baseArgs,
+      success: false,
+      error: "extension runtime was superseded by a newer orchestration epoch",
+    });
+    expect(result.failureKind).toBe("unknown");
+  });
+});

package/src/execution/__tests__/pi-invocation.test.ts

@@ -5,7 +5,7 @@ import * as path from "node:path";
 
 import { afterEach, describe, expect, it } from "vitest";
 
-import { getPiInvocation } from "../pi-invocation.ts";
+import { getPiInvocation } from "../engine/engines/pi/pi-invocation.ts";
 import { RELAY_ENV_NODE, RELAY_ENV_SCRIPT, RELAY_ENV_SOCKET } from "../relay-env.ts";
 
 describe("getPiInvocation", () => {

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";
@@ -34,8 +52,9 @@ function makeRecord(over: Partial<ExecutionRecord> = {}): ExecutionRecord {
   const base = createRecord("r1", {
     agent: "worker",
     model: "m",
-    mode: "sync",
+    mode: "background",
     task: "t",
+    slug: "test",
     startedAt: 1000,
     rootSessionId: "sess-current",
     // 对齐生产 register 路径（subagent-service createRecord：one-shot 显式 false）
@@ -50,7 +69,7 @@ function makeRecord(over: Partial<ExecutionRecord> = {}): ExecutionRecord {
  */
 function writeSessionJsonl(
   filePath: string,
-  identity: { id: string; agent: string; mode: "sync" | "background"; task: string; startedAt: number; rootSessionId?: string; parentRecordId?: string; depth?: number; lastTs?: number; chatMode?: boolean },
+  identity: { id: string; agent: string; mode: "background"; task: string; startedAt: number; rootSessionId?: string; parentRecordId?: string; depth?: number; lastTs?: number; chatMode?: boolean },
   assistantText = "result text",
 ): void {
   const lastTs = identity.lastTs ?? identity.startedAt + 1000;
@@ -106,6 +125,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();
   });
 
   // ============================================================
@@ -114,7 +139,7 @@ describe("RecordStore", () => {
   describe("archive 立即移除", () => {
     it("archive 后 record 立即从内存移除（不再 linger）", () => {
       const store = new RecordStore(tmpDir);
-      const r = makeRecord({ id: "sync-1", mode: "sync", status: "closed" });
+      const r = makeRecord({ id: "sync-1", mode: "background", status: "closed" });
       store.register(r);
       expect(store.getMutable("sync-1")).toBeDefined();
       store.archive(r);
@@ -988,7 +1013,7 @@ describe("RecordStore", () => {
       // chatMode 必须显式在场（one-shot=false）——renderer isDone 判据依赖它。
       expect(Object.keys(data).sort()).toEqual([
         "agent", "chatMode", "depth", "displayItems", "eventLog",
-        "id", "mode", "model", "rootSessionId", "round", "startedAt",
+        "id", "mode", "model", "rootSessionId", "round", "slug", "startedAt",
         "status", "task", "totalTokens", "turns", "v", "worktree",
       ]);
       expect(data).toMatchObject({
@@ -997,7 +1022,7 @@ describe("RecordStore", () => {
         agent: "worker",
         task: "t",
         status: "running",
-        mode: "sync",
+        mode: "background",
         startedAt: 1000,
         rootSessionId: "sess-current",
         chatMode: false,
@@ -1054,4 +1079,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: "background",
+        task: "t",
+        startedAt: 1000,
+      });
+
+      const store = new RecordStore(tmpDir);
+      const records = store.collectRecords(100);
+      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: "background",
+        task: "t",
+        startedAt: 1000,
+      });
+
+      const store = new RecordStore(tmpDir);
+      store.collectRecords(100);
+      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__/records-cwd-isolation.test.ts

@@ -26,7 +26,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-  fs.rmSync(tmpAgentDir, { recursive: true, force: true });
+  fs.rmSync(tmpAgentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
 });
 
 /** 写一个最小合法的 manifest 到指定 records 目录。 */
@@ -36,7 +36,7 @@ function writeManifest(recordsDir: string, id: string): string {
     id,
     rootSessionId: "sess-1",
     agentName: "worker",
-    status: "completed",
+    status: "closed",
     createdAt: Date.now(),
   };
   const filePath = path.join(recordsDir, `${id}.json`);