tianshu-harness 3.23.0

package/dist/verification-attribution-EKG4CNUV.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  assessImpactedTestCoverage,
+  createVerificationAttribution,
+  getEffectiveVerifications
+} from "./chunk-ZO3I3A7O.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  assessImpactedTestCoverage,
+  createVerificationAttribution,
+  getEffectiveVerifications
+};

package/dist/volatile-git-MBTST7RA.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  createGitStatusCache,
+  formatGitStatus,
+  getGitInjectedContext,
+  gitStatusCache
+} from "./chunk-EXUE5W2F.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  createGitStatusCache,
+  formatGitStatus,
+  getGitInjectedContext,
+  gitStatusCache
+};

package/dist/wave-checkpoint-XLIIHXQA.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  buildResumeFromCheckpoint,
+  clearCheckpoint,
+  deriveTeamGroupId,
+  formatCheckpointList,
+  listCheckpoints,
+  loadCheckpoint,
+  saveCheckpoint
+} from "./chunk-3VGD2FXB.js";
+import "./chunk-UXNLELW6.js";
+import "./chunk-TVHW77C7.js";
+import "./chunk-4QJ3Y5JM.js";
+import "./chunk-CGOADM2X.js";
+import "./chunk-6HSVXHCZ.js";
+import "./chunk-ADIVZ2D5.js";
+import "./chunk-Z5Z3JHJY.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  buildResumeFromCheckpoint,
+  clearCheckpoint,
+  deriveTeamGroupId,
+  formatCheckpointList,
+  listCheckpoints,
+  loadCheckpoint,
+  saveCheckpoint
+};

