@zhushanwen/pi-subagent-workflow 8.5.0 → 8.6.0

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

@@ -5,8 +5,9 @@
 // （usage 收口进 getTotalUsage，text 收口进 getFullText，均在 execution-record.test 测）。
 import { describe, expect, it } from "vitest";
 
-import { extractParsedOutput } from "../output-collector.ts";
-import type { ToolCall } from "../types.ts";
+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 type { ExecutionRecord, ToolCall } from "../types.ts";
 
 // ============================================================
 // extractParsedOutput
@@ -58,4 +59,300 @@ describe("extractParsedOutput", () => {
     ];
     expect(extractParsedOutput(calls)).toEqual({ ok: true });
   });
+
+  // [F-1 失败吞没修复] 失败调用（pi 失败路径 details 默认 {}）的 details 不是
+  // schema 校验产出——journal 实锤 tool_end isError=true details={} 曾被当
+  // parsedOutput，gate 终止/模型自弃的 run 以 parsedOutput={} 静默 completed。
+  it("skips failed structured-output call with details:{} (isError=true) — no parsedOutput", () => {
+    const calls: ToolCall[] = [
+      { toolName: "bash", result: { content: [] } },
+      { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "Schema validation failed: /target is required" }] } },
+    ];
+    expect(extractParsedOutput(calls)).toBeUndefined();
+  });
+
+  it("skips failed call with details, still picks later valid call (reverse order)", () => {
+    const calls: ToolCall[] = [
+      { toolName: "structured-output", isError: true, result: { details: {} } },
+      { toolName: "structured-output", result: { details: { fixed: true } } },
+    ];
+    expect(extractParsedOutput(calls)).toEqual({ fixed: true });
+  });
+
+  it("isError on non-structured-output calls does not affect extraction", () => {
+    const calls: ToolCall[] = [
+      { toolName: "bash", isError: true, result: { details: "ignored" } },
+      { toolName: "structured-output", result: { details: { answer: 1 } } },
+    ];
+    expect(extractParsedOutput(calls)).toEqual({ answer: 1 });
+  });
+});
+
+// ============================================================
+// describeMissingParsedOutput（F-1 三态归因）
+// ============================================================
+
+describe("describeMissingParsedOutput", () => {
+  it("returns undefined when a valid parsedOutput exists", () => {
+    const calls: ToolCall[] = [
+      { toolName: "structured-output", isError: true, result: { details: {} } },
+      { toolName: "structured-output", result: { details: { ok: 1 } } },
+    ];
+    expect(describeMissingParsedOutput(calls)).toBeUndefined();
+  });
+
+  it("state 1: validation failure — isError calls present, error carries last summary", () => {
+    const calls: ToolCall[] = [
+      { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "Schema validation failed: /target is required" }] } },
+    ];
+    const msg = describeMissingParsedOutput(calls);
+    expect(msg).toContain("failed");
+    expect(msg).toContain("1 structured-output call(s) failed");
+    expect(msg).toContain("Schema validation failed: /target is required");
+  });
+
+  it("state 2: structured-output never called — error hints to check extension install (C1 blind spot)", () => {
+    const calls: ToolCall[] = [
+      { toolName: "bash", result: { content: [] } },
+      { toolName: "read", result: { content: [] } },
+    ];
+    const msg = describeMissingParsedOutput(calls);
+    expect(msg).toContain("structured-output tool was never called");
+    expect(msg).toContain("structured-output extension is installed");
+  });
+
+  it("state 3: SO called successfully but no details", () => {
+    const calls: ToolCall[] = [
+      { toolName: "structured-output", result: { content: [] } },
+    ];
+    const msg = describeMissingParsedOutput(calls);
+    expect(msg).toContain("none of the successful calls carried result details");
+  });
+
+  it("empty toolCalls → state 2 (never called)", () => {
+    expect(describeMissingParsedOutput([])).toContain("never called");
+  });
+
+  it("summary truncates long error text (300 chars cap)", () => {
+    const longText = "x".repeat(500);
+    const calls: ToolCall[] = [
+      { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: longText }] } },
+    ];
+    const msg = describeMissingParsedOutput(calls);
+    expect(msg).toContain("...");
+    expect(msg!.length).toBeLessThan(longText.length);
+  });
+
+  // 文案约束：不得命中 execute-agent-call 的 STALE_CONTEXT_PATTERNS（"aborted" 等），
+  // 否则会被误诊为 stale-context 跳过重试。
+  it("messages avoid STALE_CONTEXT_PATTERNS substrings (no false stale-context triage)", () => {
+    const samples = [
+      describeMissingParsedOutput([])!,
+      describeMissingParsedOutput([{ toolName: "structured-output", isError: true, result: { details: {} } }])!,
+      describeMissingParsedOutput([{ toolName: "structured-output", result: { content: [] } }])!,
+    ];
+    for (const msg of samples) {
+      const lower = msg.toLowerCase();
+      expect(lower).not.toContain("aborted");
+      expect(lower).not.toContain("ctx is stale");
+      expect(lower).not.toContain("context canceled");
+    }
+  });
+
+  // ── [F-R1] 态2（isError 分支）错误摘要拼接段中和 ──
+  //
+  // 动态错误文本（模型/provider 原始错误）可能携带 "aborted"/"ctx is stale" 等
+  // STALE_CONTEXT_PATTERNS 词；不中和则归因 error 经 collectResult → result.error
+  // 流到 execute-agent-call 的 isStaleContextErrorMsg 分诊，被误诊为 stale-context
+  // 跳过重试。固定前缀静态无命中（上一用例锁定），中和只针对动态段。
+  describe("F-R1: 态2 错误摘要 STALE_CONTEXT_PATTERNS 中和", () => {
+    function failedSoCallsWith(text: string): ToolCall[] {
+      return [
+        { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text }] } },
+      ];
+    }
+
+    it("失败 content 含 'aborted'/'ctx is stale' → 摘要被 [redacted]，归因 error 不触发 isStaleContextErrorMsg", () => {
+      const msg = describeMissingParsedOutput(
+        failedSoCallsWith("Request aborted: context canceled — ctx is stale after session replacement"),
+      )!;
+      expect(msg).toContain("[redacted]");
+      const lower = msg.toLowerCase();
+      expect(lower).not.toContain("aborted");
+      expect(lower).not.toContain("ctx is stale");
+      expect(lower).not.toContain("context canceled");
+      // 消费点语义锁定：归因 error 进入 stale-context 分诊必须为 false（可重试）
+      expect(isStaleContextErrorMsg(msg)).toBe(false);
+    });
+
+    it("大小写变体（'ABORTED'）同样被中和（分诊是大小写不敏感子串匹配）", () => {
+      const msg = describeMissingParsedOutput(failedSoCallsWith("ABORTED by provider"))!;
+      expect(msg).toContain("[redacted]");
+      expect(isStaleContextErrorMsg(msg)).toBe(false);
+    });
+
+    it("无动态内容时整条归因也不命中（防御回归锁定）", () => {
+      const msg = describeMissingParsedOutput([
+        { toolName: "structured-output", isError: true, result: { details: {} } },
+      ])!;
+      expect(isStaleContextErrorMsg(msg)).toBe(false);
+    });
+
+    it("neutralizeStalePatterns：多 pattern 同时命中 + 无命中原样透传", () => {
+      expect(neutralizeStalePatterns("aborted CTX IS STALE / context canceled")).toBe(
+        "[redacted] [redacted] / [redacted]",
+      );
+      expect(neutralizeStalePatterns("provider socket hang up")).toBe("provider socket hang up");
+    });
+  });
+
+  // ── [F-R4] 态2 文案按最后错误内容分类，不再硬编码 "(schema validation)" ──
+  describe("F-R4: 态2 失败原因分类", () => {
+    it("最后错误含 'validation failed'（大小写不敏感）→ (schema validation)", () => {
+      const calls: ToolCall[] = [
+        { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "Schema validation failed: /target is required" }] } },
+      ];
+      const msg = describeMissingParsedOutput(calls)!;
+      expect(msg).toContain("(schema validation)");
+      expect(msg).not.toContain("(execution failure)");
+    });
+
+    it("最后错误为非校验失败（如 provider 错误）→ (execution failure)", () => {
+      const calls: ToolCall[] = [
+        { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "provider socket hang up" }] } },
+      ];
+      const msg = describeMissingParsedOutput(calls)!;
+      expect(msg).toContain("(execution failure)");
+      expect(msg).not.toContain("(schema validation)");
+    });
+  });
+});
+
+// ============================================================
+// MF-1: 三态可重试性矩阵（确定性失败标记）
+// ============================================================
+
+describe("MF-1: 三态可重试性矩阵（确定性失败标记）", () => {
+  // 矩阵（SSOT 注释在 execute-agent-call DETERMINISTIC_SCHEMA_FAILURE_PREFIX 与
+  // describeMissingParsedOutput JSDoc，本 describe 是执行面锁定）：
+  //   态① 从未调用 SO            → 带标记 → 不可重试（环境确定性，C1 安装盲区）
+  //   态② SO isError（gate 终止/不可满足 schema）→ 带标记 → 不可重试（同 schema 重试必同结果）
+  //   态③ 调用过但无 details       → 无标记 → 可重试（可能瞬态，保留既有重试语义）
+
+  it("态① 从未调用 SO → error 以确定性标记开头（不可重试）", () => {
+    const msg = describeMissingParsedOutput([])!;
+    expect(msg.startsWith(DETERMINISTIC_SCHEMA_FAILURE_PREFIX)).toBe(true);
+    expect(isDeterministicSchemaFailureMsg(msg)).toBe(true);
+  });
+
+  it("态② isError/schema validation 子类 → error 以确定性标记开头（不可重试）", () => {
+    const msg = describeMissingParsedOutput([
+      { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "Schema validation failed: /target is required" }] } },
+    ])!;
+    expect(msg.startsWith(DETERMINISTIC_SCHEMA_FAILURE_PREFIX)).toBe(true);
+    expect(isDeterministicSchemaFailureMsg(msg)).toBe(true);
+  });
+
+  it("态② execution failure 子类（provider 瞬态）同样带标记（isError 态整体不重试）", () => {
+    const msg = describeMissingParsedOutput([
+      { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "provider socket hang up" }] } },
+    ])!;
+    expect(isDeterministicSchemaFailureMsg(msg)).toBe(true);
+  });
+
+  it("态③ 调用过但无 details → 不带标记（可重试语义保留）", () => {
+    const msg = describeMissingParsedOutput([
+      { toolName: "structured-output", result: { content: [] } },
+    ])!;
+    expect(isDeterministicSchemaFailureMsg(msg)).toBe(false);
+  });
+
+  it("有有效 parsedOutput → 无归因无标记（不适用矩阵）", () => {
+    expect(
+      describeMissingParsedOutput([{ toolName: "structured-output", result: { details: { ok: 1 } } }]),
+    ).toBeUndefined();
+  });
+
+  // 验收④：标记词不命中 STALE_CONTEXT_PATTERNS——若命中，isStaleContextErrorMsg
+  // 分诊（判定在前）会抢先归因 stale-context，虽然同样不重试，但归因语义被污染
+  // （TUI/日志把 schema 失败误报为 stale）。
+  it("标记词与全部 STALE_CONTEXT_PATTERNS 零交集，isStaleContextErrorMsg 不抢先", () => {
+    const lower = DETERMINISTIC_SCHEMA_FAILURE_PREFIX.toLowerCase();
+    for (const pattern of STALE_CONTEXT_PATTERNS) {
+      expect(lower.includes(pattern)).toBe(false);
+    }
+    expect(isStaleContextErrorMsg(DETERMINISTIC_SCHEMA_FAILURE_PREFIX)).toBe(false);
+  });
+});
+
+// ============================================================
+// collectResult — F-1 集成行为（schemaExpected → 失败标注）
+// ============================================================
+
+describe("collectResult — F-1 schemaExpected 失败标注", () => {
+  /** 最小 ExecutionRecord stub（collectResult 只读 turns/toolCalls 派生面）。 */
+  function makeRecordWithCalls(calls: ToolCall[]): ExecutionRecord {
+    return {
+      id: "rec-1",
+      turns: [{ toolCalls: calls, text: "done", turnCount: 1, closed: true }],
+      turnCount: 1,
+    } as unknown as ExecutionRecord;
+  }
+
+  const baseArgs = {
+    startTime: Date.now(),
+    sessionId: "s-1",
+    sessionFile: undefined,
+  };
+
+  it("schemaExpected + failed SO call (details:{}) + success=true → success=false + error attributed", () => {
+    const record = makeRecordWithCalls([
+      { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "validation boom" }] } },
+    ]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("validation boom");
+    expect(result.parsedOutput).toBeUndefined();
+  });
+
+  it("schemaExpected + never called SO + success=true → error hints extension check", () => {
+    const record = makeRecordWithCalls([{ toolName: "bash", result: { content: [] } }]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.success).toBe(false);
+    expect(result.error).toContain("structured-output extension is installed");
+  });
+
+  it("schemaExpected + valid details → success preserved (S3 e2e semantics no regression)", () => {
+    const record = makeRecordWithCalls([
+      { toolName: "structured-output", result: { details: { answer: 42 } } },
+    ]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.success).toBe(true);
+    expect(result.error).toBeUndefined();
+    expect(result.parsedOutput).toEqual({ answer: 42 });
+  });
+
+  it("no schemaExpected (plain mode) + no SO call → success unchanged", () => {
+    const record = makeRecordWithCalls([{ toolName: "bash", result: { content: [] } }]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined });
+    expect(result.success).toBe(true);
+    expect(result.parsedOutput).toBeUndefined();
+  });
+
+  it("success=false path: existing error not overwritten by F-1 attribution", () => {
+    const record = makeRecordWithCalls([]);
+    const result = collectResult(record, { ...baseArgs, success: false, error: "provider boom", schemaExpected: true });
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("provider boom");
+  });
+
+  it("[MF-1] F-1 标注的 error 携带确定性标记（流到 executeAgentCall 即不可重试）", () => {
+    const record = makeRecordWithCalls([
+      { toolName: "structured-output", isError: true, result: { details: {}, content: [{ type: "text", text: "Schema validation failed: /target is required" }] } },
+    ]);
+    const result = collectResult(record, { ...baseArgs, success: true, error: undefined, schemaExpected: true });
+    expect(result.success).toBe(false);
+    expect(result.error).toBeDefined();
+    expect(isDeterministicSchemaFailureMsg(result.error)).toBe(true);
+  });
 });

