@zhushanwen/pi-subagent-workflow 8.6.0 → 8.7.0

package/src/execution/__tests__/one-shot-upgrade.test.ts

@@ -1,205 +0,0 @@
-// src/execution/__tests__/one-shot-upgrade.test.ts
-//
-// SP-5 one-shot upgrade：非 chatMode active record 收到 message 时自动升级 chatMode。
-//
-// 场景：one-shot subagent（conversation=false）完成首轮后 record 仍在内存（running/idle），
-// LLM 调 message 续聊 → messageHandler 检测非 chatMode + active → 置 chatMode=true（upgrade）→
-// 走 deliverMessage 统一路径（热路径或冷路径 resume）。
-//
-// mock 策略：真实 SubagentService + mock runSpawn（受控），getChildByRecord/spawnedChildren
-// 提供真实 Map 语义（deliverMessage 热路径需要 child 存在）。
-
-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";
-
-// mock logger
-const { loggerMock } = vi.hoisted(() => ({
-  loggerMock: { debug: vi.fn(), warn: vi.fn(), error: vi.fn(), info: vi.fn() },
-}));
-vi.mock("@zhushanwen/pi-extension-logger", () => ({ getLogger: () => loggerMock }));
-
-// mock session-runner：runSpawn 受控 + killAllSpawnedChildren 空实现；
-// getChildByRecord/spawnedChildren 提供真实 Map 语义。
-vi.mock("../session-runner.ts", () => {
-  const spawnedChildren = new Map<string, unknown>();
-  return {
-    runSpawn: vi.fn(),
-    killAllSpawnedChildren: vi.fn(),
-    spawnedChildren,
-    getChildByRecord: (id: string): unknown => spawnedChildren.get(id),
-  };
-});
-
-import { runSpawn, spawnedChildren } from "../session-runner.ts";
-import type { SessionRunnerContext } from "../session-runner.ts";
-import { createRecord } from "../execution-record.ts";
-import { ModelConfigService } from "../model-config-service.ts";
-import type { ModelInfo } from "../model-resolver.ts";
-import { RecordStore } from "../record-store.ts";
-import { SubagentService } from "../subagent-service.ts";
-import type { PiLike } from "../subagent-service.ts";
-import type { AgentResult, ExecutionRecord } from "../types.ts";
-import { messageHandler } from "../../interface/subagent-actions.ts";
-
-const mockRunSpawn = vi.mocked(runSpawn);
-
-const STUB_MODEL: ModelInfo = { id: "test-model", name: "Test", provider: "test", reasoning: false };
-
-function makeTmpAgentDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), "upgrade-test-"));
-}
-
-function makePi(): PiLike & {
-  appendEntry: ReturnType<typeof vi.fn>;
-  events: { emit: ReturnType<typeof vi.fn> };
-  sendMessage: ReturnType<typeof vi.fn>;
-} {
-  return { appendEntry: vi.fn(), events: { emit: vi.fn() }, sendMessage: vi.fn() };
-}
-
-function makeResult(success: boolean): AgentResult {
-  return {
-    text: success ? "done" : "err",
-    turns: 1,
-    durationMs: 100,
-    success,
-    error: success ? undefined : "boom",
-    sessionId: "sess-1",
-    toolCalls: [],
-  };
-}
-
-interface ServiceInternals {
-  store: RecordStore;
-  sessionRootId: string | null;
-}
-
-/** 非 chatMode background record（one-shot 模式）。 */
-function makeOneShotRecord(
-  sessionRootId: string,
-  status: "running" = "running",
-  id = "sa-oneshot",
-): ExecutionRecord {
-  const record = createRecord(id, {
-    agent: "general-purpose",
-    model: "test/test-model",
-    thinkingLevel: "low",
-    mode: "background",
-    task: "one-shot task",
-    slug: "oneshot",
-    startedAt: 1000,
-    rootSessionId: sessionRootId,
-    // chatMode 不传 = undefined = 非 chatMode（one-shot）
-  });
-  record.status = status;
-  record.controller = new AbortController();
-  // v4 B-1：one-shot 完成后 record 为 running（idle 折入 running）+ isResumable（无活进程）。
-  // sessionFile 总设（resumeRound 冷路径校验需要，热路径无害）。
-  record.sessionFile = "/tmp/fake-session.jsonl";
-  record.round = 1;
-  return record;
-}
-
-// ============================================================
-// SP-5 one-shot upgrade
-// ============================================================
-
-describe("SP-5 one-shot upgrade（message → chatMode + 冷 resume）", () => {
-  let agentDir: string;
-  let service: SubagentService;
-  let store: RecordStore;
-  let sessionRootId: string;
-
-  beforeEach(() => {
-    agentDir = makeTmpAgentDir();
-    const modelService = new ModelConfigService({ agentDir });
-    service = new SubagentService({ cwd: agentDir, modelService });
-    service.initSession({ pi: makePi(), sessionId: "root-session" });
-    const internals = service as unknown as ServiceInternals;
-    store = internals.store;
-    sessionRootId = internals.sessionRootId!;
-  });
-
-  afterEach(() => {
-    service.dispose();
-    fs.rmSync(agentDir, { recursive: true, force: true });
-  });
-
-  // TC-1: one-shot done 后 message 触发 upgrade（chatMode=true）
-  // 场景：one-shot running record → message → chatMode 被置 true → deliverMessage 热路径（child 存在）
-  it("TC-1: one-shot running record 收到 message → chatMode 升级为 true", async () => {
-    const record = makeOneShotRecord(sessionRootId, "running");
-    store.register(record);
-
-    // 注册 mock child 让 deliverMessage 走热路径
-    const mockChild = { killed: false, pid: 12345, stdin: { write: vi.fn(() => true) } };
-    spawnedChildren.set(record.id, mockChild as unknown);
-
-    // 验证升级前 chatMode 为 falsy
-    expect(record.chatMode).toBeFalsy();
-
-    await messageHandler(service, { subagentId: record.id, text: "follow-up" });
-
-    // 验证 chatMode 被升级
-    expect(record.chatMode).toBe(true);
-    // 验证 record 仍为 running（deliverMessage 热路径设 running）
-    expect(record.status).toBe("running");
-    // 验证 record 在内存中（非终态，未被 archive）
-    expect(store.getMutable(record.id)).toBeDefined();
-
-    // 清理
-    spawnedChildren.delete(record.id);
-  });
-
-  // TC-2: upgrade 后走冷路径 resume
-  // 场景：one-shot idle record（进程已死）→ message → chatMode=true → deliverMessage 冷路径 → resumeRound
-  it("TC-2: one-shot idle record 收到 message → chatMode 升级 + 冷路径 resume", async () => {
-    // one-shot 完成态 record（running + isResumable）需要 sessionFile（resumeRound 冷路径校验）
-    fs.writeFileSync("/tmp/fake-session.jsonl", "");
-    const record = makeOneShotRecord(sessionRootId);
-    store.register(record);
-
-    // mock runSpawn 返回成功（resume 后的 spawn）
-    mockRunSpawn.mockImplementation(async (_ctx: SessionRunnerContext) => {
-      return makeResult(true);
-    });
-
-    expect(record.chatMode).toBeFalsy();
-
-    await messageHandler(service, { subagentId: record.id, text: "resume message" });
-
-    // 验证 chatMode 被升级
-    expect(record.chatMode).toBe(true);
-    // 验证走了 resumeRound → runSpawn（冷路径）
-    expect(mockRunSpawn).toHaveBeenCalled();
-    // record 被 resumeRound 设为 running，runAndFinalize 完成后保持 running（v4 B-1 idle 折入 running）
-    // 关键是 record 不在终态
-    expect(record.status).not.toBe("closed");
-  });
-
-  // TC-3: upgrade 后 record 可续聊（非终态）
-  // 场景：验证升级后的 record 不会被 finalize 为终态，仍可接受后续 message
-  it("TC-3: upgrade 后 record 可续聊（非终态，仍在内存）", async () => {
-    const record = makeOneShotRecord(sessionRootId);
-    store.register(record);
-
-    // runSpawn 返回成功
-    mockRunSpawn.mockImplementation(async () => makeResult(true));
-
-    await messageHandler(service, { subagentId: record.id, text: "first resume" });
-
-    // chatMode 已升级
-    expect(record.chatMode).toBe(true);
-
-    // 关键验证：record 仍在内存（getMutable 返回非 undefined）——未被 archive 到终态
-    const mutable = store.getMutable(record.id);
-    expect(mutable).toBeDefined();
-    expect(mutable!.chatMode).toBe(true);
-
-    // 验证 status 不是终态（closed 是终态；running 是非终态，v4 B-1 idle 折入 running）
-    expect(record.status).toBe("running");
-  });
-});

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

