@zhushanwen/subagent-core 0.2.0 → 0.5.1

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

@@ -61,14 +61,18 @@ vi.mock("node:fs", async () => {
 
 vi.mock("../alive-store.ts", () => ({
   writeAliveMarker: vi.fn(),
+  // [T5②] keep-alive 心跳刷新读取现有 marker id（缺失兜底 record.id）
+  readAliveMarker: vi.fn(() => undefined),
+  isProcessAlive: vi.fn(() => false),
 }));
 
 // 场景 ① 依赖 keep-alive 分支命中：count=1（有活跃后代 → 不 kill → 重挂 watchdog）
 vi.mock("../session-pending.ts", () => ({
   readActivePendingFromSessionFile: vi.fn(() => ({ count: 1 })),
+  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` };
@@ -76,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";
@@ -102,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,
@@ -163,7 +167,7 @@ describe("[F-R2] stdout 回调链内 fail-fast throw 不逃逸", () => {
     }
   });
 
-  it("② chatMode agent_settled armIdleTimer throw → 降级不挂 idle timer，onRoundSettled 照常、提前 resolve", async () => {
+  it("② chatMode agent_settled armIdleTimer throw → 降级挂 DEFAULT idle timer + warn，onRoundSettled 照常、提前 resolve", async () => {
     const record = makeChatModeRecord("sa-f2-idle");
     const onRoundSettled = vi.fn();
     const ctx: Partial<SessionRunnerContext> = { onRoundSettled };
@@ -176,18 +180,22 @@ describe("[F-R2] stdout 回调链内 fail-fast throw 不逃逸", () => {
     emitStdoutLine(child, { type: "agent_settled" });
     await new Promise((r) => setTimeout(r, 20));
 
-    // 降级语义：idle timer 未挂（throw 发生在 arm 入口校验，先于 setTimeout）
-    expect(hasIdleTimer(record.id)).toBe(false);
+    // [T4② / PS-4] 降级语义修正：旧「不挂」（丢通知放行门 + 进程回收）改为
+    // 「挂 DEFAULT_IDLE_TIMEOUT_MS + warn」——防御性兜底保住两个不变量且可见
+    expect(hasIdleTimer(record.id)).toBe(true);
     expect(child.killed).toBe(false);
 
     // catch 后续语句照常执行：本轮完成通知不因 GC timer 故障丢失
     expect(onRoundSettled).toHaveBeenCalledTimes(1);
 
-    // 错误可见
+    // 错误可见（原失败留痕）+ 降级动作可见（T4②）
     expect(loggerMock.error).toHaveBeenCalledWith(
       expect.stringContaining("armIdleTimer"),
       expect.objectContaining({ detail: expect.stringContaining("exceeds the Node setTimeout limit") }),
     );
+    expect(loggerMock.warn).toHaveBeenCalledWith(
+      expect.stringContaining("fell back to DEFAULT_IDLE_TIMEOUT_MS"),
+    );
 
     // 收尾：chatMode 首轮 agent_settled 已 resolveRun(0)，close 后 runSpawn 正常返回
     child.stdout.end();

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

@@ -0,0 +1,91 @@
+// src/execution/__tests__/service-kill-escalation.test.ts
+//
+// [u-svc / T2④ / LC-2] killRecordChildWithEscalation 真实现行为（服务侧 kill 收敛入口，
+// 无 SpawnRunState 调用方）：
+//   - child 不在 spawnedChildren / 已 killed → no-op（与旧 `child && !child.killed` 守卫
+//     语义逐字对齐）；
+//   - SIGTERM 后 30s 未见 exit → SIGKILL 升级（SIGTERM 被无视的幽灵进程防线）；
+//   - exit 到达 → 升级 timer 自动清除；
+//   - 同 record 重复调用先清旧升级 timer（防叠加）。
+
+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 "../engine/engines/pi/session-runner.ts";
+
+const SIGKILL_ESCALATION_MS = 30_000;
+
+describe("T2④ killRecordChildWithEscalation", () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout"] });
+    _resetServiceKillStateForTest();
+    spawnedChildren.clear();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+    _resetServiceKillStateForTest();
+    spawnedChildren.clear();
+  });
+
+  it("is a no-op when the record has no registered child", () => {
+    expect(() => killRecordChildWithEscalation("sa-missing", "test")).not.toThrow();
+  });
+
+  it("is a no-op when the child already received a kill request (escalation owned by prior path)", () => {
+    const child = new FakeChild();
+    child.killed = true;
+    const killSpy = vi.spyOn(child, "kill");
+    spawnedChildren.set("sa-killed", child as unknown as ChildProcess);
+    killRecordChildWithEscalation("sa-killed", "test");
+    expect(killSpy).not.toHaveBeenCalled();
+  });
+
+  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 as unknown as ChildProcess);
+
+    killRecordChildWithEscalation("sa-escalate", "closeChatIdle");
+    expect(killSpy).toHaveBeenNthCalledWith(1, "SIGTERM");
+
+    await vi.advanceTimersByTimeAsync(SIGKILL_ESCALATION_MS - 1);
+    expect(killSpy).toHaveBeenCalledTimes(1); // 未到期不升级
+
+    await vi.advanceTimersByTimeAsync(1);
+    expect(killSpy).toHaveBeenNthCalledWith(2, "SIGKILL");
+  });
+
+  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 as unknown as ChildProcess);
+
+    killRecordChildWithEscalation("sa-exit", "cancelBackground");
+    child.emit("exit", 0, null);
+    await vi.advanceTimersByTimeAsync(SIGKILL_ESCALATION_MS + 1_000);
+    expect(killSpy).toHaveBeenCalledTimes(1); // 只有 SIGTERM，无 SIGKILL
+  });
+
+  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 as unknown as ChildProcess);
+
+    killRecordChildWithEscalation("sa-repeat", "first");
+    await vi.advanceTimersByTimeAsync(10_000);
+    // 第二次调用前 child.killed 已为 true（首次 SIGTERM 置位）→ no-op 路径
+    killRecordChildWithEscalation("sa-repeat", "second");
+    expect(killSpy).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(SIGKILL_ESCALATION_MS);
+    expect(killSpy).toHaveBeenCalledTimes(2); // 首次 timer 正常触发（未被重复调用清掉）
+    expect(killSpy).toHaveBeenNthCalledWith(2, "SIGKILL");
+  });
+});

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
 // ============================================================
@@ -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);
+  });
+});