package/src/execution/__tests__/rpc-mode.test.ts

@@ -11,7 +11,7 @@ import { parseSpawnLine } from "../spawn-event-adapter.ts";
 
 describe("buildSpawnArgs - RPC mode", () => {
   const baseParams = {
-    model: "gpt-4",
+    modelRef: { provider: "openai", id: "gpt-4" },
     thinkingLevel: undefined,
     agentTools: undefined,
     appendSystemPromptPath: undefined,

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

@@ -69,7 +69,7 @@ vi.mock("../temp-prompt.ts", () => ({
   cleanupTempPrompt: vi.fn(async () => {}),
 }));
 
-import { killAllSpawnedChildren, runSpawn, spawnedChildren, WAKEUP_GRACE_MS, computeWatchdogMs } from "../session-runner.ts";
+import { killAllSpawnedChildren, runSpawn, spawnedChildren, WAKEUP_GRACE_MS, computeWatchdogMs, SPAWN_WATCHDOG_ENV } from "../session-runner.ts";
 import { readActivePendingFromSessionFile } from "../session-pending.ts";
 import {
   emitStdoutLine,
@@ -98,10 +98,16 @@ describe("runSpawn", () => {
     vi.clearAllMocks();
     // existsSync 默认 false（sessionFile 不存在兜底路径）
     mockExistsSync.mockReturnValue(false);
+    // [F-4 假红源修复] env 隔离：makeOpts 默认 maxTurns=undefined →
+    // resolveSpawnWatchdogMs 走 env 兑底分支，宿主 export SPAWN_WATCHDOG 即假红。
+    // 空串 = 未设（raw falsy 判定）；MF-4b 用例内的手动 save/delete/restore 与本
+    // stub 兼容（finally 恢复到 stub 值，语义不变）。
+    vi.stubEnv(SPAWN_WATCHDOG_ENV, "");
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
+    vi.unstubAllEnvs();
   });
 
   // ── 1. orphan 进程兜底（C1）──
@@ -492,6 +498,43 @@ 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 误设会让「不限时」断言失效）
+      const prevWatchdogEnv = process.env[SPAWN_WATCHDOG_ENV];
+      delete process.env[SPAWN_WATCHDOG_ENV];
+      mockPending.mockReturnValue({ count: 2 });
+      const record = makeRecord();
+      const promise = runSpawn(record, "Task: slow-desc-no-turns", makeOpts(), makeCtx());
+
+      await waitForSpawn();
+      const child = lastSpawnedChild();
+
+      vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "Date"] });
+      try {
+        emitStdoutLine(child, sessionHeader());
+        emitStdoutLine(child, { type: "agent_end", messages: [], willRetry: false });
+        await new Promise((r) => setImmediate(r));
+        // keep alive：不 kill
+        expect(child.killed).toBe(false);
+
+        // 超过旧 50min 估算默认仍不 kill = watchdog 未 re-arm
+        await vi.advanceTimersByTimeAsync(51 * 60 * 1000);
+        expect(child.killed).toBe(false);
+
+        child.stdout.end();
+        child.stderr.end();
+        child.emit("close", 143);
+
+        const result = await promise;
+        expect(result.success).toBe(true);
+      } finally {
+        if (prevWatchdogEnv !== undefined) process.env[SPAWN_WATCHDOG_ENV] = prevWatchdogEnv;
+        vi.useRealTimers();
+      }
+    });
+
     // [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 误删/误用固定超时，

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

