@zhushanwen/pi-subagent-workflow 8.0.0 → 8.1.0

package/src/interface/tool-workflow-script.ts

@@ -211,8 +211,9 @@ export function registerWorkflowScriptTool(
           result = await actionList(registry);
           break;
         default:
-          result = textResult(`Unknown action: ${String(params.action)}`, true);
-          break;
+          // 防御性（schema StringEnum 先拦）：throw（W4b）——pi 只对 execute throw 置
+          // isError:true，返回值里的 isError 被 agent-loop 丢弃（agent-loop.js:453-483）。
+          throw new Error(`Unknown action: ${String(params.action)}`);
       }
       // GUI 协议：RPC 模式下附加 __gui__ 到 details
       return withScriptGui(result, toGuiCtx(ctx));
@@ -241,28 +242,27 @@ export function registerWorkflowScriptTool(
 
 export function actionGenerate(params: ScriptParams, signal: AbortSignal | undefined): TextContent {
   if (signal?.aborted) {
-    return textResult("Operation aborted before start", true);
+    // throw（W4b）：pi 只对 execute throw 置 isError:true（返回值 isError 被丢弃）
+    throw new Error("Operation aborted before start");
   }
   const name = params.name;
   const script = params.script;
   if (!name || !script) {
-    return textResult("generate requires 'name' and 'script' parameters", true);
+    throw new Error("generate requires 'name' and 'script' parameters");
   }
 
  // 1. Reject ESM syntax (Worker runs CJS); 'export const meta' 例外
   const stripped = script.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
   if (/\bimport\s+(?:type\s+)?[\w{*]/.test(stripped)) {
-    return textResult(
+    throw new Error(
       "Script uses ESM 'import' syntax. Workflow scripts run in a CJS Worker — use require() instead.",
-      true,
     );
   }
   const hasExportMeta = /\bexport\s+const\s+meta\s*=/.test(stripped);
   const otherExports = stripped.match(/\bexport\s+(?:const|let|var|function|default|\{)/g);
   if (otherExports && !hasExportMeta) {
-    return textResult(
+    throw new Error(
       "Script uses ESM 'export' (non-meta). Use 'const meta = {...}' at top level instead.",
-      true,
     );
   }
 
@@ -270,17 +270,15 @@ export function actionGenerate(params: ScriptParams, signal: AbortSignal | undef
   const hasPiMeta = /\/\*\s*@pi-meta\s*\n/.test(script);
   const hasLegacyMeta = script.includes("const meta") || script.includes("export const meta");
   if (!hasPiMeta && !hasLegacyMeta) {
-    return textResult(
+    throw new Error(
       "Script must contain a meta declaration: a /* @pi-meta */ YAML block comment (preferred) or legacy const meta = { ... }. The block has the form: a block comment starting with /* @pi-meta followed by YAML (name/description/phases/parameters?/usage?), closed by */ on its own line.",
-      true,
     );
   }
 
  // 3. Check agent usage
   if (!/\bagent\s*\(/.test(stripped)) {
-    return textResult(
+    throw new Error(
       "Script does not contain any agent() calls. A workflow must call agent() at least once.",
-      true,
     );
   }
 
@@ -290,7 +288,7 @@ export function actionGenerate(params: ScriptParams, signal: AbortSignal | undef
     new Function(`(async () => { ${cjsScript} })();`);
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err);
-    return textResult(`Syntax error in script: ${msg}`, true);
+    throw new Error(`Syntax error in script: ${msg}`);
   }
 
  // 4b. Round-trip: validate /* @pi-meta */ YAML before writing (v5 §4.7 / ERR4 — report linePos, don't write bad files)
@@ -300,9 +298,8 @@ export function actionGenerate(params: ScriptParams, signal: AbortSignal | undef
       const loc = "linePos" in detailed && detailed.linePos
         ? ` (line ${detailed.linePos.line}, col ${detailed.linePos.col})`
         : "";
-      return textResult(
+      throw new Error(
         `Generated /* @pi-meta */ YAML cannot be parsed${loc}: ${detailed.error}. Common causes: YAML indent errors, patternProperties regex must use double backslash (\\d not \d), or a stray star-slash inside the YAML body. Fix the meta block and retry.`,
-        true,
       );
     }
   }
@@ -332,7 +329,7 @@ async function actionLint(
 ): Promise<TextContent> {
   const name = params.name;
   if (!name) {
-    return textResult("lint requires 'name' parameter", true);
+    throw new Error("lint requires 'name' parameter");
   }
   const source = await loadScriptSource(name, registry);
   if (!source) {
@@ -341,9 +338,8 @@ async function actionLint(
     const suggestions = available
       .map((wf) => `  - ${wf.name}: ${wf.meta.description || "(no description)"}`)
       .join("\n");
-    return textResult(
+    throw new Error(
       `Workflow '${name}' not found or not available.\nAvailable:\n${suggestions || "  (none)"}`,
-      true,
     );
   }
 
@@ -386,7 +382,7 @@ async function loadScriptSource(
 async function actionSave(params: ScriptParams): Promise<TextContent> {
   const name = params.name;
   if (!name) {
-    return textResult("save requires 'name' parameter (tmp script name)", true);
+    throw new Error("save requires 'name' parameter (tmp script name)");
   }
   try {
     const result = await saveWorkflow(name, params.newName);
@@ -395,12 +391,10 @@ async function actionSave(params: ScriptParams): Promise<TextContent> {
       details: { action: "save", name, ok: true },
     };
   } catch (err: unknown) {
+    // throw（W4）：pi 只对 execute throw 置 isError:true（返回值里的 isError 被
+    // agent-loop 丢弃，agent-loop.js:453-483）——文案原样进 toolResult。
     const msg = err instanceof Error ? err.message : String(err);
-    return {
-      content: [{ type: "text", text: `Save failed: ${msg}` }],
-      details: { action: "save", name, ok: false },
-      isError: true,
-    };
+    throw new Error(`Save failed: ${msg}`);
   }
 }
 
@@ -413,7 +407,7 @@ function actionDelete(
 ): TextContent {
   const name = params.name;
   if (!name) {
-    return textResult("delete requires 'name' parameter", true);
+    throw new Error("delete requires 'name' parameter");
   }
  // deleteWorkflow 内部检查 isRunning（防止删运行中脚本）
   try {
@@ -425,12 +419,9 @@ function actionDelete(
       details: { action: "delete", name, ok: true },
     };
   } catch (err: unknown) {
+    // throw（W4）：同 save——pi 契约只有 throw 才置 isError:true。
     const msg = err instanceof Error ? err.message : String(err);
-    return {
-      content: [{ type: "text", text: `Delete failed: ${msg}` }],
-      details: { action: "delete", name, ok: false },
-      isError: true,
-    };
+    throw new Error(`Delete failed: ${msg}`);
   }
 }
 
@@ -451,17 +442,22 @@ async function actionList(registry: WorkflowScriptRegistry): Promise<TextContent
       details: { action: "list", count: available.length },
     };
   } catch (err: unknown) {
+    // throw（W4b）：list 失败改 throw（原 return isError 被 pi 丢弃），文案保持
     const msg = err instanceof Error ? err.message : String(err);
-    return textResult(`List failed: ${msg}`, true);
+    throw new Error(`List failed: ${msg}`);
   }
 }
 
 // ── helper ───────────────────────────────────────────────────
 
-function textResult(text: string, isError = false): TextContent {
+/**
+ * 构造纯文本非错误结果（W4b：isError 参数已删除——pi 只对 execute throw 置
+ * isError:true，返回值里的 isError 被 agent-loop 丢弃（agent-loop.js:453-483），
+ * 错误一律 throw，编译器兜底防回潮）。
+ */
+function textResult(text: string): TextContent {
   return {
     content: [{ type: "text", text }],
     details: undefined,
-    isError: isError || undefined,
   };
 }

package/src/interface/tool-workflow.ts

@@ -34,7 +34,6 @@ import { type Static, Type } from "typebox";
 import { SLUG_MAX_LENGTH } from "../execution/execute-options-mapper.ts";
 import { THINKING_ORDER } from "../execution/model-resolver.ts";
 import type { LauncherDeps } from "../orchestration/launcher.ts";
-import { ArgsValidationError } from "../orchestration/args-validator.ts";
 import { abortRun, runWorkflow } from "../orchestration/lifecycle.ts";
 import type { RunStore } from "../orchestration/models/ports.ts";
 import type { WorkflowRun } from "../orchestration/models/workflow-run.ts";
@@ -250,8 +249,9 @@ function withGui(
 /** 按 WorkflowToolDetails 构造对应的 GuiComponent。 */
 export function buildWorkflowGui(details: WorkflowToolDetails) {
   if (details.action === "run") {
-    // not_found 是脚本未找到的逻辑错误（isError:true），不能走通用 mapper 的 done/check 成功映射。
-    // 短路为 danger severity 的 stats-line，与 isError 文案一致。
+    // not_found 曾是「isError:true + not_found details」的错误形态（W4 前返回值 isError 被
+    // pi 丢弃）；W4 后该错误改为 throw（details 不再产出此形态），本分支保留消费历史
+    // session entry / 防御性渲染，不能走通用 mapper 的 done/check 成功映射。
     if (details.status === "not_found") {
       return guiComponent("stats-line", {
         items: [{ label: "run", value: "not found", severity: "danger" as const }],
@@ -346,11 +346,13 @@ export function registerWorkflowTool(
     ): Promise<ToolResult> {
  // P1-2: Honor abort signal up-front
       if (signal?.aborted) {
-        return textResult("Operation aborted before start", true);
+        // throw（W4b）：pi 只对 execute throw 置 isError:true，返回值里的 isError
+        // 被 agent-loop 丢弃（agent-loop.js:453-483）——文案原样进 toolResult。
+        throw new Error("Operation aborted before start");
       }
- // P1-6: Reentry guard
+ // P1-6: Reentry guard（acquire 失败时尚未持有 guard，throw 前无需 release）
       if (!acquireReentryGuard(reentryRef)) {
-        return textResult(REENTRY_BUSY_MESSAGE, true);
+        throw new Error(REENTRY_BUSY_MESSAGE);
       }
       try {
         let result: ToolResult;
@@ -370,7 +372,7 @@ export function registerWorkflowTool(
           default: {
             // Exhaustiveness check — 新增 WorkflowAction 成员时未补 case，tsc 在此报错。
             const _exhaustive: never = action;
-            return textResult(`Unknown action: ${String(_exhaustive)}`, true);
+            throw new Error(`Unknown action: ${String(_exhaustive)}`);
           }
         }
         // GUI 协议：RPC 模式下附加 __gui__ 到 details
@@ -417,30 +419,27 @@ export async function actionRun(
 ): Promise<ToolResult> {
   const name = params.name;
   if (!name) {
-    return textResult("run requires 'name' parameter (absolute .js path from <available_workflows> <location>). Correct: {\"action\":\"run\",\"name\":\"<ref>\",\"args\":{...}}", true);
+    throw new Error("run requires 'name' parameter (absolute .js path from <available_workflows> <location>). Correct: {\"action\":\"run\",\"name\":\"<ref>\",\"args\":{...}}");
   }
   // 弱模型常见误用（P0 静默失败）：把 task/items 等 args 子字段平铺到 workflow params
   // 顶层（缺 args 嵌套）。args ?? {} 会静默 args={}，启动缺参 run 不报错——比 subagent
   // 平铺事故更严重。m6：先 registry.getPath（动态参数集来源——schema 即 SSOT），
   // not_found 优先返回；平铺检测报错带 Correct 正例纠正。
   const script = await deps.registry.getPath(name);
-  if (!script) {
- // 模糊匹配建议
+  // W4c：config-loader 的 toCachedMeta 对不可读/不存在文件返回 available:false 的
+  // stub（非 undefined），仅判 !script 会绕过 not_found → 空 sourceCode 假启动
+  //（W4b verifier 探针实测复现）。与下方 suggestions 分支的 wf.available 过滤口径对齐。
+  if (!script || !script.available) {
+ // 模糊匹配建议。throw（W4）：pi 只对 execute throw 置 isError:true，
+ // 返回值里的 isError 被 agent-loop 丢弃（agent-loop.js:453-483）——文案原样进 toolResult。
     const all = await deps.registry.loadAll();
     const available = all.filter((wf) => wf.available);
     const suggestions = available
       .map((wf) => `  - ${wf.name}: ${wf.meta.description || "(no description)"}`)
       .join("\n");
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Workflow '${name}' not found. Available:\n${suggestions || "  (none)"}\nUse <location> from <available_workflows> for the absolute .js path.`,
-        },
-      ],
-      details: { action: "run", runId: "", status: "not_found", name },
-      isError: true,
-    };
+    throw new Error(
+      `Workflow '${name}' not found. Available:\n${suggestions || "  (none)"}\nUse <location> from <available_workflows> for the absolute .js path.`,
+    );
   }
 
   // m6：动态参数集（schema 即 SSOT）→ 平铺检测；无 parameters → 单次 warn + 跳过
@@ -455,17 +454,15 @@ export async function actionRun(
   }
   const flattened = findFlattenedArgKeys(params, knownKeys, knownPatterns);
   if (flattened.length > 0) {
-    return textResult(
+    throw new Error(
       `Detected ${flattened.join(", ")} at top level — they belong inside 'args'. ` +
       `Correct: {"action":"run","name":"${name}","args":{${flattened.map((k) => `"${k}": "<value>"`).join(", ")}}}`,
-      true,
     );
   }
   // slug 运行时护栏（与 subagent startHandler 对称的纵深防御；schema maxLength 是第一道关卡）
   if (params.slug !== undefined && params.slug.length > SLUG_MAX_LENGTH) {
-    return textResult(
+    throw new Error(
       `slug exceeds ${SLUG_MAX_LENGTH} chars (got ${params.slug.length}). Shorten to a kebab-case label, e.g. "fix-login", "extract-urls".`,
-      true,
     );
   }
   const args = params.args ?? {};
@@ -473,36 +470,25 @@ export async function actionRun(
   const time = params.time;
 
  // 构建 RunSpec + 启动（m3：parameters 从 script.meta 拷贝——chokepoint 校验用；
- // 校验失败 → isError ToolResult 带 §5.3 指引，非 ArgsValidationError 保持传播）
-  let runId: string;
-  try {
-    runId = await runWorkflow(
-      {
-        scriptSource: script.toExecutable(),
-        args,
-        budgetTokens: tokens,
-        budgetTimeMs: time,
-        scriptName: script.name,
-        slug: params.slug,
-        scriptPath: script.path,
-        description: script.meta.description,
-        parameters: script.meta.parameters,
-        model: params.model,
-        thinkingLevel: params.thinkingLevel,
-      },
-      deps,
-      signal,
-    );
-  } catch (err) {
-    if (err instanceof ArgsValidationError) {
-      return {
-        content: [{ type: "text", text: err.message }],
-        details: { action: "run", runId: "", status: "invalid_args", name: script.name },
-        isError: true,
-      };
-    }
-    throw err;
-  }
+ // 校验失败 → ArgsValidationError 直接 throw 给 pi（W4：err.message 含 §5.3 指引，
+ // pi catch 后原文案进 toolResult content 并置 isError:true），其他错误保持传播）
+  const runId = await runWorkflow(
+    {
+      scriptSource: script.toExecutable(),
+      args,
+      budgetTokens: tokens,
+      budgetTimeMs: time,
+      scriptName: script.name,
+      slug: params.slug,
+      scriptPath: script.path,
+      description: script.meta.description,
+      parameters: script.meta.parameters,
+      model: params.model,
+      thinkingLevel: params.thinkingLevel,
+    },
+    deps,
+    signal,
+  );
 
   return {
     content: [
@@ -551,13 +537,12 @@ async function actionLifecycle(
 ): Promise<ToolResult> {
   const runId = params.runId;
   if (!runId) {
-    return textResult(`'runId' is required for ${action}. Correct: {"action":"${action}","runId":"<id>"} (use action:"status" to find runId)`, true);
+    throw new Error(`'runId' is required for ${action}. Correct: {"action":"${action}","runId":"<id>"} (use action:"status" to find runId)`);
   }
   const run = deps.runs.get(runId);
   if (!run) {
-    return textResult(
+    throw new Error(
       `Workflow '${runId}' not found. Use action:status to list active runs and their runIds.`,
-      true,
     );
   }
   try {
@@ -575,8 +560,9 @@ async function actionLifecycle(
       details: { action, runId, status: newStatus, reason: run.state.reason },
     };
   } catch (err) {
+    // throw（W4b）：abortRun 失败改 throw（原 return isError 被 pi 丢弃），"Error: " 前缀保持
     const msg = err instanceof Error ? err.message : String(err);
-    return textResult(`Error: ${msg}`, true);
+    throw new Error(`Error: ${msg}`);
   }
 }
 
@@ -597,10 +583,6 @@ function toRunSummary(run: WorkflowRun, store: RunStore): RunSummary {
   };
 }
 
-function textResult(text: string, isError = false): ToolResult {
-  return {
-    content: [{ type: "text", text }],
-    details: undefined,
-    isError: isError || undefined,
-  };
-}
+// W4b：原 textResult(text, isError) helper 已删除——23 处错误路径全部改 throw
+// （pi 只对 execute throw 置 isError:true，返回值里的 isError 被 agent-loop 丢弃，
+// agent-loop.js:453-483），且本文件无非错误纯文本结果用途，无残留调用方。

package/src/interface/views/detail-content.ts

@@ -272,7 +272,7 @@ function renderOutcomeSection(
   if (node.status === "running" && node.live) {
     // 运行中：显示实时指标（elapsed/tokens/turns）替代空荡的 "Still running..."
     const live = projectLiveProgress(node.live);
-    const tokK = live.totalTokens > 0 ? `${Math.round(live.totalTokens / 1000)}k tok` : "0 tok";
+    const tokK = live.totalTokens > 0 ? `${Math.round(live.totalTokens / BUDGET_TOKENS_DIVISOR)}k tok` : "0 tok";
     rightLines.push(theme.fg("dim", `  Running · ${formatElapsedSeconds(live.elapsedSeconds)} · ${tokK} · ${live.turns} turn${live.turns !== 1 ? "s" : ""}`));
     if (live.lastError) {
       rightLines.push(theme.fg("warning", `  ⚠ ${live.lastError.slice(0, mainWidth - BOX_BORDER_CHARS)}`));

package/src/orchestration/__tests__/__fixtures__/worker-template.snapshot.txt

@@ -100,7 +100,9 @@ function _safePost(msg, context) {
         // 不丢失。失败 resolve 为空字符串是既定容错策略。
         // parsedOutput: validated data object from structured-output execute().
         // Fallback to content (raw text) when no schema was requested or on error.
-        // W2 改动 9(b)：returnMeta===true 时 resolve {value,sessionFile,worktreePath,error}（对称缓存重放 9c）；否则单值。
+        // W2 改动 9(b)：returnMeta===true 时 resolve {value,sessionFile,worktreePath,error,usage,durationMs,sessionId}
+        // （对称缓存重放 9c）；否则单值。usage/durationMs/sessionId 为 rfl 仪表透传（tier-1 §7.1，
+        // AgentResult 已含、此处原样转发，缺省 undefined 兼容旧主线程）。
         const _value = msg.result.parsedOutput ?? msg.result.content;
         if (pending.returnMeta) {
           pending.resolve({
@@ -108,6 +110,9 @@ function _safePost(msg, context) {
             sessionFile: msg.result.sessionFile,
             worktreePath: msg.result.worktreePath,
             error: msg.result.error,
+            usage: msg.result.usage,
+            durationMs: msg.result.durationMs,
+            sessionId: msg.result.sessionId,
           });
         } else {
           pending.resolve(_value);
@@ -204,6 +209,9 @@ function _safePost(msg, context) {
           sessionFile: cached.sessionFile,
           worktreePath: cached.worktreePath,
           error: cached.error,
+          usage: cached.usage,
+          durationMs: cached.durationMs,
+          sessionId: cached.sessionId,
         };
       }
       return _cachedValue;

package/src/orchestration/__tests__/execute-agent-call.test.ts

@@ -5,7 +5,11 @@
 
 import { describe, expect, it, vi } from "vitest";
 
-import { executeAgentCall } from "../execute-agent-call.ts";
+import {
+  executeAgentCall,
+  isStaleContextErrorMsg,
+  STALE_CONTEXT_PATTERNS,
+} from "../execute-agent-call.ts";
 import { AgentCall } from "../models/agent-call.ts";
 import { Budget } from "../models/budget.ts";
 import type { AgentRunner } from "../models/ports.ts";
@@ -264,3 +268,47 @@ describe("isOrphaned 守卫", () => {
     }
   });
 });
+
+// ── W4b: STALE_CONTEXT_PATTERNS 对齐 pi 真实文案（stale 分诊） ──
+//
+// pi 0.84.x 真实 stale 文案（extensions/runner.ts:531，dist runner.js:567）：
+// "This extension ctx is stale after session replacement or reload. Do not use
+//  a captured pi or command ctx after ctx.newSession(), ..."
+// 旧 patterns（"stale context"/"stalecontext"）与该文案零匹配（词序相反），
+// stale 错误曾退化为普通错误照常重试 3 次——W4b 词序修正 + 对齐 scheduler
+// 已验证 marker 'stale after session replacement'（runtime.ts STALE_CTX_MARKER）。
+
+/** pi 真实 stale 文案前半（含 marker 全文前缀，锚定真实串而非自造缩写）。 */
+const PI_REAL_STALE_MESSAGE =
+  "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload().";
+
+describe("W4b: stale 分诊对齐 pi 真实文案", () => {
+  it("真实文案全文 → isStaleContextErrorMsg true（'ctx is stale' 词序 + scheduler marker 双命中）", () => {
+    expect(isStaleContextErrorMsg(PI_REAL_STALE_MESSAGE)).toBe(true);
+  });
+
+  it("patterns 含 scheduler 已验证 marker 'stale after session replacement'", () => {
+    expect(STALE_CONTEXT_PATTERNS).toContain("stale after session replacement");
+    expect(STALE_CONTEXT_PATTERNS).toContain("ctx is stale");
+  });
+
+  it("真实文案 → executeAgentCall 不重试（runner.run 恰 1 次）+ markDone failed", async () => {
+    const { call, trace } = makeAgentCallAndTrace();
+    const runner = createMockRunner(
+      vi.fn().mockResolvedValue(makeMockResult({ error: PI_REAL_STALE_MESSAGE })),
+    );
+    const budget = new Budget();
+
+    await executeAgentCall(call, runner, budget, new AbortController().signal, trace);
+
+    expect(runner.run).toHaveBeenCalledTimes(1);
+    expect(call.status).toBe("done");
+    expect(call.result?.error).toBe(PI_REAL_STALE_MESSAGE);
+    expect(trace.find(0)?.status).toBe("failed");
+  });
+
+  it("普通 transient 错误 → 不命中 stale（照常进入重试路径，现状回归）", () => {
+    expect(isStaleContextErrorMsg("transient network error")).toBe(false);
+    expect(isStaleContextErrorMsg(undefined)).toBe(false);
+  });
+});

package/src/orchestration/__tests__/jsonl-run-store-loadall-sources.test.ts

@@ -0,0 +1,171 @@
+// src/orchestration/__tests__/jsonl-run-store-loadall-sources.test.ts
+//
+// loadAll entry 源扫描（collectEntrySources + loadRunFromStateFile）定向用例（R2-TC S4）。
+//
+// 防的 bug：loadAll 的多 run 重建 / 损坏 state 文件降级。W17 已覆盖单 run 的 entry 重建、
+// link 兼容与读序优先级；本文件补齐三块未定向覆盖的分支：
+// 1. 多 run 并存（多个 workflow-record entry run + link run 同批重建，无丢失）
+// 2. 损坏 state 文件降级（末行非 JSON / 空文件 / link 指向不存在路径 / link data 缺 runId）
+//    ——单文件失败返回 null 跳过，不崩 loadAll、不阻断同批其余 run 重建
+// 3. 同 runId 多条 record entry 末条胜出在多 run 场景下不串扰
+//
+// 不 mock collectEntrySources：走 loadAll 真实通路（ctx.sessionManager.getEntries 返回
+// seed entries，loadRunFromStateFile 读真实临时文件）。record entry 一律经真实 save 产出
+//（deserializeRun 的快照 schema 以真实 serializeRun 为准，手工拼快照会绕开 schema 契约）。
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+
+import type { CustomEntry } from "@earendil-works/pi-coding-agent";
+
+import { Budget } from "../models/budget.ts";
+import { Trace } from "../models/trace.ts";
+import type { ExecutionTraceNode } from "../models/types.ts";
+import type { RunSpec } from "../models/run-spec.ts";
+import { WorkflowRun } from "../models/workflow-run.ts";
+import { JsonlRunStore } from "../jsonl-run-store.ts";
+import { mkCtx, mkPi } from "./test-mocks.ts";
+
+function makeSpec(): RunSpec {
+  return {
+    scriptSource: "module.exports = async () => {};",
+    args: {},
+    scriptName: "test-script",
+    scriptPath: "/tmp/test.js",
+    description: "test",
+  };
+}
+
+function makeTraceNode(stepIndex: number): ExecutionTraceNode {
+  return { stepIndex, agent: "worker", task: "do thing", model: "default", status: "pending" };
+}
+
+/** running → done 的完整生命周期 save（终态快照可被 deserializeRun 重建）。 */
+async function saveDoneRun(
+  sessionDir: string,
+  entries: CustomEntry[],
+  runId: string,
+): Promise<void> {
+  const store = new JsonlRunStore({ sessionDir, pi: mkPi(entries) });
+  const run = makeRunningRun(runId);
+  await store.save(run);
+  run.transition("done", "completed");
+  await store.save(run);
+}
+
+function makeRunningRun(runId: string): WorkflowRun {
+  const trace = new Trace();
+  trace.append(makeTraceNode(0));
+  return WorkflowRun.reconstruct(runId, makeSpec(), {
+    status: "running",
+    budget: new Budget(),
+    calls: new Map(),
+    trace,
+    errorLogs: [],
+  }, { startedAt: new Date().toISOString() });
+}
+
+/** 手工构造旧 workflow-state-link 指针 entry（loadAll 的 link 兼容输入）。 */
+function linkEntry(runId: string, statePath: string): CustomEntry {
+  return {
+    type: "custom",
+    customType: "workflow-state-link",
+    data: { runId, path: statePath },
+    id: `seed-link-${runId}`,
+    parentId: null,
+    timestamp: new Date().toISOString(),
+  };
+}
+
+describe("loadAll entry 源扫描：多 run 重建与损坏 state 降级（R2-TC S4）", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wf-loadall-src-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("多 run 并存：2 个 entry run + 1 个 link run 同批全部重建（无丢失）", async () => {
+    // run-a/run-b 经真实 save 通路产出终态 entry（快照形态可信）
+    const entries: CustomEntry[] = [];
+    await saveDoneRun(tmpDir, entries, "run-a");
+    await saveDoneRun(tmpDir, entries, "run-b");
+
+    // run-c：旧 link 形态（state 文件完好，无 record entry）
+    const storeC = new JsonlRunStore({ sessionDir: tmpDir });
+    const runC = makeRunningRun("run-c");
+    await storeC.save(runC);
+    runC.transition("done", "completed");
+    await storeC.save(runC);
+    const linkPath = path.join(tmpDir, "workflow-state", "run-c.jsonl");
+    expect(fs.existsSync(linkPath)).toBe(true);
+    const seedEntries: CustomEntry[] = [...entries, linkEntry("run-c", linkPath)];
+
+    const store = new JsonlRunStore({ sessionDir: tmpDir, ctx: mkCtx(seedEntries) });
+    const loaded = await store.loadAll();
+    expect(loaded.map((r) => r.runId).sort()).toEqual(["run-a", "run-b", "run-c"]);
+  });
+
+  it("损坏 state 文件（末行非 JSON）→ 该 run 跳过不崩，同批其余 run（entry run）正常返回", async () => {
+    const entries: CustomEntry[] = [];
+    await saveDoneRun(tmpDir, entries, "run-good");
+
+    const corruptPath = path.join(tmpDir, "workflow-state", "run-corrupt.jsonl");
+    fs.mkdirSync(path.dirname(corruptPath), { recursive: true });
+    fs.writeFileSync(corruptPath, "{truncated-not-json\n", "utf8");
+
+    const seedEntries: CustomEntry[] = [...entries, linkEntry("run-corrupt", corruptPath)];
+    const store = new JsonlRunStore({ sessionDir: tmpDir, ctx: mkCtx(seedEntries) });
+    const loaded = await store.loadAll();
+    expect(loaded.map((r) => r.runId)).toEqual(["run-good"]);
+  });
+
+  it("损坏形态族：空文件 / link 指向不存在路径 / link data 缺 runId → 均降级跳过，loadAll 不抛", async () => {
+    const emptyPath = path.join(tmpDir, "workflow-state", "run-empty.jsonl");
+    fs.mkdirSync(path.dirname(emptyPath), { recursive: true });
+    fs.writeFileSync(emptyPath, "", "utf8");
+    const missingPath = path.join(tmpDir, "workflow-state", "run-missing.jsonl");
+
+    const malformedLink = linkEntry("run-bad", emptyPath);
+    (malformedLink.data as Record<string, unknown>).runId = undefined; // 缺 runId 的坏指针
+
+    // 对照组：一条合法 record entry run 应正常重建（真实 save 产出）
+    const entries: CustomEntry[] = [];
+    await saveDoneRun(tmpDir, entries, "run-seeded");
+
+    const seedEntries: CustomEntry[] = [
+      ...entries,
+      linkEntry("run-empty", emptyPath),
+      linkEntry("run-missing", missingPath),
+      malformedLink,
+    ];
+    const store = new JsonlRunStore({ sessionDir: tmpDir, ctx: mkCtx(seedEntries) });
+    const loaded = await store.loadAll();
+    expect(loaded.map((r) => r.runId)).toEqual(["run-seeded"]);
+  });
+
+  it("同 runId 多条 record entry 末条胜出（running→done 收敛）+ 另一 run 不受影响（混合批不串扰）", async () => {
+    const entries: CustomEntry[] = [];
+    // run-x：两条 entry（running 中间态 + done 终态），末条胜出
+    const storeX = new JsonlRunStore({ sessionDir: tmpDir, pi: mkPi(entries) });
+    const runX = makeRunningRun("run-x");
+    await storeX.save(runX);
+    runX.transition("done", "completed");
+    await storeX.save(runX);
+    // run-y：done 终态
+    await saveDoneRun(tmpDir, entries, "run-y");
+
+    const store = new JsonlRunStore({ sessionDir: tmpDir, ctx: mkCtx(entries) });
+    const loaded = await store.loadAll();
+    const byId = new Map(loaded.map((r) => [r.runId, r]));
+    expect(loaded).toHaveLength(2);
+    expect(byId.get("run-x")?.state.status).toBe("done");
+    expect(byId.get("run-y")?.state.status).toBe("done");
+  });
+});