@zhushanwen/subagent-core 0.2.0 → 0.4.0

package/src/execution/__tests__/run-spawn-edges.test.ts

@@ -13,9 +13,19 @@
 
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
+import * as path from "node:path";
 
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+// [LC-9/T7②] Mock 共享 logger：stdout invalid 行的 debug 留痕可被断言
+//（对齐 channel-registry-handshake.test.ts 模式；vi.mock 自动 hoist 到 import 前）。
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("../../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
 vi.mock("node:child_process", async () => {
   const { FakeChild } = await import("./helpers/spawn-mock.ts");
   return {
@@ -54,11 +64,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),
 }));
 
 // [recursive-orchestration] agent_end 后代判定独立 mock（判定函数本身在 session-pending.test.ts 单独测）。
+// listActivePendingFromSessionFile：[A1-2] keep-alive 无进展 fire 时的存活后代惰性复核
+// 消费（差集清单 + pid 探活）；默认空清单 = 无存活后代 → fire 照旧处置（既有用例语义不变）。
 vi.mock("../session-pending.ts", () => ({
   readActivePendingFromSessionFile: vi.fn(() => ({ count: 0 })),
+  listActivePendingFromSessionFile: vi.fn(() => ({ items: [] })),
+  prunePendingCursor: vi.fn(),
 }));
 
 vi.mock("../temp-prompt.ts", () => ({
@@ -69,7 +86,9 @@ vi.mock("../temp-prompt.ts", () => ({
   cleanupTempPrompt: vi.fn(async () => {}),
 }));
 
-import { killAllSpawnedChildren, runSpawn, spawnedChildren, WAKEUP_GRACE_MS, computeWatchdogMs, SPAWN_WATCHDOG_ENV } from "../session-runner.ts";
+import { KEEP_ALIVE_NO_PROGRESS_TIMEOUT_MS, killAllSpawnedChildren, runSpawn, spawnedChildren, WAKEUP_GRACE_MS, maxTurnsToWatchdogMs, SPAWN_WATCHDOG_ENV } from "../session-runner.ts";
+import { writeAliveMarker } from "../alive-store.ts";
+import { getSubagentSessionDir } from "../path-encoding.ts";
 import { readActivePendingFromSessionFile } from "../session-pending.ts";
 import {
   emitStdoutLine,
@@ -258,10 +277,11 @@ describe("runSpawn", () => {
   //
   // [M8] runSpawn 的 stdout 解析容错：
   //   - parseSpawnLine 对「非法 JSON」「合法 JSON 但缺 type 字段」归为 kind:"invalid"。
-  //   - runSpawn 的 data 处理器只认 header/event 两类，invalid 行静默忽略（L559 注释
-  //     "invalid 行忽略"）——单行损坏不应中断整个事件流。
+  //   - runSpawn 的 data 处理器只认 header/event 两类，invalid 行不中断事件流。
+  //     [LC-9/T7②] 起不再静默：per-child 计数 + debug 级前 3 条样本留痕，close 时
+  //     聚合输出总数与样本（「事件行损坏被静默丢弃」曾使 LC-1 形态 (c) 无法排查）。
   //   - close 前 stdoutBuffer 若残留未以 \n 结尾的合法 event 行，close handler 会再 parse
-  //     一次（L574-579）——覆盖子进程末行漏 \n 的场景。
+  //     一次（L574-579）——覆盖子进程末行漏 \n 的场景；残留 invalid 行同计统计。
   describe("stdout 边界：损坏行 + 残留尾行 (M8)", () => {
     it("stdout 夹杂非法 JSON 行 → 该行被忽略，合法 turn_end 正常计数（不抛错）", async () => {
       const record = makeRecord();
@@ -285,6 +305,89 @@ describe("runSpawn", () => {
       expect(record.turnCount).toBe(1); // 非法行被忽略，仅 turn_end 计数
     });
 
+    // [LC-9/T7②] invalid 行可观测性：计数 + debug 样本 + close 聚合，不再零可见。
+    it("[LC-9] invalid 行计数留痕：前 3 条逐条 debug 样本 + close 聚合总数（不刷屏）", async () => {
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: invalid-obs", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+
+      emitStdoutLine(child, sessionHeader());
+      child.stdout.write("garbage-line-1\n");
+      child.stdout.write('{"foo":"bar"}\n'); // 缺 type 字段的合法 JSON，同归 invalid
+      child.stdout.write("garbage-line-3\n");
+      emitStdoutLine(child, { type: "turn_end" });
+      child.stdout.end();
+      child.emit("close", 0);
+
+      const result = await promise;
+      expect(result.success).toBe(true);
+      expect(record.turnCount).toBe(1); // 容错行为不变：invalid 不中断事件流
+
+      const debugMsgs = loggerMock.debug.mock.calls.map((c) => String(c[0]));
+      // 前 3 条逐条样本（含原始行内容，可定位是哪行损坏）
+      const sampleMsgs = debugMsgs.filter((m) => m.includes("stdout invalid line #"));
+      expect(sampleMsgs).toHaveLength(3);
+      expect(sampleMsgs[0]).toContain("#1");
+      expect(sampleMsgs[0]).toContain("garbage-line-1");
+      expect(sampleMsgs[1]).toContain('{"foo":"bar"}');
+      expect(sampleMsgs[2]).toContain("garbage-line-3");
+      // close 聚合：总数一次暴露（processTrailingLine 由 close handler 必经）
+      const aggMsgs = debugMsgs.filter((m) => m.includes("invalid line(s) dropped in total"));
+      expect(aggMsgs).toHaveLength(1);
+      expect(aggMsgs[0]).toContain("3 invalid line(s)");
+    });
+
+    it("[LC-9] invalid 行超过样本上限（5 条）→ 样本 debug 恰 3 条（防刷屏）+ 聚合仍报全量 5", async () => {
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: invalid-flood", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+
+      emitStdoutLine(child, sessionHeader());
+      for (let i = 1; i <= 5; i++) {
+        child.stdout.write(`flood-${i}\n`);
+      }
+      emitStdoutLine(child, { type: "turn_end" });
+      child.stdout.end();
+      child.emit("close", 0);
+
+      const result = await promise;
+      expect(result.success).toBe(true);
+
+      const debugMsgs = loggerMock.debug.mock.calls.map((c) => String(c[0]));
+      const sampleMsgs = debugMsgs.filter((m) => m.includes("stdout invalid line #"));
+      expect(sampleMsgs).toHaveLength(3); // MAX_INVALID_LINE_SAMPLES=3，第 4/5 条仅累计
+      const aggMsgs = debugMsgs.filter((m) => m.includes("invalid line(s) dropped in total"));
+      expect(aggMsgs).toHaveLength(1);
+      expect(aggMsgs[0]).toContain("5 invalid line(s)"); // 聚合不丢全量计数
+    });
+
+    it("[LC-9] 残留尾行为 invalid（无 \\n 结尾的损坏行）→ close handler 同计统计", async () => {
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: tail-invalid", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+
+      emitStdoutLine(child, sessionHeader());
+      // 无 \n 的损坏行：同步 emit（同上方残留用例的时序原理）残留在 stdoutBuffer，
+      // 由 close handler 的 processTrailingLine 再 parse。
+      child.stdout.emit("data", "not-json-tail");
+      child.emit("close", 0);
+
+      const result = await promise;
+      expect(result.success).toBe(true);
+
+      const debugMsgs = loggerMock.debug.mock.calls.map((c) => String(c[0]));
+      const aggMsgs = debugMsgs.filter((m) => m.includes("invalid line(s) dropped in total"));
+      expect(aggMsgs).toHaveLength(1);
+      expect(aggMsgs[0]).toContain("1 invalid line(s)");
+      expect(aggMsgs[0]).toContain("not-json-tail"); // 聚合携带样本
+    });
+
     it("stdout 夹杂合法 JSON 但缺 type 字段 → 该行被忽略，不抛错", async () => {
       const record = makeRecord();
       const promise = runSpawn(record, "Task: notype", makeOpts(), makeCtx());
@@ -457,12 +560,12 @@ describe("runSpawn", () => {
       }
     });
 
-    // [MF-4] count>0 分支的动态超时：等待超时 = computeWatchdogMs(maxTurns)，非固定 2h。
+    // [MF-4] count>0 分支的动态超时：等待超时 = maxTurnsToWatchdogMs(maxTurns)，非固定 2h。
     // maxTurns=20 → 20×5min = 100min 到期 kill。若回归到固定 2h 常量，100min 处不会 kill，
-    // 本用例 advance(computeWatchdogMs − 1) 后仍不 kill、再 +1 才 kill 的断言会失败。
-    it("MF-4: agent_end（count>0）→ 等待超时 = computeWatchdogMs(maxTurns)（动态，非固定 2h）", async () => {
+    // 本用例 advance(maxTurnsToWatchdogMs − 1) 后仍不 kill、再 +1 才 kill 的断言会失败。
+    it("MF-4: agent_end（count>0）→ 等待超时 = maxTurnsToWatchdogMs(maxTurns)（动态，非固定 2h）", async () => {
       const maxTurns = 20;
-      const expected = computeWatchdogMs(maxTurns);
+      const expected = maxTurnsToWatchdogMs(maxTurns);
       mockPending.mockReturnValue({ count: 2 });
       const record = makeRecord();
       const promise = runSpawn(record, "Task: slow-desc", makeOpts({ maxTurns }), makeCtx());
@@ -498,10 +601,13 @@ describe("runSpawn", () => {
       }
     });
 
-    // [MF-4b] 预算语义对齐：maxTurns 未传且无兑底 env → count>0 分支不 re-arm watchdog，
-    // 不限时等待后代。若误回旧 50min 估算默认，51min 处会 kill，本用例失败。
-    it("MF-4b: agent_end（count>0）+ maxTurns 未传 → 不 re-arm watchdog（不限时等待）", async () => {
-      // hermetic：确保兑底 env 未设（若外层 shell 误设会让「不限时」断言失效）
+    // [MF-4b] 预算语义对齐 + [T2-① / P-T2 降级 B]：maxTurns 未传且无兑底 env → count>0
+    // 分支不 re-arm 固定时长 watchdog，改挂**无进展检测上界**——连续静默达
+    // KEEP_ALIVE_NO_PROGRESS_TIMEOUT_MS 才处置，期间任何 stdout 活动刷新计时。
+    // 原守护意图保留：若误回旧 50min 估算默认（固定时长、不刷新），活动刷新后 51min
+    // 处早已 kill，本用例失败。
+    it("MF-4b: agent_end（count>0）+ maxTurns 未传 → 无进展检测上界（活动刷新不限时，纯静默有界）", async () => {
+      // hermetic：确保兑底 env 未设（若外层 shell 误设会让「裸缺省」断言失效）
       const prevWatchdogEnv = process.env[SPAWN_WATCHDOG_ENV];
       delete process.env[SPAWN_WATCHDOG_ENV];
       mockPending.mockReturnValue({ count: 2 });
@@ -519,10 +625,32 @@ describe("runSpawn", () => {
         // keep alive：不 kill
         expect(child.killed).toBe(false);
 
-        // 超过旧 50min 估算默认仍不 kill = watchdog 未 re-arm
-        await vi.advanceTimersByTimeAsync(51 * 60 * 1000);
+        // 静默 29min：未达无进展阈值，不 kill
+        await vi.advanceTimersByTimeAsync(KEEP_ALIVE_NO_PROGRESS_TIMEOUT_MS - 60_000);
         expect(child.killed).toBe(false);
 
+        // 子进程活动（输出一行）：静默计时刷新。若误回旧 50min 估算默认（固定时长
+        // 不刷新），此点之后不久会 kill——51min 断言守护该回归
+        emitStdoutLine(child, { type: "message_end", message: {} });
+        await new Promise((r) => setImmediate(r));
+        await vi.advanceTimersByTimeAsync(KEEP_ALIVE_NO_PROGRESS_TIMEOUT_MS - 60_000);
+        expect(child.killed).toBe(false);
+
+        // 再次活动刷新（此刻距上次活动 29min < 30min 阈值），随后静默 21min——总时钟
+        // 已 >51min 仍不 kill = 无固定时长上限（原守护点：误回旧 50min 估算默认则此处
+        // 已 kill）；距最近一次活动静默 21min < 30min 阈值。
+        emitStdoutLine(child, { type: "message_end", message: {} });
+        await new Promise((r) => setImmediate(r));
+        await vi.advanceTimersByTimeAsync(21 * 60 * 1000);
+        expect(child.killed).toBe(false);
+
+        // 连续静默达阈值（最后一次活动后 30min 无任何输出）：有界回收（新契约）。
+        // 本段 advance 跨过 SIGTERM 后的 30s 升级点（escalation 语义：FakeChild 未退出），
+        // killSignal 已升级为 SIGKILL。
+        await vi.advanceTimersByTimeAsync(KEEP_ALIVE_NO_PROGRESS_TIMEOUT_MS);
+        expect(child.killed).toBe(true);
+        expect(child.killSignal).toBe("SIGKILL");
+
         child.stdout.end();
         child.stderr.end();
         child.emit("close", 143);
@@ -537,11 +665,11 @@ describe("runSpawn", () => {
 
     // [S-9] pending.error 分支（sessionFile 不可读 → 保守 keep-alive + re-arm dynamic watchdog）
     // 集成行为 guard：session-pending 单测覆盖 error 返回值，但 session-runner 的 no-kill +
-    // re-arm 到 computeWatchdogMs(maxTurns) 行为无集成 guard。若 re-arm 误删/误用固定超时，
+    // re-arm 到 maxTurnsToWatchdogMs(maxTurns) 行为无集成 guard。若 re-arm 误删/误用固定超时，
     // 保守 keep-alive 会退化成永久挂起或被固定超时误杀。
     it("S-9: agent_end（count=0 + error）→ 保守不 kill + watchdog re-arm 到动态超时", async () => {
       const maxTurns = 20;
-      const expected = computeWatchdogMs(maxTurns);
+      const expected = maxTurnsToWatchdogMs(maxTurns);
       mockPending.mockReturnValue({ count: 0, error: "session file unreadable: EACCES" });
       const record = makeRecord();
       const promise = runSpawn(record, "Task: unreadable", makeOpts({ maxTurns }), makeCtx());
@@ -557,7 +685,7 @@ describe("runSpawn", () => {
         // 保守策略：sessionFile 不可读时不 kill（宁可空等也不误杀有后代的进程）
         expect(child.killed).toBe(false);
 
-        // watchdog re-arm 到动态超时（computeWatchdogMs(maxTurns)），未到期不 kill
+        // watchdog re-arm 到动态超时（maxTurnsToWatchdogMs(maxTurns)），未到期不 kill
         await vi.advanceTimersByTimeAsync(expected - 1);
         expect(child.killed).toBe(false);
 
@@ -684,4 +812,266 @@ describe("runSpawn", () => {
       expect(record.turnCount).toBe(1);
     });
   });
+
+  // ── 4. [T1/RC-1+RC-2] agent_end 惰性回补 + [T1/LC-4] 收尾反查 ──
+  //
+  // RC-1：RPC mode 的 get_state 握手一次性（7s 预算耗尽永不再试），sessionFile 成为
+  // 永久缺失。T1 双管：
+  //   ① agent_end 决策点发现 sessionFile 缺失 → 现场单次 get_state（idle 子进程毫秒级
+  //      应答，探针 P-T1）回填后走正常三分支；
+  //   ② 回补失败不重试 → 既有保守分支（行为不劣化）；
+  //   ③ close 收尾 findSessionFileByHeaderId 兜底移出 if (record.sessionFile) 守卫——
+  //      「sessionId 有、sessionFile 无」形态（两字段独立采集）也做 sessionDir 反查。
+  //
+  // 测试形态：不 emit header（RPC mode）→ record.sessionFile 只能靠 get_state 回填。
+  // stdin 上第 1 个 get_state 是 spawn 握手（测试不回应 = 握手失败），第 2 个是 agent_end
+  // 惰性回补（按用例决定回应与否）。
+  describe("[T1] agent_end 惰性回补 + LC-4 收尾反查", () => {
+    const mockPending = vi.mocked(readActivePendingFromSessionFile);
+    const mockWriteAliveMarker = vi.mocked(writeAliveMarker);
+    const mockReaddirSync = vi.mocked(fs.readdirSync);
+
+    /** 统计 stdin 收到的 get_state 请求数（握手 1 次 + agent_end 惰性回补 1 次）。 */
+    function countGetStateRequests(child: FakeChild): { seen: number } {
+      const counter = { seen: 0 };
+      child.stdin.on("data", (data: Buffer | string) => {
+        const text = typeof data === "string" ? data : data.toString();
+        for (const line of text.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            if ((JSON.parse(line) as { type?: string }).type === "get_state") counter.seen++;
+          } catch {
+            // prompt 命令等非 JSON 行忽略
+          }
+        }
+      });
+      return counter;
+    }
+
+    /** 只对第 N 次（1-based）get_state 回应 response（其余不回应 = 握手失败）。 */
+    function respondToNthGetState(
+      child: FakeChild,
+      nth: number,
+      data: Record<string, unknown>,
+    ): void {
+      let seen = 0;
+      child.stdin.on("data", (chunk: Buffer | string) => {
+        const text = typeof chunk === "string" ? chunk : chunk.toString();
+        for (const line of text.split("\n")) {
+          if (!line.trim()) continue;
+          let cmd: { type?: string; id?: string };
+          try {
+            cmd = JSON.parse(line) as { type?: string; id?: string };
+          } catch {
+            continue;
+          }
+          if (cmd.type !== "get_state" || !cmd.id) continue;
+          seen++;
+          if (seen === nth) {
+            emitStdoutLine(child, {
+              type: "response",
+              command: "get_state",
+              success: true,
+              id: cmd.id,
+              data,
+            });
+          }
+        }
+      });
+    }
+
+    /** 轮询等待条件（真实 timers；vi.waitFor 在本 vitest 版本下偶发过早，见 spawn-mock 注释）。 */
+    async function waitFor(cond: () => boolean, timeoutMs = 2000): Promise<void> {
+      const deadline = Date.now() + timeoutMs;
+      while (!cond()) {
+        if (Date.now() > deadline) throw new Error("condition not met within timeout");
+        await new Promise((r) => setTimeout(r, 10));
+      }
+    }
+
+    // ① 握手失败（sessionFile 空）→ agent_end 惰性 get_state 回填 → 正常三分支（final kill）
+    it("① 握手失败 sessionFile 缺失 → agent_end 惰性 get_state 回填 → 无后代走 final kill（非保守不杀）", async () => {
+      // 回补成功后判定：无活跃后代 → final kill 分支（若仍走保守分支则不会 kill，断言失败）
+      mockPending.mockReturnValue({ count: 0 });
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: lazy-backfill", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+      const counter = countGetStateRequests(child);
+      // 第 1 个 get_state（spawn 握手）不回应；第 2 个（agent_end 惰性回补）回应完整数据
+      const expectedSessionFile =
+        "/tmp/test/agents/subagents/--tmp-test--/sessions/lazy-backfill.jsonl";
+      respondToNthGetState(child, 2, {
+        sessionFile: expectedSessionFile,
+        sessionId: "lazy-sess",
+      });
+
+      // 不 emit header（RPC mode 形态）：agent_end 时 record.sessionFile 缺失
+      emitStdoutLine(child, { type: "agent_end", messages: [], willRetry: false });
+
+      // 决策点异步：惰性 get_state → 回填 → readActivePending(count=0) → final kill
+      await waitFor(() => child.killed);
+      expect(child.killSignal).toBe("SIGTERM");
+
+      // 回填落地：record.sessionFile + alive marker（对齐 finishHandshake 回填面）
+      expect(record.sessionFile).toBe(expectedSessionFile);
+      expect(mockWriteAliveMarker).toHaveBeenCalledWith(
+        expectedSessionFile,
+        expect.objectContaining({ pid: child.pid, id: "lazy-sess" }),
+      );
+      // 惰性请求确实发出：握手 1 次 + agent_end 惰性 1 次
+      expect(counter.seen).toBeGreaterThanOrEqual(2);
+
+      // 收尾：close 让 runSpawn resolve
+      child.stdout.end();
+      child.stderr.end();
+      child.emit("close", 143);
+      const result = await promise;
+      expect(result.success).toBe(true);
+      expect(result.sessionFile).toBe(expectedSessionFile);
+    });
+
+    // ② 回补超时/失败 → 仍走保守分支（行为不劣化）
+    it("② 回补无响应超时 → record.sessionFile 仍缺失 → 保守不杀（不劣化为 final kill）", async () => {
+      // mock 判定：sessionFile 缺失形态返回 error（真实现语义，见 session-pending.ts:85）
+      mockPending.mockReturnValue({ count: 0, error: "no sessionFile (handshake not settled)" });
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: lazy-timeout", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+      const counter = countGetStateRequests(child);
+
+      vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
+      try {
+        emitStdoutLine(child, { type: "agent_end", messages: [], willRetry: false });
+        // stdin flush 依赖真实事件循环（setImmediate 不 fake）：决策点已发出惰性 get_state
+        await new Promise((r) => setImmediate(r));
+        // 惰性请求已发出（握手 1 + 惰性 1），但无人回应
+        expect(counter.seen).toBe(2);
+        expect(child.killed).toBe(false);
+
+        // 1s 回补预算到期：空结果 → 不重试 → readActivePending error → 保守分支
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(record.sessionFile).toBeUndefined();
+        expect(child.killed).toBe(false); // 保守不杀
+
+        // maxTurns 未传（opts 默认）+ env 未设 → 保守分支挂无进展检测上界
+        // [T2-① / P-T2 降级 B] 不再「不限时」：连续静默达阈值才处置；此处静默
+        // 29min（< 30min 阈值）不 kill——保守 keep-alive 仍有界但不被时长误杀
+        await vi.advanceTimersByTimeAsync(KEEP_ALIVE_NO_PROGRESS_TIMEOUT_MS - 60_000);
+        expect(child.killed).toBe(false);
+
+        child.stdout.end();
+        child.stderr.end();
+        child.emit("close", 143);
+        const result = await promise;
+        // 进程最终由 close 收尾（保守分支不吞掉 runSpawn 的完成）
+        expect(result.success).toBe(true);
+        expect(record.sessionFile).toBeUndefined();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    // ③ [T1/LC-4] sessionId 有 + sessionFile 无 → close 收尾 findSessionFileByHeaderId 可达
+    // 形态说明：握手只回 sessionId 时握手自身 7s 预算耗尽才 settle（其 timer 创建于
+    // useFakeTimers 之前，fake advance 驱不动）——本用例经 agent_end 惰性回补只回
+    // sessionId，同产「handshakeResult.sessionId 有、record.sessionFile 无」形态，
+    // 且顺带覆盖惰性回补的 sessionId 补入 handshakeResult 分支（close 收尾 lookupId 源）。
+    it("③ LC-4: 惰性回补只回 sessionId（sessionFile 仍无）→ close 收尾 sessionDir 反查修正 record.sessionFile", async () => {
+      // sessionFile 缺失 → 决策点惰性回补；回补判定保守（error → 不杀）
+      mockPending.mockReturnValue({ count: 0, error: "no sessionFile (handshake not settled)" });
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: lc4-lookup", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+      // 第 2 个 get_state（惰性回补）只回 sessionId（两字段独立采集的 RC-1 残余形态）
+      respondToNthGetState(child, 2, { sessionId: "sess-lc4" });
+
+      vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
+      try {
+        emitStdoutLine(child, { type: "agent_end", messages: [], willRetry: false });
+        // flush：惰性 get_state 写出 + response 回流 → 回补拿到 sessionId（无 sessionFile）
+        await new Promise((r) => setImmediate(r));
+        await new Promise((r) => setImmediate(r));
+        await vi.advanceTimersByTimeAsync(1000); // 回补预算到期兜底（response 已先行到达）
+
+        // 保守分支：sessionFile 仍缺失 → 不杀（LC-4 修复前的死路：无任何反查可达）
+        expect(record.sessionFile).toBeUndefined();
+        expect(child.killed).toBe(false);
+
+        // 兜底查找的目录命中项：文件名格式 <timestamp>_<sessionId>.jsonl
+        const ctx = makeCtx();
+        const sessionDir = getSubagentSessionDir(ctx.agentDir, ctx.rootCwd);
+        const matchedName = "20260901T12000000_sess-lc4.jsonl";
+        mockReaddirSync.mockReturnValue([matchedName, "unrelated_other.jsonl"]);
+
+        // close 收尾：lookupId = handshakeResult.sessionId（惰性回补补入）→ 反查命中
+        child.stdout.end();
+        child.stderr.end();
+        child.emit("close", 0);
+        await promise;
+
+        const expected = path.join(sessionDir, matchedName);
+        expect(record.sessionFile).toBe(expected);
+        // findSessionFileByHeaderId 真实执行过（readdirSync 收到 sessionDir）
+        expect(mockReaddirSync).toHaveBeenCalledWith(sessionDir);
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    // ④ [A1-3] 回补 await 的异步窗口内 close 竞态：continuation 在三分支前复核进程生死，
+    // 已死直接 return——否则 keep-alive 分支 re-arm 泄漏 timer + touch marker 向死 pid
+    // 写心跳。本用例让回补窗口（1s 预算）内进程死亡，回补超时 continuation 恢复时
+    // 进程已 close 收尾：断言无 marker 写入、无任何新 kill 信号。
+    it("④ A1-3: 回补等待窗口内 kill → close → continuation 不触达三分支（不 touch marker / 不挂 timer）", async () => {
+      // 若守卫缺失（回归），continuation 会以 count=1 走 keep-alive 分支：
+      // touchAliveMarkerForHeartbeat 写 marker + 裸缺省 arm 无进展 timer（30min 后 kill）
+      mockPending.mockReturnValue({ count: 1 });
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: lazy-race-close", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+      const killSpy = vi.spyOn(child, "kill");
+
+      vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
+      try {
+        // 不 emit header（RPC mode 形态）→ record.sessionFile 缺失 → agent_end 触发惰性回补
+        emitStdoutLine(child, { type: "agent_end", messages: [], willRetry: false });
+        // stdin flush 依赖真实事件循环：惰性 get_state 已写出，continuation 阻塞在 await
+        await new Promise((r) => setImmediate(r));
+        expect(child.killed).toBe(false);
+
+        // await 窗口内进程死亡：kill + close（真 ChildProcess close 后 exitCode 非 null，
+        // FakeChild 需手动赋值模拟该语义——A1-3 守卫读取的就是它）
+        child.kill("SIGTERM");
+        child.exitCode = 143;
+        child.stdout.end();
+        child.stderr.end();
+        child.emit("close", 143);
+        await promise; // close 收尾完成（timer 清理 / 句柄移除）
+
+        // 给 record 补 sessionFile：让回归路径（守卫缺失时 continuation 触达 keep-alive
+        // 分支）的 touchAliveMarkerForHeartbeat 可观测（无 sessionFile 它会提前 no-op）
+        record.sessionFile = "/tmp/fake-race-session.jsonl";
+
+        // 回补预算到期 → continuation 恢复：应命中 A1-3 守卫直接 return
+        await vi.advanceTimersByTimeAsync(1000);
+
+        // 无 marker 写入（守卫缺失时 touchAliveMarkerForHeartbeat 会写）
+        expect(mockWriteAliveMarker).not.toHaveBeenCalled();
+        // 无任何 timer 触发的 kill（守卫缺失时无进展 timer 30min 后会二次 kill）
+        await vi.advanceTimersByTimeAsync(KEEP_ALIVE_NO_PROGRESS_TIMEOUT_MS + WAKEUP_GRACE_MS);
+        expect(killSpy).toHaveBeenCalledTimes(1); // 仅手动 kill 那一次
+        expect(child.killSignal).toBe("SIGTERM");
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+  });
 });

package/src/execution/__tests__/run-spawn-integration.test.ts

@@ -649,7 +649,7 @@ describe("runSpawn", () => {
     it("watchdog 超时（>30min）→ child.kill(SIGTERM) 被调用", async () => {
       const record = makeRecord();
       // 不 await——runSpawn 内部 await 子进程 close，watchdog 触发 kill 后还需 emit close 才 resolve
-      // [M-1] maxTurns=6 使 computeWatchdogMs 返回下限 30min（max(30min, 6*5min) = 30min）
+      // [M-1] maxTurns=6 使 maxTurnsToWatchdogMs 返回下限 30min（max(30min, 6*5min) = 30min）
       const promise = runSpawn(record, "Task: hang", makeOpts({ maxTurns: 6 }), makeCtx());
 
       const child = await waitForSpawnFake();

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

@@ -61,11 +61,15 @@ 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", () => ({
@@ -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,89 @@
+// 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 { FakeChild } from "./helpers/spawn-mock.ts";
+import {
+  _resetServiceKillStateForTest,
+  killRecordChildWithEscalation,
+  spawnedChildren,
+} from "../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);
+    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);
+
+    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);
+
+    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);
+
+    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");
+  });
+});