@@ -0,0 +1,199 @@
+// src/execution/__tests__/run-spawn-stdout-callback-throw.test.ts
+//
+// [F-R2] stdout data 同步回调链内 fail-fast throw 不逃逸（不升级为 uncaughtException 崩宿主）。
+//
+// 背景：session-runner 的两处 timer 安全校验调用位于 child.stdout.on("data") 同步回调链内：
+//   ① agent_end keep-alive 分支的 resolveSpawnWatchdogMs（→ assertSafeTimerDelay fail-fast）
+//   ② chatMode agent_settled 分支的 armIdleTimer（→ assertSafeTimerDelay fail-fast）
+// 旧实现任一处 throw 都会逃出事件回调 = Node uncaughtException 崩宿主进程。
+// 修复：调用点包 try/catch 降级（不挂 timer），错误经 bestEffort("error") 可见。
+//
+// mock 结构与 run-spawn-chatmode-settled.test.ts 一致（FakeChild + lifecycle-manager 真实模块）。
+// logger 整体 mock（loggerMock spy）断言错误可见——「fail-fast 语义保留（错误可见、行为明确）
+// 但不升级为进程崩溃」。
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+// logger mock：bestEffort / session-runner 共享同一 loggerMock（断言错误可见性）。
+// vi.hoisted：vi.mock 工厂被提升到顶层 const 之前执行，loggerMock 必须经 vi.hoisted 创建。
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+}));
+vi.mock("@zhushanwen/pi-extension-logger", () => ({ getLogger: () => loggerMock }));
+
+vi.mock("node:child_process", async () => {
+  const { FakeChild } = await import("./helpers/spawn-mock.ts");
+  return {
+    spawn: vi.fn(() => new FakeChild()),
+    // buildEnvBlock 的 git branch 调用（execFile 异步）：默认 err-first 兜底 → catch → branch=""
+    execFile: vi.fn(
+      (
+        _cmd: string,
+        _args: readonly string[],
+        _opts: unknown,
+        cb: (err: Error | null, stdout?: string, stderr?: string) => void,
+      ) => cb(new Error("execFile not configured in this test")),
+    ),
+  };
+});
+
+vi.mock("node:fs", async () => {
+  const actual = await import("node:fs");
+  return {
+    default: {
+      ...actual,
+      mkdirSync: vi.fn(),
+      existsSync: vi.fn(() => false),
+      appendFileSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      readdirSync: vi.fn(() => []),
+    },
+    mkdirSync: vi.fn(),
+    existsSync: vi.fn(() => false),
+    appendFileSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    readdirSync: vi.fn(() => []),
+    promises: actual.promises,
+  };
+});
+
+vi.mock("../alive-store.ts", () => ({
+  writeAliveMarker: vi.fn(),
+}));
+
+// 场景 ① 依赖 keep-alive 分支命中：count=1（有活跃后代 → 不 kill → 重挂 watchdog）
+vi.mock("../session-pending.ts", () => ({
+  readActivePendingFromSessionFile: vi.fn(() => ({ count: 1 })),
+}));
+
+vi.mock("../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` };
+  }),
+  cleanupTempPrompt: vi.fn(async () => {}),
+}));
+
+import { runSpawn, SPAWN_WATCHDOG_ENV } from "../session-runner.ts";
+import type { SessionRunnerContext } from "../session-runner.ts";
+import { hasIdleTimer, _resetLifecycleState } from "../lifecycle-manager.ts";
+import { createRecord } from "../execution-record.ts";
+import type { ExecutionRecord } from "../types.ts";
+import {
+  emitStdoutLine,
+  type FakeChild,
+  lastSpawnedChild as lastSpawnedChildOf,
+  makeCtx,
+  makeOpts,
+  makeRecord,
+  sessionHeader,
+  waitForSpawn as waitForSpawnOf,
+} from "./helpers/spawn-mock.ts";
+
+const mockSpawn = vi.mocked(spawn);
+
+const lastSpawnedChild = (): FakeChild => lastSpawnedChildOf(mockSpawn);
+const waitForSpawn = (timeoutMs = 1000): Promise<void> => waitForSpawnOf(mockSpawn, timeoutMs);
+
+/** 构造 chatMode record（idleTimeoutMs 设为超出 setTimeout 安全域的值 → assertSafeTimerDelay throw）。 */
+function makeChatModeRecord(id = "sa-f2-idle"): ExecutionRecord {
+  return createRecord(id, {
+    agent: "general-purpose",
+    model: "test-model",
+    mode: "sync",
+    task: "chat task",
+    slug: "chat",
+    startedAt: 1_000_000,
+    rootSessionId: "root-session",
+    parentRecordId: undefined,
+    depth: 0,
+    chatMode: true,
+    // > 2^31-1：Node setTimeout 溢出域，assertSafeTimerDelay fail-fast
+    idleTimeoutMs: Number.MAX_SAFE_INTEGER,
+  });
+}
+
+describe("[F-R2] stdout 回调链内 fail-fast throw 不逃逸", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    _resetLifecycleState();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    _resetLifecycleState();
+  });
+
+  it("① agent_end keep-alive 分支 resolveSpawnWatchdogMs throw → 降级不 re-arm，run 正常收尾，error 可见", async () => {
+    const record = makeRecord();
+    const promise = runSpawn(record, "Task: keepalive", makeOpts(), makeCtx());
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    emitStdoutLine(child, sessionHeader("sess-fr2a"));
+    // 初始 watchdog 解析在 spawn 后同步块内已完成（env 未设 → 不挂）。
+    // 此刻设非法 env：agent_end keep-alive 分支再读 env → assertSafeTimerDelay throw。
+    process.env[SPAWN_WATCHDOG_ENV] = String(Number.MAX_SAFE_INTEGER);
+    try {
+      emitStdoutLine(child, { type: "agent_end", willRetry: false });
+      // 给 stream flush 留一个 tick（对齐 chatmode 测试模式）：throw 若逃逸回调，
+      // vitest 会以 unhandled error 判本测试失败——能走到断言即「未崩宿主」。
+      await new Promise((r) => setTimeout(r, 20));
+
+      // 降级语义：不 re-arm（无 timer 可直接观察的是——子进程未被 kill、run 未被中断）
+      expect(child.killed).toBe(false);
+
+      // 错误可见（fail-fast 语义保留）：bestEffort("error") 经 logger.error 落日志
+      expect(loggerMock.error).toHaveBeenCalledWith(
+        expect.stringContaining("resolveSpawnWatchdogMs"),
+        expect.objectContaining({ detail: expect.stringContaining("exceeds the Node setTimeout limit") }),
+      );
+
+      // 收尾：run 正常完成（未被回调异常打断）
+      child.stdout.end();
+      child.stderr.end();
+      child.emit("close", 0);
+      const result = await promise;
+      expect(result.success).toBe(true);
+    } finally {
+      delete process.env[SPAWN_WATCHDOG_ENV];
+    }
+  });
+
+  it("② chatMode agent_settled armIdleTimer throw → 降级不挂 idle timer，onRoundSettled 照常、提前 resolve", async () => {
+    const record = makeChatModeRecord("sa-f2-idle");
+    const onRoundSettled = vi.fn();
+    const ctx: Partial<SessionRunnerContext> = { onRoundSettled };
+    const promise = runSpawn(record, "Task: idle", makeOpts(), makeCtx(ctx as SessionRunnerContext));
+
+    await waitForSpawn();
+    const child = lastSpawnedChild();
+
+    emitStdoutLine(child, sessionHeader("sess-fr2b"));
+    emitStdoutLine(child, { type: "agent_settled" });
+    await new Promise((r) => setTimeout(r, 20));
+
+    // 降级语义：idle timer 未挂（throw 发生在 arm 入口校验，先于 setTimeout）
+    expect(hasIdleTimer(record.id)).toBe(false);
+    expect(child.killed).toBe(false);
+
+    // catch 后续语句照常执行：本轮完成通知不因 GC timer 故障丢失
+    expect(onRoundSettled).toHaveBeenCalledTimes(1);
+
+    // 错误可见
+    expect(loggerMock.error).toHaveBeenCalledWith(
+      expect.stringContaining("armIdleTimer"),
+      expect.objectContaining({ detail: expect.stringContaining("exceeds the Node setTimeout limit") }),
+    );
+
+    // 收尾：chatMode 首轮 agent_settled 已 resolveRun(0)，close 后 runSpawn 正常返回
+    child.stdout.end();
+    child.stderr.end();
+    child.emit("close", 0);
+    const result = await promise;
+    expect(result.success).toBe(true);
+  });
+});

