@zhushanwen/pi-subagent-workflow 8.5.0 → 8.7.0

package/src/execution/worktree-registry.ts

@@ -1,222 +0,0 @@
-// src/runtime/worktree-registry.ts
-//
-// 全局 worktree 注册表：跨 repo 记录所有活 pi-sub-* worktree。
-//
-// 取代旧的 per-cwd 扫描 + .session mapping sidecar 链。
-// 旧 reaper 的两个根本缺陷由此消除：
-//   1. 触发覆盖：旧 scan 扫「当前 cwd 对应的 repo」，workspace 根 / 非 git 目录启动时
-//      rev-parse 报错整个挂掉；且 tmpdir 下的 checkout 永远不会被 pi cwd "看到"。
-//      → 新 scan 遍历全局注册表，不依赖 cwd 是否 git repo。
-//   2. 判据脆弱：旧 scan 用 .finalized/.cancelled 终态 marker 作主判据，进程崩溃时
-//      无人写终态 → 孤儿永久泄漏。→ 新判据：pid 死活一条判到底。
-//
-// 并发模型：
-//   - 跨进程互斥（D5a）：add/updatePid/remove 的 load→mutate→save 全程持
-//     proper-lockfile 异步锁（<worktrees.json>.lock，协议登记 data-source-registry.md §6）。
-//     锁不可用（重试耗尽）时降级为无锁 RMW + warn——注册表是 best-effort 数据，
-//     降级不比锁前更差，条目丢失由 reaper 对账兜底（worktree-manager scan 的
-//     双向 diff，见 reconcileWithPhysical）。
-//   - 同步 IO（readFileSync/writeFileSync）持锁执行：锁内临界区毫秒级，
-//     async 锁 + sync IO 组合在单线程 event loop 内无 interleaving。
-//   - 原子写：写 .tmp → rename，防写一半崩溃产生损坏 JSON。
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-
-import { withFileLock } from "@zhushanwen/pi-file-lock";
-import { getLogger } from "@zhushanwen/pi-extension-logger";
-
-import { bestEffort } from "./best-effort.ts";
-
-const logger = getLogger("subagents");
-
-/** create→spawn 宽限期（ms）：pid=0 条目超过此阈值判 create 后崩溃。 */
-export const SPAWN_GRACE_MS = 60_000;
-
-/** JSON 缩进空格数（可读性 + diff 友好）。 */
-const JSON_INDENT = 2;
-
-/** tmp 随机段：36 进制取 8 字符（跳过 "0." 前缀），与 pid 组合保证并发唯一。 */
-const TMP_RANDOM_BASE = 36;
-const TMP_RANDOM_SLICE_START = 2; // 跳过 Math.random 字符串的 "0." 前缀
-const TMP_RANDOM_SLICE_END = 10;
-
-/** 注册表 JSON 顶层结构的运行时类型守卫。 */
-function isRegistryData(value: unknown): value is { entries: WorktreeEntry[] } {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    "entries" in value &&
-    Array.isArray(value.entries)
-  );
-}
-
-/**
- * 注册表条目：一条 = 一个活 worktree。
- * 字段全部来自 WorktreeHandle + session-runner 已捕获的 child.pid，零新数据源。
- */
-export interface WorktreeEntry {
-  /** 主仓库根目录（git -C <repo> 操作目标）。 */
-  readonly repo: string;
-  /** 分支名（"pi-sub-<recordId>"）。 */
-  readonly branch: string;
-  /** checkout 目录（tmpdir 下，= WorktreeHandle.path）。 */
-  readonly checkout: string;
-  /** 子进程 pid（0 = create-spawn 窗口，尚未拿到 pid）。 */
-  readonly pid: number;
-  /** 创建时间戳（ms，SPAWN_GRACE 判据 + 调试用）。 */
-  readonly createdAt: number;
-  /**
-   * 对应 subagent session jsonl 文件全路径（诊断/兼容字段，reaper 据 pid 死活判孤儿）。
-   * session-runner first header 拿到 pid 时补全（create 时 record.sessionFile 尚未确定）。
-   * 可选：旧 worktrees.json / 非 worktree 模式无此字段，向后兼容（undefined 时 reaper 走原 pid 判据）。
-   */
-  readonly sessionFile?: string;
-}
-
-/**
- * 全局 worktree 注册表。
- *
- * 文件位置：<agentDir>/subagents/worktrees.json（repo 无关层级，跨 repo 共享）
- * 格式：{ "entries": WorktreeEntry[] }
- */
-export class WorktreeRegistry {
-  private readonly filePath: string;
-
-  constructor(agentDir: string) {
-    this.filePath = path.join(agentDir, "subagents", "worktrees.json");
-  }
-
-  /**
-   * 新增条目（create 成功后调，pid=0 占位）。
-   * 同 branch 已存在则覆盖（防残留覆盖）。
-   * 跨进程锁内 RMW（D5a）；锁降级路径见 mutate。
-   */
-  async add(entry: WorktreeEntry): Promise<void> {
-    await this.mutate((entries) => {
-      const idx = entries.findIndex((e) => e.branch === entry.branch);
-      if (idx >= 0) {
-        entries[idx] = entry;
-      } else {
-        entries.push(entry);
-      }
-    });
-  }
-
-  /**
-   * 更新 pid（runSpawn spawn() 返回后同步调）。
-   * branch 不存在则忽略（create 后崩溃 + reaper 已清的竞态）。
-   * sessionFile 可选补全：传入时填入 entry（reaper 据 pid 死活判孤儿，不读本字段）。
-   */
-  async updatePid(branch: string, pid: number, sessionFile?: string): Promise<void> {
-    await this.mutate(
-      (entries) => {
-        const idx = entries.findIndex((e) => e.branch === branch);
-        if (idx >= 0) {
-          entries[idx] = {
-            ...entries[idx],
-            pid,
-            ...(sessionFile !== undefined ? { sessionFile } : {}),
-          };
-        }
-      },
-      { branch, pid },
-    );
-  }
-
-  /**
-   * 移除条目（cleanup/reaper 清理后调）。
-   * branch 不存在则忽略（幂等）。
-   */
-  async remove(branch: string): Promise<void> {
-    await this.mutate(
-      (entries) => {
-        const filtered = entries.filter((e) => e.branch !== branch);
-        if (filtered.length !== entries.length) {
-          entries.length = 0;
-          entries.push(...filtered);
-        }
-      },
-      { branch },
-    );
-  }
-
-  /**
-   * 锁内 RMW 统一入口：withLock(load → mutate → save)。
-   *
-   * 降级语义（对齐本类既有 best-effort 约定——注册表写失败不阻断 create/cleanup
-   * 主流程）：锁获取失败（重试耗尽 ELOCKED 等）→ warn + 无锁执行同一段 RMW
-   * （= D5a 之前的 last-write-wins 行为，条目丢失由 reaper 对账兜底），
-   * 不抛错、永不 reject（调用方含 session-runner 的 fire-and-forget 回调）。
-   */
-  private async mutate(
-    mutate: (entries: WorktreeEntry[]) => void,
-    context?: { branch?: string; pid?: number },
-  ): Promise<void> {
-    const run = (): void => {
-      const entries = this.load();
-      mutate(entries);
-      this.save(entries, context);
-    };
-    try {
-      await withFileLock(this.filePath, () => {
-        run();
-        return Promise.resolve();
-      });
-    } catch (lockErr) {
-      // 锁不可用（ELOCKED 重试耗尽 / 锁目录损坏等）：降级无锁 RMW。
-      // 竞争窗口内可能丢条目（旧缺陷形态），由 reaper 对账（scan 双向 diff）收敛。
-      logger.warn("[worktree] registry lock unavailable, degraded to lock-free RMW", {
-        ...(context ?? {}),
-        err: lockErr instanceof Error ? lockErr.message : String(lockErr),
-      });
-      try {
-        run();
-      } catch (err) {
-        bestEffort(err, "worktree registry degraded RMW");
-      }
-    }
-  }
-
-  /**
-   * 加载全部条目（reaper 遍历用）。
-   * 文件不存在 / 解析失败 / IO 错误 → 返回空数组（视为无活 worktree）。
-   */
-  load(): WorktreeEntry[] {
-    try {
-      const raw = fs.readFileSync(this.filePath, "utf-8");
-      const parsed = JSON.parse(raw) as unknown;
-      if (isRegistryData(parsed)) {
-        return parsed.entries;
-      }
-      return [];
-    } catch {
-      // 文件不存在（首次运行）/ 解析失败（损坏）/ IO 错误 → 空注册表
-      return [];
-    }
-  }
-
-  /**
-   * 原子写入全部条目。
-   * best-effort：写入失败不阻断主流程（create/cleanup 的 git 操作已执行，
-   * 注册表与 git 状态的短暂不一致靠下次 reaper 对账收敛）。
-   * 写盘失败时 warn 日志（带 branch/pid 上下文，补全失败可观测闭环）。
-   */
-  private save(entries: WorktreeEntry[], context?: { branch?: string; pid?: number }): void {
-    try {
-      fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
-      // tmp 名带 pid + 随机段：锁降级（无锁并发 RMW）时多进程 tmp 互不覆盖
-      const tmp = `${this.filePath}.tmp_${process.pid}_${Math.random().toString(TMP_RANDOM_BASE).slice(TMP_RANDOM_SLICE_START, TMP_RANDOM_SLICE_END)}`;
-      fs.writeFileSync(tmp, JSON.stringify({ entries }, null, JSON_INDENT), "utf-8");
-      fs.renameSync(tmp, this.filePath);
-    } catch (err) {
-      bestEffort(err, "worktree registry save");
-      // [worktree-reaper-fix] 补全写盘失败静默吞错时，条目 pid 恒 0、60s 后被 reaper 误删
-      // 活 worktree 且无诊断线索。此 warn 与 reaper scan 的 pid=0 warn 呼应，形成闭环。
-      logger.warn(
-        "[worktree] registry save failed; pid may stay 0 and be reaped by orphan reaper",
-        { ...(context ?? {}), err: err instanceof Error ? err.message : String(err) },
-      );
-    }
-  }
-}

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

@@ -1,336 +0,0 @@
-"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", "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 为空字符串是既定容错策略。
-        // 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,
-        // 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,
-          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, 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) || "";
-  _safePost({ type: "return", runId, result, workerLogs: _workerLogs }, "return");
-}).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");
-});