@zhushanwen/pi-subagent-workflow 7.3.4 → 8.0.0

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

@@ -0,0 +1,325 @@
+"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"]);
+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}（对称缓存重放 9c）；否则单值。
+        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,
+          });
+        } 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,
+      };
+    } 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,
+        };
+      } 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"]);
+    }
+
+    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,
+        };
+      }
+      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");
+});

package/src/orchestration/__tests__/args-validator.test.ts

@@ -93,7 +93,7 @@ describe("validateRunArgs — 校验语义", () => {
     const args = { targetType: "git-diff", target: "main", autoCommit: "false", maxRounds: "10" };
     const spec = makeSpec(reviewFixLoopParameters(), args);
     expect(() => validateRunArgs(spec)).not.toThrow();
-    expect(spec.args).toBe(args); // 原地 mutate，引用不变（worker/resume 同一对象）
+    expect(spec.args).toBe(args); // 原地 mutate，引用不变（worker 启动/崩溃重跑同一对象）
     expect(spec.args.autoCommit).toBe(false);
     expect(spec.args.maxRounds).toBe(10);
   });

package/src/orchestration/__tests__/config-loader.test.ts

@@ -446,6 +446,44 @@ describe("getWorkflowByPath — 按绝对路径加载（S2 路径统一核心新
     expect(meta!.phases).toEqual([]);
     expect(meta!.path).toBe("/nonexistent/ghost.js");
   });
+
+  // ── IF4（外部 #5 残留）：source 按路径推导（.tmp → tmp） ──
+  // 修复前：任意路径硬编码 "user-pi" → .tmp 下脚本按路径加载被错标 saved，
+  // 与 discoverWorkflows 对 project-pi-tmp 源的正确映射矛盾。
+
+  it("IF4: workspaceRoot/.pi/workflows/.tmp 下的脚本按路径加载 source = tmp", async () => {
+    // findWorkspaceRoot 指向临时工作区 → tmp 前缀判定生效
+    mockedFindWorkspaceRoot.mockReturnValue(ws.root);
+    const tmpScriptPath = await writeScript(ws.tmpDir, "adhoc.js", validScript("adhoc"));
+
+    const meta = await getWorkflowByPath(tmpScriptPath);
+
+    expect(meta).toBeDefined();
+    expect(meta!.available).toBe(true);
+    expect(meta!.source).toBe("tmp");
+  });
+
+  it("IF4: 非 .tmp 路径按路径加载 source = saved（输出不变，DS4）", async () => {
+    mockedFindWorkspaceRoot.mockReturnValue(ws.root);
+    const savedPath = await writeScript(ws.projectDir, "byfile.js", validScript("byfile"));
+
+    const meta = await getWorkflowByPath(savedPath);
+
+    expect(meta).toBeDefined();
+    expect(meta!.available).toBe(true);
+    expect(meta!.source).toBe("saved");
+  });
+
+  it("IF4: tmp 前缀判定不误伤同名前缀目录（.tmp-other/ 非 .tmp/）", async () => {
+    mockedFindWorkspaceRoot.mockReturnValue(ws.root);
+    const siblingDir = join(ws.projectDir, ".tmp-other");
+    await mkdir(siblingDir, { recursive: true });
+    const siblingPath = await writeScript(siblingDir, "sib.js", validScript("sib"));
+
+    const meta = await getWorkflowByPath(siblingPath);
+
+    expect(meta!.source).toBe("saved");
+  });
 });
 
 describe("WorkflowScanConfig 类型接口", () => {