@zhushanwen/subagent-core 0.2.0

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

@@ -0,0 +1,349 @@
+"use strict";
+// Module-scope helpers: accessible to BOTH the IIFE body AND the outer
+// .then()/.catch() handlers (which run outside the IIFE). _workerLogs/
+// _pushWorkerLog/_safePost + the parentPort/workerData handles must all live
+// here — a previous version declared _safePost inside the IIFE, so the
+// .then()/.catch() return/error handlers threw ReferenceError: _safePost is
+// not defined, crashing the Worker on EVERY script return (exit code 1) and
+// losing all diagnostics. require() is cached, so destructuring once at module
+// load and reusing everywhere avoids the redundant require calls that used to
+// appear in the IIFE and the outer .then/.catch.
+const { parentPort: _parentPort, workerData: _workerData } = require("node:worker_threads");
+const _workerLogs = [];
+// IF6(#12): known agent() fields — hoisted to module scope, built once per worker
+// (was rebuilt inside agent() on every call; field set is call-invariant).
+const _KNOWN_FIELDS = new Set(["prompt", "description", "schema", "model", "scene", "label", "task", "agent", "phase", "skill", "timeoutMs", "maxTurns", "cwd", "fork", "worktree", "returnMeta", "thinkingLevel", "engine"]);
+function _pushWorkerLog(level, args) {
+  try { _workerLogs.push({ level, message: args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ") }); } catch (e) { /* swallow */ }
+}
+// ── safePostMessage wrapper: 统一 postMessage 防御（DataCloneError 等）──
+// Module-scope so the outer .then/.catch return/error handlers can use it.
+// context 取值约定（诊断标识）：固定为消息类型字面量——
+// "agent-call" / "workflow-call" / "return" / "error"，调用方据此在日志里
+// 一眼定位是哪类 postMessage 失败。新增调用点必须传对应 context。
+function _safePost(msg, context) {
+  try { _parentPort.postMessage(msg); return true; }
+  catch (e) {
+    const errMsg = e && e.message ? e.message : String(e);
+    const stack = e && e.stack ? e.stack : "";
+    _pushWorkerLog("error", ["[postMessage failed:" + context + "]", errMsg, stack]);
+    return false;
+  }
+}
+(async () => {
+  const parentPort = _parentPort;
+  const workerData = _workerData;
+
+  if (!parentPort) {
+    throw new Error("Workflow worker: parentPort is null — not running in a Worker thread");
+  }
+
+  // ── Intercept console.* to avoid leaking worker diagnostics into the input area ──
+  console.log = function (...args) { _pushWorkerLog("log", args); };
+  console.warn = function (...args) { _pushWorkerLog("warn", args); };
+  console.error = function (...args) { _pushWorkerLog("error", args); };
+  console.info = function (...args) { _pushWorkerLog("info", args); };
+
+  // ── Internal state ──
+  let _callIdCounter = 0;
+  let _agentCallCount = 0;
+  const _pendingCalls = new Map();
+  const _callCache = workerData.callCache instanceof Map
+    ? workerData.callCache
+    : new Map(Object.entries(workerData.callCache || {}).map(([k, v]) => [Number(k), v]));
+
+  // ── Injected globals ──
+  const $ARGS = (workerData.args && typeof workerData.args === "object") ? workerData.args : {};
+  const args = $ARGS;
+  const $WORKSPACE = typeof workerData.workspace === "string" ? workerData.workspace : "";
+  const _budgetData = {
+    total: (workerData.budget && workerData.budget.maxTokens) || 0,
+    _spentTokens: (workerData.budget && workerData.budget.usedTokens) ?? 0,
+    _spentCost: (workerData.budget && workerData.budget.usedCost) ?? 0,
+  };
+  const $BUDGET = {
+    get total() { return _budgetData.total; },
+    spent() { return _budgetData._spentTokens; },
+    remaining() { return Math.max(0, _budgetData.total - _budgetData._spentTokens); },
+  };
+
+  // ── Run-level model/thinkingLevel override (Option B symmetric single-path) ──
+  // Injected from workerData (set by workerHost from RunSpec.model/thinkingLevel).
+  // agent() reads these as run-level defaults; per-call explicit opts still win.
+  const $MODEL = (workerData.model && typeof workerData.model === "string") ? workerData.model : undefined;
+  const $THINKING_LEVEL = (workerData.thinkingLevel && typeof workerData.thinkingLevel === "string") ? workerData.thinkingLevel : undefined;
+
+  // ── WorkflowAbortedError ──
+  class WorkflowAbortedError extends Error {
+    constructor(reason) {
+      super("Workflow aborted: " + (reason || "No reason"));
+      this.name = "WorkflowAbortedError";
+      this.reason = reason || "";
+    }
+  }
+
+  // ── Message handler (main thread → worker) ──
+  parentPort.on("message", (msg) => {
+    if (msg.type === "agent-result") {
+      const pending = _pendingCalls.get(msg.callId);
+      if (pending) {
+        _pendingCalls.delete(msg.callId);
+        if (typeof msg.result !== "undefined") {
+          _callCache.set(msg.callId, msg.result);
+        }
+        // 失败不传播到 agent 外部：resolve 而非 reject。
+        // 旧实现在 result.error 时 reject，单 agent 失败会冒到 worker 顶层 .catch()
+        // → 发 type:"error" → handleScriptError → rebuildRuntime → SIGKILL 同伴进程，
+        // 把单点失败放大成整批崩溃。改为始终 resolve（错误时回退到 content 文本），
+        // 让 parallel() 下的脚本容错循环（parseResult → null → skip）自然接管。
+        // 错误原因已由主线程 executeAgentCall → trace.update(result.error) 保留在 trace/TUI，
+        // 不丢失。失败 resolve 为空字符串是既定容错策略。
+        // [MF-4] schema 模式下失败时 agent() 仍 resolve（content 回退、不 throw）——
+        // 需要检查错误时请用 returnMeta:true（resolve 值含 error 字段）。
+        // 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,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({
+            value: _value,
+            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);
+        }
+      }
+    } else if (msg.type === "workflow-result") {
+      const pending = _pendingCalls.get(msg.callId);
+      if (pending) {
+        _pendingCalls.delete(msg.callId);
+        pending.resolve(msg.result);
+      }
+    } else if (msg.type === "abort") {
+      const err = new WorkflowAbortedError(msg.reason);
+      _pendingCalls.forEach((p) => { p.reject(err); });
+      _pendingCalls.clear();
+    } else if (msg.type === "budget-update" && msg.budget) {
+      _budgetData._spentTokens = msg.budget.usedTokens ?? _budgetData._spentTokens;
+      _budgetData._spentCost = msg.budget.usedCost ?? _budgetData._spentCost;
+    }
+    // "budget-warning" is informational; no required handling
+  });
+
+  let _currentPhase = "";
+  function phase(name) { _currentPhase = String(name); }
+
+  function log(msg) {
+    try { parentPort.postMessage({ type: "log", phase: _currentPhase, message: String(msg) }); } catch(e) { /* swallow */ }
+  }
+
+  async function agent(firstArg, secondArg) {
+    let opts;
+    if (typeof firstArg === "string") {
+      opts = {
+        prompt: firstArg,
+        description: (secondArg && typeof secondArg === "object" && secondArg.label) || undefined,
+        schema: (secondArg && typeof secondArg === "object" && secondArg.schema) || undefined,
+        model: (secondArg && typeof secondArg === "object" && secondArg.model) || $MODEL,
+        scene: (secondArg && typeof secondArg === "object" && secondArg.scene) || undefined,
+        phase: (secondArg && typeof secondArg === "object" && secondArg.phase) || undefined,
+        thinkingLevel: (secondArg && typeof secondArg === "object" && secondArg.thinkingLevel) || $THINKING_LEVEL,
+        // step 级 turn 上限（turn limiter；显式 0/负 = 显式不限，压过 spawn watchdog env 兑底，SP-6）
+        // ?? 语义保真：仅 null/undefined 归 undefined（走 env 兑底），显式 0 保留（U5 参数 > env）
+        maxTurns: (secondArg && typeof secondArg === "object" ? secondArg.maxTurns : undefined) ?? undefined,
+        // P4 D9③：step 级 engine 显式指定（仅限必须某引擎独有能力的场景）
+        engine: (secondArg && typeof secondArg === "object" && secondArg.engine) || undefined,
+      };
+    } else if (typeof firstArg === "object" && firstArg !== null) {
+      if (firstArg.prompt) {
+        opts = firstArg;
+      } else if (firstArg.task || firstArg.agent) {
+        // fork/worktree/returnMeta forwarded here (parity with agent({prompt,...}) and direct-pass
+        // branches). Previously this shortcut dropped them (w1 only noted, not wired).
+        opts = {
+          prompt: firstArg.task || firstArg.prompt || "",
+          description: firstArg.label || firstArg.description,
+          agent: firstArg.agent,
+          schema: firstArg.schema,
+          model: firstArg.model || $MODEL,
+          scene: firstArg.scene,
+          skill: firstArg.skill,
+          timeoutMs: firstArg.timeoutMs,
+          maxTurns: firstArg.maxTurns,
+          cwd: firstArg.cwd,
+          fork: firstArg.fork,
+          worktree: firstArg.worktree,
+          returnMeta: firstArg.returnMeta,
+          thinkingLevel: firstArg.thinkingLevel || $THINKING_LEVEL,
+          engine: firstArg.engine,
+        };
+      } else {
+        opts = firstArg;
+      }
+    } else {
+      throw new Error("agent() requires a prompt string or options object as first argument");
+    }
+
+    // Run-level fallback for object branches (opts = firstArg direct assign).
+    // Priority: agent() explicit > $MODEL global (set from workerData.model).
+    if (!opts.model && $MODEL) opts.model = $MODEL;
+    if (!opts.thinkingLevel && $THINKING_LEVEL) opts.thinkingLevel = $THINKING_LEVEL;
+
+    // Validate known agent() fields to catch API misuse early (_KNOWN_FIELDS at module scope)
+    const _unknownFields = Object.keys(opts).filter((k) => !_KNOWN_FIELDS.has(k));
+    if (_unknownFields.length > 0) {
+      _pushWorkerLog("warn", ["[workflow] agent() received unknown fields: " + _unknownFields.join(", ") + ". Known fields: prompt, description, schema, model, scene, label, task, agent, phase, skill, timeoutMs, maxTurns, cwd, fork, worktree, returnMeta, thinkingLevel, engine"]);
+    }
+
+    const callId = _callIdCounter;
+    _callIdCounter++;
+    _agentCallCount++;
+    if (_callCache.has(callId)) {
+      const cached = _callCache.get(callId);
+      // 与 live handler 对齐：失败也 resolve（回退 content），不 throw。
+      // 见 agent-result 消息处理的注释：拒绝传播失败到 agent 外部。
+      // W2 改动 9(c)：returnMeta 分支（对称 handler 9b），opts 仍在闭包作用域。
+      if (!cached) return undefined;
+      const _cachedValue = cached.parsedOutput ?? cached.content;
+      if (opts.returnMeta === true) {
+        return {
+          value: _cachedValue,
+          sessionFile: cached.sessionFile,
+          worktreePath: cached.worktreePath,
+          error: cached.error,
+          usage: cached.usage,
+          durationMs: cached.durationMs,
+          sessionId: cached.sessionId,
+        };
+      }
+      return _cachedValue;
+    }
+
+    const _effectivePhase = opts.phase || _currentPhase;
+    delete opts.phase;
+
+    if (!_safePost({ type: "agent-call", callId, opts, phase: _effectivePhase }, "agent-call")) {
+      return Promise.reject(new Error("postMessage failed for agent-call (callId=" + callId + "): see workerLogs"));
+    }
+    return new Promise((resolve, reject) => {
+      _pendingCalls.set(callId, { resolve, reject, returnMeta: opts.returnMeta === true });
+    });
+  }
+
+  async function parallel(calls) {
+    if (typeof calls === "function") { return calls(); }
+    const settled = await Promise.allSettled(calls.map((c) => {
+      if (c && typeof c.then === "function") { return c; }
+      if (typeof c === "function") { return c(); }
+      if (typeof c === "object" && c !== null && (c.task || c.agent)) { return agent(c); }
+      return agent(c);
+    }));
+    return settled.map((r) => {
+      if (r.status === "fulfilled") {
+        const v = r.value;
+        if (v !== null && typeof v === "object" && !Array.isArray(v)) {
+          // 主线程 fallback（postAgentResult/postResult serialization failed）回发的对象含 error 字段
+          // → 归一化为 failed 形状，与脚本侧 r.status === "failed" 检查统一
+          if (typeof v.error === "string" && v.error.length > 0) return { status: "failed", error: v.error };
+          return v;
+        }
+        return { status: "failed", error: "agent returned non-object result (type=" + typeof v + ")" };
+      }
+      const reason = r.reason;
+      const errMsg = reason instanceof Error ? reason.message : String(reason);
+      return { status: "failed", error: errMsg };
+    });
+  }
+
+  async function pipeline(firstArg, ...restStages) {
+    // Single-arg mode: pipeline([stage1, stage2, ...])
+    if (Array.isArray(firstArg) && restStages.length === 0) {
+      let result;
+      for (let i = 0; i < firstArg.length; i++) {
+        try { result = await firstArg[i](result); }
+        catch (e) {
+          const msg = e && e.message ? e.message : String(e);
+          _pushWorkerLog("error", ["[pipeline stage " + i + " failed]", msg]);
+          throw e;
+        }
+      }
+      return result;
+    }
+    // Cartesian product mode: pipeline([items], stage1, stage2, ...)
+    if (Array.isArray(firstArg) && restStages.length > 0 && typeof restStages[0] === "function") {
+      const results = [];
+      for (let idx = 0; idx < firstArg.length; idx++) {
+        const item = firstArg[idx];
+        let val = item;
+        let failed = false;
+        for (const stage of restStages) {
+          if (failed) break;
+          try { val = await stage(val); }
+          catch (e) {
+          const msg = e && e.message ? e.message : String(e);
+          _pushWorkerLog("error", ["[pipeline cartesian stage failed for item " + (idx + 1) + "]", msg]);
+          val = null; failed = true;
+          }
+        }
+        results.push(val);
+      }
+      return results;
+    }
+    throw new Error("pipeline() expects pipeline([stage1, ...]) or pipeline([items], stage1, ...)");
+  }
+
+  // ── workflow global — nested workflow invocation ──
+  async function workflow(name, args) {
+    if (typeof name !== "string" || name.length === 0) {
+      throw new Error("workflow() requires a workflow name string as first argument");
+    }
+    const workflowArgs = (typeof args === "object" && args !== null) ? args : {};
+    const callId = _callIdCounter;
+    _callIdCounter++;
+    if (!_safePost({ type: "workflow-call", callId, name, args: workflowArgs }, "workflow-call")) {
+      return Promise.reject(new Error("postMessage failed for workflow-call (name=" + name + "): see workerLogs"));
+    }
+    return new Promise((resolve, reject) => {
+      _pendingCalls.set(callId, { resolve, reject });
+    });
+  }
+
+  // ── User workflow script ──
+  // sample exercising template features
+const name = $ARGS.name ?? "default";
+phase("build");
+const spec = await agent("build it", { label: "builder", schema: { type: "object" } });
+const results = await parallel([
+  agent({ task: "unit tests", agent: "./tester.md" }),
+  agent({ task: "lint", agent: "./linter.md", skill: "lint-skill" }),
+]);
+await pipeline([(x) => x, (x) => x]);
+await workflow("deploy", { env: "prod" });
+log("done " + name + " " + $WORKSPACE + " " + $BUDGET.remaining());
+module.exports = { execute: async (ctx) => ctx.agent("finalize") };
+
+  // ── Auto-invoke execute() for module.exports pattern ──
+  if (typeof module !== "undefined" && module.exports && typeof module.exports.execute === "function") {
+    return await module.exports.execute({ agent, parallel, pipeline, phase, log, workflow, $ARGS, $WORKSPACE, $BUDGET });
+  }
+})().then((result) => {
+  const runId = (_workerData.args && typeof _workerData.args === "object" && _workerData.args._runId) || "";
+  if (!_safePost({ type: "return", runId, result, workerLogs: _workerLogs }, "return")) {
+    // [F1] return 值不可克隆（含 function/Symbol/循环引用 → DataCloneError）时 _safePost
+    // 只能记日志返回 false——若不补救，worker 将静默 exit(0)，主线程收不到任何终态消息，
+    // run 永久 running、runAndWait 悬挂。回发可克隆的 error 消息（DataCloneError 详情
+    // 已由 _safePost 记入 _workerLogs 随消息带回），让主线程 handleScriptError 接管，
+    // run 经既有重试矩阵收敛到终态 failed。
+    _safePost({ type: "error", runId, error: "Workflow return value could not be delivered (structured-clone failed) — see workerLogs for the postMessage error", workerLogs: _workerLogs }, "error");
+  }
+}).catch((err) => {
+  const runId = (_workerData.args && typeof _workerData.args === "object" && _workerData.args._runId) || "";
+  _safePost({ type: "error", runId, error: err.message || String(err), workerLogs: _workerLogs }, "error");
+});

package/src/orchestration/__tests__/agent-call-catch-fallback.test.ts

@@ -0,0 +1,202 @@
+// src/orchestration/__tests__/agent-call-catch-fallback.test.ts
+//
+// U7: dispatchAgentCall catch 分支回发 agent-result 给 worker（吞错兜底）
+//
+// 场景：executeAgentCall（或 gate.withSlot）抛非 Abort 异常时，原 catch 块仅
+// console.error，worker 内对应 callId 的 pending Promise 永不 resolve → agent()
+// 永久 await → worker 脚本挂死。修复后 catch 块构造 failed AgentResult 并
+// postAgentResult 回 worker，使 pending Promise 能 resolve（结果为 error）。
+//
+// 通过 handleWorkerMessage 触发 dispatchAgentCall（内部函数不 export）。
+// Mock 构造模式参考 agent-call-stream.test.ts。
+
+import { describe, expect, it, vi } from "vitest";
+
+import { handleWorkerMessage } from "../error-recovery.ts";
+import type { LifecycleDeps, WorkerHandlers } from "../models/ports.ts";
+import { Trace } from "../models/trace.ts";
+import type { WorkflowRun } from "../models/workflow-run.ts";
+import type { AgentResult } from "../models/types.ts";
+
+// ── helpers ──────────────────────────────────────────────────
+
+/** 构造 status="running" 的 mock WorkflowRun，含 trace/budget/calls/runtime。
+ *  worker.postMessage 为 vi.fn spy，便于断言回发内容。gate.withSlot 直接 await fn()
+ *  让异常透传到外层 .catch（模拟 executeAgentCall 抛错的真实链路）。 */
+function makeRunningRun(runId: string): WorkflowRun {
+  const trace = new Trace();
+  const controller = new AbortController();
+  return {
+    runId,
+    spec: { scriptName: "test-wf", scriptSource: "agent('hi')", args: {}, runId, slug: undefined },
+    state: {
+      status: "running" as const,
+      reason: undefined,
+      trace,
+      budget: {
+        usedTokens: 0,
+        usedCost: 0,
+        totalCallCount: 0,
+        consume: vi.fn(),
+        isExceeded: vi.fn(() => false),
+        incrementCallCount: vi.fn(),
+      },
+      calls: new Map(),
+      scriptResult: undefined,
+    },
+    meta: { startedAt: new Date().toISOString(), workerErrorCount: 0, scriptErrorCount: 0 },
+    runtime: {
+      controller,
+      worker: { postMessage: vi.fn() },
+    },
+    transition: vi.fn(),
+    replaceRuntime: vi.fn(),
+  } as unknown as WorkflowRun;
+}
+
+/** LifecycleDeps mock，runner.run 可配置为 reject 指定 error。 */
+function makeDeps(opts: { runnerError?: Error } = {}): LifecycleDeps {
+  const runnerRun = vi.fn(async () => {
+    if (opts.runnerError) throw opts.runnerError;
+    return { content: "OK", durationMs: 10, error: undefined, toolCalls: [] } as AgentResult;
+  });
+  return {
+    store: { save: vi.fn(async () => {}) },
+    workerHost: { start: vi.fn() },
+    runner: { run: runnerRun },
+    runs: new Map(),
+    eventBus: { emit: vi.fn() },
+    onRunDone: vi.fn(),
+    log: vi.fn(),
+    // streamSink 不设 = undefined（本测试不关心 stream）
+  } as unknown as LifecycleDeps;
+}
+
+function makeHandlers(): WorkerHandlers {
+  return {
+    onMessage: vi.fn(async () => {}),
+    onError: vi.fn(async () => {}),
+    onExit: vi.fn(async () => {}),
+  } as unknown as WorkerHandlers;
+}
+
+/** agent-call 消息 */
+function makeAgentCallMsg(callId: number): unknown {
+  return {
+    type: "agent-call",
+    callId,
+    phase: "test-phase",
+    opts: { prompt: "test task", agent: "worker", description: "test-slug" },
+  };
+}
+
+/** 从 postMessage spy 的所有调用中找 type:"agent-result" 且 callId 匹配的参数。 */
+function findAgentResultPost(
+  postMessage: ReturnType<typeof vi.fn>,
+  callId: number,
+): { type: string; callId: number; result: AgentResult; cached: boolean } | undefined {
+  for (const call of postMessage.mock.calls) {
+    const msg = call[0] as { type?: string; callId?: number; result?: AgentResult; cached?: boolean };
+    if (msg?.type === "agent-result" && msg.callId === callId) return msg as never;
+  }
+  return undefined;
+}
+
+/** 静默 console.error（catch 块会打印失败日志，避免污染测试输出）。 */
+function silenceConsoleError(): () => void {
+  const spy = vi.spyOn(console, "error").mockImplementation(() => {});
+  return () => spy.mockRestore();
+}
+
+// ── U7a: 非 Abort 异常 → postAgentResult 回发 failed result ──
+
+describe("U7a: catch 分支兜底回发 agent-result（非 Abort 异常）", () => {
+  it("runner.run reject 'runner exploded' → worker 收到 {success:false, error:'runner exploded'}", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const deps = makeDeps({ runnerError: new Error("runner exploded") });
+      const run = makeRunningRun("wf-catch-001");
+      const handlers = makeHandlers();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(run, makeAgentCallMsg(2), deps, handlers);
+
+      // dispatchAgentCall 内 void withSlot(...)（fire-and-forget），需等微任务完成
+      await vi.waitFor(() => {
+        expect(findAgentResultPost(postMessage, 2)).toBeDefined();
+      });
+
+      const posted = findAgentResultPost(postMessage, 2)!;
+      expect(posted.type).toBe("agent-result");
+      expect(posted.callId).toBe(2);
+      expect(posted.cached).toBe(false);
+      // AgentResult.error 字段承载错误信息（与 resolveAgentOpts 失败路径一致）
+      expect(posted.result.error).toBe("runner exploded");
+      expect(posted.result.content).toBe("");
+
+      // state 一致性三件套（review should_fix）：
+      // trace node 标 failed（不遗留 running 幽灵节点）
+      const traceNode = run.state.trace.find(2);
+      expect(traceNode?.status).toBe("failed");
+      expect(traceNode?.result?.error).toBe("runner exploded");
+      // node.live 清除（防内存泄漏）
+      expect(traceNode?.live).toBeUndefined();
+      // 持久化（catch 是最需留证的场景）
+      expect(deps.store.save).toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("非 Error 值 reject（字符串）→ error 字段为该字符串", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const deps = makeDeps({ runnerError: "string failure" as unknown as Error });
+      const run = makeRunningRun("wf-catch-002");
+      const handlers = makeHandlers();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(run, makeAgentCallMsg(7), deps, handlers);
+
+      await vi.waitFor(() => {
+        expect(findAgentResultPost(postMessage, 7)).toBeDefined();
+      });
+
+      const posted = findAgentResultPost(postMessage, 7)!;
+      expect(posted.result.error).toBe("string failure");
+    } finally {
+      restore();
+    }
+  });
+});
+
+// ── U7b: AbortError → 不回发（预期路径，吞掉） ──
+
+describe("U7b: AbortError 不回发 agent-result", () => {
+  it("runner.run reject AbortError → postAgentResult 不被调用", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const abortErr = new Error("aborted");
+      abortErr.name = "AbortError";
+      const deps = makeDeps({ runnerError: abortErr });
+      const run = makeRunningRun("wf-catch-003");
+      const handlers = makeHandlers();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(run, makeAgentCallMsg(3), deps, handlers);
+
+      // 等待 fire-and-forget 链路稳定：无 agent-result 回发。
+      // 先 flush 微任务队列（多次确保 withSlot promise 已 settle），
+      // 再断言断言期内无 agent-result。vi.waitFor 用反向断言会一满足就 return，
+      // 故采用：跑若干 microtask tick 后静态断言。
+      for (let i = 0; i < 5; i++) {
+        // eslint-disable-next-line no-await-in-loop -- 排空微任务队列的固定 tick 循环（vi.waitFor 反向断言会一满足即返回，不适用），非逐项等待
+        await Promise.resolve();
+      }
+      const posted = findAgentResultPost(postMessage, 3);
+      expect(posted).toBeUndefined();
+    } finally {
+      restore();
+    }
+  });
+});