package/dist/web-cli-DUG4I35O.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/cli/web-cli.ts
+init_esm_shims();
+var USAGE = [
+  "rivet web \u2014 web \u5DE5\u5177\u547D\u4EE4\u884C\u5165\u53E3\u4E0E\u8FDE\u901A\u6027\u81EA\u68C0",
+  "",
+  "  rivet web search <query> [--count N] [--json]   \u641C\u7D22\u5E76\u9010\u540E\u7AEF\u62A5\u544A\u7ED3\u679C",
+  "  rivet web fetch <url> [--json]                  \u6293\u53D6 URL \u8F6C markdown",
+  "  rivet web status [--json]                       \u6253\u5370 web \u914D\u7F6E\u751F\u6548\u72B6\u6001",
+  "",
+  "\u793A\u4F8B\uFF1A",
+  '  rivet web search "GLM-5.2 \u53D1\u5E03"',
+  "  rivet web fetch https://example.com",
+  "  rivet web status"
+].join("\n");
+async function runWebCLI(args, ctx = {}) {
+  const write = ctx.write ?? ((s) => process.stdout.write(s));
+  const sub = args[0];
+  if (!sub || sub === "-h" || sub === "--help") {
+    write(USAGE + "\n");
+    return sub ? 0 : 1;
+  }
+  const { loadConfig } = await import("./manager-ROZBCWPA.js");
+  const config = loadConfig({ cwd: ctx.cwd ?? process.cwd() });
+  switch (sub) {
+    case "search":
+      return runSearch(args.slice(1), config, write);
+    case "fetch":
+      return runFetch(args.slice(1), config, write);
+    case "status":
+      return runStatus(args.slice(1), config, write);
+    default:
+      write(`\u672A\u77E5\u5B50\u547D\u4EE4: "${sub}"
+
+${USAGE}
+`);
+      return 1;
+  }
+}
+async function runSearch(args, config, write) {
+  const json = args.includes("--json");
+  const countIdx = args.indexOf("--count");
+  const count = countIdx >= 0 && args[countIdx + 1] ? clampInt(args[countIdx + 1], 1, 20, 10) : 10;
+  const query = args.filter((a) => !a.startsWith("-") && a !== "--json").join(" ").trim();
+  if (!query) {
+    write("\u7528\u6CD5: rivet web search <query> [--count N] [--json]\n");
+    return 1;
+  }
+  const { buildSearchBackends } = await import("./build-backends-5KXKR2S4.js");
+  const { runBackendChain } = await import("./chain-7MAMFXZ3.js");
+  const { resolveProxyForUrl } = await import("./proxy-resolver-V2Y6534D.js");
+  const proxyOpts = {
+    ...config.network.proxy ? { proxyUrl: config.network.proxy } : {},
+    ...config.network.noProxy ? { noProxy: config.network.noProxy } : {}
+  };
+  const backends = buildSearchBackends(config, { proxy: proxyOpts });
+  const timeoutMs = config.search.timeoutMs;
+  const result = await runBackendChain(backends, query, count, timeoutMs);
+  if (json) {
+    write(JSON.stringify({
+      query,
+      count,
+      backend: result.backend,
+      results: result.results,
+      errors: result.errors,
+      proxy: resolveProxyForUrl("https://example.com", proxyOpts) ?? null
+    }, null, 2) + "\n");
+    return result.results.length > 0 ? 0 : 1;
+  }
+  const lines = [];
+  lines.push(`\u641C\u7D22\uFF1A\u300C${query}\u300D`);
+  const proxy = resolveProxyForUrl("https://example.com", proxyOpts);
+  lines.push(`\u4EE3\u7406\uFF1A${proxy ?? "\u76F4\u8FDE"}`);
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push("\u540E\u7AEF\u94FE\u8DEF\uFF1A");
+    for (const e of result.errors) {
+      lines.push(`  \u2717 ${e.backend}: ${e.message}`);
+    }
+  }
+  if (result.backend) {
+    lines.push(`  \u2713 ${result.backend} \u547D\u4E2D ${result.results.length} \u6761`);
+  }
+  lines.push("");
+  if (result.results.length === 0) {
+    lines.push("\u672A\u627E\u5230\u7ED3\u679C\uFF08\u6240\u6709\u540E\u7AEF\u5747\u65E0\u7ED3\u679C\u6216\u5931\u8D25\uFF09\u3002");
+    write(lines.join("\n") + "\n");
+    return 1;
+  }
+  for (let i = 0; i < result.results.length; i++) {
+    const r = result.results[i];
+    lines.push(`${i + 1}. ${r.title}`);
+    lines.push(`   ${r.url}`);
+    if (r.snippet) lines.push(`   ${r.snippet}`);
+    lines.push("");
+  }
+  write(lines.join("\n") + "\n");
+  return 0;
+}
+async function runFetch(args, config, write) {
+  const json = args.includes("--json");
+  const url = args.find((a) => !a.startsWith("-") && a !== "--json");
+  if (!url) {
+    write("\u7528\u6CD5: rivet web fetch <url> [--json]\n");
+    return 1;
+  }
+  const { fetchMarkdown } = await import("./fetch-core-ZPPYDSZH.js");
+  const { buildFetchOptions } = await import("./build-options-66Y4ZE7C.js");
+  const opts = { ...buildFetchOptions(config), cwd: process.cwd() };
+  const outcome = await fetchMarkdown(url, {}, opts);
+  if (json) {
+    write(JSON.stringify(outcome, null, 2) + "\n");
+    return outcome.ok ? 0 : 1;
+  }
+  if (!outcome.ok) {
+    write(`\u6293\u53D6\u5931\u8D25\uFF1A${outcome.error}
+`);
+    return 1;
+  }
+  const via = outcome.via ? ` ${outcome.via}` : "";
+  const cache = outcome.fromCache ? "\uFF08\u7F13\u5B58\uFF09" : "";
+  write(`URL\uFF1A${url}
+\u72B6\u6001\uFF1A${outcome.status}${cache}${via}
+\u957F\u5EA6\uFF1A${outcome.markdown.length}
+
+`);
+  const MAX = 5e4;
+  const body = outcome.markdown.length > MAX ? outcome.markdown.slice(0, MAX) + `
+
+\u2026\uFF08\u5DF2\u622A\u65AD\uFF0C\u5171 ${outcome.markdown.length} \u5B57\u7B26\uFF09` : outcome.markdown;
+  write(body + "\n");
+  return 0;
+}
+async function runStatus(args, config, write) {
+  const json = args.includes("--json");
+  const { resolveProxyForUrl } = await import("./proxy-resolver-V2Y6534D.js");
+  const { buildSearchBackends } = await import("./build-backends-5KXKR2S4.js");
+  const proxyOpts = {
+    ...config.network.proxy ? { proxyUrl: config.network.proxy } : {},
+    ...config.network.noProxy ? { noProxy: config.network.noProxy } : {}
+  };
+  const proxy = resolveProxyForUrl("https://example.com", proxyOpts);
+  const proxySource = config.network.proxy ? "config (network.proxy)" : process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy ? "env (HTTPS_PROXY/HTTP_PROXY)" : proxy ? "system (OS)" : "direct\uFF08\u76F4\u8FDE\uFF09";
+  const backends = buildSearchBackends(config, { proxy: proxyOpts });
+  const backendStatus = backends.map((b) => ({
+    name: b.name,
+    available: b.isAvailable()
+  }));
+  const status = {
+    proxy: { url: proxy ?? null, source: proxySource },
+    noProxy: config.network.noProxy ?? null,
+    search: {
+      backends: config.search.backends,
+      timeoutMs: config.search.timeoutMs,
+      region: config.search.region ?? null,
+      backendStatus
+    },
+    fetch: {
+      jinaBaseUrl: config.fetch.jinaBaseUrl,
+      enablePlaywright: config.fetch.enablePlaywright,
+      userAgent: config.fetch.userAgent,
+      timeoutMs: config.fetch.timeoutMs
+    }
+  };
+  if (json) {
+    write(JSON.stringify(status, null, 2) + "\n");
+    return 0;
+  }
+  const lines = [];
+  lines.push("\u2550\u2550\u2550 Web \u5DE5\u5177\u914D\u7F6E\u751F\u6548\u72B6\u6001 \u2550\u2550\u2550");
+  lines.push("");
+  lines.push("\u2500\u2500 \u4EE3\u7406 \u2500\u2500");
+  lines.push(`  \u5730\u5740\uFF1A${proxy ?? "\uFF08\u76F4\u8FDE\uFF09"}`);
+  lines.push(`  \u6765\u6E90\uFF1A${proxySource}`);
+  if (config.network.noProxy) lines.push(`  NO_PROXY\uFF1A${config.network.noProxy}`);
+  lines.push("");
+  lines.push("\u2500\u2500 web_search \u540E\u7AEF\u94FE \u2500\u2500");
+  for (const b of backendStatus) {
+    const mark = b.available ? "\u2713" : "\u2717";
+    const note = b.available ? "\u53EF\u7528" : "\u4E0D\u53EF\u7528\uFF08\u7F3A API key \u6216\u672A\u914D\u7F6E\uFF09";
+    lines.push(`  ${mark} ${b.name} \u2014 ${note}`);
+  }
+  lines.push(`  \u8D85\u65F6\uFF1A${config.search.timeoutMs}ms`);
+  if (config.search.region) lines.push(`  \u533A\u57DF\uFF1A${config.search.region}`);
+  lines.push("");
+  lines.push("\u2500\u2500 web_fetch \u2500\u2500");
+  lines.push(`  Jina Reader\uFF1A${config.fetch.jinaBaseUrl}`);
+  lines.push(`  Playwright \u6E32\u67D3\uFF1A${config.fetch.enablePlaywright ? "\u5F00" : "\u5173"}`);
+  lines.push(`  User-Agent\uFF1A${config.fetch.userAgent}`);
+  lines.push(`  \u8D85\u65F6\uFF1A${config.fetch.timeoutMs}ms`);
+  lines.push("");
+  lines.push("\u63D0\u793A\uFF1A\u7528 `rivet web search <query>` / `rivet web fetch <url>` \u5B9E\u6D4B\u8FDE\u901A\u6027\u3002");
+  write(lines.join("\n") + "\n");
+  return 0;
+}
+function clampInt(raw, min, max, fallback) {
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(Math.max(n, min), max);
+}
+function formatSearchResultText(query, result, proxy) {
+  const lines = [];
+  lines.push(`\u641C\u7D22\uFF1A\u300C${query}\u300D`);
+  lines.push(`\u4EE3\u7406\uFF1A${proxy ?? "\u76F4\u8FDE"}`);
+  lines.push("");
+  if (result.errors.length > 0) {
+    lines.push("\u540E\u7AEF\u94FE\u8DEF\uFF1A");
+    for (const e of result.errors) lines.push(`  \u2717 ${e.backend}: ${e.message}`);
+  }
+  if (result.backend) lines.push(`  \u2713 ${result.backend} \u547D\u4E2D ${result.results.length} \u6761`);
+  lines.push("");
+  if (result.results.length === 0) {
+    lines.push("\u672A\u627E\u5230\u7ED3\u679C\uFF08\u6240\u6709\u540E\u7AEF\u5747\u65E0\u7ED3\u679C\u6216\u5931\u8D25\uFF09\u3002");
+    return lines.join("\n");
+  }
+  for (let i = 0; i < result.results.length; i++) {
+    const r = result.results[i];
+    lines.push(`${i + 1}. ${r.title}`);
+    lines.push(`   ${r.url}`);
+    if (r.snippet) lines.push(`   ${r.snippet}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+export {
+  formatSearchResultText,
+  runWebCLI
+};

package/dist/web-search-3IK542AA.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  WEB_SEARCH_TOOL,
+  createWebSearchTool
+} from "./chunk-JRF5L6OD.js";
+import {
+  runBackendChain
+} from "./chunk-EBJTVRQN.js";
+import {
+  BingBackend,
+  BraveBackend,
+  DuckDuckGoBackend,
+  TavilyBackend,
+  buildSearchBackends,
+  decodeHtmlEntities,
+  parseDuckDuckGoResults
+} from "./chunk-J4U4AW46.js";
+import "./chunk-2HDP7RMR.js";
+import "./chunk-O5VZQKCB.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  BingBackend,
+  BraveBackend,
+  DuckDuckGoBackend,
+  TavilyBackend,
+  WEB_SEARCH_TOOL,
+  buildSearchBackends,
+  createWebSearchTool,
+  decodeHtmlEntities,
+  parseDuckDuckGoResults,
+  runBackendChain
+};

package/dist/workers/cpu-worker.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  astEditComputeRaw,
+  astScanRaw,
+  diffLinesRaw,
+  diffStructuredRaw,
+  diffUnifiedRaw,
+  esbuildTransformRaw,
+  parseEventsJsonlRaw,
+  parseEventsTailRaw
+} from "../chunk-EGEI2RQA.js";
+import {
+  init_esm_shims
+} from "../chunk-5GGOGLSN.js";
+
+// src/workers/cpu-worker.ts
+init_esm_shims();
+import { parentPort } from "worker_threads";
+var tasks = {
+  diffUnifiedRaw,
+  diffStructuredRaw,
+  diffLinesRaw,
+  parseEventsJsonlRaw,
+  parseEventsTailRaw,
+  esbuildTransformRaw,
+  astScanRaw,
+  astEditComputeRaw
+};
+parentPort?.on("message", (msg) => {
+  const fn = tasks[msg.task];
+  if (!fn) {
+    parentPort?.postMessage({ id: msg.id, ok: false, error: `unknown task: ${msg.task}` });
+    return;
+  }
+  Promise.resolve().then(() => fn(...msg.args)).then((result) => {
+    parentPort?.postMessage({ id: msg.id, ok: true, result });
+  }).catch((err) => {
+    parentPort?.postMessage({
+      id: msg.id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  });
+});

package/dist/workflow-runner-HX7UBAYG.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  init_paths,
+  workflowsDir
+} from "./chunk-BCQXEZPJ.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/agent/workflow-runner.ts
+init_esm_shims();
+init_paths();
+import { readFileSync, existsSync, readdirSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+var WORKFLOWS_DIR = ".rivet/workflows";
+var TRACES_DIR = ".rivet/traces";
+function parseWorkflow(yaml) {
+  const lines = yaml.split("\n");
+  const def = { name: "", steps: [] };
+  let currentStep = null;
+  let inInputs = false;
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\r$/, "");
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const nameMatch = line.match(/^name:\s*(.+)$/);
+    if (nameMatch) {
+      def.name = nameMatch[1].trim();
+      continue;
+    }
+    const descMatch = line.match(/^description:\s*(.+)$/);
+    if (descMatch) {
+      def.description = descMatch[1].trim();
+      continue;
+    }
+    if (/^inputs:\s*$/.test(line)) {
+      inInputs = true;
+      def.inputs = {};
+      continue;
+    }
+    if (inInputs && /^[a-z]/.test(line.trim()) && !line.startsWith(" ")) {
+      inInputs = false;
+    }
+    if (inInputs) {
+      const m = line.trim().match(/^(\w+):\s*(.+)$/);
+      if (m) def.inputs[m[1]] = m[2].trim();
+      continue;
+    }
+    if (/^steps:\s*$/.test(line)) {
+      continue;
+    }
+    const stepMatch = line.match(/^\s*- (?:id:\s*)?(\w+)/);
+    if (stepMatch) {
+      if (currentStep) def.steps.push(currentStep);
+      currentStep = { id: stepMatch[1], tool: "", input: {} };
+      const toolOnSameLine = line.match(/tool:\s*(\S+)/);
+      if (toolOnSameLine) currentStep.tool = toolOnSameLine[1].replace(/['"]/g, "");
+      continue;
+    }
+    if (currentStep && line.startsWith("    ")) {
+      const trimmed = line.trim();
+      const toolMatch = trimmed.match(/^tool:\s*(.+)$/);
+      if (toolMatch) {
+        currentStep.tool = toolMatch[1].trim().replace(/['"]/g, "");
+        continue;
+      }
+      const dependsMatch = trimmed.match(/^depends_on:\s*\[(.*)\]$/);
+      if (dependsMatch) {
+        currentStep.depends_on = dependsMatch[1].split(",").map((s) => s.trim().replace(/['"]/g, "")).filter(Boolean);
+        continue;
+      }
+      const onFailureMatch = trimmed.match(/^on_failure:\s*(.+)$/);
+      if (onFailureMatch) {
+        currentStep.on_failure = onFailureMatch[1].trim().replace(/['"]/g, "");
+        continue;
+      }
+      const conditionMatch = trimmed.match(/^condition:\s*(.+)$/);
+      if (conditionMatch) {
+        currentStep.condition = conditionMatch[1].trim();
+        continue;
+      }
+      const inputMatch = trimmed.match(/^(\w+):\s*(.*)$/);
+      if (inputMatch) {
+        const key = inputMatch[1];
+        let val = inputMatch[2].trim().replace(/^["']|["']$/g, "");
+        if (val === "true") val = true;
+        else if (val === "false") val = false;
+        else if (/^\d+$/.test(val)) val = parseInt(val, 10);
+        if (!currentStep.input) currentStep.input = {};
+        currentStep.input[key] = val;
+      }
+    }
+  }
+  if (currentStep) def.steps.push(currentStep);
+  if (!def.name) throw new Error("Workflow must have a name");
+  if (def.steps.length === 0) throw new Error("Workflow must have at least one step");
+  for (const s of def.steps) {
+    if (!s.tool) throw new Error(`Step "${s.id}" must have a tool`);
+  }
+  return def;
+}
+function resolveVars(value, ctx) {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([^}]+)\}/g, (match, ref) => {
+      const parts = ref.split(".");
+      if (parts.length === 1) {
+        const val = ctx.inputs[parts[0]];
+        return val !== void 0 ? String(val) : match;
+      }
+      const [stepId, ...fieldParts] = parts;
+      const stepResult = ctx.stepResults[stepId];
+      if (!stepResult) return match;
+      const fieldVal = fieldParts.reduce((acc, k) => acc && typeof acc === "object" ? acc[k] : void 0, stepResult);
+      return fieldVal !== void 0 ? String(fieldVal) : match;
+    });
+  }
+  if (Array.isArray(value)) return value.map((v) => resolveVars(v, ctx));
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) result[k] = resolveVars(v, ctx);
+    return result;
+  }
+  return value;
+}
+function topoSort(steps) {
+  const sorted = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(step) {
+    if (visited.has(step.id)) return;
+    if (visiting.has(step.id)) throw new Error(`Circular dependency at step "${step.id}"`);
+    visiting.add(step.id);
+    for (const depId of step.depends_on ?? []) {
+      const dep = steps.find((s) => s.id === depId);
+      if (!dep) throw new Error(`Step "${step.id}" depends on unknown step "${depId}"`);
+      visit(dep);
+    }
+    visiting.delete(step.id);
+    visited.add(step.id);
+    sorted.push(step);
+  }
+  for (const s of steps) visit(s);
+  return sorted;
+}
+async function runWorkflow(def, inputs, cwd, executor, onProgress) {
+  const MAX_RETRIES = 3;
+  const traceId = `wf-${def.name}-${Date.now().toString(36)}`;
+  const trace = {
+    workflowName: def.name,
+    traceId,
+    startedAt: Date.now(),
+    inputs,
+    steps: [],
+    finalStatus: "pending"
+  };
+  const ctx = { inputs, stepResults: {}, cwd, onProgress };
+  const ordered = topoSort(def.steps);
+  let i = 0;
+  let retries = 0;
+  while (i < ordered.length) {
+    const step = ordered[i];
+    const stepTrace = {
+      stepId: step.id,
+      tool: step.tool,
+      status: "running",
+      startedAt: Date.now()
+    };
+    if (step.condition) {
+      const resolvedCondition = resolveVars(step.condition, ctx);
+      if (resolvedCondition === "false" || resolvedCondition === false) {
+        stepTrace.status = "skipped";
+        stepTrace.endedAt = Date.now();
+        trace.steps.push(stepTrace);
+        onProgress?.(step.id, "skipped");
+        i++;
+        continue;
+      }
+    }
+    onProgress?.(step.id, "running");
+    const resolvedInput = resolveVars(step.input ?? {}, ctx);
+    try {
+      stepTrace.input = resolvedInput;
+      const result = await executor(step.tool, resolvedInput, ctx);
+      stepTrace.output = result.output?.slice(0, 2e3);
+      stepTrace.error = result.error;
+      stepTrace.status = result.error ? "failed" : "done";
+      stepTrace.endedAt = Date.now();
+      stepTrace.durationMs = stepTrace.endedAt - stepTrace.startedAt;
+      ctx.stepResults[step.id] = { output: result.output, ...result.error ? { error: result.error } : {} };
+      trace.steps.push(stepTrace);
+      onProgress?.(step.id, stepTrace.status);
+      if (result.error && step.on_failure && retries < MAX_RETRIES) {
+        const targetIdx = ordered.findIndex((s) => s.id === step.on_failure);
+        if (targetIdx >= 0) {
+          retries++;
+          i = targetIdx;
+          continue;
+        }
+      }
+      if (result.error) {
+        trace.finalStatus = "failed";
+        trace.endedAt = Date.now();
+        trace.totalDurationMs = trace.endedAt - trace.startedAt;
+        return trace;
+      }
+    } catch (err) {
+      stepTrace.status = "failed";
+      stepTrace.error = err instanceof Error ? err.message : String(err);
+      stepTrace.endedAt = Date.now();
+      stepTrace.durationMs = stepTrace.endedAt - stepTrace.startedAt;
+      trace.steps.push(stepTrace);
+      onProgress?.(step.id, "failed");
+      trace.finalStatus = "failed";
+      trace.endedAt = Date.now();
+      trace.totalDurationMs = trace.endedAt - trace.startedAt;
+      return trace;
+    }
+    i++;
+  }
+  const lastByStep = /* @__PURE__ */ new Map();
+  for (const s of trace.steps) lastByStep.set(s.stepId, s);
+  trace.finalStatus = [...lastByStep.values()].every((s) => s.status === "done" || s.status === "skipped") ? "done" : "failed";
+  trace.endedAt = Date.now();
+  trace.totalDurationMs = trace.endedAt - trace.startedAt;
+  return trace;
+}
+function loadWorkflow(cwd, name) {
+  const paths = [
+    join(cwd, WORKFLOWS_DIR, `${name}.yaml`),
+    join(cwd, WORKFLOWS_DIR, `${name}.yml`),
+    join(workflowsDir(), `${name}.yaml`)
+  ];
+  for (const p of paths) {
+    if (existsSync(p)) return parseWorkflow(readFileSync(p, "utf-8"));
+  }
+  return null;
+}
+function listWorkflows(cwd) {
+  const names = /* @__PURE__ */ new Set();
+  for (const dir of [join(cwd, WORKFLOWS_DIR), workflowsDir()]) {
+    if (existsSync(dir)) {
+      for (const f of readdirSync(dir)) {
+        if (f.endsWith(".yaml") || f.endsWith(".yml")) names.add(f.replace(/\.ya?ml$/, ""));
+      }
+    }
+  }
+  return [...names].sort();
+}
+function saveTrace(cwd, trace) {
+  const dir = join(cwd, TRACES_DIR);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${trace.traceId}.json`), JSON.stringify(trace, null, 2), "utf-8");
+}
+function loadTrace(cwd, traceId) {
+  const p = join(cwd, TRACES_DIR, `${traceId}.json`);
+  if (!existsSync(p)) return null;
+  return JSON.parse(readFileSync(p, "utf-8"));
+}
+function listTraces(cwd, limit = 10) {
+  const dir = join(cwd, TRACES_DIR);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => {
+    try {
+      return JSON.parse(readFileSync(join(dir, f), "utf-8"));
+    } catch {
+      return null;
+    }
+  }).filter((t) => t !== null).sort((a, b) => b.startedAt - a.startedAt).slice(0, limit);
+}
+function formatTrace(trace) {
+  const lines = [
+    `Workflow: ${trace.workflowName}  (${trace.traceId})`,
+    `Status: ${trace.finalStatus}  Duration: ${trace.totalDurationMs ? `${(trace.totalDurationMs / 1e3).toFixed(1)}s` : "\u2014"}`,
+    `Started: ${new Date(trace.startedAt).toLocaleString()}`,
+    "",
+    "Steps:"
+  ];
+  for (const s of trace.steps) {
+    const glyph = s.status === "done" ? "\u2713" : s.status === "failed" ? "\u2717" : s.status === "skipped" ? "\u2298" : s.status === "running" ? "\u25D0" : "\u25CC";
+    const dur = s.durationMs ? `${(s.durationMs / 1e3).toFixed(1)}s` : "\u2014";
+    lines.push(`  ${glyph} ${s.stepId} (${s.tool})  ${dur}`);
+    if (s.error) lines.push(`    error: ${s.error}`);
+  }
+  return lines.join("\n");
+}
+export {
+  formatTrace,
+  listTraces,
+  listWorkflows,
+  loadTrace,
+  loadWorkflow,
+  parseWorkflow,
+  resolveVars,
+  runWorkflow,
+  saveTrace,
+  topoSort
+};

package/dist/worktree-baseline-O5NCU6M2.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  createWorktreeBaseline
+} from "./chunk-D2TCGRSX.js";
+import "./chunk-5GGOGLSN.js";
+export {
+  createWorktreeBaseline
+};