@@ -1,358 +0,0 @@
-// src/__tests__/output-collector.test.ts
-//
-// 锁定 extractParsedOutput 纯函数契约——它被 collectResult 直接消费，决定
-// AgentResult.parsedOutput 字段。toUsageTotal / collectResponseText 已删除
-// （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 type { ExecutionRecord, ToolCall } from "../types.ts";
-
-// ============================================================
-// extractParsedOutput
-// ============================================================
-
-describe("extractParsedOutput", () => {
-  it("returns undefined for empty toolCalls", () => {
-    expect(extractParsedOutput([])).toBeUndefined();
-  });
-
-  it("returns undefined when no structured-output call exists", () => {
-    const calls: ToolCall[] = [
-      { toolName: "bash", result: { details: "x" } },
-      { toolName: "read", result: { details: "y" } },
-    ];
-    expect(extractParsedOutput(calls)).toBeUndefined();
-  });
-
-  it("returns undefined when structured-output has no result.details", () => {
-    const calls: ToolCall[] = [
-      { toolName: "structured-output", result: { content: [] } },
-      { toolName: "structured-output", result: {} },
-      { toolName: "structured-output" },
-    ];
-    expect(extractParsedOutput(calls)).toBeUndefined();
-  });
-
-  it("returns details when exactly one structured-output call has details", () => {
-    const calls: ToolCall[] = [
-      { toolName: "bash" },
-      { toolName: "structured-output", result: { details: { answer: 42 } } },
-    ];
-    expect(extractParsedOutput(calls)).toEqual({ answer: 42 });
-  });
-
-  it("returns the LAST structured-output details (reverse iteration)", () => {
-    const calls: ToolCall[] = [
-      { toolName: "structured-output", result: { details: "first" } },
-      { toolName: "bash" },
-      { toolName: "structured-output", result: { details: "second" } },
-    ];
-    expect(extractParsedOutput(calls)).toBe("second");
-  });
-
-  it("ignores isError structured-output calls without details, picks one with details", () => {
-    const calls: ToolCall[] = [
-      { toolName: "structured-output", isError: true, result: { content: [{ type: "text", text: "bad" }] } },
-      { toolName: "structured-output", result: { details: { ok: true } } },
-    ];
-    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);
-  });
-});