@zhushanwen/pi-subagent-workflow 8.14.7 → 9.0.0

package/src/interface/tool-workflow.ts

@@ -1,50 +1,55 @@
 /**
- * Workflow Extension — workflow tool（3 actions，FR-5 tool 收口）。
+ * Workflow Extension — workflow tool（4 actions，FR-5 tool 收口）。
  *
  * 合并原 tool-workflow.ts + tool-workflow-run.ts 为单 tool。
  *
  * Actions:
- * - run: registry.get → runWorkflow（直接启动，无需用户确认）
+ * - run: registry.getPath → runWorkflow（直接启动，无需用户确认）
  * - status: 列出 runs（deps.runs）
  * - abort: 调 abortRun
+ * - resume: 调 resumeRun（interrupted 态 run 断点续跑，D14 args 校验在入口）
  *
- * **restart 不包含**（D-9 废弃）；**pause/resume 不包含**（一次性生命周期——run
- * 不可挂起，提前停止用 abort，要新结果开新 run）。
+ * **restart 不包含**（D-9 废弃）；**pause 不包含**（一次性生命周期——run 不可
+ * 挂起，提前停止用 abort，要新结果开新 run）。**resume 是中断恢复不是挂起恢复**：
+ * 仅 interrupted 态 run 可续（崩溃收编 / terminate 被动失联后的断点续跑，
+ * workflow-run-resume-revision U3/D14），不是把活跃 run 暂停再继续。
  *
  * 层归属：Interface。依赖 Pi SDK + Engine lifecycle/launcher + helpers。
  */
 
+import { readFileSync } from "node:fs";
+import os from "node:os";
+
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { getLogger } from "@zhushanwen/pi-extension-logger";
 
 const logger = getLogger("tool-workflow");
 import { Text } from "@earendil-works/pi-tui";
-import {
-  guiComponent,
-  type GuiContext,
-  type GuiRenderResult,
-  guiResult,
-  isGuiCapable,
-} from "@zhushanwen/extension-protocol";
 import { type Static, Type } from "typebox";
 
 import { SLUG_MAX_LENGTH } from "@zhushanwen/subagent-core";
 import { THINKING_ORDER } from "@zhushanwen/subagent-core";
 import type { LauncherDeps } from "@zhushanwen/subagent-core";
-import { abortRun, runWorkflow } from "@zhushanwen/subagent-core";
+import { abortRun, resumeRun, runWorkflow } from "@zhushanwen/subagent-core";
+import type { ResumeRunOptions } from "@zhushanwen/subagent-core";
 import type { RunStore } from "@zhushanwen/subagent-core";
 import type { WorkflowRun } from "@zhushanwen/subagent-core";
+// [D8 创建期拒单] 模型目录分类裁决 + 宿主注入的模型清单投影访问器（既有投影面：
+// session_start 把 ctx.modelRegistry 注入 ModelConfigService 单例——extension 零
+// runtime import，H2/P5 宿主注入同款先例）。
+import { assertModelInCatalog } from "@zhushanwen/subagent-core";
+import { getModelConfigService } from "@zhushanwen/subagent-core";
 // D9 closure：core args-meta 消费（reservedKeys 注入见下方 ARGS_META_OPTIONS）
 // MAX_TIMER_DELAY_MS：OR-1 消费（barrel 导出，深路径经 u-2c 删通配后 tsc 不可解析）
 import {
   argKeysFromMeta,
   findFlattenedArgKeys,
   MAX_TIMER_DELAY_MS,
+  workflowNotFoundMessage,
 } from "@zhushanwen/subagent-core";
-import { assertEntryTimeBudget, assertSlugWithinLimit } from "@zhushanwen/subagent-core";
+import { assertEntryTimeBudget, assertEntryTokenBudget, assertSlugWithinLimit } from "@zhushanwen/subagent-core";
 import { runSummary } from "@zhushanwen/subagent-core";