package/src/execution/__tests__/session-runner-schema-env.test.ts

@@ -94,8 +94,10 @@ import {
   applySchemaEnvToChildEnv,
   type RunOptions,
   runSpawn,
+  SCHEMA_ENV_MAX_BYTES,
   type SessionRunnerContext,
 } from "../session-runner.ts";
+import { schemaEnvByteLength } from "../../shared/schema-env.ts";
 
 const mockSpawn = vi.mocked(spawn);
 const mockExistsSync = vi.mocked(fs.existsSync);
@@ -225,6 +227,43 @@ describe("applySchemaEnvToChildEnv (T3.9/T3.11/T3.16)", () => {
     expect(childEnv.HOME).toBe("/home/user");
     expect(childEnv.PI_WORKFLOW_SCHEMA).toBe('{"x":1}');
   });
+
+  // [SO-DATA-4] 边界内通过：255KB（< 256KiB 上限）正常注入，行为不变
+  it("[SO-DATA-4] 255KB schema 正常注入（上限内不误拒）", () => {
+    const childEnv: Record<string, string | undefined> = {};
+    // ASCII 串 byteLength === length，构造 255KB 纯 JSON body（外层再包一层合法 JSON）
+    const padding = "x".repeat(255 * 1024);
+    const schemaJson = JSON.stringify({ type: "object", properties: { pad: { const: padding } } });
+    expect(schemaEnvByteLength(schemaJson)).toBeLessThanOrEqual(SCHEMA_ENV_MAX_BYTES);
+    applySchemaEnvToChildEnv(childEnv, schemaJson);
+    expect(childEnv.PI_WORKFLOW_SCHEMA).toBe(schemaJson);
+  });
+
+  // [SO-DATA-4] 超限 fail-fast：257KB 拒绝，错误消息含实际大小 + 精简/拆分指引 + E2BIG 归因
+  it("[SO-DATA-4] 257KB schema fail-fast 拒绝（错误含实际大小与恢复指引）", () => {
+    const childEnv: Record<string, string | undefined> = {};
+    const padding = "x".repeat(257 * 1024);
+    const schemaJson = JSON.stringify({ type: "object", properties: { pad: { const: padding } } });
+    expect(schemaEnvByteLength(schemaJson)).toBeGreaterThan(SCHEMA_ENV_MAX_BYTES);
+    expect(() => applySchemaEnvToChildEnv(childEnv, schemaJson)).toThrow(
+      expect.objectContaining({
+        message: expect.stringContaining("bytes exceeds"),
+      }),
+    );
+    // 错误消息含实际大小、上限、精简/拆分指引与 E2BIG 归因（可操作性验收）
+    try {
+      applySchemaEnvToChildEnv(childEnv, schemaJson);
+      throw new Error("expected applySchemaEnvToChildEnv to throw");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      expect(msg).toContain(String(schemaEnvByteLength(schemaJson))); // 实际大小
+      expect(msg).toContain(String(SCHEMA_ENV_MAX_BYTES)); // 上限值
+      expect(msg).toContain("simplify the schema"); // 精简指引
+      expect(msg).toContain("E2BIG"); // ARG_MAX/E2BIG 约束说明
+    }
+    // fail-fast：不写入半截值
+    expect(childEnv.PI_WORKFLOW_SCHEMA).toBeUndefined();
+  });
 });
 
 // ── runSpawn 集成测试：schemaEnv 经 RunOptions → childEnv ──