@zhushanwen/subagent-core 0.4.0 → 0.6.0

package/src/execution/__tests__/run-spawn-stdout-callback-throw.test.ts

@@ -72,7 +72,7 @@ vi.mock("../session-pending.ts", () => ({
   prunePendingCursor: vi.fn(),
 }));
 
-vi.mock("../temp-prompt.ts", () => ({
+vi.mock("../engine/engines/pi/temp-prompt.ts", () => ({
   writePromptToTempFile: vi.fn(async (agent: string) => {
     const safeName = agent.replace(/[^\w.-]+/g, "_");
     return { dir: `/tmp/fake-${safeName}`, filePath: `/tmp/fake-${safeName}/prompt-${safeName}.md` };
@@ -80,8 +80,8 @@ vi.mock("../temp-prompt.ts", () => ({
   cleanupTempPrompt: vi.fn(async () => {}),
 }));
 
-import { runSpawn, SPAWN_WATCHDOG_ENV } from "../session-runner.ts";
-import type { SessionRunnerContext } from "../session-runner.ts";
+import { runSpawn, SPAWN_WATCHDOG_ENV } from "../engine/engines/pi/session-runner.ts";
+import type { SessionRunnerContext } from "../engine/engines/pi/session-runner.ts";
 import { hasIdleTimer, _resetLifecycleState } from "../lifecycle-manager.ts";
 import { createRecord } from "../execution-record.ts";
 import type { ExecutionRecord } from "../types.ts";
@@ -106,7 +106,7 @@ function makeChatModeRecord(id = "sa-f2-idle"): ExecutionRecord {
   return createRecord(id, {
     agent: "general-purpose",
     model: "test-model",
-    mode: "sync",
+    mode: "background",
     task: "chat task",
     slug: "chat",
     startedAt: 1_000_000,

package/src/execution/__tests__/service-kill-escalation.test.ts

@@ -10,12 +10,14 @@
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+import type { ChildProcess } from "node:child_process";
+
 import { FakeChild } from "./helpers/spawn-mock.ts";
 import {
   _resetServiceKillStateForTest,
   killRecordChildWithEscalation,
   spawnedChildren,
-} from "../session-runner.ts";
+} from "../engine/engines/pi/session-runner.ts";
 
 const SIGKILL_ESCALATION_MS = 30_000;
 
@@ -41,7 +43,7 @@ describe("T2④ killRecordChildWithEscalation", () => {
     const child = new FakeChild();
     child.killed = true;
     const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-killed", child);
+    spawnedChildren.set("sa-killed", child as unknown as ChildProcess);
     killRecordChildWithEscalation("sa-killed", "test");
     expect(killSpy).not.toHaveBeenCalled();
   });
@@ -49,7 +51,7 @@ describe("T2④ killRecordChildWithEscalation", () => {
   it("sends SIGTERM and escalates to SIGKILL after 30s without exit", async () => {
     const child = new FakeChild();
     const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-escalate", child);
+    spawnedChildren.set("sa-escalate", child as unknown as ChildProcess);
 
     killRecordChildWithEscalation("sa-escalate", "closeChatIdle");
     expect(killSpy).toHaveBeenNthCalledWith(1, "SIGTERM");
@@ -64,7 +66,7 @@ describe("T2④ killRecordChildWithEscalation", () => {
   it("clears the escalation timer when the child exits in time", async () => {
     const child = new FakeChild();
     const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-exit", child);
+    spawnedChildren.set("sa-exit", child as unknown as ChildProcess);
 
     killRecordChildWithEscalation("sa-exit", "cancelBackground");
     child.emit("exit", 0, null);
@@ -75,7 +77,7 @@ describe("T2④ killRecordChildWithEscalation", () => {
   it("repeated calls clear the previous escalation timer (no stacking)", async () => {
     const child = new FakeChild();
     const killSpy = vi.spyOn(child, "kill");
-    spawnedChildren.set("sa-repeat", child);
+    spawnedChildren.set("sa-repeat", child as unknown as ChildProcess);
 
     killRecordChildWithEscalation("sa-repeat", "first");
     await vi.advanceTimersByTimeAsync(10_000);

package/src/execution/__tests__/session-context-resolver.test.ts

@@ -23,7 +23,6 @@ describe("resolveSessionContext", () => {
   it("fork=false, worktree=false → shouldFork=false, effectiveCwd=mainCwd", () => {
     const result = resolveSessionContext({
       fork: false,
-      worktree: false,
       mainCwd: MAIN_CWD,
       agentDir: AGENT_DIR,
     });
@@ -37,7 +36,6 @@ describe("resolveSessionContext", () => {
   it("fork=true, worktree=false → shouldFork=true, forkSource=mainSessionFile", () => {
     const result = resolveSessionContext({
       fork: true,
-      worktree: false,
       mainCwd: MAIN_CWD,
       mainSessionFile: SESSION_FILE,
       agentDir: AGENT_DIR,

package/src/execution/__tests__/session-file-gc.test.ts

@@ -17,6 +17,12 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import * as aliveStore from "../alive-store.ts";
 import { maybeCleanupExpiredSessionFiles } from "../session-file-gc.ts";
 
+// [D8] 引擎池 TTL 兜底走 getEngineDataDir() 解析 dataDir——测试必须钉到 tmpAgentDir，
+// 防止命中真实 XYZ_AGENT_DATA_DIR（或宿主 fallback）误清开发机数据。
+vi.mock("../engine/common/data-dir.ts", () => ({
+  getEngineDataDir: () => tmpAgentDir,
+}));
+
 // ============================================================
 // helpers
 // ============================================================
@@ -28,7 +34,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-  fs.rmSync(tmpAgentDir, { recursive: true, force: true });
+  fs.rmSync(tmpAgentDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
   vi.restoreAllMocks();
 });
 
@@ -291,3 +297,32 @@ describe("maybeCleanupExpiredSessionFiles", () => {
     expect(fs.existsSync(tmp)).toBe(true);
   });
 });
+
+describe("[D8] 引擎池 TTL 兜底（maybeCleanupExpiredSessionFiles 挂载 cleanupExpiredPoolRefs）", () => {
+  /** 池内建一个 journal 并把 mtime 设为指定天数前。 */
+  function createPoolJournal(poolKey: string, taskId: string, daysAgo: number): string {
+    const poolDir = path.join(tmpAgentDir, "engines", "zcode", poolKey);
+    fs.mkdirSync(poolDir, { recursive: true });
+    const journal = path.join(poolDir, `journal-${taskId}.jsonl`);
+    fs.writeFileSync(journal, "{}\n", "utf-8");
+    const targetTime = Date.now() / 1000 - daysAgo * 86400;
+    fs.utimesSync(journal, targetTime, targetTime);
+    return journal;
+  }
+
+  it("超龄 journal 随概率门触发回收（engines/<engineId>/<poolKey>/ 下）", () => {
+    forceCleanupTrigger();
+    const oldJournal = createPoolJournal("home-p-m", "bg-1", 31);
+    const youngJournal = createPoolJournal("home-p-m", "bg-2", 5);
+    maybeCleanupExpiredSessionFiles(tmpAgentDir, "/cwd");
+    expect(fs.existsSync(oldJournal)).toBe(false);
+    expect(fs.existsSync(youngJournal)).toBe(true);
+  });
+
+  it("概率门跳过时引擎池不动", () => {
+    forceCleanupSkip();
+    const oldJournal = createPoolJournal("home-p-m", "bg-3", 31);
+    maybeCleanupExpiredSessionFiles(tmpAgentDir, "/cwd");
+    expect(fs.existsSync(oldJournal)).toBe(true);
+  });
+});

package/src/execution/__tests__/session-pending.test.ts

@@ -1,24 +1,32 @@
 // src/execution/__tests__/session-pending.test.ts
 //
-// [LC-6/T6②] session-pending 增量游标有界化：register−unregister 差集计数 + 剪枝。
+// readActivePendingFromSessionFile：读 session 文件算活跃后代（pending 差集）。
+// 覆盖：差集、快速路径过滤、文件不存在/坏行/未回填 sessionFile。
+// u-5c 迁自壳套件 src/__tests__/session-pending.test.ts（被测 module 是 core 件，
+// 唯一测试覆盖原落壳——设计 §2.2 C6 / §1 目标 6）。
 //
-// 覆盖：
-//   - 差集等值（语义不变）：register/unregister 差集、同 id 重 register 覆盖、
-//     unregister 后同 id 再 register 恢复活跃、count 端口收到的 = 活跃差集、
-//     latestUnregister 60s 唤醒窗口判据不受差集化影响。
-//   - 剪枝：文件删除后 cursor 自动剪枝（重建同名文件从头全量读，不残留旧 offset）；
-//     prunePendingCursor 原语（进程 close 侧回收）；prune 不存在条目 no-op。
+// 迁移改写：原壳版注入真实 @zhushanwen/pi-pending-notifications 计数器锚定差集
+// 语义；core 依赖闭包禁 pi 系包（u-5c 验收「零跨包 specifier」），改为下方
+// countActiveFromEntries 等价转写（逐字对照 extensions/universal/
+// pending-notifications/src/state.ts 同名实现的两遍差集算法：先收 unregister id
+// 集，再计 register 差集按 id 去重）——pi 侧算法自身由该包自有测试守卫。
 //
-// 真实 fs（临时目录）——增量游标的 offset/差集语义被真实文件形态执行
-//（对齐 descendant-sweep.test.ts 模式；该文件的差集清单/交错用例继续回归）。
+// 合并终态（feat 容器 + dev [LC-6/T6②] 增量游标有界化增量）：
+//   - 差集已由 per-file 游标内联（activeRegisters Map，见 session-pending.ts
+//     PendingReadCursor）——countActiveFromEntries 端口收到的 = 活跃差集（非全量
+//     行），等价转写在差集输入上幂等（unregister 行已被游标抵消，转写第一遍空
+//     扫不改变结果），feat 族结果断言全部保持。
+//   - 追加 [LC-6] 差集计数语义等值 + 游标剪枝两族（差集清单 listActivePending
+//     FromSessionFile / prunePendingCursor 原语 / 文件删除惰性剪枝 / 端口收差集
+//     口径断言）——真实 fs（临时目录）执行 offset/差集语义。
 
 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 { configureNotifyDomain, resetNotifyDomainForTests } from "../../core/notify-ports.ts";
+
 import {
   clearPendingCursors,
   listActivePendingFromSessionFile,
@@ -26,19 +34,83 @@ import {
   readActivePendingFromSessionFile,
 } from "../session-pending.ts";
 
+/** pi pending entries 的最小可识别形状（与 pi state.ts EntryLike 同构，运行时守卫）。 */
+interface PendingEntryLike {
+  customType?: unknown;
+  data?: { id?: unknown } | null;
+}
+
+/**
+ * countActiveFromEntries 等价转写（u-5c：core 闭包禁 pi 包 import）。
+ * 算法逐字对照 @zhushanwen/pi-pending-notifications src/state.ts：
+ * 两遍扫描——第一遍收 pending:unregister 的 id 集，第二遍计 pending:register
+ * 中未被注销且未见过的 id（按 id 去重）。返回 { count }（端口契约拆 .count
+ * 的上游形态）。
+ */
+function countActiveFromEntries(entries: unknown[]): { count: number } {
+  const unregistered = new Set<string>();
+  for (const raw of entries) {
+    // S-10：entries 元素可能是 null/undefined（坏数据），断言前先守卫
+    if (!raw || typeof raw !== "object") continue;
+    const entry = raw as PendingEntryLike;
+    if (entry.customType !== "pending:unregister") continue;
+    const data = (entry.data ?? {}) as { id?: unknown };
+    if (typeof data.id === "string") unregistered.add(data.id);
+  }
+
+  const seen = new Set<string>();
+  let count = 0;
+  for (const raw of entries) {
+    if (!raw || typeof raw !== "object") continue;
+    const entry = raw as PendingEntryLike;
+    if (entry.customType !== "pending:register") continue;
+    const data = (entry.data ?? {}) as { id?: unknown };
+    if (typeof data.id !== "string" || unregistered.has(data.id) || seen.has(data.id)) continue;
+    seen.add(data.id);
+    count += 1;
+  }
+  return { count };
+}
+
+// 计数器经通知域窄端口注入（session-pending 不再直接 import pi-pending-notifications）
+// ——注入差集计数等价实现保住差集语义回归面（真函数返回 CountActiveResult，端口
+// 契约是 number（拆 .count，与 pi 壳 createPiNotifyDomainPorts 适配同构）；
+// afterEach 重置防注入态泄漏。dev [LC-6] 族用 stubCountingPort 按用例覆盖
+// （configureNotifyDomain 覆盖式写入，内层后执行生效）。
 let sessionDir = "";
 
 beforeEach(() => {
+  configureNotifyDomain({
+    countActiveFromEntries: (entries) => countActiveFromEntries(entries).count,
+  });
   clearPendingCursors();
   sessionDir = fs.mkdtempSync(path.join(os.tmpdir(), "session-pending-"));
 });
 
 afterEach(() => {
-  clearPendingCursors();
   resetNotifyDomainForTests();
-  fs.rmSync(sessionDir, { recursive: true, force: true });
+  clearPendingCursors();
+  fs.rmSync(sessionDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
 });
 
+function makeTmpSessionFile(lines: string[]): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "session-pending-test-"));
+  const file = path.join(dir, "session.jsonl");
+  fs.writeFileSync(file, lines.join("\n") + "\n");
+  return file;
+}
+
+const mkRegister = (id: string, type: "subagent" | "workflow" = "subagent") =>
+  JSON.stringify({ type: "custom", customType: "pending:register", data: { id, type, name: id } });
+
+const mkUnregister = (id: string, reason = "completed", ts = "2026-08-06T08:00:00.000Z") =>
+  JSON.stringify({ type: "custom", customType: "pending:unregister", data: { id, reason }, timestamp: ts });
+
+const mkMessage = (role: string, text: string) =>
+  JSON.stringify({ type: "message", id: `m-${Date.now()}-${Math.random()}`, message: { role, content: [{ type: "text", text }] } });
+
+// ─── dev [LC-6] 族 helpers（真实 fs + entryLine 形态） ─────
+
 function entryLine(customType: string, data: Record<string, unknown>): string {
   return `${JSON.stringify({
     type: "custom",
@@ -54,12 +126,183 @@ function registerData(id: string, sessionId: string): Record<string, unknown> {
 }
 
 /** 注入直数端口：返回收到的 entry 数（观察 count 口径的消费面）。 */
-function stubCountingPort(): (entries: unknown[]) => number {
-  const counter = vi.fn((entries: unknown[]) => entries.length);
+function stubCountingPort(): ReturnType<typeof vi.fn<(entries: unknown[]) => number>> {
+  const counter = vi.fn((entries: unknown[]) => entries.length) as ReturnType<typeof vi.fn<(entries: unknown[]) => number>>;
   configureNotifyDomain({ countActiveFromEntries: counter });
   return counter;
 }
 
+describe("readActivePendingFromSessionFile", () => {
+  const tmpFiles: string[] = [];
+
+  afterEach(() => {
+    for (const f of tmpFiles.splice(0)) {
+      try {
+        fs.rmSync(path.dirname(f), { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+      } catch {
+        // 清理失败不影响断言
+      }
+    }
+  });
+
+  it("无 pending entries → count 0", () => {
+    const file = makeTmpSessionFile([mkMessage("user", "hi"), mkMessage("assistant", "hello")]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 0, recentUnregister: false });
+  });
+
+  it("纯 register → count = 活跃后代数", () => {
+    const file = makeTmpSessionFile([mkRegister("bg-1"), mkRegister("bg-2", "workflow")]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 2, recentUnregister: false });
+  });
+
+  it("register + unregister 同 id → 差集抵消", () => {
+    const file = makeTmpSessionFile([mkRegister("bg-1"), mkUnregister("bg-1")]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 0, recentUnregister: false });
+  });
+
+  it("混合：部分注销 → 只统计仍活跃的（真实 e2e 场景：P 的 agent_end 时 explorer 未注销）", () => {
+    const file = makeTmpSessionFile([
+      mkRegister("bg-1"),
+      mkUnregister("bg-1", "completed"),
+      mkRegister("explorer-1"),
+      mkMessage("assistant", "waiting for explorer..."),
+    ]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 1, recentUnregister: false });
+  });
+
+  it("fork 继承的主 session register 已被 expired unregister 抵消 → 不干扰", () => {
+    // 模拟 P fork 主 session：继承 register（sessionId 不匹配），session_start 重建补 unregister(expired)
+    const file = makeTmpSessionFile([
+      mkRegister("parent-bg"),
+      mkUnregister("parent-bg", "expired"),
+      mkRegister("my-bg"),
+    ]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 1, recentUnregister: false });
+  });
+
+  it("坏行（截断 JSON）跳过，不影响其余判定", () => {
+    const file = makeTmpSessionFile([
+      '{"type":"custom","customType":"pending:register","data":{"id":"bg-1"',
+      mkRegister("bg-2"),
+    ]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 1, recentUnregister: false });
+  });
+
+  it("sessionFile 未回填（undefined）→ error（调用方保守不 kill）", () => {
+    const res = readActivePendingFromSessionFile(undefined);
+    expect(res.count).toBe(0);
+    expect(res.error).toBeDefined();
+  });
+
+  it("文件不存在 → error（调用方保守不 kill）", () => {
+    const res = readActivePendingFromSessionFile("/nonexistent/path/session.jsonl");
+    expect(res.count).toBe(0);
+    expect(res.error).toBeDefined();
+  });
+
+  it("最近 60s 内有 unregister → recentUnregister=true（后代刚完成，唤醒在路上——竞态窗口不 kill）", () => {
+    const file = makeTmpSessionFile([
+      mkRegister("bg-live"),
+      mkUnregister("bg-live", "completed", new Date().toISOString()),
+    ]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 0, recentUnregister: true });
+  });
+
+  it("unregister 在 60s 窗口外 → recentUnregister=false（正常 kill 路径）", () => {
+    const file = makeTmpSessionFile([
+      mkRegister("bg-live"),
+      mkUnregister("bg-live", "completed", "2020-01-01T00:00:00.000Z"),
+    ]);
+    tmpFiles.push(file);
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 0, recentUnregister: false });
+  });
+
+  // [S-4] fast-path 按值匹配而非序列化格式。旧行 `line.includes('"customType":"pending:')`
+  // 耦合 pi 的 JSON 序列化空格习惯（冒号后无空格）。若 pi 改序列化（单行内冒号后加空格），
+  // 旧实现全过滤 → count=0 → keep-alive 静默失效 → recursive tree 被杀、steer 丢失。
+  // 本用例构造冒号后带空格的单行 JSON，验证值匹配仍命中 + 解析正确。
+  it("S-4: 序列化冒号后带空格 → 仍正确解析（防 fast-path 格式耦合导致 keep-alive 静默失效）", () => {
+    const file = makeTmpSessionFile([
+      `{ "type": "message", "message": { "role": "user", "content": [] } }`,
+      `{ "type": "custom", "customType": "pending:register", "data": { "id": "bg-1", "type": "subagent", "name": "bg-1" } }`,
+      `{ "type": "custom", "customType": "pending:unregister", "data": { "id": "bg-1", "reason": "completed" }, "timestamp": "2020-01-01T00:00:00.000Z" }`,
+      `{ "type": "custom", "customType": "pending:register", "data": { "id": "bg-2", "type": "subagent", "name": "bg-2" } }`,
+    ]);
+    tmpFiles.push(file);
+    // bg-1 register+unregister 抵消，bg-2 仍活跃 → count=1。
+    // 旧 fast-path（`"customType":"pending:` 冒号无空格）会跳过所有行 → count=0（静默失效）。
+    expect(readActivePendingFromSessionFile(file)).toEqual({ count: 1, recentUnregister: false });
+  });
+});
+
+// [perf] 增量游标行为：同文件重复判定（层主被多个后代唤醒 N 次 → N 次 agent_end）
+// 只读上次 offset 之后的新增行，累计差集语义与全量读一致。
+describe("readActivePendingFromSessionFile — 增量游标 [perf]", () => {
+  let dir: string;
+  let file: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), "session-pending-incr-"));
+    file = path.join(dir, "session.jsonl");
+    clearPendingCursors();
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 20 });
+  });
+
+  it("首次全量 + append 后增量：unregister 只抵消对应 id（与全量读一致）", () => {
+    fs.writeFileSync(file, mkRegister("d1") + "\n" + mkRegister("d2") + "\n");
+    expect(readActivePendingFromSessionFile(file).count).toBe(2);
+
+    fs.appendFileSync(file, mkUnregister("d1", "completed") + "\n");
+    const r = readActivePendingFromSessionFile(file);
+    expect(r.error).toBeUndefined();
+    expect(r.count).toBe(1);
+  });
+
+  it("EOF 半行（append 竞态）不入账，补全换行后入账", () => {
+    fs.writeFileSync(file, mkRegister("d1") + "\n");
+    expect(readActivePendingFromSessionFile(file).count).toBe(1);
+
+    // 半行：无尾换行 → offset 不推进该行
+    const full = mkUnregister("d1", "completed", new Date().toISOString());
+    fs.appendFileSync(file, full.slice(0, full.length - 4));
+    expect(readActivePendingFromSessionFile(file).count).toBe(1);
+
+    // 补全（剩余字符 + 换行）→ 消费
+    fs.appendFileSync(file, full.slice(-4) + "\n");
+    const r = readActivePendingFromSessionFile(file);
+    expect(r.count).toBe(0);
+    expect(r.recentUnregister).toBe(true);
+  });
+
+  it("文件 truncate/重建（size 回退）→ 重置游标从头全读", () => {
+    fs.writeFileSync(file, mkRegister("d1") + "\n" + mkRegister("d2") + "\n");
+    expect(readActivePendingFromSessionFile(file).count).toBe(2);
+
+    fs.writeFileSync(file, mkRegister("d3") + "\n");
+    expect(readActivePendingFromSessionFile(file).count).toBe(1);
+  });
+
+  it("clearPendingCursors 后重新全量（累计 entries 不残留旧账）", () => {
+    fs.writeFileSync(file, mkRegister("d1") + "\n");
+    expect(readActivePendingFromSessionFile(file).count).toBe(1);
+    clearPendingCursors();
+    fs.appendFileSync(file, mkRegister("d2") + "\n");
+    expect(readActivePendingFromSessionFile(file).count).toBe(2);
+  });
+});
+
+// ─── [LC-6/T6②] 差集计数语义等值 + 游标剪枝（dev 增量） ────
+
 describe("[LC-6] 差集计数语义等值", () => {
   it("register−unregister 差集：unregister 后 count/list 归零", () => {
     const counter = stubCountingPort();