-import { mapRunIcon, mapRunStatus, toGuiCtx } from "./gui-mappers.ts";
 import { ID_PREVIEW_LENGTH } from "./id-preview.ts";
 import type { RunStartDetails, WorkflowToolResult } from "./tool-result.ts";
 import {
@@ -57,11 +62,10 @@ import { formatRunStatusElapsed } from "./format.ts";
 import {
   assertNotAborted,
   buildRunSpecFromScript,
-  formatAvailableWorkflowList,
   optionSlugSuffix,
   renderTextResult,
+  throwPrefixed,
 } from "./tool-shared.ts";
-import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 
 // ── Parameter schema ─────────────────────────────────────────
 
@@ -69,18 +73,20 @@ import { toErrorMessage } from "@zhushanwen/pi-ext-guards";
 export type WorkflowAction =
   | "run"
   | "status"
-  | "abort";
+  | "abort"
+  | "resume";
 
 const WORKFLOW_ACTIONS: readonly WorkflowAction[] = [
   "run",
   "status",
   "abort",
+  "resume",
 ];
 
 const WorkflowParams = Type.Object({
   action: StringEnum(WORKFLOW_ACTIONS, { description: "Workflow action to execute" }),
   name: Type.Optional(
-    Type.String({ description: "Workflow ref: builtin/saved workflow name from <available_workflows> (C5: run accepts names), or absolute path to the .js script (use <location>; run action)" }),
+    Type.String({ description: "Workflow ref: absolute path to the .js script — use the <location> value from <available_workflows> (bare names are rejected; run action)" }),
   ),
   slug: Type.Optional(
     Type.String({
@@ -91,15 +97,18 @@ const WorkflowParams = Type.Object({
     }),
   ),
   runId: Type.Optional(
-    Type.String({ description: "Workflow run ID (abort action)" }),
+    Type.String({ description: "Workflow run ID (abort / resume action; find it via action:status)" }),
   ),
   args: Type.Optional(
     Type.Record(Type.String(), Type.Unknown(), {
-      description: "Arguments passed to workflow as key-value pairs (run action)",
+      description:
+        "Arguments passed to workflow as key-value pairs (run action). For resume: optional — when passed, " +
+        "must deep-equal the run's original args (except the internal _runId key); mismatch is rejected with " +
+        "the differing fields listed. Omit to reuse the original args.",
     }),
   ),
   tokens: Type.Optional(Type.Number({ description: "Max token budget — ONLY set when user explicitly requests a limit; omit = unlimited (default)" })),
-  time: Type.Optional(Type.Number({ description: `Max time budget in ms — ONLY set when user explicitly requests a limit; omit = unlimited (default; hard ceiling ${MAX_TIMER_DELAY_MS} ms — larger values fail fast at entry)` })),
+  time: Type.Optional(Type.Number({ description: `Max time budget in ms — ONLY set when user explicitly requests a limit; omit = unlimited (default; hard ceiling ${MAX_TIMER_DELAY_MS} ms — larger values fail fast at entry). For resume: the budget applied to the resumed execution (active time already spent by the run is counted against it; suspended time is not)` })),
   error: Type.Optional(
     Type.String({ description: "Error/reason message (optional, used with abort)" }),
   ),
@@ -160,7 +169,7 @@ interface RunSummary {
   startedAt?: string;
   completedAt?: string;
   error?: string;
-  /** Run 状态快照文件绝对路径（<sessionDir>/workflow-state/<runId>.jsonl）。 */
+  /** run 唯一持久件（record 事件流 <sessionDir>/workflow-state/<runId>.record.jsonl）的绝对路径。 */
   stateFile?: string;
 }
 
@@ -170,78 +179,23 @@ interface RunSummary {
  * Discriminated union of `workflow` tool `details` payloads.
  *
  * Discriminant: `action`. Each action's details shape is explicitly typed so
- * downstream consumers (GUI list-tree renderer, structured-output) can narrow
- * without unsafe casts.
+ * downstream consumers (structured-output) can narrow without unsafe casts.
  */
 export type WorkflowToolDetails =
-  | ({ action: "run"; name: string; __gui__?: GuiRenderResult } & RunStartDetails)
-  | { action: "status"; runs: RunSummary[]; __gui__?: GuiRenderResult }
-  | { action: "abort"; runId: string; status: string; reason?: string; __gui__?: GuiRenderResult };
+  | ({ action: "run"; name: string } & RunStartDetails)
+  | { action: "status"; runs: RunSummary[] }
+  | { action: "abort"; runId: string; status: string; reason?: string }
+  | ({ action: "resume"; runId: string } & RunStartDetails);
 
 /** Result returned by the `workflow` tool's execute（公共骨架见 tool-result.ts）。 */
 type WorkflowExecuteResult = WorkflowToolResult<WorkflowToolDetails | undefined>;
 
-// ── GUI 协议 helpers ───────────────────────────────────────
-
-/** 为 details 附加 __gui__（RPC 模式下）。union 各成员已声明 __gui__?，无需强转。 */
-function withGui(
-  details: WorkflowToolDetails | undefined,
-  ctx?: GuiContext,
-): WorkflowToolDetails | undefined {
-  if (!details) return undefined;
-  if (ctx && isGuiCapable(ctx)) {
-    return { ...details, __gui__: guiResult(buildWorkflowGui(details)) };
-  }
-  return details;
-}
-
-/** 按 WorkflowToolDetails 构造对应的 GuiComponent。 */
-export function buildWorkflowGui(details: WorkflowToolDetails) {
-  if (details.action === "run") {
-    // 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 }],
-      });
-    }
-    const statusStr = details.status;
-    return guiComponent("list-tree", {
-      items: [{
-        label: [details.name, details.slug, details.runId.slice(0, ID_PREVIEW_LENGTH)].filter(Boolean).join(" "),
-        status: mapRunStatus(statusStr),
-        icon: mapRunIcon(statusStr),
-      }],
-    });
-  }
-  if (details.action === "status") {
-    return guiComponent("list-tree", {
-      items: details.runs.map((r) => {
-        const statusStr = r.reason ? `${r.status} (${r.reason})` : r.status;
-        return {
-          label: [r.name, r.slug, r.runId.slice(0, ID_PREVIEW_LENGTH)].filter(Boolean).join(" "),
-          status: mapRunStatus(statusStr),
-          icon: mapRunIcon(statusStr),
-        };
-      }),
-    });
-  }
-  // abort（唯一 lifecycle action）：破坏性终止非成功完成，用 warn 与成功区分
-  return guiComponent("stats-line", {
-    items: [{
-      label: details.action,
-      value: details.runId.slice(0, ID_PREVIEW_LENGTH),
-      severity: "warn" as const,
-    }],
-  });
-}
-
 // ── Tool registration ────────────────────────────────────────
 
 /**
- * 注册 workflow tool（3 actions: run / status / abort；pause/resume 已随一次性
- * 生命周期移除——enum 拒绝由 pi 核心校验拦截，见 F3）。
+ * 注册 workflow tool（4 actions: run / status / abort / resume；pause 已随一次性
+ * 生命周期移除——enum 拒绝由 pi 核心校验拦截，见 F3。resume = interrupted 态断点
+ * 续跑，不是挂起恢复）。
  *
  * @param pi ExtensionAPI
  * @param deps LauncherDeps（LifecycleDeps + registry）
@@ -261,28 +215,34 @@ export function registerWorkflowTool(
     name: "workflow",
     label: "Workflow",
     description:
-      "Execute and control workflows: run (start), status, abort.\n" +
+      "Execute and control workflows: run (start), status, abort, resume (continue an interrupted run).\n" +
       "Replaces workflow + workflow-run tools.",
-    promptSnippet: "Run, abort, or check workflow status",
+    promptSnippet: "Run, abort, resume, or check workflow status",
     promptGuidelines: [
       "PRIORITY: When user says 'workflow', 'run workflow', try run action FIRST.",
       "All listed workflows run DIRECTLY with action:run — refs/descriptions come from " +
       "<available_workflows> (injected each turn). For parameter details, read the <location> " +
       "script file (script header has @pi-meta parameters + usage + phases). Do NOT use " +
       "workflow-script generate for patterns already covered by available workflows.",
-      "run: pass the workflow ref as name — the listed <name> (builtin/saved workflow) or its <location> absolute .js path from <available_workflows> — then start in background (no user confirmation needed).",
+      "run: pass the workflow ref as name — ALWAYS the <location> absolute .js path from <available_workflows> (bare names are rejected with a not-found error listing locations).",
       "DO NOT bash sleep or poll status after starting — results appear automatically via notifyDone.",
-      "Runs are one-shot: there is no pause/resume — to stop a run early use abort; for a fresh result start a new run.",
+      "Runs are one-shot: there is no pause — to stop a run early use abort; for a fresh result start a new run. " +
+      "resume is ONLY for runs whose status is interrupted (crash or session-switch during execution): it replays " +
+      "completed calls from the record at zero token cost and continues where the run stopped. " +
+      "Do NOT resume a settled (done/failed/cancelled) run — start a new run instead.",
+      "resume: pass the SAME args as the original run (they are verified field-by-field; a mismatch is rejected " +
+      "with the differing fields listed). Omit args to reuse the original ones. Changed args = different intent = new run.",
       "Call shapes (JSON): " +
       "- run: {\"action\":\"run\",\"name\":\"<script>\",\"args\":{...},\"tokens\":N,\"time\":N,\"model\":\"<provider/modelId>\",\"thinkingLevel\":\"<level>\"}. " +
       "- status: {\"action\":\"status\"}. " +
-      "- abort: {\"action\":\"abort\",\"runId\":\"<id>\"} (optional: {\"error\":\"<reason>\"}).",
+      "- abort: {\"action\":\"abort\",\"runId\":\"<id>\"} (optional: {\"error\":\"<reason>\"}). " +
+      "- resume: {\"action\":\"resume\",\"runId\":\"<id>\",\"args\":{...},\"time\":N} — args/time optional.",
       "Budget: Do NOT set tokens/time unless the user explicitly requests a limit. Built-in workflows run unlimited by default.",
       "Model/thinkingLevel: omit by default (inherit main agent's model). Only set model/thinkingLevel when the user explicitly requests a specific model or thinking depth for this run.",
       "Anti-patterns: Flattening args sub-fields (task/items/...) to the top level — they belong inside args. Calling {\"action\":\"run\"} without name.",
-      "CRITICAL: For orchestration patterns, ALWAYS use action:run with an existing built-in " +
-      "name — NEVER use workflow-script action:generate to recreate patterns already covered " +
-      "by available workflows. workflow-script generate is ONLY for novel patterns.",
+      "CRITICAL: For orchestration patterns, ALWAYS use action:run with the <location> absolute " +
+      "path of a listed workflow — NEVER use workflow-script action:generate to recreate patterns " +
+      "already covered by available workflows. workflow-script generate is ONLY for novel patterns.",
     ],
     parameters: WorkflowParams,
 
@@ -315,7 +275,10 @@ export function registerWorkflowTool(
             result = actionStatus(deps);
             break;
           case "abort":
-            result = await actionLifecycle("abort", params, deps);
+            result = await actionAbort(params, deps);
+            break;
+          case "resume":
+            result = await actionResume(params, deps);
             break;
           default: {
             // Exhaustiveness check — 新增 WorkflowAction 成员时未补 case，tsc 在此报错。
@@ -323,11 +286,9 @@ export function registerWorkflowTool(
             throw new Error(`Unknown action: ${String(_exhaustive)}`);
           }
         }
-        // GUI 协议：RPC 模式下附加 __gui__ 到 details
-        return {
-          ...result,
-          details: withGui(result.details, toGuiCtx(_ctx)),
-        };
+        // workflow 块分支（WORKFLOW_TOOL_NAMES 集合分流）恒折叠单行不消费 __gui__
+        // （D8 裁决），details 不构造 GUI 描述符。
+        return result;
       } finally {
         releaseReentryGuard(reentryRef);
       }
@@ -350,9 +311,7 @@ export function registerWorkflowTool(
       );
     },
 
-    renderResult(result: { content?: Array<{ type: string; text?: string }> }, _options: unknown, _theme: Theme, _context?: unknown) {
-      return renderTextResult(result);
-    },
+    renderResult: renderTextResult,
   });
 }
 
@@ -365,40 +324,34 @@ export async function actionRun(
 ): Promise<WorkflowExecuteResult> {
   const name = params.name;
   if (!name) {
-    throw new Error("run requires 'name' parameter (absolute .js path from <available_workflows> <location>). Correct: {\"action\":\"run\",\"name\":\"<ref>\",\"args\":{...}}");
+    throw new Error(
+      "run requires 'name' parameter (absolute .js path from <available_workflows> <location>). Correct: {\"action\":\"run\",\"name\":\"<ref>\"}",
+    );
   }
   // 弱模型常见误用（P0 静默失败）：把 task/items 等 args 子字段平铺到 workflow params
   // 顶层（缺 args 嵌套）。args ?? {} 会静默 args={}，启动缺参 run 不报错——比 subagent
   // 平铺事故更严重。m6：先 registry.getPath（动态参数集来源——schema 即 SSOT），
   // not_found 优先返回；平铺检测报错带 Correct 正例纠正。
   //
-  // C5③（convergence D-4 pi 半边）：name 解析先查内置/已保存 workflow 名
-  // （registry.get——内置 chain/parallel/map-reduce/scatter-gather/review-fix-loop 或
-  // 用户 project/user 级脚本名，按 tmp>project>user>npm 优先级合并）——内置名命中
-  // 直接用内置脚本；未命中再走 getPath（绝对路径，~/ 展开——normalizeRef 既有）。
-  // 严格超集：现有路径用法零变化（路径串不会撞 workflow 名——名字是简单标识符），
-  // 两者都未命中仍走原 not_found 报错（建议清单不变）。
-  let script = await deps.registry.get(name);
-  if (!script) {
-    script = await deps.registry.getPath(name);
-  }
+  // [D4-1 按名解析退役] name 解析 = 路径单通道（getPath：绝对路径 + ~/ 展开，
+  // normalizeRef 既有——相对路径/裸名一律 null → not_found 拒单，既有文案列全部
+  // 可用条目并附 location，失败一次即可按绝对路径自救）。原 registry.get（内置名 +
+  // 用户保存名）按名解析整体退役：派发终态形态 = 全路径（用户裁决 2026-09-21），
+  // P5 修复发现面后注册表会命中内置名让裸名「复活」——反向违反终态裁决，故机制
+  // 删除而非禁用。行为变更四要素：量级 = 裸名派发调用；旧行为 = registry.get 命中
+  // 即启动；新行为 = not_found 拒单（零 token 沉没）；恢复 = 按清单 location 重试。
+  const script = await deps.registry.getPath(name);
   // W4c：config-loader 的 toCachedMeta 对不可读/不存在文件返回 available:false 的
   // stub（非 undefined），仅判 !script 会绕过 not_found → 空 sourceCode 假启动
-  //（W4b verifier 探针实测复现）。与下方 suggestions 分支的 wf.available 过滤口径对齐。
+  //（W4b verifier 探针实测复现）。
   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 suggestions = formatAvailableWorkflowList(all);
-    // [按名解析自救指引] 摘要逐条附绝对路径 location：run 的 name 形参最贴近的
+    // throw（W4）：pi 只对 execute throw 置 isError:true，返回值里的 isError 被
+    // agent-loop 丢弃（agent-loop.js:453-483）——文案原样进 toolResult。
+    // [全路径自救指引] 清单逐条附绝对路径 location：run 的 name 形参最贴近的
     // 读取面就是本清单（<available_workflows> 注入面在 start 时已过时/可能不在
-    // 上下文）——模型按清单里的名字重试（8.6.0 实装 getPath-only 时代的实测失败
-    // 形态，2026-09-14 嵌套 subagent 现场）还是注定 throw；带上 location 后失败
-    // 一次即可按绝对路径自救。main 的 C5③ 按名解析（registry.get 内置/已保存名
-    // 优先）是主修复，本行是清单侧恢复指引闭环。
-    throw new Error(
-      `Workflow '${name}' not found. Available (name — use the absolute location path as 'name' when the bare name is rejected):\n${suggestions || "  (none)"}`,
-    );
+    // 上下文）——带 location 后失败一次即可按绝对路径自救。按名解析已退役
+    // （D4-1），location 是唯一活路；文案单源 = core launcher.workflowNotFoundMessage。
+    throw new Error(await workflowNotFoundMessage(name, deps));
   }
 
   // m6：动态参数集（schema 即 SSOT）→ 平铺检测；无 parameters → 单次 warn + 跳过
@@ -432,7 +385,31 @@ export async function actionRun(
   // Type.Number 直通（无上界）——超 setTimeout 安全域的值会穿透到 lifecycle 内层
   // 防线（assertSafeTimerDelay），而入口拦截让它永不进入副作用链（判定与文案单点在
   // core shared/entry-guards；LLM 可据消息自纠：clamp 或省略走 unlimited 语义）。
+  // 负值同在入口拒绝：tokens 负值会被 Budget 的 maxTokens>0 守卫、time 负值会被
+  // lifecycle 的 budgetTimeMs>0 判定静默升格 unlimited（显式预算被忽略），入口拦截
+  // 替代静默升格。
   assertEntryTimeBudget(time);
+  assertEntryTokenBudget(tokens);
+
+  // [D8 创建期拒单] 工具参数 model 是创建期唯一静态声明源（agent 资产 frontmatter
+  // model 随脚本 JS 动态求值不可静态解析——由派发期 isPiRoute 对称校验覆盖，
+  // 见 workflow-dispatch.resolveWorkflowIdentity）。查无 = run 创建失败（同步 throw，
+  // 零 spawn 零 token），错误列可用清单 + 分类修复指引（查无 vs provider 配置漂移）。
+  // 目录经宿主注入投影访问：session_start 已把 ctx.modelRegistry 注入
+  // ModelConfigService 单例；单例缺席（生产不可达——tool execute 前必有 session_start）
+  // 降级跳过 + warn 留痕，派发期 identity 解析仍是权威裁决。
+  if (params.model !== undefined) {
+    const modelService = getModelConfigService();
+    if (modelService === null) {
+      logger.warn(
+        "[tool-workflow] model catalog unavailable (model service not initialized) — creation-time model check skipped; dispatch-time identity resolution remains authoritative",
+      );
+    } else {
+      assertModelInCatalog(params.model, modelService.getModelRegistry(), {
+        source: "run-level model override",
+      });
+    }
+  }
 
  // 构建 RunSpec + 启动（m3：parameters 从 script.meta 拷贝——chokepoint 校验用；
  // 校验失败 → ArgsValidationError 直接 throw 给 pi（W4：err.message 含 §5.3 指引，
@@ -488,18 +465,37 @@ function actionStatus(deps: LauncherDeps): WorkflowExecuteResult {
   };
 }
 
-// ── abort lifecycle action ────────────────────────────────────
+// ── abort action ─────────────────────────────────────────────
 
-// 一次性生命周期：abort 是唯一的提前停止方式（pause/resume 已随 D-2 移除），
-// action 参数保留字面量类型与 WorkflowAction 单成员分发对齐。
-async function actionLifecycle(
-  action: "abort",
+/**
+ * [W2/V1 D1 分流表第 6 行] 单一判源函数（CLI 面显示/排序的混合判源收拢）：输出
+ * 投影三态 status（running|interrupted|done——重水合中断 run 经 meta.interruptedAt
+ * 投影中断态，[D2] 与 shared WorkflowRunStatus 三态同词；活体终局经进程内终局
+ * 记录注册表判定、恢复路径写点 run 经聚合 status 读）。判源 = core runSummary
+ * 投影，散落的等价分支形态不采用（D1 否决记录：散落分支在 grep 层不可区分，
+ * 活体判据误用漏网）。
+ *
+ * 排序键契约：STATUS_ORDER 权重表只消费本函数的三态输出；outcome 细分由
+ * runSummary.reason 并列承载（列表行 reasonSuffix）。
+ *
+ * 落点说明（实施期登记）：函数体消费 core barrel 既有导出 runSummary，落本文件
+ * 使 commands/WorkflowsView 可单向 import（commands → view 既有边使 commands.ts
+ * 落点成环，本文件与两者均无既有边）。
+ */
+export function displayStatusOf(run: WorkflowRun): "running" | "interrupted" | "done" {
+  return runSummary(run).status;
+}
+
+// 一次性生命周期：abort 是唯一的提前停止方式（pause/resume 已随 D-2 移除）。
+async function actionAbort(
   params: WorkflowToolParams,
   deps: LauncherDeps,
 ): Promise<WorkflowExecuteResult> {
   const runId = params.runId;
   if (!runId) {
-    throw new Error(`'runId' is required for ${action}. Correct: {"action":"${action}","runId":"<id>"} (use action:"status" to find runId)`);
+    throw new Error(
+      "abort requires 'runId' parameter. Correct: {\"action\":\"abort\",\"runId\":\"<id>\"} (use action:\"status\" to find runId)",
+    );
   }
   const run = deps.runs.get(runId);
   if (!run) {
@@ -508,10 +504,14 @@ async function actionLifecycle(
     );
   }
   try {
-    const oldStatus = run.state.status;
+    // [W2/V1 D1 分流表第 7 行] abort 读回换源：oldStatus/newStatus/reason 全部
+    // 取 runSummary 投影（活体终局经终局记录派生 DoneReason——原两态机字段读随
+    // 活体写点删除停更，abort 后 state.reason 恒 undefined）。
+    const oldStatus = displayStatusOf(run);
     await abortRun(runId, deps, params.error);
-    const newStatus = run.state.status;
-    const reasonSuffix = run.state.reason ? ` (${run.state.reason})` : "";
+    const summary = runSummary(run);
+    const newStatus = summary.status;
+    const reasonSuffix = summary.reason ? ` (${summary.reason})` : "";
     return {
       content: [
         {
@@ -519,13 +519,219 @@ async function actionLifecycle(
           text: `Workflow '${run.spec.scriptName}' (${runId}): ${oldStatus} → ${newStatus}${reasonSuffix}`,
         },
       ],
-      details: { action, runId, status: newStatus, reason: run.state.reason },
+      details: { action: "abort", runId, status: newStatus, reason: summary.reason },
     };
   } catch (err) {
-    // throw（W4b）：abortRun 失败改 throw（原 return isError 被 pi 丢弃），"Error: " 前缀保持
-    const msg = toErrorMessage(err);
-    throw new Error(`Error: ${msg}`);
+    // "Error: " 前缀是 abortRun 失败的既有 LLM 可见形态，保持不变
+    throwPrefixed("Error", err);
+  }
+}
+
+// ── resume action（D14 args 校验 + resumeRun 接线）──────────
+
+/**
+ * D14 比对排除键：rfl 仪表向 spec.args 原地注入的稳定 `_runId`（lifecycle
+ * runWorkflow 注入面）——run 派发的机器字段，不属用户意图，比对前双侧剔除。
+ */
+const RESUME_ARGS_EXCLUDED_KEY = "_runId";
+
+/** record 流内 run-created 帧的 args 读取结果（D14 比对的数据源形态）。 */
+type HistoricalArgs =
+  | { kind: "args"; args: Record<string, unknown> }
+  | { kind: "absent" }
+  | { kind: "truncated" };
+
+/**
+ * record 行 → run-created 帧窄化（type 字面量判别 + args 全文 / argsSummary 透传；
+ * 非该帧 / 非 object 返回 undefined——结构判别走运行时守卫，不做断言）。
+ */
+function asRunCreatedFrame(parsed: unknown): { args?: unknown; argsSummary: unknown } | undefined {
+  if (typeof parsed !== "object" || parsed === null) return undefined;
+  if (!("type" in parsed) || parsed.type !== "run-created") return undefined;
+  return {
+    args: "args" in parsed ? parsed.args : undefined,
+    argsSummary: "argsSummary" in parsed ? parsed.argsSummary : undefined,
+  };
+}
+
+/**
+ * 读 run-created 帧的历史 args（D14 比对数据源；record 流是唯一事实源）。
+ *
+ * - args 全文优先（设计 §3.1 载荷表 run-created 行「args」——现行写入面
+ *   dispatchRunCreated 随帧落全文，任意体积的 args 都可逐字段深度比对）；
+ * - 流不存在 / 无 run-created 帧 → absent：不在 D14 层拒绝——资格判据（无 record
+ *   流 / 首帧缺失）归 resumeRun 权威文案，此处不重复实现（分层：D14 只管 args 一致性）；
+ * - 旧格式帧回落 argsSummary（无 args 字段）：截断（>256 字符，写侧
+ *   summarizeRunArgs 截断标记）→ truncated——截断摘要无法逐字段比对，保守拒绝
+ *   （静默放行 = 静默忽略传入 args，D14 不采用形态）；
+ * - 解析失败 → throw：args/argsSummary 是 JSON.stringify 产物，未截断必可解析——
+ *   不可解析 = 流被篡改或写入器 bug（对齐 D12 拒绝精神）。
+ */
+function readHistoricalArgs(recordPath: string, runId: string): HistoricalArgs {
+  let content: string;
+  try {
+    content = readFileSync(recordPath, "utf8");
+  } catch {
+    return { kind: "absent" };
   }
+  for (const line of content.split("\n")) {
+    if (line.trim().length === 0) continue;
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const frame = asRunCreatedFrame(parsed);
+    if (frame === undefined) continue;
+    // args 全文优先：大 args run 的 D14 逐字段比对由此成立（truncated 拒绝只对
+    // 旧格式帧的截断摘要形态出现）
+    if (isPlainObject(frame.args)) return { kind: "args", args: frame.args };
+    const summary = frame.argsSummary;
+    if (typeof summary !== "string" || summary.length === 0) return { kind: "absent" };
+    if (summary.endsWith("…")) return { kind: "truncated" };
+    let args: unknown;
+    try {
+      args = JSON.parse(summary);
+    } catch {
+      // 未截断摘要必可解析（JSON.stringify 产物）——不可解析 = 字段被篡改/流损坏，
+      // 与上方 malformed 分支同构拒绝（裸 SyntaxError 无恢复指引，不透出）。
+      throw new Error(
+        `Resume rejected: original args of run ${runId} are malformed in its record stream — ` +
+          "the record stream is the sole source of truth. Recovery: inspect the record file for external edits; " +
+          "if unrepairable, start a new run.",
+      );
+    }
+    if (!isPlainObject(args)) {
+      throw new Error(
+        `Resume rejected: original args of run ${runId} are malformed in its record stream — ` +
+          "the record stream is the sole source of truth. Recovery: inspect the record file for external edits; " +
+          "if unrepairable, start a new run.",
+      );
+    }
+    return { kind: "args", args };
+  }
+  return { kind: "absent" };
+}
+
+/** plain object 判定（数组/null 排除——数组按值比、不递归键差）。 */
+function isPlainObject(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+/**
+ * 逐字段深度比对（D14）——返回差异字段描述列表（空 = 一致）。
+ *
+ * 差异三形态：仅 resume 侧有（unexpected）/ 仅原 run 侧有（missing）/ 值不等
+ * （mismatch）。嵌套 plain object 递归比对（路径 `a.b` 形态）；数组与原始值按
+ * JSON 值比。值展示用 JSON.stringify（函数/undefined 等不可序列化形态按原样）。
+ */
+export function diffResumeArgs(
+  incoming: Record<string, unknown>,
+  historical: Record<string, unknown>,
+): string[] {
+  return diffPlainObject(incoming, historical).map((d) => `args.${d}`);
+}
+
+/** diffResumeArgs 的递归体（裸键路径，`a.b` 形态——前缀由公开包装统一添加）。 */
+function diffPlainObject(
+  incoming: Record<string, unknown>,
+  historical: Record<string, unknown>,
+): string[] {
+  const diffs: string[] = [];
+  const keys = new Set([...Object.keys(incoming), ...Object.keys(historical)]);
+  keys.delete(RESUME_ARGS_EXCLUDED_KEY);
+  for (const key of [...keys].sort()) {
+    const hasIn = Object.hasOwn(incoming, key);
+    const hasHist = Object.hasOwn(historical, key);
+    if (!hasIn || !hasHist) {
+      const holder = hasIn ? "resume args only (not in original run)" : "original run only (missing from resume args)";
+      diffs.push(`${key}: ${holder}`);
+      continue;
+    }
+    const a = incoming[key];
+    const b = historical[key];
+    if (isPlainObject(a) && isPlainObject(b)) {
+      diffs.push(...diffPlainObject(a, b).map((d) => `${key}.${d}`));
+      continue;
+    }
+    const sa = JSON.stringify(a);
+    const sb = JSON.stringify(b);
+    if (sa !== sb) diffs.push(`${key}: resume ${sa ?? String(a)} vs original ${sb ?? String(b)}`);
+  }
+  return diffs;
+}
+
+/**
+ * resume action：interrupted 态 run 断点续跑。
+ *
+ * 入口语义（D14）：
+ * - runId 必需；
+ * - args 可选——传入时与 run-created 帧的历史 args 逐字段深度比对（排除 `_runId`），
+ *   不一致明确拒绝并列出差异字段（换 args 重放 = 换意图，属新 run）；不传默认沿用历史；
+ * - time 可选——resume 执行段的时间预算（活跃段算式在 core：已耗活跃时间计入、
+ *   搁置不计）；入口护栏（负值/超安全域）与 run action 同源（assertEntryTimeBudget）。
+ *
+ * 资格拒绝（非 interrupted / record 损坏 / 锁被占 / D13 嵌套 / 预算耗尽）由 core
+ * resumeRun 权威裁决——ResumeRejectionError 文案含恢复指引，原样透出（throw，
+ * pi 置 isError:true）。
+ */
+export async function actionResume(
+  params: WorkflowToolParams,
+  deps: LauncherDeps,
+): Promise<WorkflowExecuteResult> {
+  const runId = params.runId;
+  if (!runId) {
+    throw new Error(
+      "resume requires 'runId' parameter. Correct: {\"action\":\"resume\",\"runId\":\"<id>\"} (use action:\"status\" to find runId; args optional — must equal the original run's args)",
+    );
+  }
+  assertEntryTimeBudget(params.time);
+
+  // D14 args 校验（fail-fast——先于任何副作用；不一致即拒绝，不触碰 run 状态）
+  if (params.args !== undefined) {
+    const historical = readHistoricalArgs(deps.store.stateFilePath(runId), runId);
+    if (historical.kind === "truncated") {
+      // 仅旧格式帧（args 全文载荷落地前落盘、截断摘要形态）到达此分支——现行
+      // 写入面随帧落 args 全文，任意体积可逐字段比对
+      throw new Error(
+        `Resume rejected: original args of run ${runId} exceed the record's args summary limit ` +
+          "(legacy record stream without the full-args payload) — they cannot be verified field-by-field. " +
+          "Recovery: start a new run for these arguments, or resume WITHOUT args knowing $ARGS will be empty " +
+          "(a truncated summary cannot be reconstructed).",
+      );
+    }
+    if (historical.kind === "args") {
+      const diffs = diffResumeArgs(params.args, historical.args);
+      if (diffs.length > 0) {
+        throw new Error(
+          `Resume rejected: args for run ${runId} differ from the original run — resume replays the same intent; ` +
+            `changed arguments belong to a new run. Differing fields:\n  - ${diffs.join("\n  - ")}\n` +
+            "Recovery: pass the original args exactly, omit args to reuse them, or start a new run.",
+        );
+      }
+    }
+    // absent：D14 层不拒绝——无 record 流 / 无 run-created 帧的资格判据归 resumeRun 权威文案
+  }
+
+  const options: ResumeRunOptions = {
+    ...(params.time !== undefined ? { budgetTimeMs: params.time } : {}),
+    host: os.hostname(),
+  };
+  await resumeRun(runId, deps, options);
+
+  return {
+    content: [
+      {
+        type: "text",
+        text:
+          `Resuming workflow run ${runId} — completed calls are replayed from the record at zero token cost, ` +
+          "unfinished calls are re-dispatched. Running in background — DO NOT bash sleep or poll status; " +
+          "results are auto-delivered via notifyDone.",
+      },
+    ],
+    details: { action: "resume", runId, status: "running", stateFile: deps.store.stateFilePath(runId) },
+  };
 }
 
 // ── helpers ──────────────────────────────────────────────────