@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

package/src/interface/bg-notify-render.ts

@@ -22,6 +22,7 @@
 import type { Component } from "@earendil-works/pi-tui";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 
+import { displayAgentName } from "../shared/agent-ref.ts";
 import {
   firstLine,
   padToVisible,
@@ -52,11 +53,16 @@ const MIN_BORDER_WIDTH = BORDER_CHARS + INNER_PAD_TOTAL + 1;
  */
 interface BgNotifyRecord {
   id: string;
-  status: "done" | "failed" | "cancelled";
+  /** v4 B-1: closed（终态，含 cancelled）或 running（对话模式轮次完成，旧 idle）。 */
+  status: "running" | "closed";
+  /** L2 关闭原因子枚举（仅 status="closed" 时有意义）。 */
+  closedReason?: string;
   agent: string;
   model?: string;
   result?: string;
   error?: string;
+  /** 对话轮次计数（仅 idle 有意义）。 */
+  round?: number;
   /** [MF#1] worktree background 完成通知携带的 patch 文件路径。 */
   patchFile?: string;
 }
@@ -207,17 +213,34 @@ function sanitizeAnsiForBg(text: string): string {
 function renderRecordLines(record: BgNotifyRecord, t: ThemeLike): string[] {
   const glyph = statusGlyph(record.status);
   const icon = glyph.icon ?? "•";
-  const agent = truncLine(record.agent, AGENT_MAX_WIDTH);
+  const agent = truncLine(displayAgentName(record.agent), AGENT_MAX_WIDTH);
   // model 段：agent 后、状态描述前，accent 色。空则省略（向后兼容旧 record）。
   const modelPart = record.model
     ? ` ${t.fg("dim", "·")} ${t.fg("accent", truncLine(record.model, MODEL_MAX_WIDTH))}`
     : "";
-  const verb = record.status === "done" ? "finished" : record.status === "failed" ? "failed" : "cancelled";
+  // v4 B-1: closed 统一终态（含 cancelled）。按 closedReason 派生文案。
+  const reason = record.closedReason ?? "gc";
+  let verb: string;
+  if (reason === "cancelled") {
+    verb = "cancelled";
+  } else if (reason === "gc" && record.error) {
+    verb = "failed";
+  } else {
+    verb = "finished";
+  }
   const idShort = shortId(record.id);
   const head = `${t.fg(glyph.color, icon)} ${t.bold(agent)}${modelPart}${t.fg("dim", ` — background subagent ${verb} - ${idShort}`)}`;
 
   switch (record.status) {
-    case "done": {
+    case "closed": {
+      // v4 B-1: closed 统一终态（含 cancelled）。cancelled 无正文；失败显示错误；否则结果/patch。
+      const r = record.closedReason ?? "gc";
+      if (r === "cancelled") {
+        return [head];
+      }
+      if (r === "gc" && record.error) {
+        return [head, t.fg("dim", truncLine(`Error: ${firstLineSanitized(record.error)}`, BODY_MAX_WIDTH))];
+      }
       if (!record.result && !record.patchFile) return [head];
       const lines: string[] = [];
       if (record.result) {
@@ -229,10 +252,9 @@ function renderRecordLines(record: BgNotifyRecord, t: ThemeLike): string[] {
       }
       return [head, ...lines];
     }
-    case "failed":
-      return [head, t.fg("dim", truncLine(`Error: ${record.error ? firstLineSanitized(record.error) : "(unknown)"}`, BODY_MAX_WIDTH))];
-    case "cancelled":
+    case "running":
     default:
+      // v4 B-1: 对话模式轮次完成（旧 idle 折入 running）——仅标题行。
       return [head];
   }
 }
@@ -263,7 +285,7 @@ function extractBgNotifyRecord(details: unknown): BgNotifyRecord | undefined {
   const status = d.status;
   const agent = d.agent;
   if (
-    (status !== "done" && status !== "failed" && status !== "cancelled") ||
+    (status !== "closed" && status !== "running") ||
     typeof agent !== "string"
   ) {
     return undefined;
@@ -275,6 +297,8 @@ function extractBgNotifyRecord(details: unknown): BgNotifyRecord | undefined {
     model: typeof d.model === "string" ? d.model : undefined,
     result: typeof d.result === "string" ? d.result : undefined,
     error: typeof d.error === "string" ? d.error : undefined,
+    closedReason: typeof d.closedReason === "string" ? d.closedReason : undefined,
+    round: typeof d.round === "number" ? d.round : undefined,
     // [MF#1] 提取 patchFile（worktree background 完成通知携带）。
     patchFile: typeof d.patchFile === "string" ? d.patchFile : undefined,
   };

package/src/interface/command-actions.ts

@@ -16,23 +16,36 @@ export type SubagentRpcAction =
 
 /** /workflows RPC action 判别联合。 */
 export type WorkflowRpcAction =
-  | { action: "pause"; runId: string }
-  | { action: "resume"; runId: string }
   | { action: "abort"; runId: string }
-  | { action: "lifecycle-missing-id"; verb: "pause" | "resume" | "abort" }
+  | { action: "lifecycle-missing-id"; verb: LifecycleVerb }
+  | { action: "lifecycle-removed"; verb: "pause" | "resume" }
   | { action: "noop" };
 
 /** workflow lifecycle verb 类型。 */
-type LifecycleVerb = "pause" | "resume" | "abort";
+type LifecycleVerb = "abort";
 
 /** workflow lifecycle verb 集合。 */
-const LIFECYCLE_VERBS: ReadonlySet<LifecycleVerb> = new Set(["pause", "resume", "abort"]);
+const LIFECYCLE_VERBS: ReadonlySet<LifecycleVerb> = new Set(["abort"]);
 
 /** verb 是否为 lifecycle action（类型守卫，收窄到 LifecycleVerb）。 */
 function isLifecycleVerb(verb: string): verb is LifecycleVerb {
   return LIFECYCLE_VERBS.has(verb as LifecycleVerb);
 }
 
+/**
+ * 已移除的 lifecycle verb 集合（pause/resume——run 一次性生命周期化后删除，
+ * 解析为 lifecycle-removed 提示，而非 unknown noop）。
+ */
+const REMOVED_LIFECYCLE_VERBS: ReadonlySet<"pause" | "resume"> = new Set([
+  "pause",
+  "resume",
+]);
+
+/** verb 是否为已移除的 lifecycle action（类型守卫，收窄到 "pause" | "resume"）。 */
+function isRemovedLifecycleVerb(verb: string): verb is "pause" | "resume" {
+  return REMOVED_LIFECYCLE_VERBS.has(verb as "pause" | "resume");
+}
+
 /**
  * 解析 /subagents RPC 命令字符串。
  *
@@ -60,8 +73,11 @@ export function parseSubagentRpcCommand(argsStr: string): SubagentRpcAction {
  * 解析 /workflows RPC 命令字符串。
  *
  * 支持格式：
- * - `pause|resume|abort <runId>` → 对应 lifecycle action + runId
- * - `pause|resume|abort`（无 runId）→ { action: "lifecycle-missing-id", verb }
+ * - `abort <runId>` → { action: "abort", runId }
+ * - `abort`（无 runId）→ { action: "lifecycle-missing-id", verb: "abort" }
+ * - `pause|resume ...`（已移除的 lifecycle verb，带或不带 runId 均同）→
+ *   { action: "lifecycle-removed", verb }——removed verb 优先于 missing-id 判定
+ *  （提示语义优先：用户应得知能力已删除并获 abort 指引，而非被引导补 runId）
  * - 其他（空 / 未知 action / 无参）→ { action: "noop" }
  */
 export function parseWorkflowRpcCommand(argsStr: string): WorkflowRpcAction {
@@ -69,6 +85,9 @@ export function parseWorkflowRpcCommand(argsStr: string): WorkflowRpcAction {
   if (args.length === 0) return { action: "noop" };
 
   const [verb, runId] = args;
+  if (isRemovedLifecycleVerb(verb)) {
+    return { action: "lifecycle-removed", verb };
+  }
   if (isLifecycleVerb(verb)) {
     if (!runId) return { action: "lifecycle-missing-id", verb };
     return { action: verb, runId };

package/src/interface/commands.ts

@@ -11,7 +11,7 @@
  * - /workflow save <name> → 用 workflow-script tool { action: "save" }
  * - /workflow delete <name> → 用 workflow-script tool { action: "delete" }
  *
- * 层归属：Interface。依赖 Pi SDK + Engine lifecycle（pause/resume/abort，注入 ViewActions）
+ * 层归属：Interface。依赖 Pi SDK + Engine lifecycle（abort，注入 ViewActions）
  * + WorkflowsView（读 WorkflowRun 聚合根）。
  *
  * 参考：
@@ -22,7 +22,7 @@
 import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
 
 import type { LauncherDeps } from "../orchestration/launcher.ts";
-import { abortRun, pauseRun, resumeRun } from "../orchestration/lifecycle.ts";
+import { abortRun } from "../orchestration/lifecycle.ts";
 import type { WorkflowRun } from "../orchestration/models/workflow-run.ts";
 import { parseWorkflowRpcCommand } from "./command-actions.ts";
 import { createWorkflowsView, type ViewActions } from "./views/WorkflowsView.ts";
@@ -30,10 +30,9 @@ import { createWorkflowsView, type ViewActions } from "./views/WorkflowsView.ts"
 /** runId 截断长度（显示用）。 */
 const RUNID_SHORT = 8;
 
-/** status 显示顺序：running/paused 优先（活跃态在前），再 startedAt 倒序。 */
+/** status 显示顺序：running 优先（活跃态在前），再 startedAt 倒序。 */
 const STATUS_ORDER: Record<string, number> = {
   running: 0,
-  paused: 1,
   done: 2,
 };
 /** 未知 status 的默认排序权重（排在已知 status 之后）。 */
@@ -52,12 +51,12 @@ const UNKNOWN_STATUS_WEIGHT = 9;
  * · 1 run → 直接打开
  * · 多 runs → select 选 → 打开选中 run 的 view
  *
- * ViewActions（pause/resume/abort）由本 command 注入——view 本身不持 lifecycle 依赖，
+ * ViewActions（abort）由本 command 注入——view 本身不持 lifecycle 依赖，
  * 只通过 actions 回调与 engine 交互（解耦，便于 view 单测）。
  *
  * @param api ExtensionAPI
  * @param getRuns 获取当前 session 的 runs（Map<runId, WorkflowRun>）
- * @param deps LauncherDeps（lifecycle pause/resume/abort 用）
+ * @param deps LauncherDeps（lifecycle abort 用）
  */
 export function registerWorkflowsCommand(
   api: ExtensionAPI,
@@ -65,7 +64,7 @@ export function registerWorkflowsCommand(
   deps: LauncherDeps,
 ): void {
   api.registerCommand("workflows", {
-    description: "Open workflow panel. /workflows [runId] | /workflows pause|resume|abort <runId>",
+    description: "Open workflow panel. /workflows [runId] | /workflows abort <runId>",
     getArgumentCompletions(prefix: string) {
       const trimmed = prefix.trimStart();
       const parts = trimmed.split(/\s+/).filter(Boolean);
@@ -73,14 +72,12 @@ export function registerWorkflowsCommand(
       // 第一级：lifecycle 动词（带尾随空格，选中后继续补 runId）
       if (parts.length <= 1) {
         return [
-          { label: "pause", value: "pause ", description: "Pause a workflow run" },
-          { label: "resume", value: "resume ", description: "Resume a paused workflow run" },
           { label: "abort", value: "abort ", description: "Abort a workflow run" },
         ].filter((opt) => opt.label.startsWith(trimmed.toLowerCase()));
       }
 
       // 第二级：lifecycle 动词后补全当前 session 的 runId
-      if (parts[0] === "pause" || parts[0] === "resume" || parts[0] === "abort") {
+      if (parts[0] === "abort") {
         try {
           const runs = sortedRuns(getRuns());
           if (runs.length === 0) return null;
@@ -102,21 +99,25 @@ export function registerWorkflowsCommand(
       if (ctx.mode === "rpc") {
         const parsed = parseWorkflowRpcCommand(args);
         switch (parsed.action) {
-          case "pause":
-          case "resume":
           case "abort": {
             try {
-              if (parsed.action === "pause") await pauseRun(parsed.runId, deps);
-              else if (parsed.action === "resume") await resumeRun(parsed.runId, deps);
-              else await abortRun(parsed.runId, deps);
-              const pastTense = parsed.action === "abort" ? "aborted" : `${parsed.action}d`;
-              ctx.ui.notify(`Workflow ${parsed.runId}: ${pastTense}`, "info");
+              await abortRun(parsed.runId, deps);
+              // abort 单态后 pastTense 固定（原三态拼接随 pause/resume 删除）
+              ctx.ui.notify(`Workflow ${parsed.runId}: aborted`, "info");
             } catch (err) {
               const msg = err instanceof Error ? err.message : String(err);
-              ctx.ui.notify(`Failed to ${parsed.action} workflow ${parsed.runId}: ${msg}`, "warning");
+              ctx.ui.notify(`Failed to abort workflow ${parsed.runId}: ${msg}`, "warning");
             }
             return;
           }
+          case "lifecycle-removed":
+            // 已移除的 lifecycle verb（pause/resume）：run 一次性生命周期后不可挂起，
+            // 给定制指引而非 Usage（F3 定稿——提示语义优先于 missing-id）
+            ctx.ui.notify(
+              `Workflow ${parsed.verb} has been removed — runs are one-shot. To stop a run early: /workflows abort <runId>`,
+              "warning",
+            );
+            return;
           case "lifecycle-missing-id":
             ctx.ui.notify(`Usage: /workflows ${parsed.verb} <runId>`, "warning");
             return;
@@ -187,7 +188,7 @@ export function registerWorkflowsCommand(
 // ── Helpers ──────────────────────────────────────────────────
 
 /**
- * 取 runs 按 status（running/paused 优先）+ startedAt 倒序排序。
+ * 取 runs 按 status（running 优先）+ startedAt 倒序排序。
  * 复用 main 的 UX 顺序（活跃态在前，新的在前）。
  */
 function sortedRuns(runs: Map<string, WorkflowRun>): WorkflowRun[] {
@@ -205,7 +206,7 @@ function sortedRuns(runs: Map<string, WorkflowRun>): WorkflowRun[] {
 /**
  * 打开 WorkflowsView（三级导航 TUI），注入 lifecycle ViewActions。
  *
- * ViewActions 通过 deps 调 lifecycle（pause/resume/abort），与 view 解耦——
+ * ViewActions 通过 deps 调 lifecycle（abort），与 view 解耦——
  * view 单测可注入 mock actions（见 workflows-view.test.ts）。
  */
 async function openView(
@@ -215,8 +216,6 @@ async function openView(
   deps: LauncherDeps,
 ): Promise<void> {
   const actions: ViewActions = {
-    pause: (runId: string) => pauseRun(runId, deps),
-    resume: (runId: string) => resumeRun(runId, deps),
     abort: (runId: string) => abortRun(runId, deps),
   };
   await createWorkflowsView(run, theme, ctx, actions, deps.store.stateFilePath(run.runId));

package/src/interface/format.ts

@@ -174,17 +174,9 @@ export function statusGlyph(status: ExecutionStatus): { icon: string | undefined
   switch (status) {
     case "running":
       return { icon: undefined, color: "accent" };
-    case "done":
+    case "closed":
+      // v4 B-1: closed 统一终态（含 cancelled）。默认 ✓ success 色。
       return { icon: "✓", color: "success" };
-    case "failed":
-      return { icon: "✗", color: "error" };
-    case "cancelled":
-      return { icon: "■", color: "muted" };
-    case "crashed":
-      return { icon: "✝", color: "error" };
-    default:
-      // 防御:运行时 status 可能是意外值(SDK 投影异常/未来新增状态),兜底为 running 语义
-      return { icon: undefined, color: "accent" };
   }
 }
 
@@ -235,7 +227,7 @@ export function firstLine(text?: string): string {
 /**
  * 从 renderCall/execute 的 unknown args 安全提取 agent 名.
  * 类型守卫窄化(替代 `as { agent?: string }` 全可选断言).
- * 无 agent 字段或非空字符串时兌底 DEFAULT_AGENT_NAME(与 service 层 resolveIdentity 一致,
+ * 无 agent 字段或非空字符串时兜底 DEFAULT_AGENT_NAME(与 service 层 resolveIdentity 一致,
  * 保证 block 标题显示的名与实际加载的 agent.md 相符).
  */
 export function extractAgentName(args: unknown): string {
@@ -390,6 +382,20 @@ export function formatDisplayItem(item: DisplayItem, theme: ThemeLike): string {
 // ANSI 安全截断
 // ============================================================
 
+/**
+ * SGR 序列 sticky regex（truncLine 专用）。
+ *
+ * lastIndex 置位后 exec/test 只在该位置匹配（等价 `flat.slice(pos).match(/^\x1b\[[0-9;]*m/)`，
+ * 但零子串分配）。同步代码内「设 lastIndex → 立即用」，无跨调用残留。
+ */
+const SGR_STICKY_RE = /\x1b\[[0-9;]*m/y;
+
+/** 判断 s 在 pos 处是否开始一个 SGR 序列（非 SGR ESC——OSC/非 SGR CSI/裸 ESC——返回 false）。 */
+function isSgrStart(s: string, pos: number): boolean {
+  SGR_STICKY_RE.lastIndex = pos;
+  return SGR_STICKY_RE.test(s);
+}
+
 /**
  * 截断文本到 maxWidth 可见宽度(带省略号 `…`,ANSI 安全).
  *
@@ -400,6 +406,16 @@ export function formatDisplayItem(item: DisplayItem, theme: ThemeLike): string {
  * 截断时 `result + activeStyles.join("") + "…"`——重应用 active 样式,背景不断裂.
  * 用 Intl.Segmenter grapheme 切分,正确处理 emoji/CJK/组合字符.
  *
+ * 性能（IF12/#18）：旧实现逐字符 `flat.slice(end).match(...)` 是 O(n²)（每字符
+ * 一次子串分配 + 正则扫描）；现改为 `indexOf("\x1b", ...)` 跳到下一 ESC，仅在 ESC
+ * 位置做一次 sticky 判定——纯文本段零分配零正则。
+ *
+ * **非 SGR ESC 行为（等价关键，逐字节等价的定义点）**：OSC（\x1b]0;..\x07）、
+ * 非 SGR CSI（\x1b[K）、裸 \x1b 后跟非 [ 字符——均不构成文本段边界，作为纯文本
+ * 并入 textPortion 被 segmenter 消费（占 currentWidth、进 result），与旧实现
+ * 「while 停点集合 = SGR 序列起点」完全一致。输出由 __fixtures__/truncline.snapshot.json
+ * （改造前实现生成）逐字节锚定。
+ *
  * 移植自 pi-subagents render.ts:44-89.
  */
 export function truncLine(text: string, maxWidth: number): string {
@@ -417,8 +433,9 @@ export function truncLine(text: string, maxWidth: number): string {
   let i = 0;
 
   while (i < flat.length) {
-    // 捕获 ANSI SGR 序列
-    const ansiMatch = flat.slice(i).match(/^\x1b\[[0-9;]*m/);
+    // 捕获 ANSI SGR 序列（sticky：只在 i 处匹配，等价旧 slice(i).match(/^.../m)）
+    SGR_STICKY_RE.lastIndex = i;
+    const ansiMatch = SGR_STICKY_RE.exec(flat);
     if (ansiMatch) {
       const code = ansiMatch[0];
       result += code;
@@ -432,10 +449,20 @@ export function truncLine(text: string, maxWidth: number): string {
       continue;
     }
 
-    // 找到下一段纯文本(非 ANSI)的边界
-    let end = i;
-    while (end < flat.length && !flat.slice(end).match(/^\x1b\[[0-9;]*m/)) {
-      end++;
+    // 找到下一段纯文本(非 ANSI)的边界：下一处 SGR 序列起点（或串尾）。
+    // indexOf 跳到 ESC 候选位，仅对 ESC 位置做一次 sticky 判定；非 SGR ESC
+    // （OSC/\x1b[K/裸 \x1b）不构成边界、并入文本段（end 推进到该 ESC 之后继续找），
+    // 与旧逐字符 while 的停点集合逐字节一致。
+    let end = flat.length;
+    for (
+      let escPos = flat.indexOf("\x1b", i);
+      escPos !== -1;
+      escPos = flat.indexOf("\x1b", escPos + 1)
+    ) {
+      if (isSgrStart(flat, escPos)) {
+        end = escPos;
+        break;
+      }
     }
 
     // 按 grapheme 迭代这段文本,累加到 targetWidth

package/src/interface/gui-mappers.ts

@@ -31,17 +31,17 @@ type TreeStatus = NonNullable<TreeItem["status"]>;
 /**
  * 把 workflow/subagent 状态字符串映射到 list-tree 的三态 status。
  *
- * 输入可能是纯 RunStatus（running/paused/done）、RunStatus+reason 组合
+ * 输入可能是纯 RunStatus（running/done）、RunStatus+reason 组合
  * （如 "done (failed)"），或 subagent status（running/done/failed/cancelled/crashed）。
  *
  * 映射规则：
- *   - running（含 paused，paused 可恢复，语义近 running）→ running
+ *   - running → running
  *   - failed / aborted / error / crashed / cancelled / budget_limited / time_limited → failed
  *   - 其他（done / completed / success / pending）→ done
  */
 export function mapRunStatus(status: string): TreeStatus {
   const s = status.toLowerCase();
-  if (s.includes("running") || s.includes("paused")) return "running";
+  if (s.includes("running")) return "running";
   if (
     s.includes("failed") ||
     s.includes("abort") ||
@@ -59,14 +59,12 @@ export function mapRunStatus(status: string): TreeStatus {
 /**
  * 把状态字符串映射到 TreeItem.icon。
  *
- *   running       → circle（进行中）
- *   paused        → pause（暂停可恢复）
- *   failed/abort/cancel/crash → cross
- *   其他（done）  → check
+ *   running                       → circle（进行中）
+ *   failed/abort/cancel/crash     → cross
+ *   其他（done）                  → check
  */
 export function mapRunIcon(status: string): TreeItemIcon {
   const s = status.toLowerCase();
-  if (s.includes("paused")) return "pause";
   if (s.includes("running")) return "circle";
   if (
     s.includes("failed") ||

package/src/interface/helpers.ts

@@ -25,6 +25,139 @@ import { mapRunIcon, mapRunStatus } from "./gui-mappers.ts";
 const JSON_INDENT = 2;
 const MAX_RESULT_LENGTH = 8000;
 
+// ── bounded pretty 序列化（IF13/#19，TC5/ES5，helpers 私有）─────────
+
+/**
+ * bounded JSON pretty 序列化：只生成会被保留的前缀（≤8000 输出与
+ * JSON.stringify(value, null, JSON_INDENT) 逐字节一致；>8000 输出与
+ * 全量序列化后 .slice(0, budget) + "\n... (truncated)" 逐字节一致——
+ * 等价测试锚定，见 __tests__/helpers-bounded-serialize.test.ts）。
+ *
+ * 现状成本：全量 stringify 产生数 MB 中间串再丢弃 99%；本函数在输出字符流
+ * 越过 budget 后停止一切生成。保真策略：原语（string/number/boolean/null/bigint）
+ * 逐值复用 JSON.stringify（转义/Unicode/数字格式原生一致，零重实现），仅结构
+ * 拼装（2 空格缩进/逗号/括号）自实现。
+ *
+ * 特殊值语义（TC5 a-d，与原生 JSON.stringify 全值域对齐）：
+ * (a) 含 toJSON 的对象 → 该子树整体走一次 JSON.stringify(subtree)（原生会先调
+ *     toJSON，如 Date 输出带引号序列化串；bounded 拼装展开会与原生不同）。注意
+ *     边界：toJSON 返回对象时原生 pretty 会按缩进展开，本实现按原语串接其
+ *     compact 形态——设计 TC5 锚定面为 Date 型（返回字符串）toJSON。
+ * (b) 任何 stringify 抛出（BigInt → TypeError）→ 整体回退 String(value)（对齐
+ *     旧实现整体 try/catch 的整串回退；禁止逐节点回退——输出形态与整串回退不同）。
+ * (c) 对象属性值为 undefined/function/symbol → 拼装时跳过（原生省略）。
+ * (d) 数组元素为 undefined/function/symbol → 序列化为 "null"（原生行为）。
+ *
+ * 截断边界（输出字符流层级，与对完整串 slice 逐字节等价）：逐段 append 时本段
+ * 会使总长越过 budget → 只 append 本段前 (budget - 已累积) 字符（恰好 budget，
+ * 可切在转义序列/括号中间，不补任何结构闭合）；越过（exceeded）才追加
+ * "\n... (truncated)" 标记——恰好 ===budget 不加（> 判定）。
+ *
+ * 祖先 Set 循环引用守卫：命中 → 整体回退 String(value)（同 (b) 整串回退语义）。
+ */
+function boundedPrettySerialize(value: unknown, budget: number): string {
+  const ancestors = new Set<object>();
+  let out = "";
+  let exceeded = false;
+
+  /** 逐段追加：越过 budget 时截到恰好 budget 并置 exceeded（后续生成全部剪枝）。 */
+  function append(s: string): void {
+    if (exceeded) return;
+    if (out.length + s.length <= budget) {
+      out += s;
+      return;
+    }
+    out += s.slice(0, budget - out.length);
+    exceeded = true;
+  }
+
+  function serialize(v: unknown, depth: number): void {
+    if (exceeded) return;
+    const t = typeof v;
+    // 原语逐值复用原生序列化；bigint 的 JSON.stringify 抛 TypeError → 顶层 catch
+    // 整体回退 (b)；NaN/Infinity → "null"（原生行为）
+    if (v === null || t === "string" || t === "number" || t === "boolean" || t === "bigint") {
+      append(JSON.stringify(v));
+      return;
+    }
+    if (t === "object" && v !== null) {
+      const obj = v as object;
+      if (ancestors.has(obj)) {
+        // 循环引用 → 整体回退 String(value)（旧实现同款整串回退）
+        throw new TypeError("circular reference");
+      }
+      // (a) toJSON 子树整体 stringify（Reflect.get 取属性，避免不安全断言）
+      if (typeof Reflect.get(obj, "toJSON") === "function") {
+        append(JSON.stringify(obj));
+        return;
+      }
+      ancestors.add(obj);
+      const childIndent = " ".repeat(JSON_INDENT * (depth + 1));
+      const closeIndent = " ".repeat(JSON_INDENT * depth);
+      if (Array.isArray(obj)) {
+        const arr = obj as unknown[];
+        if (arr.length === 0) {
+          append("[]");
+        } else {
+          append("[\n");
+          for (let i = 0; i < arr.length && !exceeded; i++) {
+            if (i > 0) append(",\n");
+            append(childIndent);
+            const el = arr[i];
+            // (d) 数组元素 undefined/function/symbol → "null"
+            if (el === undefined || typeof el === "function" || typeof el === "symbol") {
+              append("null");
+            } else {
+              serialize(el, depth + 1);
+            }
+          }
+          append("\n" + closeIndent + "]");
+        }
+      } else {
+        // (c) 对象属性 undefined/function/symbol 跳过（Object.entries 同原生：
+        // 只取 own enumerable，symbol 键天然不出现；getter 求值语义与原生一致）
+        const entries = Object.entries(obj).filter(
+          ([, val]) => val !== undefined && typeof val !== "function" && typeof val !== "symbol",
+        );
+        if (entries.length === 0) {
+          append("{}");
+        } else {
+          append("{\n");
+          for (let i = 0; i < entries.length && !exceeded; i++) {
+            if (i > 0) append(",\n");
+            append(childIndent + JSON.stringify(entries[i][0]) + ": ");
+            serialize(entries[i][1], depth + 1);
+          }
+          append("\n" + closeIndent + "}");
+        }
+      }
+      ancestors.delete(obj);
+      return;
+    }
+    // 顶层 undefined/function/symbol（调用方守卫后不可达；防御兜底对齐原生 "null"）
+    append(JSON.stringify(v) ?? "null");
+  }
+
+  try {
+    serialize(value, 0);
+    return exceeded ? out + "\n... (truncated)" : out;
+  } catch {
+    // (b) 整体回退：String(value)（超 budget 仍截断 + 标记，与旧实现截断路径一致）
+    const fallback = String(value);
+    return fallback.length > budget
+      ? fallback.slice(0, budget) + "\n... (truncated)"
+      : fallback;
+  }
+}
+
+/**
+ * notifiedRunIds 去重窗口大小。
+ *
+ * 最近该数量的已通知 runId 可去重，更旧挤出后不再去重——runId 全局唯一
+ * （wf-<Date.now>-<rand>），旧 id 重现概率为零，语义无损。
+ */
+export const MAX_NOTIFIED_RUN_IDS = 1000;
+
 /** runId 前 8 字符用于显示（与 buildWorkflowGui 的 label 格式一致）。 */
 const RUN_ID_DISPLAY_LENGTH = 8;
 
@@ -88,16 +221,10 @@ export function notifyDone(
 
   if (run.state.scriptResult !== undefined && run.state.scriptResult !== null) {
     // M10: scriptResult 来自 worker 脚本返回值（用户可控），可能含循环引用导致 JSON.stringify 抛 TypeError
-    let serialized: string;
-    try {
-      serialized = JSON.stringify(run.state.scriptResult, null, JSON_INDENT);
-    } catch {
-      serialized = String(run.state.scriptResult);
-    }
-    const truncated =
-      serialized.length > MAX_RESULT_LENGTH
-        ? serialized.slice(0, MAX_RESULT_LENGTH) + "\n... (truncated)"
-        : serialized;
+    // IF13(#19)：bounded 序列化（只生成会被保留的前缀；BigInt/循环引用整体回退
+    // String(x) 与旧实现整串 catch 同款）——≤8000 与旧全量 pretty 逐字节一致，
+    // >8000 与 .slice(0,8000)+标记 逐字节一致（等价测试锚定）
+    const truncated = boundedPrettySerialize(run.state.scriptResult, MAX_RESULT_LENGTH);
     parts.push("");
     parts.push("--- Script Result ---");
     parts.push(truncated);
@@ -151,3 +278,36 @@ export function notifyDone(
     { triggerTurn: true, deliverAs: "steer" },
   );
 }
+
+/**
+ * 把 runId 纳入 notifiedRunIds 去重窗口，超 cap 时删最旧（契约 W3C2）。
+ *
+ * 职责拆分：**去重判定**留在 notifyDone 的 has 读（本体零改动），
+ * 本函数只持**有界化**职责——返回 void，不引入双重去重判定语义。
+ *
+ * 语义：
+ * - 幂等 add：Set.add 对已存在元素不改变其迭代位置（重复 track 同一 id，
+ *   其「最旧」地位不变）。
+ * - FIFO 有界：Set 迭代序=插入序，超 cap 时删迭代器首元素=最旧。
+ *   被挤出窗口的旧 id 再经 notifyDone 会重新发送（runId 全局唯一，旧 id
+ *   重现概率为零，该边界由 W3TC12 单测钉死）。
+ *
+ * 调用点：index.ts onRunDone 回调内、notifyDone 之后（notifyDone 内部已 add，
+ * 此处 track 的 add 是幂等二次添加）。
+ *
+ * @param notifiedRunIds 去重 Set（调用方持有，scope 到 factory 实例）
+ * @param runId run 标识
+ * @param cap 窗口大小（默认 MAX_NOTIFIED_RUN_IDS）
+ */
+export function trackNotifiedRunId(
+  notifiedRunIds: Set<string>,
+  runId: string,
+  cap: number = MAX_NOTIFIED_RUN_IDS,
+): void {
+  notifiedRunIds.add(runId);
+  while (notifiedRunIds.size > cap) {
+    const oldest = notifiedRunIds.values().next().value;
+    if (oldest === undefined) break;
+    notifiedRunIds.delete(oldest);
+  }
+}