@bastani/atomic 0.9.63 → 0.9.64

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -558,6 +558,502 @@ var init_store_backend = __esm(() => {
   };
 });
 
+// dist/builtin/workflows/src/runs/shared/prompt-callsite.ts
+import { fileURLToPath } from "node:url";
+function normalizeSlashes(path) {
+  return path.replace(/\\/g, "/");
+}
+function normalizeStackPath(framePath) {
+  let normalized = framePath;
+  if (normalized.startsWith("file://")) {
+    try {
+      normalized = fileURLToPath(normalized);
+    } catch {
+      try {
+        normalized = decodeURIComponent(new URL(normalized).pathname);
+      } catch {}
+    }
+  }
+  normalized = normalizeSlashes(normalized).replace(/^\/([A-Za-z]:\/)/, "$1");
+  return normalized;
+}
+function currentModuleRuntimeRoot() {
+  const modulePath = normalizeStackPath(fileURLToPath(import.meta.url));
+  const markers = ["packages/workflows/src/", ...PACKAGED_WORKFLOW_RUNTIME_ROOTS.map((root) => root.slice(1))];
+  for (const marker of markers) {
+    const index = modulePath.indexOf(marker);
+    if (index >= 0)
+      return modulePath.slice(0, index + marker.length);
+  }
+  return;
+}
+function isWorkflowRuntimeFrame(normalizedPath) {
+  const path = normalizeSlashes(normalizedPath);
+  if (path.startsWith("packages/workflows/src/"))
+    return true;
+  if (CURRENT_WORKFLOW_RUNTIME_ROOT !== undefined && path.startsWith(CURRENT_WORKFLOW_RUNTIME_ROOT)) {
+    return true;
+  }
+  const comparable = path.startsWith("/") ? path : `/${path}`;
+  return PACKAGED_WORKFLOW_RUNTIME_ROOTS.some((runtimeRoot) => comparable.includes(runtimeRoot));
+}
+function parsePromptStackFrame(stackLine) {
+  const line = stackLine.trim();
+  if (line.length === 0)
+    return;
+  if (line.includes("node:internal") || line.includes("bun:") || line.includes("(native:"))
+    return;
+  const match = line.match(/(\S+):(\d+):(\d+)\)?$/);
+  if (!match)
+    return;
+  const [, rawFramePath, lineNumber, columnNumber] = match;
+  if (rawFramePath === undefined || lineNumber === undefined || columnNumber === undefined)
+    return;
+  const normalizedPath = normalizeStackPath(rawFramePath.replace(/^\(/, ""));
+  return { normalizedPath, lineNumber, columnNumber };
+}
+function normalizedPromptCallsiteFrame(stackLine) {
+  const frame = parsePromptStackFrame(stackLine);
+  if (frame === undefined)
+    return;
+  if (isWorkflowRuntimeFrame(frame.normalizedPath))
+    return;
+  return `${frame.normalizedPath}:${frame.lineNumber}:${frame.columnNumber}`;
+}
+function selectPromptCallsiteFrame(stack) {
+  return stack.split(`
+`).slice(1).map(normalizedPromptCallsiteFrame).find((candidate) => candidate !== undefined);
+}
+var PACKAGED_WORKFLOW_RUNTIME_ROOTS, CURRENT_WORKFLOW_RUNTIME_ROOT;
+var init_prompt_callsite = __esm(() => {
+  PACKAGED_WORKFLOW_RUNTIME_ROOTS = ["/dist/builtin/workflows/src/"];
+  CURRENT_WORKFLOW_RUNTIME_ROOT = currentModuleRuntimeRoot();
+});
+
+// dist/builtin/workflows/src/shared/workflow-source.ts
+function isWorkflowRuntimeModule(path) {
+  const normalized = normalizeStackPath(path);
+  return normalized === OWN_MODULE_PATH || isWorkflowRuntimeFrame(normalized);
+}
+function recordWorkflowSource(definition, path) {
+  WORKFLOW_SOURCES.set(definition, path);
+}
+function workflowSource(definition) {
+  return WORKFLOW_SOURCES.get(definition);
+}
+var WORKFLOW_SOURCES, OWN_MODULE_PATH;
+var init_workflow_source = __esm(() => {
+  init_prompt_callsite();
+  WORKFLOW_SOURCES = new WeakMap;
+  OWN_MODULE_PATH = normalizeStackPath(import.meta.url);
+});
+
+// dist/builtin/workflows/src/engine/run-rejection-boundary.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { inspect } from "node:util";
+import { isStaleExtensionContextError } from "@bastani/atomic";
+function boundaryBag() {
+  return globalThis;
+}
+function sharedBoundary() {
+  const bag = boundaryBag();
+  const existing = bag[BOUNDARY_KEY];
+  if (existing !== undefined && existing.version === 5)
+    return existing;
+  const created = {
+    version: 5,
+    store: new AsyncLocalStorage,
+    owners: new WeakMap,
+    promises: new WeakMap,
+    scopes: new Set,
+    runs: new Map,
+    ended: new Map,
+    stops: new Set,
+    listener: undefined
+  };
+  bag[BOUNDARY_KEY] = created;
+  return created;
+}
+function isObject(value2) {
+  return typeof value2 === "object" && value2 !== null || typeof value2 === "function";
+}
+function isPrimitive(value2) {
+  return !isObject(value2);
+}
+function safeField(value2, key) {
+  try {
+    return value2[key];
+  } catch {
+    return;
+  }
+}
+function strongerEffect(left, right) {
+  return left === "fail-run" || right === "fail-run" ? "fail-run" : "ignore";
+}
+function addAttribution(into, scope, effect) {
+  into.set(scope, strongerEffect(into.get(scope), effect));
+}
+function recordedOwners(boundary, reason) {
+  const owners = new Map;
+  let stopped = false;
+  const seen = new Set;
+  const pending = [{ value: reason, depth: 0 }];
+  while (pending.length > 0) {
+    const { value: value2, depth } = pending.pop();
+    if (depth > MAX_CAUSE_DEPTH)
+      continue;
+    if (isPrimitive(value2)) {
+      if (depth === 0 || value2 !== undefined && value2 !== null) {
+        for (const scope of boundary.scopes) {
+          const entry = scope.primitives.get(value2);
+          if (entry !== undefined)
+            addAttribution(owners, scope, entry.effect);
+        }
+        if (typeof value2 === "string" && boundary.stops.has(value2))
+          stopped = true;
+      }
+      continue;
+    }
+    if (seen.has(value2))
+      continue;
+    seen.add(value2);
+    for (const [scope, effect] of boundary.owners.get(value2) ?? [])
+      addAttribution(owners, scope, effect);
+    pending.push({ value: safeField(value2, "cause"), depth: depth + 1 });
+    const errors = safeField(value2, "errors");
+    if (Array.isArray(errors))
+      for (const entry of errors)
+        pending.push({ value: entry, depth: depth + 1 });
+  }
+  return { owners, stopped };
+}
+function pruneEndedSources(boundary) {
+  const now = Date.now();
+  for (const [source, trees] of boundary.ended) {
+    for (const [rootRunId, endedAt] of trees)
+      if (now - endedAt > ENDED_RUN_GRACE_MS)
+        trees.delete(rootRunId);
+    if (trees.size === 0)
+      boundary.ended.delete(source);
+  }
+}
+function recordEndedRun(boundary, scope) {
+  if (scope.source === undefined)
+    return;
+  const trees = boundary.ended.get(scope.source) ?? new Map;
+  trees.set(scope.rootRunId, Date.now());
+  boundary.ended.set(scope.source, trees);
+}
+function endedInAnotherRunTree(boundary, source, live) {
+  for (const endedRoot of boundary.ended.get(source)?.keys() ?? [])
+    if (endedRoot !== live.rootRunId)
+      return true;
+  return false;
+}
+function recognizedSources(boundary) {
+  pruneEndedSources(boundary);
+  const sources = new Set(boundary.ended.keys());
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source !== undefined)
+      sources.add(scope.source);
+  return sources;
+}
+function authoringSource(reason, sources) {
+  if (sources.size === 0 || !isObject(reason))
+    return;
+  const stack = safeField(reason, "stack");
+  if (typeof stack !== "string")
+    return;
+  for (const line of stack.split(`
+`)) {
+    if (!line.trimStart().startsWith("at "))
+      continue;
+    const path = parsePromptStackFrame(line)?.normalizedPath;
+    if (path === undefined)
+      continue;
+    if (isWorkflowRuntimeModule(path))
+      return;
+    if (/\/node_modules\//.test(path))
+      continue;
+    if (sources.has(path))
+      return path;
+  }
+  return;
+}
+function hasAncestorIn(scope, candidates) {
+  for (let ancestor = scope.parent;ancestor !== undefined; ancestor = ancestor.parent) {
+    if (candidates.has(ancestor))
+      return true;
+  }
+  return false;
+}
+function outermostLiveRuns(boundary, source) {
+  const matching = new Set;
+  for (const scope of boundary.scopes)
+    if (scope.live && scope.source === source)
+      matching.add(scope);
+  const outermost = new Set;
+  for (const scope of matching)
+    if (!hasAncestorIn(scope, matching))
+      outermost.add(scope);
+  return outermost;
+}
+function runOfSource(boundary, source) {
+  const [only, ...others] = outermostLiveRuns(boundary, source);
+  if (only === undefined)
+    return new Map;
+  if (others.length > 0 || only.sharedSource)
+    return;
+  if (endedInAnotherRunTree(boundary, source, only))
+    return;
+  return new Map([[only, "fail-run"]]);
+}
+function markSharedSource(boundary, source) {
+  const runs = outermostLiveRuns(boundary, source);
+  if (runs.size > 1)
+    for (const run of runs)
+      run.sharedSource = true;
+}
+function rejectingRun(boundary, recorded, promise, scoped) {
+  const tracked = promise === undefined ? undefined : boundary.promises.get(promise);
+  if (tracked !== undefined && recorded.has(tracked))
+    return tracked;
+  if (scoped !== undefined && recorded.has(scoped))
+    return scoped;
+  return;
+}
+function attribute(boundary, reason, promise) {
+  const { owners: recorded, stopped } = recordedOwners(boundary, reason);
+  const scoped = boundary.store.getStore();
+  if (recorded.size > 1) {
+    const rejecting = rejectingRun(boundary, recorded, promise, scoped);
+    if (rejecting !== undefined)
+      return new Map([[rejecting, recorded.get(rejecting) ?? "fail-run"]]);
+  }
+  if (recorded.size > 0)
+    return recorded;
+  if (stopped)
+    return new Map;
+  if (scoped !== undefined && boundary.scopes.has(scoped))
+    return new Map([[scoped, "fail-run"]]);
+  const origin = authoringSource(reason, recognizedSources(boundary));
+  if (origin === undefined)
+    return;
+  if (scoped !== undefined)
+    return new Map([[scoped, "ignore"]]);
+  return runOfSource(boundary, origin);
+}
+function unhandledRejectionError(reason) {
+  return Object.assign(new Error("This error originated either by throwing inside of an async function without a catch block, " + `or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${inspect(reason)}".`), { code: "ERR_UNHANDLED_REJECTION" });
+}
+function unhandledRejectionsMode() {
+  const args = [...(process.env.NODE_OPTIONS ?? "").split(/\s+/), ...process.execArgv];
+  let mode = "throw";
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index] ?? "";
+    if (arg.startsWith(`${FLAG}=`))
+      mode = arg.slice(FLAG.length + 1);
+    else if (arg === FLAG && args[index + 1] !== undefined)
+      mode = args[index + 1] ?? mode;
+  }
+  return mode;
+}
+function surfaceNatively(boundary, reason) {
+  const listener = boundary.listener;
+  if (listener === undefined || process.listenerCount(EVENT) > 1)
+    return;
+  if (!NATIVE_REPORTING_MODES.has(unhandledRejectionsMode()))
+    return;
+  process.nextTick(() => {
+    process.removeListener(EVENT, listener);
+    Promise.reject(reason);
+    setImmediate(() => {
+      if (!process.listeners(EVENT).includes(listener))
+        process.on(EVENT, listener);
+    });
+  });
+}
+function onUnhandledRejection(reason, promise) {
+  const boundary = sharedBoundary();
+  const owners = attribute(boundary, reason, promise);
+  if (owners === undefined) {
+    surfaceNatively(boundary, reason);
+    return;
+  }
+  const error = isObject(reason) ? reason : unhandledRejectionError(reason);
+  const staleExtensionContext = isStaleExtensionContextError(error);
+  for (const [scope, effect] of owners) {
+    if (effect !== "fail-run" || !scope.live)
+      continue;
+    if (staleExtensionContext) {
+      console.error(`atomic-workflows: run ${scope.runId} ignored a stale extension-context rejection`, error);
+      continue;
+    }
+    try {
+      scope.fail(error);
+    } catch {}
+  }
+}
+function ensureInstalled(boundary) {
+  if (boundary.listener !== undefined)
+    return;
+  boundary.listener = onUnhandledRejection;
+  process.on(EVENT, onUnhandledRejection);
+}
+function record(boundary, scope, reason, effect) {
+  if (isPrimitive(reason)) {
+    recordPrimitive(scope, reason, effect);
+    return;
+  }
+  const owners = boundary.owners.get(reason);
+  if (owners === undefined)
+    boundary.owners.set(reason, new Map([[scope, effect]]));
+  else
+    addAttribution(owners, scope, effect);
+}
+function recordStop(boundary, reason) {
+  boundary.stops.delete(reason);
+  boundary.stops.add(reason);
+  if (boundary.stops.size <= MAX_STOP_STRINGS)
+    return;
+  const oldest = boundary.stops.values().next();
+  if (!oldest.done)
+    boundary.stops.delete(oldest.value);
+}
+function recordPrimitive(scope, reason, effect) {
+  if (!scope.live)
+    return;
+  if (scope.primitives.size >= MAX_PRIMITIVES_PER_RUN && !scope.primitives.has(reason)) {
+    const oldest = scope.primitives.keys().next();
+    if (!oldest.done)
+      scope.primitives.delete(oldest.value);
+  }
+  scope.generation += 1;
+  const generation = scope.generation;
+  scope.primitives.set(reason, { effect: strongerEffect(scope.primitives.get(reason)?.effect, effect), generation });
+  afterPendingRejectionReports().then(() => {
+    if (scope.primitives.get(reason)?.generation === generation)
+      scope.primitives.delete(reason);
+  });
+}
+function discardFailure() {}
+function afterPendingRejectionReports() {
+  return new Promise((resolve) => {
+    const { port1, port2 } = new MessageChannel;
+    port1.onmessage = () => {
+      port1.close();
+      port2.close();
+      resolve();
+    };
+    port2.postMessage(undefined);
+  });
+}
+function currentRunConsole() {
+  return sharedBoundary().store.getStore()?.console;
+}
+function openRunRejectionScope(options) {
+  const boundary = sharedBoundary();
+  ensureInstalled(boundary);
+  pruneEndedSources(boundary);
+  const parent = options.parentRunId === undefined ? undefined : boundary.runs.get(options.parentRunId);
+  const rootRunId = parent?.rootRunId ?? options.runId;
+  const scope = {
+    runId: options.runId,
+    rootRunId,
+    source: options.source === undefined ? undefined : normalizeStackPath(options.source),
+    parent,
+    fail: options.fail,
+    primitives: new Map,
+    generation: 0,
+    live: true,
+    sharedSource: false,
+    console: parent !== undefined ? parent.console : options.consoleLog === true ? { rootRunId, bytes: 0, capped: false, announced: false } : undefined
+  };
+  boundary.scopes.add(scope);
+  boundary.runs.set(scope.runId, scope);
+  if (scope.source !== undefined)
+    markSharedSource(boundary, scope.source);
+  return {
+    run: (callback) => boundary.store.run(scope, callback),
+    contain: (promise, effect = "fail-run") => {
+      boundary.promises.set(promise, scope);
+      promise.then(undefined, (reason) => record(boundary, scope, reason, effect));
+      return promise;
+    },
+    watch: (promise) => {
+      const watched = promise.then(undefined, (reason) => {
+        record(boundary, scope, reason, "fail-run");
+        throw reason;
+      });
+      boundary.promises.set(watched, scope);
+      return watched;
+    },
+    ignore: (reason) => {
+      if (typeof reason === "string")
+        recordStop(boundary, reason);
+      else
+        record(boundary, scope, reason, "ignore");
+    },
+    settle: afterPendingRejectionReports,
+    close: () => {
+      scope.live = false;
+      scope.fail = discardFailure;
+      recordEndedRun(boundary, scope);
+      afterPendingRejectionReports().then(() => {
+        scope.primitives.clear();
+        scope.parent = undefined;
+        boundary.scopes.delete(scope);
+        if (boundary.runs.get(scope.runId) === scope)
+          boundary.runs.delete(scope.runId);
+      });
+    }
+  };
+}
+function containStageRejections(stage, scope) {
+  const contained = Object.create(stage);
+  const descriptors = {};
+  for (const name of WATCHED_STAGE_METHODS) {
+    descriptors[name] = {
+      value: (...args) => {
+        const result = Reflect.apply(stage[name], stage, args);
+        return result instanceof Promise ? scope.watch(result) : result;
+      }
+    };
+  }
+  Object.defineProperties(contained, descriptors);
+  return contained;
+}
+function containUiRejections(ui, scope) {
+  return {
+    input: (prompt) => scope.watch(ui.input(prompt)),
+    confirm: (message) => scope.watch(ui.confirm(message)),
+    select: (message, options) => scope.watch(ui.select(message, options)),
+    editor: (initial) => scope.watch(ui.editor(initial)),
+    custom: (factory, options) => scope.watch(ui.custom(factory, options))
+  };
+}
+var EVENT = "unhandledRejection", BOUNDARY_KEY, FLAG = "--unhandled-rejections", MAX_CAUSE_DEPTH = 8, MAX_PRIMITIVES_PER_RUN = 64, MAX_STOP_STRINGS = 64, ENDED_RUN_GRACE_MS = 30000, NATIVE_REPORTING_MODES, WATCHED_STAGE_METHODS;
+var init_run_rejection_boundary = __esm(() => {
+  init_prompt_callsite();
+  init_workflow_source();
+  BOUNDARY_KEY = Symbol.for("atomic-workflows/run-rejection-boundary@5");
+  NATIVE_REPORTING_MODES = new Set(["throw", "warn-with-error-code"]);
+  WATCHED_STAGE_METHODS = [
+    "prompt",
+    "complete",
+    "sendUserMessage",
+    "steer",
+    "followUp",
+    "setModel",
+    "setThinkingLevel",
+    "cycleModel",
+    "cycleThinkingLevel",
+    "navigateTree",
+    "compact",
+    "abort"
+  ];
+});
+
 // dist/builtin/workflows/src/shared/flat-string.ts
 function flattenTruncatedString(value2) {
   return value2.split("").join("");
@@ -5419,32 +5915,36 @@ var init_workflow_tool_abort = __esm(() => {
 });
 
 // dist/builtin/workflows/src/engine/run-tool-control-registry.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 function createToolControlRegistry() {
   const byRun = new Map;
   const admissionByRun = new Map;
   const runControls = new Map;
-  const makeHandle = (registration) => ({
-    runId: registration.runId,
-    nodeId: registration.nodeId,
-    name: registration.name,
-    settled: registration.settled,
-    get aborted() {
-      return registration.controller.signal.aborted;
-    },
-    abort(scope) {
-      const existing = registration.controller.signal.reason;
-      if (registration.controller.signal.aborted && existing instanceof WorkflowToolAbortError)
-        return existing;
-      const reason = new WorkflowToolAbortError({
-        runId: registration.runId,
-        nodeId: registration.nodeId,
-        toolName: registration.name,
-        scope
-      });
-      registration.controller.abort(reason);
-      return reason;
-    }
-  });
+  const makeHandle = (registration) => {
+    const inRegisteringContext = AsyncLocalStorage2.snapshot();
+    return {
+      runId: registration.runId,
+      nodeId: registration.nodeId,
+      name: registration.name,
+      settled: registration.settled,
+      get aborted() {
+        return registration.controller.signal.aborted;
+      },
+      abort(scope) {
+        const existing = registration.controller.signal.reason;
+        if (registration.controller.signal.aborted && existing instanceof WorkflowToolAbortError)
+          return existing;
+        const reason = new WorkflowToolAbortError({
+          runId: registration.runId,
+          nodeId: registration.nodeId,
+          toolName: registration.name,
+          scope
+        });
+        inRegisteringContext(() => registration.controller.abort(reason));
+        return reason;
+      }
+    };
+  };
   return {
     register(registration) {
       let runMap = byRun.get(registration.runId);
@@ -5956,11 +6456,11 @@ function canonicalJsonString(value2) {
 var init_durable_hash = () => {};
 
 // dist/builtin/workflows/src/durable/backend.ts
-import { closeSync, openSync, readSync } from "node:fs";
+import { closeSync as closeSync2, openSync as openSync2, readSync } from "node:fs";
 function readSessionHeaderId(sessionFile) {
   let fd;
   try {
-    fd = openSync(sessionFile, "r");
+    fd = openSync2(sessionFile, "r");
   } catch {
     return;
   }
@@ -5974,7 +6474,7 @@ function readSessionHeaderId(sessionFile) {
   } catch {
     return;
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 }
 function migrateStageSessionCheckpoint(checkpoint) {
@@ -6740,96 +7240,6 @@ function resolve_budget(layers) {
 // dist/builtin/workflows/src/shared/workflow-heartbeat-contract.ts
 var DEFAULT_WORKFLOW_HEARTBEAT_INTERVAL_MINUTES = 15, WORKFLOW_HEARTBEAT_CUSTOM_TYPE = "workflows:workflow-heartbeat";
 
-// dist/builtin/workflows/src/runs/shared/prompt-callsite.ts
-import { fileURLToPath } from "node:url";
-function normalizeSlashes(path) {
-  return path.replace(/\\/g, "/");
-}
-function normalizeStackPath(framePath) {
-  let normalized = framePath;
-  if (normalized.startsWith("file://")) {
-    try {
-      normalized = fileURLToPath(normalized);
-    } catch {
-      try {
-        normalized = decodeURIComponent(new URL(normalized).pathname);
-      } catch {}
-    }
-  }
-  normalized = normalizeSlashes(normalized).replace(/^\/([A-Za-z]:\/)/, "$1");
-  return normalized;
-}
-function currentModuleRuntimeRoot() {
-  const modulePath = normalizeStackPath(fileURLToPath(import.meta.url));
-  const markers = ["packages/workflows/src/", ...PACKAGED_WORKFLOW_RUNTIME_ROOTS.map((root) => root.slice(1))];
-  for (const marker of markers) {
-    const index = modulePath.indexOf(marker);
-    if (index >= 0)
-      return modulePath.slice(0, index + marker.length);
-  }
-  return;
-}
-function isWorkflowRuntimeFrame(normalizedPath) {
-  const path = normalizeSlashes(normalizedPath);
-  if (path.startsWith("packages/workflows/src/"))
-    return true;
-  if (CURRENT_WORKFLOW_RUNTIME_ROOT !== undefined && path.startsWith(CURRENT_WORKFLOW_RUNTIME_ROOT)) {
-    return true;
-  }
-  const comparable = path.startsWith("/") ? path : `/${path}`;
-  return PACKAGED_WORKFLOW_RUNTIME_ROOTS.some((runtimeRoot) => comparable.includes(runtimeRoot));
-}
-function parsePromptStackFrame(stackLine) {
-  const line = stackLine.trim();
-  if (line.length === 0)
-    return;
-  if (line.includes("node:internal") || line.includes("bun:") || line.includes("(native:"))
-    return;
-  const match = line.match(/(\S+):(\d+):(\d+)\)?$/);
-  if (!match)
-    return;
-  const [, rawFramePath, lineNumber, columnNumber] = match;
-  if (rawFramePath === undefined || lineNumber === undefined || columnNumber === undefined)
-    return;
-  const normalizedPath = normalizeStackPath(rawFramePath.replace(/^\(/, ""));
-  return { normalizedPath, lineNumber, columnNumber };
-}
-function normalizedPromptCallsiteFrame(stackLine) {
-  const frame = parsePromptStackFrame(stackLine);
-  if (frame === undefined)
-    return;
-  if (isWorkflowRuntimeFrame(frame.normalizedPath))
-    return;
-  return `${frame.normalizedPath}:${frame.lineNumber}:${frame.columnNumber}`;
-}
-function selectPromptCallsiteFrame(stack) {
-  return stack.split(`
-`).slice(1).map(normalizedPromptCallsiteFrame).find((candidate) => candidate !== undefined);
-}
-var PACKAGED_WORKFLOW_RUNTIME_ROOTS, CURRENT_WORKFLOW_RUNTIME_ROOT;
-var init_prompt_callsite = __esm(() => {
-  PACKAGED_WORKFLOW_RUNTIME_ROOTS = ["/dist/builtin/workflows/src/"];
-  CURRENT_WORKFLOW_RUNTIME_ROOT = currentModuleRuntimeRoot();
-});
-
-// dist/builtin/workflows/src/shared/workflow-source.ts
-function isWorkflowRuntimeModule(path) {
-  const normalized = normalizeStackPath(path);
-  return normalized === OWN_MODULE_PATH || isWorkflowRuntimeFrame(normalized);
-}
-function recordWorkflowSource(definition, path) {
-  WORKFLOW_SOURCES.set(definition, path);
-}
-function workflowSource(definition) {
-  return WORKFLOW_SOURCES.get(definition);
-}
-var WORKFLOW_SOURCES, OWN_MODULE_PATH;
-var init_workflow_source = __esm(() => {
-  init_prompt_callsite();
-  WORKFLOW_SOURCES = new WeakMap;
-  OWN_MODULE_PATH = normalizeStackPath(import.meta.url);
-});
-
 // dist/builtin/workflows/src/workflows/identity.ts
 function normalizeWorkflowName(name) {
   if (!name || typeof name !== "string") {
@@ -7879,7 +8289,7 @@ var init_legacy_journal_tables = __esm(() => {
 });
 
 // dist/builtin/workflows/src/durable/journal/sql-run-journal.ts
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 import {
   assertStorageSchemaVersion,
   renderStorageIdentifiers as renderStorageIdentifiers2,
@@ -7905,7 +8315,7 @@ class SqlRunJournal {
   database;
   tables;
   legacy;
-  appendGuard = new AsyncLocalStorage;
+  appendGuard = new AsyncLocalStorage3;
   constructor(database, tables, legacy) {
     this.database = database;
     this.tables = tables;
@@ -8395,7 +8805,7 @@ var init_sql_run_journal = __esm(() => {
 });
 
 // dist/builtin/workflows/src/durable/journal/resolution.ts
-import { dirname as dirname2, isAbsolute, join } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join2 } from "node:path";
 import { getAgentDir, selectProcessStorage } from "@bastani/atomic";
 import {
   StorageConfigError,
@@ -8407,7 +8817,7 @@ function provideRunJournalHostModules(modules) {
 }
 function selectRunJournal(options = {}) {
   const agentDir = options.agentDir ?? getAgentDir();
-  const defaultPath = join(dirname2(agentDir), "workflows", "journal.sqlite");
+  const defaultPath = join2(dirname2(agentDir), "workflows", "journal.sqlite");
   if (options.journal !== undefined) {
     if (options.journal !== null && typeof options.journal === "object" && "createRun" in options.journal) {
       const journal = options.journal;
@@ -8444,8 +8854,8 @@ function selectRunJournal(options = {}) {
   const value2 = journal !== undefined ? journal : options.settings?.storage;
   if (value2 === undefined)
     return { kind: "sqlite", path: defaultPath };
-  const selection = selectStorage(value2, "settings", journal !== undefined ? "workflows.journal" : "storage", journal !== undefined ? defaultPath : join(dirname2(agentDir), "storage.sqlite"));
-  const resolved = selection.kind === "sqlite" && !isAbsolute(selection.path) ? { ...selection, path: join(dirname2(agentDir), selection.path) } : selection;
+  const selection = selectStorage(value2, "settings", journal !== undefined ? "workflows.journal" : "storage", journal !== undefined ? defaultPath : join2(dirname2(agentDir), "storage.sqlite"));
+  const resolved = selection.kind === "sqlite" && !isAbsolute(selection.path) ? { ...selection, path: join2(dirname2(agentDir), selection.path) } : selection;
   origins.set(resolved, { source: "settings" });
   return resolved;
 }
@@ -8496,11 +8906,11 @@ var init_resolution = __esm(() => {
 });
 
 // dist/builtin/workflows/src/durable/journal/sqlite-run-journal.ts
-import { dirname as dirname3, join as join2 } from "node:path";
+import { dirname as dirname3, join as join3 } from "node:path";
 import { getAgentDir as getAgentDir2, openNodeSqliteDatabase, validateStoragePrefix, wrapNodeSqliteDatabase } from "@bastani/atomic";
 function workflowJournalPath() {
   const override = process.env.ATOMIC_WORKFLOW_JOURNAL_PATH;
-  return override !== undefined && override.length > 0 ? override : join2(dirname3(getAgentDir2()), "workflows", "journal.sqlite");
+  return override !== undefined && override.length > 0 ? override : join3(dirname3(getAgentDir2()), "workflows", "journal.sqlite");
 }
 async function openSqlRunJournal(source = workflowJournalPath(), options = {}) {
   validateStoragePrefix(options.prefix);
@@ -8629,7 +9039,7 @@ function asRecord(value2) {
 function field(value2, key) {
   return asRecord(value2)?.[key];
 }
-function safeField(value2, key) {
+function safeField2(value2, key) {
   try {
     return field(value2, key);
   } catch {
@@ -8655,26 +9065,26 @@ function findProcessFailureError(value2, seen, depth) {
   if (value2 === null || typeof value2 !== "object" || depth >= 8 || seen.has(value2))
     return;
   seen.add(value2);
-  if (nonZeroExitCode(safeField(value2, "exitCode")))
+  if (nonZeroExitCode(safeField2(value2, "exitCode")))
     return value2;
-  if (nonEmptyProcessOutput(safeField(value2, "stdout")))
+  if (nonEmptyProcessOutput(safeField2(value2, "stdout")))
     return value2;
-  if (nonEmptyProcessOutput(safeField(value2, "stderr")))
+  if (nonEmptyProcessOutput(safeField2(value2, "stderr")))
     return value2;
   for (const key of ["cause", "error", "response", "body"]) {
-    const selected = findProcessFailureError(safeField(value2, key), seen, depth + 1);
+    const selected = findProcessFailureError(safeField2(value2, key), seen, depth + 1);
     if (selected !== undefined)
       return selected;
   }
-  const diagnostics = safeField(value2, "diagnostics");
+  const diagnostics = safeField2(value2, "diagnostics");
   if (Array.isArray(diagnostics)) {
     for (const diagnostic of diagnostics) {
-      const selected = findProcessFailureError(safeField(diagnostic, "error") ?? diagnostic, seen, depth + 1);
+      const selected = findProcessFailureError(safeField2(diagnostic, "error") ?? diagnostic, seen, depth + 1);
       if (selected !== undefined)
         return selected;
     }
   }
-  const errors = safeField(value2, "errors");
+  const errors = safeField2(value2, "errors");
   if (!Array.isArray(errors))
     return;
   for (const error of errors) {
@@ -8880,7 +9290,7 @@ function isInfrastructureError(value2) {
 }
 function isRetryableWorkflowError(error) {
   let current = error;
-  for (let depth = 0;depth < MAX_CAUSE_DEPTH && current !== undefined && current !== null; depth++) {
+  for (let depth = 0;depth < MAX_CAUSE_DEPTH3 && current !== undefined && current !== null; depth++) {
     if (isInfrastructureError(current))
       return true;
     current = current instanceof Error ? current.cause : undefined;
@@ -8907,7 +9317,7 @@ function failedOnInfrastructureFault(result) {
     return true;
   return Array.isArray(result.stages) && result.stages.some((stage) => stage?.status === "failed" && (names(stage.failureCode) || names(stage.error)));
 }
-var WORKFLOW_INFRASTRUCTURE_ERROR_NAME = "WorkflowInfrastructureError", WORKFLOW_INFRASTRUCTURE_FAULTS, MAX_CAUSE_DEPTH = 8, FAULT_PATTERNS, WorkflowInfrastructureError;
+var WORKFLOW_INFRASTRUCTURE_ERROR_NAME = "WorkflowInfrastructureError", WORKFLOW_INFRASTRUCTURE_FAULTS, MAX_CAUSE_DEPTH3 = 8, FAULT_PATTERNS, WorkflowInfrastructureError;
 var init_workflow_infrastructure_error = __esm(() => {
   WORKFLOW_INFRASTRUCTURE_FAULTS = new Set([
     "worker_lost",
@@ -10055,9 +10465,9 @@ var init_workflow_human_input = __esm(() => {
 });
 
 // dist/builtin/workflows/src/extension/wiring.ts
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import {
-  isStaleExtensionContextError as isStaleExtensionContextError5,
+  isStaleExtensionContextError as isStaleExtensionContextError6,
   ModelRuntime,
   noOpUIContext,
   resolveRestoredModelReference
@@ -10202,7 +10612,7 @@ function emitLateIntercomRoute(pi, meta, messages, options, batch) {
   try {
     pi.events.emit(LATE_STAGE_MESSAGE_EVENT2, event);
   } catch (error) {
-    if (!isStaleExtensionContextError5(error))
+    if (!isStaleExtensionContextError6(error))
       throw error;
     return Promise.reject(error);
   }
@@ -10214,7 +10624,7 @@ function routeThroughStaleContextGuard(route) {
   try {
     return route();
   } catch (error) {
-    if (!isStaleExtensionContextError5(error))
+    if (!isStaleExtensionContextError6(error))
       throw error;
     return Promise.reject(error);
   }
@@ -10484,8 +10894,8 @@ function createAgentSessionAdapter(baseOptions = {}, stageUiBroker) {
     async createAgentSession(options, prepareOptions) {
       if (options && !options.modelRuntime && typeof options.model === "string") {
         options.modelRuntime = await ModelRuntime.create({
-          authPath: options.agentDir ? join3(options.agentDir, "auth.json") : undefined,
-          modelsPath: options.agentDir ? join3(options.agentDir, "models.json") : undefined
+          authPath: options.agentDir ? join4(options.agentDir, "auth.json") : undefined,
+          modelsPath: options.agentDir ? join4(options.agentDir, "models.json") : undefined
         });
         await resolveStageModel(options, false);
       }
@@ -10986,7 +11396,7 @@ var init_executor_abort = __esm(() => {
 });
 
 // dist/builtin/workflows/src/shared/prompt-callsite-context.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
 function withPromptCallerStack(stack, delegate) {
   if (stack === undefined)
     return delegate();
@@ -10997,7 +11407,7 @@ function currentPromptCallerStack() {
 }
 var promptCallerStacks;
 var init_prompt_callsite_context = __esm(() => {
-  promptCallerStacks = new AsyncLocalStorage2;
+  promptCallerStacks = new AsyncLocalStorage4;
 });
 
 // dist/builtin/workflows/src/workers/pooled-prompt-limits.ts
@@ -12291,7 +12701,7 @@ function sleepOrAbort(ms, signal) {
 var init_retry = () => {};
 
 // dist/builtin/workflows/src/durable/tool-outcome.ts
-function safeField2(error, key) {
+function safeField3(error, key) {
   try {
     return field(error, key);
   } catch {
@@ -12299,7 +12709,7 @@ function safeField2(error, key) {
   }
 }
 function exposedText(error, key) {
-  const value2 = safeField2(error, key);
+  const value2 = safeField3(error, key);
   if (typeof value2 === "string")
     return value2;
   try {
@@ -12340,7 +12750,7 @@ function safeErrorText(error) {
 }
 function normalizeWorkflowToolError(error) {
   error = selectProcessFailureError(error);
-  const exitCode = safeField2(error, "exitCode");
+  const exitCode = safeField3(error, "exitCode");
   const stdout = exposedText(error, "stdout");
   const stderr = exposedText(error, "stderr");
   let message;
@@ -13865,7 +14275,7 @@ class PromptReservationState {
 }
 
 // dist/builtin/workflows/src/durable/journal/journal-backend.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage5 } from "node:async_hooks";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { setImmediate as setImmediate2 } from "node:timers";
 import { StorageError } from "@bastani/atomic/storage";
@@ -13921,7 +14331,7 @@ function createTurnSlicer(threshold, budgetMs = TURN_BUDGET_MS) {
     turnStart();
     if (queue.length === 0 && !draining && waiting() < threshold)
       return run();
-    const inCallerContext = AsyncLocalStorage3.snapshot();
+    const inCallerContext = AsyncLocalStorage5.snapshot();
     return new Promise((resolve, reject) => {
       queue.push(() => {
         let result;
@@ -13998,7 +14408,7 @@ class JournalDurableBackend {
   catalogToken;
   leases = new Map;
   executions = new Map;
-  executionContext = new AsyncLocalStorage3;
+  executionContext = new AsyncLocalStorage5;
   pending = new Map;
   waitingOperations = 0;
   reconciledPendingStages = new Map;
@@ -14010,7 +14420,7 @@ class JournalDurableBackend {
   state = "open";
   closing;
   renewing = new Map;
-  mutationContext = new AsyncLocalStorage3;
+  mutationContext = new AsyncLocalStorage5;
   processExitCleanup;
   unregisterExecutionStorages = registerExecutionStorages(this.executionContext, this.mutationContext);
   constructor(journal, holderId = `${PROCESS_HOLDER_ID}:${randomUUID5()}`, ownsJournal = true) {
@@ -14493,7 +14903,7 @@ class JournalDurableBackend {
         event,
         ...key === undefined ? {} : { key },
         ...requiresRegisteredRun ? { requiresRegisteredRun } : {},
-        context: AsyncLocalStorage3.snapshot(),
+        context: AsyncLocalStorage5.snapshot(),
         resolve,
         reject
       });
@@ -15416,23 +15826,23 @@ var init_workflow_artifact_env = __esm(() => {
 import { randomUUID as randomUUID6 } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdir, readdir, rm, stat } from "node:fs/promises";
-import { dirname as dirname4, join as join4 } from "node:path";
+import { dirname as dirname4, join as join5 } from "node:path";
 import { getAgentDir as getAgentDir4, getEnvValue } from "@bastani/atomic";
 function workflowArtifactRoot() {
   const override = getEnvValue(ENV_WORKFLOW_ARTIFACT_DIR);
   if (override !== undefined && override.length > 0)
     return override;
-  return join4(dirname4(getAgentDir4()), "workflows");
+  return join5(dirname4(getAgentDir4()), "workflows");
 }
 function workflowArtifactRunsRoot() {
-  return join4(workflowArtifactRoot(), "runs");
+  return join5(workflowArtifactRoot(), "runs");
 }
 function safeRunId(runId) {
   const safe = runId.replace(/[^A-Za-z0-9._-]/g, "_");
   return safe.length > 0 ? safe : "run";
 }
 function workflowArtifactRunPath(runId) {
-  return join4(workflowArtifactRunsRoot(), safeRunId(runId));
+  return join5(workflowArtifactRunsRoot(), safeRunId(runId));
 }
 function normalizeSerializedPath(value2) {
   return value2.replaceAll("\\", "/").replace(/\/{2,}/g, "/");
@@ -15568,7 +15978,7 @@ async function pruneWorkflowArtifactRuns(root = workflowArtifactRunsRoot(), now
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const entryPath = join4(root, entry.name);
+      const entryPath = join5(root, entry.name);
       let metadata;
       try {
         metadata = await stat(entryPath);
@@ -15623,7 +16033,7 @@ async function ensureWorkflowArtifactRunDirectory(runId) {
 }
 function workflowArtifactDirectoryPath(runId) {
   const effectiveRunId = runId ?? randomUUID6();
-  return join4(workflowArtifactRunPath(effectiveRunId), `artifact-${randomUUID6()}`);
+  return join5(workflowArtifactRunPath(effectiveRunId), `artifact-${randomUUID6()}`);
 }
 async function ensureWorkflowArtifactDirectory(directory) {
   await pruneArtifactRootIfDue(workflowArtifactRunsRoot(), Date.now());
@@ -17378,7 +17788,7 @@ function taskWithSharedDefaults(taskOptions, options) {
 var init_executor_task_prompts = () => {};
 
 // dist/builtin/workflows/src/runs/foreground/executor-direct-helpers.ts
-import { isAbsolute as isAbsolute8, join as join12, resolve as resolve10 } from "node:path";
+import { isAbsolute as isAbsolute8, join as join13, resolve as resolve10 } from "node:path";
 import { CONFIG_DIR_NAME } from "@bastani/atomic";
 function positiveConcurrency(value2) {
   if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 < 1)
@@ -17534,7 +17944,7 @@ function resolvedTaskCwd(cwd, workflowInvocationCwd) {
   return isAbsolute8(cwd) ? cwd : resolve10(workflowInvocationCwd, cwd);
 }
 function taskWorktreeOutputsRoot(runId) {
-  return join12(workflowArtifactRunPath(runId), "task-outputs");
+  return join13(workflowArtifactRunPath(runId), "task-outputs");
 }
 function prepareTaskWorktrees(tasks, options, runId, scope, workflowInvocationCwd = process.cwd(), symlinkDirectories) {
   if (options.worktree !== true && !tasks.some((task) => task.worktree === true)) {
@@ -17559,9 +17969,9 @@ function prepareTaskWorktrees(tasks, options, runId, scope, workflowInvocationCw
     tasks: tasks.map((task, index) => ({ ...task, cwd: setup.worktrees[index].agentCwd })),
     setup,
     agents,
-    diffsDir: join12(setup.cwd, CONFIG_DIR_NAME, "workflows", "worktree-diffs", runId, scope),
+    diffsDir: join13(setup.cwd, CONFIG_DIR_NAME, "workflows", "worktree-diffs", runId, scope),
     outputIsolations: tasks.map((_, index) => ({
-      baseDir: join12(trustedRoot, runId, scope, String(index)),
+      baseDir: join13(trustedRoot, runId, scope, String(index)),
       trustedRoot
     }))
   };
@@ -19004,7 +19414,7 @@ function raceAbort2(operation, signal) {
 
 // dist/builtin/workflows/src/shared/possible-stages.ts
 import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname11, join as join13, resolve as resolve11 } from "node:path";
+import { dirname as dirname11, join as join14, resolve as resolve11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function scanPossibleStagesFromSource(entrySourcePath, options = {}) {
   const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
@@ -19020,7 +19430,7 @@ function resolveBuiltinDefinitionSource(name) {
   const builtinDir = fileURLToPath3(new URL("../../builtin/", import.meta.url));
   for (const stem of [name, kebabCase(name)]) {
     for (const extension of [".ts", ".js"]) {
-      const candidate = join13(builtinDir, `${stem}${extension}`);
+      const candidate = join14(builtinDir, `${stem}${extension}`);
       if (isFileSync(candidate))
         return candidate;
     }
@@ -20463,9 +20873,9 @@ function resolveRelativeSpecifier(specifier, importingFile) {
     return;
   const candidates = [];
   if (specifier.endsWith(".js")) {
-    candidates.push(join13(dirname11(importingFile), `${specifier.slice(0, -3)}.ts`));
+    candidates.push(join14(dirname11(importingFile), `${specifier.slice(0, -3)}.ts`));
   }
-  candidates.push(join13(dirname11(importingFile), specifier), join13(dirname11(importingFile), `${specifier}.ts`), join13(dirname11(importingFile), `${specifier}.js`), join13(dirname11(importingFile), specifier, "index.ts"), join13(dirname11(importingFile), specifier, "index.js"));
+  candidates.push(join14(dirname11(importingFile), specifier), join14(dirname11(importingFile), `${specifier}.ts`), join14(dirname11(importingFile), `${specifier}.js`), join14(dirname11(importingFile), specifier, "index.ts"), join14(dirname11(importingFile), specifier, "index.js"));
   return candidates.find((candidate) => isFileSync(candidate));
 }
 function isFileSync(path) {
@@ -20500,7 +20910,7 @@ var init_possible_stages = __esm(() => {
 
 // dist/builtin/workflows/src/workers/admission-host.ts
 import { execFile, execFileSync } from "node:child_process";
-import { readdirSync as readdirSync4, readFileSync as readFileSync5 } from "node:fs";
+import { readdirSync as readdirSync5, readFileSync as readFileSync5 } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { hostname } from "node:os";
 function admissionBootIdentity() {
@@ -20551,7 +20961,7 @@ function scanProcessGroup(group) {
     let complete = true;
     let entries;
     try {
-      entries = readdirSync4("/proc");
+      entries = readdirSync5("/proc");
     } catch {
       return { members, complete: false };
     }
@@ -57360,10 +57770,10 @@ var init_verification_prompts = __esm(() => {
 // dist/builtin/workflows/builtin/pattern-artifact-root.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { mkdir as mkdir2 } from "node:fs/promises";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 async function stableArtifactRoot(ctx, workflowName) {
   const cwd = ctx.cwd ?? process.cwd();
-  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join14(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID9()}`));
+  const artifactDir = await ctx.tool("artifact-root", { workflow: workflowName }, async () => join15(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID9()}`));
   await mkdir2(artifactDir, { recursive: true });
   return artifactDir;
 }
@@ -57403,7 +57813,7 @@ function fold_usage(results) {
 
 // dist/builtin/workflows/builtin/adversarial-verification-runner.ts
 import { readFile as readFile2, writeFile } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 import { Type as Type4 } from "typebox";
 function isRecord3(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -57498,8 +57908,8 @@ async function writeInvalid(path, stage) {
 }
 async function runAdversarialVerification(ctx) {
   const root = await stableArtifactRoot(ctx, "adversarial-verification");
-  const criteriaPath = join15(root, "criteria.md");
-  const candidatePath = join15(root, "candidate.md");
+  const criteriaPath = join16(root, "criteria.md");
+  const candidatePath = join16(root, "candidate.md");
   const resolvedCriteria = resolveCriteria(ctx.inputs.criteria);
   await writeFile(criteriaPath, renderCriteriaMarkdown(resolvedCriteria));
   await ctx.task("worker", { prompt: renderWorkerPrompt(ctx.inputs.task), context: "fresh", output: candidatePath, outputMode: "file-only" });
@@ -57531,7 +57941,7 @@ async function runAdversarialVerification(ctx) {
           criterion,
           verifierIndex: index + 1,
           name,
-          artifactPath: join15(root, `verification-${round}-${criterion.id}-${index + 1}.json`)
+          artifactPath: join16(root, `verification-${round}-${criterion.id}-${index + 1}.json`)
         });
       }
     }
@@ -57584,8 +57994,8 @@ async function runAdversarialVerification(ctx) {
     const decision = decide_verification(roundResult, { acceptMean, quorumFraction: QUORUM_FRACTION });
     finalDecision = decision;
     finalMean = meanScore(scoreReports);
-    scoreTablePath = join15(root, `verification-summary-${round}.json`);
-    reviewReportPath = join15(root, `review-${round}.json`);
+    scoreTablePath = join16(root, `verification-summary-${round}.json`);
+    reviewReportPath = join16(root, `review-${round}.json`);
     const summary = {
       scores: scoreReports,
       mean: finalMean,
@@ -57766,7 +58176,7 @@ var GROUNDED_REPORTING2 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/classify-and-act-runner.ts
 import { writeFile as writeFile2 } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import { Type as Type6 } from "typebox";
 function safeName(value2) {
   const normalized = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -57806,7 +58216,7 @@ async function runClassifyAndAct(ctx) {
   const needsFallback = exactCategory === undefined || confidence < ctx.inputs.confidence_threshold;
   const fallback = needsFallback ? await resolveFallbackCategory(ctx, exactCategory) : undefined;
   const category = fallback?.category ?? exactCategory;
-  const classificationPath = join16(artifactDir, "classification.json");
+  const classificationPath = join17(artifactDir, "classification.json");
   await writeFile2(classificationPath, JSON.stringify({
     proposed_category: proposedCategory,
     selected_category: category,
@@ -57816,7 +58226,7 @@ async function runClassifyAndAct(ctx) {
     fallback_used: needsFallback,
     fallback_mode: fallback?.fallbackMode ?? "none"
   }, null, 2));
-  const actionPath = join16(artifactDir, `action-${safeName(category)}.md`);
+  const actionPath = join17(artifactDir, `action-${safeName(category)}.md`);
   const action = await ctx.task(`action-${safeName(category)}`, {
     tools: actionTools(category),
     prompt: actionPrompt({ prompt: ctx.inputs.prompt, category, classificationPath }),
@@ -57956,7 +58366,7 @@ var GROUNDED_REPORTING3 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/fan-out-and-synthesize-runner.ts
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { Type as Type8 } from "typebox";
 function safeName2(value2, index) {
   const normalized = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -57987,9 +58397,9 @@ async function runFanOutAndSynthesize(ctx) {
     context: "fresh"
   });
   const partitions = parsedPartitions(plan.structured, ctx.inputs.max_branches, ctx.inputs.prompt);
-  const partitionPath = join17(artifactDir, "partition-plan.json");
+  const partitionPath = join18(artifactDir, "partition-plan.json");
   await writeFile3(partitionPath, JSON.stringify({ task: ctx.inputs.prompt, partitions }, null, 2));
-  const branchPaths = partitions.map((partition, index) => join17(artifactDir, `branch-${safeName2(partition.label, index)}.md`));
+  const branchPaths = partitions.map((partition, index) => join18(artifactDir, `branch-${safeName2(partition.label, index)}.md`));
   const steps = partitions.map((partition, index) => ({
     name: `branch-${safeName2(partition.label, index)}`,
     prompt: branchPrompt({ prompt: ctx.inputs.prompt, ...partition }),
@@ -57999,13 +58409,13 @@ async function runFanOutAndSynthesize(ctx) {
     outputMode: "file-only"
   }));
   await ctx.parallel(steps, { concurrency: Math.min(ctx.inputs.max_concurrency, partitions.length), failFast: false });
-  const manifestPath = join17(artifactDir, "manifest.json");
+  const manifestPath = join18(artifactDir, "manifest.json");
   await writeFile3(manifestPath, JSON.stringify({
     task: ctx.inputs.prompt,
     partition_plan: partitionPath,
     branches: partitions.map((partition, index) => ({ ...partition, artifact_path: branchPaths[index] }))
   }, null, 2));
-  const synthesisPath = join17(artifactDir, "synthesis.md");
+  const synthesisPath = join18(artifactDir, "synthesis.md");
   const synthesis = await ctx.task("synthesize", {
     prompt: synthesisPrompt(ctx.inputs.prompt, manifestPath),
     context: "fresh",
@@ -58170,7 +58580,7 @@ var init_generate_and_filter_prompts = __esm(() => {
 
 // dist/builtin/workflows/builtin/generate-and-filter-runner.ts
 import { readFile as readFile3, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 import { Type as Type10 } from "typebox";
 function isRecord4(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
@@ -58189,7 +58599,7 @@ function judgeDecision(value2) {
 }
 async function runGenerateAndFilter(ctx) {
   const root = await stableArtifactRoot(ctx, "generate-and-filter");
-  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join18(root, `candidate-${index + 1}.md`));
+  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join19(root, `candidate-${index + 1}.md`));
   const shortlistLimit = Math.min(ctx.inputs.shortlist_size, ctx.inputs.num_candidates);
   await ctx.parallel(candidatePaths.map((path, index) => ({
     name: `generate-${index + 1}`,
@@ -58198,9 +58608,9 @@ async function runGenerateAndFilter(ctx) {
     output: path,
     outputMode: "file-only"
   })), { concurrency: ctx.inputs.max_concurrency, failFast: false });
-  const manifestPath = join18(root, "manifest.json");
+  const manifestPath = join19(root, "manifest.json");
   await writeFile4(manifestPath, JSON.stringify({ task: ctx.inputs.prompt, candidate_artifact_paths: candidatePaths }, null, 2));
-  const filterPath = join18(root, "filter.json");
+  const filterPath = join19(root, "filter.json");
   const filtered = await ctx.task("dedupe-and-filter", {
     prompt: renderFilterPrompt(ctx.inputs.prompt, candidatePaths, shortlistLimit),
     context: "fresh",
@@ -58217,7 +58627,7 @@ async function runGenerateAndFilter(ctx) {
   let judgePath = null;
   let decisionPath = filterPath;
   if (ctx.inputs.use_judge) {
-    judgePath = join18(root, "judge.json");
+    judgePath = join19(root, "judge.json");
     const judgeCandidates = await Promise.all(shortlist.map(async (path) => ({ path, body: await readFile3(path, "utf8") })));
     const judgePrompt = renderJudgePrompt(ctx.inputs.prompt, filterPath, shortlistLimit, judgeCandidates);
     const judged = await ctx.task("judge", {
@@ -58233,7 +58643,7 @@ async function runGenerateAndFilter(ctx) {
     shortlist = judgedShortlist.length > 0 ? judgedShortlist : shortlist;
     decisionPath = judgePath;
   }
-  const finalPath = join18(root, "shortlist.md");
+  const finalPath = join19(root, "shortlist.md");
   const finalShortlist = await ctx.task("final-shortlist", {
     prompt: renderFinalShortlistPrompt(ctx.inputs.prompt, decisionPath),
     context: "fresh",
@@ -58762,7 +59172,7 @@ var init_review_convergence = __esm(() => {
 
 // dist/builtin/workflows/builtin/goal-artifacts.ts
 import { writeFile as writeFile5 } from "node:fs/promises";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 function artifactSafeName(value2) {
   const safe = value2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
   return safe.length > 0 ? safe : "artifact";
@@ -58773,7 +59183,7 @@ function withoutTurn(value2) {
   return copy;
 }
 async function writeReviewArtifact(artifactDir, reviewer, decision, rawText, convergenceDecision) {
-  const artifactPath = join19(artifactDir, `review-${artifactSafeName(reviewer)}.json`);
+  const artifactPath = join20(artifactDir, `review-${artifactSafeName(reviewer)}.json`);
   await writeFile5(artifactPath, `${JSON.stringify({ reviewer, decision, convergence_decision: convergenceDecision, raw_text: rawText }, null, 2)}
 `, { encoding: "utf8" });
   return artifactPath;
@@ -58782,7 +59192,7 @@ async function writeReviewRoundArtifact(artifactDir, reviews, consolidatedFindin
   reviewer: review.reviewer,
   findings: review.findings
 }))), reverification = []) {
-  const artifactPath = join19(artifactDir, "review-round-latest.json");
+  const artifactPath = join20(artifactDir, "review-round-latest.json");
   const visibleReviews = reviews.map(withoutTurn);
   await writeFile5(artifactPath, `${JSON.stringify({ reviews: visibleReviews, consolidated_findings: consolidatedFindings, reverification }, null, 2)}
 `, { encoding: "utf8" });
@@ -59012,7 +59422,7 @@ var init_goal_review = __esm(() => {
 // dist/builtin/workflows/builtin/goal-ledger.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
 import { readFile as readFile4, rename, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
-import { dirname as dirname12, join as join20 } from "node:path";
+import { dirname as dirname12, join as join21 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 function withoutTurn2(value2) {
   const copy = { ...value2 };
@@ -59037,7 +59447,7 @@ function modelVisibleLedger(ledger) {
   };
 }
 function goalLedgerStatePath(ledgerPath) {
-  return join20(dirname12(ledgerPath), LEDGER_STATE_FILENAME);
+  return join21(dirname12(ledgerPath), LEDGER_STATE_FILENAME);
 }
 function appendLifecycleEvent(ledger, event, summary, turn = ledger.turns) {
   ledger.lifecycle.push({
@@ -59113,7 +59523,7 @@ function recoverLegacyExecutionInterruption(ledger) {
   return true;
 }
 async function createGoalLedger(objective, acceptanceCriteria, artifactDir) {
-  const ledgerPath = join20(artifactDir, LEDGER_FILENAME);
+  const ledgerPath = join21(artifactDir, LEDGER_FILENAME);
   const existing = await readExistingGoalLedger(ledgerPath);
   if (existing !== undefined) {
     if (recoverLegacyExecutionInterruption(existing))
@@ -59620,7 +60030,7 @@ var init_goal_orchestrator_prompts = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/goal-runner.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function positiveInteger(value2, fallback) {
   if (typeof value2 !== "number" || !Number.isFinite(value2) || value2 <= 0) {
     return fallback;
@@ -59671,7 +60081,7 @@ async function runGoalWorkflow(ctx, options) {
       appendLifecycleEvent(ledger, "work_turn_started", "Orchestrator started.", turn);
       await writeGoalLedger(ledgerPath, ledger);
     }
-    const orchestratorReceiptPath = join21(artifactDir, "orchestrator-receipt.md");
+    const orchestratorReceiptPath = join22(artifactDir, "orchestrator-receipt.md");
     const orchestratorForkOptions = forkContinuationOptions(previousOrchestratorSessionId);
     const orchestratorPrompt = orchestratorForkOptions.forkFromSessionId === undefined ? renderGoalOrchestratorPrompt({
       ledger,
@@ -59742,7 +60152,7 @@ async function runGoalWorkflow(ctx, options) {
       const reviewerName = result.name ?? result.stageName;
       const normalizedReviewerName = reviewerName.replace(/-\d+$/u, "");
       const parsed = reviewerContractError === undefined ? parsedReviewDecisionFromResult(result, reviewerName) : { decision: reviewerErrorDecision(reviewerContractError.message), parsed: false, diagnostics: [reviewerContractError.message] };
-      const reviewArtifactPath = join21(artifactDir, `review-${artifactSafeName(normalizedReviewerName)}.json`);
+      const reviewArtifactPath = join22(artifactDir, `review-${artifactSafeName(normalizedReviewerName)}.json`);
       const record = reviewDecisionToRecord({
         turn,
         reviewer: normalizedReviewerName,
@@ -60063,7 +60473,7 @@ var GROUNDED_REPORTING5 = "Before reporting progress, audit each claim against a
 
 // dist/builtin/workflows/builtin/loop-until-done-runner.ts
 import { mkdir as mkdir3, writeFile as writeFile7 } from "node:fs/promises";
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 import { Type as Type16 } from "typebox";
 function progressCurve(entries) {
   return entries.flatMap((entry) => entry.progress === undefined ? [] : [entry.progress.score]);
@@ -60146,18 +60556,18 @@ async function writeLedger(path, task, maxIterations, status, entries) {
 }
 async function runLoopUntilDone(ctx) {
   const artifactDir = await stableArtifactRoot(ctx, "loop-until-done");
-  const iterationsDir = join22(artifactDir, "iterations");
-  const evaluationsDir = join22(artifactDir, "evaluations");
+  const iterationsDir = join23(artifactDir, "iterations");
+  const evaluationsDir = join23(artifactDir, "evaluations");
   await mkdir3(iterationsDir, { recursive: true });
   await mkdir3(evaluationsDir, { recursive: true });
-  const ledgerPath = join22(artifactDir, "progress-ledger.json");
+  const ledgerPath = join23(artifactDir, "progress-ledger.json");
   const entries = [];
   const iterationArtifactPaths = [];
   const evaluationArtifactPaths = [];
   await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "active", entries);
   for (let iteration = 1;iteration <= ctx.inputs.max_iterations; iteration += 1) {
-    const iterationPath = join22(iterationsDir, `iteration-${iteration}.md`);
-    const evaluationPath = join22(evaluationsDir, `evaluation-${iteration}.json`);
+    const iterationPath = join23(iterationsDir, `iteration-${iteration}.md`);
+    const evaluationPath = join23(evaluationsDir, `evaluation-${iteration}.json`);
     iterationArtifactPaths.push(iterationPath);
     evaluationArtifactPaths.push(evaluationPath);
     await ctx.task(`iteration-${iteration}`, {
@@ -60206,7 +60616,7 @@ async function runLoopUntilDone(ctx) {
     await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, decision.done ? "complete" : "active", entries);
     if (decision.done) {
       const report = progressReport(entries);
-      const resultPath = join22(artifactDir, "result.md");
+      const resultPath = join23(artifactDir, "result.md");
       const final = await ctx.task("completion-summary", {
         prompt: renderCompletionPrompt({ task: ctx.inputs.prompt, ledgerPath, iterationPath }),
         context: "fresh",
@@ -60323,9 +60733,9 @@ var init_loop_until_done = __esm(() => {
 
 // dist/builtin/workflows/builtin/open-claude-design-utils.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { mkdirSync as mkdirSync6 } from "node:fs";
+import { mkdirSync as mkdirSync7 } from "node:fs";
 import { tmpdir, userInfo } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 import { Type as Type18 } from "typebox";
 import { createChildProcessEnvironment as createChildProcessEnvironment3 } from "@bastani/atomic";
 function taggedPrompt3(sections) {
@@ -60368,32 +60778,32 @@ function tmpArtifactBase() {
   try {
     user = userInfo().username.replace(/[^A-Za-z0-9._-]/g, "_") || "default";
   } catch {}
-  return join23(tmpdir(), `open-claude-design-${user}`);
+  return join24(tmpdir(), `open-claude-design-${user}`);
 }
 function prepareArtifactDir(cwd = process.cwd()) {
   const runId = `${new Date().toISOString().replace(/[:.]/g, "-")}-${Math.random().toString(36).slice(2, 8)}`;
   const tmpCandidates = [
-    join23(tmpArtifactBase(), runId),
-    join23(tmpdir(), "open-claude-design", runId)
+    join24(tmpArtifactBase(), runId),
+    join24(tmpdir(), "open-claude-design", runId)
   ];
-  const candidates = process.env.NODE_ENV === "test" ? tmpCandidates : [join23(cwd, "specs", "design", runId), ...tmpCandidates];
+  const candidates = process.env.NODE_ENV === "test" ? tmpCandidates : [join24(cwd, "specs", "design", runId), ...tmpCandidates];
   for (const candidate of candidates) {
     try {
-      mkdirSync6(candidate, { recursive: true });
+      mkdirSync7(candidate, { recursive: true });
       return {
         runId,
         artifactDir: candidate,
-        previewPath: join23(candidate, "preview.html"),
-        specPath: join23(candidate, "spec.html")
+        previewPath: join24(candidate, "preview.html"),
+        specPath: join24(candidate, "spec.html")
       };
     } catch {}
   }
-  const fallback = join23(tmpArtifactBase(), runId);
+  const fallback = join24(tmpArtifactBase(), runId);
   return {
     runId,
     artifactDir: fallback,
-    previewPath: join23(fallback, "preview.html"),
-    specPath: join23(fallback, "spec.html")
+    previewPath: join24(fallback, "preview.html"),
+    specPath: join24(fallback, "spec.html")
   };
 }
 function ensureAgentBrowser() {
@@ -60727,8 +61137,8 @@ var init_open_claude_design_live_protocol = __esm(() => {
 });
 
 // dist/builtin/workflows/builtin/open-claude-design-setup.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join24 } from "node:path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join25 } from "node:path";
 function renderDiscoveryContext(discovery) {
   return [
     `Confirmed design brief: ${discovery.brief}`,
@@ -60793,10 +61203,10 @@ async function runDiscoveryAndInit(args) {
   };
 }
 function designContextPath(artifactDir) {
-  return join24(artifactDir, DESIGN_CONTEXT_FILENAME);
+  return join25(artifactDir, DESIGN_CONTEXT_FILENAME);
 }
 function referencesBriefPath(artifactDir) {
-  return join24(artifactDir, REFERENCES_BRIEF_FILENAME);
+  return join25(artifactDir, REFERENCES_BRIEF_FILENAME);
 }
 function buildReferenceDiscoveryPrompt(args) {
   const siteList = REFERENCE_DESIGN_SITES.map((site, index) => `${index + 1}. ${site.name} — ${site.url}`).join(`
@@ -60822,8 +61232,8 @@ function buildReferenceDiscoveryPrompt(args) {
       [
         "Use the agent-browser skill to open each gallery; if `agent-browser` reports a missing browser executable, follow the bootstrap rules and retry once.",
         "From each gallery, choose 1-3 fitting designs and CLICK INTO each actual live or project-detail page; do not capture only the grid or thumbnail.",
-        `Capture motion across the entire page: start \`agent-browser record start ${join24(args.artifactDir, "ref-<site>-<n>.webm")}\`, scroll smoothly in small increments with waits (using repeated \`agent-browser scroll down 600\` or \`agent-browser mouse wheel 600\`) so animations fire and lazy content loads, then run \`agent-browser record stop\`.`,
-        `Also run \`agent-browser screenshot ${join24(args.artifactDir, "ref-<site>-<n>.png")} --full\`; this still is the minimum when video is unavailable.`,
+        `Capture motion across the entire page: start \`agent-browser record start ${join25(args.artifactDir, "ref-<site>-<n>.webm")}\`, scroll smoothly in small increments with waits (using repeated \`agent-browser scroll down 600\` or \`agent-browser mouse wheel 600\`) so animations fire and lazy content loads, then run \`agent-browser record stop\`.`,
+        `Also run \`agent-browser screenshot ${join25(args.artifactDir, "ref-<site>-<n>.png")} --full\`; this still is the minimum when video is unavailable.`,
         "Record the actual destination URL, title, and author. For each reference, cite observed layout, typography, color, spacing, and motion traits rather than inferred traits.",
         "Assess fit against DESIGN.md, PRODUCT.md, and the ds-* discovery evidence in the design-context file; prefer on-brand references and flag departures.",
         "Use ask_user_question to ask which reference direction they prefer, offering 2-4 strongest options plus `None of these fit`. If none fit, ask them to provide a reference image, screenshot, URL, or local file path and record the answer.",
@@ -60848,7 +61258,7 @@ function buildReferenceDiscoveryPrompt(args) {
 }
 function writeRequiredContextArtifact(artifactDir, filePath, content, label) {
   try {
-    mkdirSync7(artifactDir, { recursive: true });
+    mkdirSync8(artifactDir, { recursive: true });
     writeFileSync4(filePath, `${content}
 `);
   } catch (error) {
@@ -61400,7 +61810,7 @@ var init_ralph_review_gate = __esm(() => {
 
 // dist/builtin/workflows/builtin/ralph-core.ts
 import { mkdir as mkdir4, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname13, join as join25 } from "node:path";
+import { dirname as dirname13, join as join26 } from "node:path";
 import { Type as Type20 } from "typebox";
 function taggedPrompt4(sections) {
   return sections.map(([tag, content]) => {
@@ -61440,11 +61850,11 @@ function slugifyResearchTopic(prompt) {
 }
 function defaultResearchPath(prompt, now = new Date) {
   const date = now.toISOString().slice(0, 10);
-  return join25(DEFAULT_RESEARCH_DIR, `${date}-${slugifyResearchTopic(prompt)}.md`);
+  return join26(DEFAULT_RESEARCH_DIR, `${date}-${slugifyResearchTopic(prompt)}.md`);
 }
 async function createImplementationNotesFile(prompt, runId) {
   const notesDir = await createWorkflowArtifactDirectory(runId);
-  const notesPath = join25(notesDir, IMPLEMENTATION_NOTES_FILENAME);
+  const notesPath = join26(notesDir, IMPLEMENTATION_NOTES_FILENAME);
   const initialNotes = [
     "# Implementation Notes",
     "",
@@ -61465,7 +61875,7 @@ async function createImplementationNotesFile(prompt, runId) {
 }
 async function createQaEvidenceVideoPath(runId) {
   const qaDir = await createWorkflowArtifactDirectory(runId);
-  return join25(qaDir, QA_E2E_VIDEO_FILENAME);
+  return join26(qaDir, QA_E2E_VIDEO_FILENAME);
 }
 function renderQaE2eVideoGuidance(qaVideoPath) {
   return [
@@ -61869,7 +62279,7 @@ var init_ralph_models = __esm(() => {
 
 // dist/builtin/workflows/builtin/ralph-runner.ts
 import { existsSync as existsSync6 } from "node:fs";
-import { join as join26, resolve as resolve12 } from "node:path";
+import { join as join27, resolve as resolve12 } from "node:path";
 async function runRalphWorkflow(ctx, options) {
   const { prompt, acceptanceCriteria, maxLoops, comparisonBaseBranch, workflowStartCwd, createPr, runId } = options;
   let latestReviewReportPath;
@@ -61930,7 +62340,7 @@ async function runRalphWorkflow(ctx, options) {
     const researchPath = workflowResearchPath;
     finalResearchPath = researchPath;
     finalPlanPath = researchPath;
-    const orchestratorReportPath = join26(artifactDir, "orchestrator-report.md");
+    const orchestratorReportPath = join27(artifactDir, "orchestrator-report.md");
     const orchestratorForkOptions = forkContinuationOptions3(previousOrchestratorSessionId);
     const orchestratorPrompt = orchestratorForkOptions.forkFromSessionId === undefined ? taggedPrompt4([
       ["acceptance_criteria", keepContext(acceptanceCriteria)],
@@ -62066,7 +62476,7 @@ Read it before implementation or delegation because it is the primary current im
         diagnostics: parsed.diagnostics,
         allowFinalActionRemaining: createPr
       });
-      const artifactPath = join26(artifactDir, `review-${artifactSafeName2(reviewer)}.json`);
+      const artifactPath = join27(artifactDir, `review-${artifactSafeName2(reviewer)}.json`);
       await writeJsonArtifact(artifactPath, {
         reviewer,
         decision: parsed.decision,
@@ -62122,7 +62532,7 @@ Read it before implementation or delegation because it is the primary current im
         usage: fold_usage([orchestrator, ...reviews, ...reverifyResults])
       }));
     }
-    latestReviewReportPath = await writeJsonArtifact(join26(artifactDir, "review-round-latest.json"), {
+    latestReviewReportPath = await writeJsonArtifact(join27(artifactDir, "review-round-latest.json"), {
       convergence_decision: roundConvergenceDecision,
       convergence: convergenceEntries,
       consolidated_findings: reverified.batch,
@@ -62491,7 +62901,7 @@ var init_tournament_prompts = __esm(() => {
 
 // dist/builtin/workflows/builtin/tournament-runner.ts
 import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile9 } from "node:fs/promises";
-import { join as join27, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve13 } from "node:path";
+import { join as join28, isAbsolute as isAbsolute9, relative as relative5, resolve as resolve13 } from "node:path";
 import { Type as Type22 } from "typebox";
 function serializableObject3(value2) {
   if (value2 === null || Array.isArray(value2) || typeof value2 !== "object")
@@ -62580,16 +62990,16 @@ function combineUsage(totals) {
 }
 async function runTournament(ctx) {
   const artifactDir = await stableArtifactRoot(ctx, "tournament");
-  const attemptsDir = join27(artifactDir, "attempts");
+  const attemptsDir = join28(artifactDir, "attempts");
   const numAttempts = ctx.inputs.num_attempts ?? 4;
   const maxConcurrency = ctx.inputs.max_concurrency ?? 4;
   const nEvaluations = ctx.inputs.n_evaluations ?? 2;
   const pivotCount = ctx.inputs.pivots ?? 1;
   const seed = ctx.inputs.seed ?? 0;
-  const judgesDir = join27(artifactDir, "judges");
+  const judgesDir = join28(artifactDir, "judges");
   await mkdir5(attemptsDir, { recursive: true });
   await mkdir5(judgesDir, { recursive: true });
-  const attemptArtifactPaths = Array.from({ length: numAttempts }, (_, index) => join27(attemptsDir, `attempt-${index + 1}.md`));
+  const attemptArtifactPaths = Array.from({ length: numAttempts }, (_, index) => join28(attemptsDir, `attempt-${index + 1}.md`));
   const models = ctx.inputs.models;
   const attemptResults = await ctx.parallel(attemptArtifactPaths.map((path, index) => ({
     name: `attempt-${index + 1}`,
@@ -62754,7 +63164,7 @@ The previous report was invalid. Return the required JSON schema exactly once.`,
   const outputRanking = ranking.map(({ label, meanPreference }) => ({ label, meanPreference }));
   const budgetPivots = Math.min(pivotCount, entrants.length);
   const comparisonBudget = (entrants.length + budgetPivots * (entrants.length - budgetPivots) + budgetPivots * (budgetPivots - 1) / 2) * criteria.length * nEvaluations;
-  const comparisonPath = join27(artifactDir, "comparisons.json");
+  const comparisonPath = join28(artifactDir, "comparisons.json");
   const assignment = modelAssignment(entrants, models);
   const phaseUsage = {
     attempts: fold_usage(attemptResults),
@@ -62790,7 +63200,7 @@ The previous report was invalid. Return the required JSON schema exactly once.`,
   await writeLedger(fold_usage([]));
   const winner = ranking[0];
   const winnerEntrant = entrants[winner.index];
-  const resultPath = join27(artifactDir, "winner.md");
+  const resultPath = join28(artifactDir, "winner.md");
   const reducer = await ctx.task("comparisons-reducer", {
     prompt: renderComparisonsReducerPrompt({
       task: ctx.inputs.prompt,
@@ -64224,13 +64634,13 @@ var init_sql_pool_queue = __esm(() => {
 });
 
 // dist/builtin/workflows/src/engine/session-closed-error.ts
-import { isStaleExtensionContextError as isStaleExtensionContextError6 } from "@bastani/atomic";
+import { isStaleExtensionContextError as isStaleExtensionContextError7 } from "@bastani/atomic";
 function reportsClosedSession(error) {
-  return "code" in error && error.code === "SessionClosed" || isStaleExtensionContextError6(error);
+  return "code" in error && error.code === "SessionClosed" || isStaleExtensionContextError7(error);
 }
 function isSessionClosedError(error) {
   let current = error;
-  for (let depth = 0;depth < MAX_CAUSE_DEPTH2 && current !== undefined; depth++) {
+  for (let depth = 0;depth < MAX_CAUSE_DEPTH4 && current !== undefined; depth++) {
     try {
       if (reportsClosedSession(current))
         return true;
@@ -64241,7 +64651,7 @@ function isSessionClosedError(error) {
   }
   return false;
 }
-var MAX_CAUSE_DEPTH2 = 8;
+var MAX_CAUSE_DEPTH4 = 8;
 var init_session_closed_error = () => {};
 
 // dist/builtin/workflows/src/shared/external-run-routes.ts
@@ -65732,24 +66142,24 @@ function createMessageReader(onMessage, onError) {
 }
 
 // dist/builtin/intercom/broker/broker-status.ts
-function isObject(value2) {
+function isObject2(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
 function isOptionalString2(value2) {
   return value2 === undefined || typeof value2 === "string";
 }
 function isBrokerStatusReport(value2) {
-  if (!isObject(value2) || typeof value2.pid !== "number" || typeof value2.sessions !== "number")
+  if (!isObject2(value2) || typeof value2.pid !== "number" || typeof value2.sessions !== "number")
     return false;
   const { storage, multiNode } = value2;
-  if (storage !== undefined && (!isObject(storage) || typeof storage.digest !== "string" || storage.source !== "env" && storage.source !== "settings"))
+  if (storage !== undefined && (!isObject2(storage) || typeof storage.digest !== "string" || storage.source !== "env" && storage.source !== "settings"))
     return false;
-  return isObject(multiNode) && (multiNode.status === "off" || multiNode.status === "starting" || multiNode.status === "on" || multiNode.status === "unavailable") && isOptionalString2(multiNode.reason) && isOptionalString2(multiNode.adapter) && isOptionalString2(multiNode.prefix) && (multiNode.peers === undefined || Array.isArray(multiNode.peers) && multiNode.peers.every((peer) => typeof peer === "string"));
+  return isObject2(multiNode) && (multiNode.status === "off" || multiNode.status === "starting" || multiNode.status === "on" || multiNode.status === "unavailable") && isOptionalString2(multiNode.reason) && isOptionalString2(multiNode.adapter) && isOptionalString2(multiNode.prefix) && (multiNode.peers === undefined || Array.isArray(multiNode.peers) && multiNode.peers.every((peer) => typeof peer === "string"));
 }
 
 // dist/builtin/intercom/broker/paths.ts
 import { homedir as homedir2 } from "os";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 function getHomeDir() {
   if (process.platform === "win32") {
     if (process.env.USERPROFILE)
@@ -65766,7 +66176,7 @@ function expandTildePath(path) {
   if (path === "~")
     return getHomeDir();
   if (path.startsWith("~/") || process.platform === "win32" && path.startsWith("~\\")) {
-    return join28(getHomeDir(), path.slice(2));
+    return join29(getHomeDir(), path.slice(2));
   }
   return path;
 }
@@ -65777,31 +66187,31 @@ function getAgentDir5() {
   const piAgentDir = process.env.PI_CODING_AGENT_DIR;
   if (piAgentDir)
     return expandTildePath(piAgentDir);
-  return join28(getHomeDir(), ".atomic", "agent");
+  return join29(getHomeDir(), ".atomic", "agent");
 }
 function sanitizePipeSegment(value2) {
   return value2.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "default";
 }
 function getIntercomDirPath(agentDir = getAgentDir5()) {
-  return join28(agentDir, "intercom");
+  return join29(agentDir, "intercom");
 }
 function getBrokerPidPath(agentDir = getAgentDir5()) {
-  return join28(getIntercomDirPath(agentDir), "broker.pid");
+  return join29(getIntercomDirPath(agentDir), "broker.pid");
 }
 function getBrokerSpawnLockPath(agentDir = getAgentDir5()) {
-  return join28(getIntercomDirPath(agentDir), "broker.spawn.lock");
+  return join29(getIntercomDirPath(agentDir), "broker.spawn.lock");
 }
 function getBrokerLogPath(agentDir = getAgentDir5()) {
-  return join28(getIntercomDirPath(agentDir), "broker.log");
+  return join29(getIntercomDirPath(agentDir), "broker.log");
 }
 function getBrokerStartAnnouncementPath(agentDir = getAgentDir5()) {
-  return join28(getIntercomDirPath(agentDir), "broker.starting");
+  return join29(getIntercomDirPath(agentDir), "broker.starting");
 }
 function getBrokerSocketPath(platform = process.platform, agentDir = getAgentDir5()) {
   if (platform === "win32") {
     return `\\\\.\\pipe\\pi-intercom-${sanitizePipeSegment(agentDir)}`;
   }
-  return join28(getIntercomDirPath(agentDir), "broker.sock");
+  return join29(getIntercomDirPath(agentDir), "broker.sock");
 }
 var BROKER_STORAGE_ENV = "ATOMIC_STORAGE";
 var init_paths = () => {};
@@ -67508,26 +67918,26 @@ var init_start_announcement = () => {};
 // dist/builtin/intercom/broker/spawn.ts
 import { spawn } from "child_process";
 import { randomUUID as randomUUID15 } from "crypto";
-import { appendFileSync, chmodSync, closeSync as closeSync3, existsSync as existsSync7, mkdirSync as mkdirSync8, openSync as openSync3, readFileSync as readFileSync7, readSync as readSync2, statSync as statSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync6 } from "fs";
-import { join as join29, dirname as dirname14 } from "path";
+import { appendFileSync, chmodSync, closeSync as closeSync4, existsSync as existsSync7, mkdirSync as mkdirSync9, openSync as openSync4, readFileSync as readFileSync7, readSync as readSync2, statSync as statSync6, unlinkSync as unlinkSync4, writeFileSync as writeFileSync6 } from "fs";
+import { join as join30, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { createRequire as createRequire3 } from "module";
 import { createChildProcessEnvironment as createChildProcessEnvironment4, isBunBinary, processSharedStorageSelection } from "@bastani/atomic";
 function isIntercomPackageRoot(dir) {
-  return existsSync7(join29(dir, "package.json")) && existsSync7(join29(dir, "broker"));
+  return existsSync7(join30(dir, "package.json")) && existsSync7(join30(dir, "broker"));
 }
 function resolveIntercomPackageRoot(moduleHref) {
   const here = dirname14(fileURLToPath5(moduleHref));
   if (isIntercomPackageRoot(here))
     return here;
-  return join29(here, "..");
+  return join30(here, "..");
 }
 function resolveBrokerEntrypoint(packageRoot) {
-  const bundled = join29(packageRoot, "broker", "broker.bundle.mjs");
-  return existsSync7(bundled) ? bundled : join29(packageRoot, "broker", "broker.ts");
+  const bundled = join30(packageRoot, "broker", "broker.bundle.mjs");
+  return existsSync7(bundled) ? bundled : join30(packageRoot, "broker", "broker.ts");
 }
 function ensurePrivateDirectory(path) {
-  mkdirSync8(path, { recursive: true, mode: 448 });
+  mkdirSync9(path, { recursive: true, mode: 448 });
   if (process.platform !== "win32")
     chmodSync(path, 448);
 }
@@ -67540,14 +67950,14 @@ function getCurrentBrokerRuntime() {
   return isBunBinary ? "bun-binary" : "bun-source";
 }
 function requireFromExtensionDir(extensionDir) {
-  return createRequire3(join29(extensionDir, "package.json"));
+  return createRequire3(join30(extensionDir, "package.json"));
 }
 function getJitiCliPath(extensionDir = EXTENSION_DIR) {
   try {
     const jitiPackage = requireFromExtensionDir(extensionDir).resolve("jiti/package.json");
-    return join29(dirname14(jitiPackage), "lib", "jiti-cli.mjs");
+    return join30(dirname14(jitiPackage), "lib", "jiti-cli.mjs");
   } catch {
-    return join29(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
+    return join30(extensionDir, "node_modules", "jiti", "lib", "jiti-cli.mjs");
   }
 }
 function getDefaultBrokerRunnerPath(extensionDir) {
@@ -67569,7 +67979,7 @@ function quoteWindowsArg(value2) {
   return `"${value2.replace(/"/g, '""')}"`;
 }
 function getWindowsHiddenLauncherPath(intercomDir = INTERCOM_DIR) {
-  return join29(intercomDir, "broker-launch.vbs");
+  return join30(intercomDir, "broker-launch.vbs");
 }
 function usesDefaultBrokerCommand(brokerCommand, brokerArgs) {
   return brokerCommand === "npx" && brokerArgs.length === 2 && brokerArgs[0] === "--no-install" && brokerArgs[1] === "tsx";
@@ -67643,7 +68053,7 @@ function resetBrokerLog(logPath = BROKER_LOG) {
   ensurePrivateDirectory(dirname14(logPath));
   try {
     const previous = readBrokerLogTail(logPath);
-    closeSync3(openSync3(logPath, "w"));
+    closeSync4(openSync4(logPath, "w"));
     if (previous.length > 0) {
       try {
         const previousPath = `${logPath}.previous`;
@@ -67672,8 +68082,8 @@ async function resetBrokerLogOnceReleased() {
 function readBrokerLogTail(logPath = BROKER_LOG, maxBytes = BROKER_LOG_TAIL_BYTES) {
   let fd;
   try {
-    fd = openSync3(logPath, "r");
-    const size = statSync5(logPath).size;
+    fd = openSync4(logPath, "r");
+    const size = statSync6(logPath).size;
     const length = Math.min(size, maxBytes);
     if (length <= 0)
       return "";
@@ -67685,7 +68095,7 @@ function readBrokerLogTail(logPath = BROKER_LOG, maxBytes = BROKER_LOG_TAIL_BYTE
   } finally {
     if (fd !== undefined) {
       try {
-        closeSync3(fd);
+        closeSync4(fd);
       } catch {}
     }
   }
@@ -67731,13 +68141,13 @@ async function spawnBrokerIfNeeded(brokerCommand, brokerArgs, readyTimeoutMs = B
       await waitForBroker(readyTimeoutMs);
       return;
     }
-    const logFd = launch.kind === "direct" ? openSync3(BROKER_LOG, "a") : undefined;
+    const logFd = launch.kind === "direct" ? openSync4(BROKER_LOG, "a") : undefined;
     let child;
     try {
       child = spawn(launch.command, launch.args, getBrokerSpawnOptions(extensionDir, logFd ?? "ignore", announcement));
     } finally {
       if (logFd !== undefined)
-        closeSync3(logFd);
+        closeSync4(logFd);
     }
     child.unref();
     await new Promise((resolve, reject) => {
@@ -68550,12 +68960,12 @@ var init_sql_pool_usage = __esm(() => {
 
 // dist/builtin/workflows/src/workers/pooled-watch-trace.ts
 import { appendFileSync as appendFileSync2 } from "node:fs";
-import { dirname as dirname15, join as join30, resolve as resolve14 } from "node:path";
+import { dirname as dirname15, join as join31, resolve as resolve14 } from "node:path";
 function configurePooledWatchTrace(journalPath, processRole) {
   if (setting === undefined || setting === "" || setting === "0")
     return;
   role = processRole;
-  file = setting === "1" ? join30(dirname15(resolve14(journalPath)), "pooled-watch-trace.jsonl") : resolve14(setting);
+  file = setting === "1" ? join31(dirname15(resolve14(journalPath)), "pooled-watch-trace.jsonl") : resolve14(setting);
 }
 function tracePooledWatch(step, detail) {
   if (file === undefined)
@@ -68749,7 +69159,7 @@ import { fork } from "node:child_process";
 import { randomUUID as randomUUID17 } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { appendFile, mkdir as mkdir6, rm as rm3, rmdir } from "node:fs/promises";
-import { dirname as dirname16, join as join31, resolve as resolve15 } from "node:path";
+import { dirname as dirname16, join as join32, resolve as resolve15 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 function isRootLeaseLost(error) {
   return error instanceof StaleLeaseError || error.message.startsWith("Stale lease for run ");
@@ -68758,7 +69168,7 @@ function unconfirmedCleanup(groups) {
   return new Error(`Local worker process cleanup unconfirmed; ${groups.length > 0 ? `process groups ${groups.join(", ")} still running after SIGKILL; ` : ""}permits quarantined`);
 }
 function workerLogDirectory(journalPath, root) {
-  return join31(dirname16(resolve15(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
+  return join32(dirname16(resolve15(journalPath)), "worker-logs", encodeURIComponent(root).replaceAll(".", "%2E"));
 }
 function token(work) {
   return {
@@ -69690,7 +70100,7 @@ class PoolCoordinator {
     this.slots.add(slot);
     let ready = false;
     let serial = Promise.resolve();
-    const logPath = join31(this.logDirectory, `${worker}.log`);
+    const logPath = join32(this.logDirectory, `${worker}.log`);
     this.logs.set(child, logPath);
     let logFailure;
     const log = createWriteStream(logPath, { flags: "a" });
@@ -74404,7 +74814,7 @@ function describeErrorWithCauses(error) {
   const messages = [];
   const visited = new Set;
   let current = error;
-  for (let depth = 0;current !== undefined && depth < MAX_CAUSE_DEPTH3 && !visited.has(current); depth++) {
+  for (let depth = 0;current !== undefined && depth < MAX_CAUSE_DEPTH5 && !visited.has(current); depth++) {
     visited.add(current);
     const message = current instanceof Error ? current.message : String(current);
     if (!messages.includes(message))
@@ -74413,7 +74823,7 @@ function describeErrorWithCauses(error) {
   }
   return messages.join(": ");
 }
-var MAX_CAUSE_DEPTH3 = 5;
+var MAX_CAUSE_DEPTH5 = 5;
 
 // dist/builtin/workflows/src/engine/run-durable-finalize.ts
 async function finalizeDurableTerminalStatus(input) {
@@ -74877,407 +75287,6 @@ function deferStageUntilRunRelease(input) {
   };
 }
 
-// dist/builtin/workflows/src/engine/run-rejection-boundary.ts
-import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
-import { inspect } from "node:util";
-import { isStaleExtensionContextError as isStaleExtensionContextError7 } from "@bastani/atomic";
-function boundaryBag() {
-  return globalThis;
-}
-function sharedBoundary() {
-  const bag = boundaryBag();
-  const existing = bag[BOUNDARY_KEY];
-  if (existing !== undefined && existing.version === 5)
-    return existing;
-  const created = {
-    version: 5,
-    store: new AsyncLocalStorage4,
-    owners: new WeakMap,
-    promises: new WeakMap,
-    scopes: new Set,
-    runs: new Map,
-    ended: new Map,
-    stops: new Set,
-    listener: undefined
-  };
-  bag[BOUNDARY_KEY] = created;
-  return created;
-}
-function isObject2(value2) {
-  return typeof value2 === "object" && value2 !== null || typeof value2 === "function";
-}
-function isPrimitive(value2) {
-  return !isObject2(value2);
-}
-function safeField3(value2, key) {
-  try {
-    return value2[key];
-  } catch {
-    return;
-  }
-}
-function strongerEffect(left, right) {
-  return left === "fail-run" || right === "fail-run" ? "fail-run" : "ignore";
-}
-function addAttribution(into, scope, effect) {
-  into.set(scope, strongerEffect(into.get(scope), effect));
-}
-function recordedOwners(boundary, reason) {
-  const owners = new Map;
-  let stopped = false;
-  const seen = new Set;
-  const pending = [{ value: reason, depth: 0 }];
-  while (pending.length > 0) {
-    const { value: value2, depth } = pending.pop();
-    if (depth > MAX_CAUSE_DEPTH4)
-      continue;
-    if (isPrimitive(value2)) {
-      if (depth === 0 || value2 !== undefined && value2 !== null) {
-        for (const scope of boundary.scopes) {
-          const entry = scope.primitives.get(value2);
-          if (entry !== undefined)
-            addAttribution(owners, scope, entry.effect);
-        }
-        if (typeof value2 === "string" && boundary.stops.has(value2))
-          stopped = true;
-      }
-      continue;
-    }
-    if (seen.has(value2))
-      continue;
-    seen.add(value2);
-    for (const [scope, effect] of boundary.owners.get(value2) ?? [])
-      addAttribution(owners, scope, effect);
-    pending.push({ value: safeField3(value2, "cause"), depth: depth + 1 });
-    const errors = safeField3(value2, "errors");
-    if (Array.isArray(errors))
-      for (const entry of errors)
-        pending.push({ value: entry, depth: depth + 1 });
-  }
-  return { owners, stopped };
-}
-function pruneEndedSources(boundary) {
-  const now = Date.now();
-  for (const [source, trees] of boundary.ended) {
-    for (const [rootRunId, endedAt] of trees)
-      if (now - endedAt > ENDED_RUN_GRACE_MS)
-        trees.delete(rootRunId);
-    if (trees.size === 0)
-      boundary.ended.delete(source);
-  }
-}
-function recordEndedRun(boundary, scope) {
-  if (scope.source === undefined)
-    return;
-  const trees = boundary.ended.get(scope.source) ?? new Map;
-  trees.set(scope.rootRunId, Date.now());
-  boundary.ended.set(scope.source, trees);
-}
-function endedInAnotherRunTree(boundary, source, live) {
-  for (const endedRoot of boundary.ended.get(source)?.keys() ?? [])
-    if (endedRoot !== live.rootRunId)
-      return true;
-  return false;
-}
-function recognizedSources(boundary) {
-  pruneEndedSources(boundary);
-  const sources = new Set(boundary.ended.keys());
-  for (const scope of boundary.scopes)
-    if (scope.live && scope.source !== undefined)
-      sources.add(scope.source);
-  return sources;
-}
-function authoringSource(reason, sources) {
-  if (sources.size === 0 || !isObject2(reason))
-    return;
-  const stack = safeField3(reason, "stack");
-  if (typeof stack !== "string")
-    return;
-  for (const line of stack.split(`
-`)) {
-    if (!line.trimStart().startsWith("at "))
-      continue;
-    const path = parsePromptStackFrame(line)?.normalizedPath;
-    if (path === undefined)
-      continue;
-    if (isWorkflowRuntimeModule(path))
-      return;
-    if (/\/node_modules\//.test(path))
-      continue;
-    if (sources.has(path))
-      return path;
-  }
-  return;
-}
-function hasAncestorIn(scope, candidates) {
-  for (let ancestor = scope.parent;ancestor !== undefined; ancestor = ancestor.parent) {
-    if (candidates.has(ancestor))
-      return true;
-  }
-  return false;
-}
-function outermostLiveRuns(boundary, source) {
-  const matching = new Set;
-  for (const scope of boundary.scopes)
-    if (scope.live && scope.source === source)
-      matching.add(scope);
-  const outermost = new Set;
-  for (const scope of matching)
-    if (!hasAncestorIn(scope, matching))
-      outermost.add(scope);
-  return outermost;
-}
-function runOfSource(boundary, source) {
-  const [only, ...others] = outermostLiveRuns(boundary, source);
-  if (only === undefined)
-    return new Map;
-  if (others.length > 0 || only.sharedSource)
-    return;
-  if (endedInAnotherRunTree(boundary, source, only))
-    return;
-  return new Map([[only, "fail-run"]]);
-}
-function markSharedSource(boundary, source) {
-  const runs = outermostLiveRuns(boundary, source);
-  if (runs.size > 1)
-    for (const run of runs)
-      run.sharedSource = true;
-}
-function rejectingRun(boundary, recorded, promise, scoped) {
-  const tracked = promise === undefined ? undefined : boundary.promises.get(promise);
-  if (tracked !== undefined && recorded.has(tracked))
-    return tracked;
-  if (scoped !== undefined && recorded.has(scoped))
-    return scoped;
-  return;
-}
-function attribute(boundary, reason, promise) {
-  const { owners: recorded, stopped } = recordedOwners(boundary, reason);
-  const scoped = boundary.store.getStore();
-  if (recorded.size > 1) {
-    const rejecting = rejectingRun(boundary, recorded, promise, scoped);
-    if (rejecting !== undefined)
-      return new Map([[rejecting, recorded.get(rejecting) ?? "fail-run"]]);
-  }
-  if (recorded.size > 0)
-    return recorded;
-  if (stopped)
-    return new Map;
-  if (scoped !== undefined && boundary.scopes.has(scoped))
-    return new Map([[scoped, "fail-run"]]);
-  const origin = authoringSource(reason, recognizedSources(boundary));
-  if (origin === undefined)
-    return;
-  if (scoped !== undefined)
-    return new Map([[scoped, "ignore"]]);
-  return runOfSource(boundary, origin);
-}
-function unhandledRejectionError(reason) {
-  return Object.assign(new Error("This error originated either by throwing inside of an async function without a catch block, " + `or by rejecting a promise which was not handled with .catch(). The promise rejected with the reason "${inspect(reason)}".`), { code: "ERR_UNHANDLED_REJECTION" });
-}
-function unhandledRejectionsMode() {
-  const args = [...(process.env.NODE_OPTIONS ?? "").split(/\s+/), ...process.execArgv];
-  let mode = "throw";
-  for (let index = 0;index < args.length; index += 1) {
-    const arg = args[index] ?? "";
-    if (arg.startsWith(`${FLAG}=`))
-      mode = arg.slice(FLAG.length + 1);
-    else if (arg === FLAG && args[index + 1] !== undefined)
-      mode = args[index + 1] ?? mode;
-  }
-  return mode;
-}
-function surfaceNatively(boundary, reason) {
-  const listener = boundary.listener;
-  if (listener === undefined || process.listenerCount(EVENT) > 1)
-    return;
-  if (!NATIVE_REPORTING_MODES.has(unhandledRejectionsMode()))
-    return;
-  process.nextTick(() => {
-    process.removeListener(EVENT, listener);
-    Promise.reject(reason);
-    setImmediate(() => {
-      if (!process.listeners(EVENT).includes(listener))
-        process.on(EVENT, listener);
-    });
-  });
-}
-function onUnhandledRejection(reason, promise) {
-  const boundary = sharedBoundary();
-  const owners = attribute(boundary, reason, promise);
-  if (owners === undefined) {
-    surfaceNatively(boundary, reason);
-    return;
-  }
-  const error = isObject2(reason) ? reason : unhandledRejectionError(reason);
-  const staleExtensionContext = isStaleExtensionContextError7(error);
-  for (const [scope, effect] of owners) {
-    if (effect !== "fail-run" || !scope.live)
-      continue;
-    if (staleExtensionContext) {
-      console.error(`atomic-workflows: run ${scope.runId} ignored a stale extension-context rejection`, error);
-      continue;
-    }
-    try {
-      scope.fail(error);
-    } catch {}
-  }
-}
-function ensureInstalled(boundary) {
-  if (boundary.listener !== undefined)
-    return;
-  boundary.listener = onUnhandledRejection;
-  process.on(EVENT, onUnhandledRejection);
-}
-function record(boundary, scope, reason, effect) {
-  if (isPrimitive(reason)) {
-    recordPrimitive(scope, reason, effect);
-    return;
-  }
-  const owners = boundary.owners.get(reason);
-  if (owners === undefined)
-    boundary.owners.set(reason, new Map([[scope, effect]]));
-  else
-    addAttribution(owners, scope, effect);
-}
-function recordStop(boundary, reason) {
-  boundary.stops.delete(reason);
-  boundary.stops.add(reason);
-  if (boundary.stops.size <= MAX_STOP_STRINGS)
-    return;
-  const oldest = boundary.stops.values().next();
-  if (!oldest.done)
-    boundary.stops.delete(oldest.value);
-}
-function recordPrimitive(scope, reason, effect) {
-  if (!scope.live)
-    return;
-  if (scope.primitives.size >= MAX_PRIMITIVES_PER_RUN && !scope.primitives.has(reason)) {
-    const oldest = scope.primitives.keys().next();
-    if (!oldest.done)
-      scope.primitives.delete(oldest.value);
-  }
-  scope.generation += 1;
-  const generation = scope.generation;
-  scope.primitives.set(reason, { effect: strongerEffect(scope.primitives.get(reason)?.effect, effect), generation });
-  afterPendingRejectionReports().then(() => {
-    if (scope.primitives.get(reason)?.generation === generation)
-      scope.primitives.delete(reason);
-  });
-}
-function discardFailure() {}
-function afterPendingRejectionReports() {
-  return new Promise((resolve) => {
-    const { port1, port2 } = new MessageChannel;
-    port1.onmessage = () => {
-      port1.close();
-      port2.close();
-      resolve();
-    };
-    port2.postMessage(undefined);
-  });
-}
-function openRunRejectionScope(options) {
-  const boundary = sharedBoundary();
-  ensureInstalled(boundary);
-  pruneEndedSources(boundary);
-  const parent = options.parentRunId === undefined ? undefined : boundary.runs.get(options.parentRunId);
-  const scope = {
-    runId: options.runId,
-    rootRunId: parent?.rootRunId ?? options.runId,
-    source: options.source === undefined ? undefined : normalizeStackPath(options.source),
-    parent,
-    fail: options.fail,
-    primitives: new Map,
-    generation: 0,
-    live: true,
-    sharedSource: false
-  };
-  boundary.scopes.add(scope);
-  boundary.runs.set(scope.runId, scope);
-  if (scope.source !== undefined)
-    markSharedSource(boundary, scope.source);
-  return {
-    run: (callback) => boundary.store.run(scope, callback),
-    contain: (promise, effect = "fail-run") => {
-      boundary.promises.set(promise, scope);
-      promise.then(undefined, (reason) => record(boundary, scope, reason, effect));
-      return promise;
-    },
-    watch: (promise) => {
-      const watched = promise.then(undefined, (reason) => {
-        record(boundary, scope, reason, "fail-run");
-        throw reason;
-      });
-      boundary.promises.set(watched, scope);
-      return watched;
-    },
-    ignore: (reason) => {
-      if (typeof reason === "string")
-        recordStop(boundary, reason);
-      else
-        record(boundary, scope, reason, "ignore");
-    },
-    settle: afterPendingRejectionReports,
-    close: () => {
-      scope.live = false;
-      scope.fail = discardFailure;
-      recordEndedRun(boundary, scope);
-      afterPendingRejectionReports().then(() => {
-        scope.primitives.clear();
-        scope.parent = undefined;
-        boundary.scopes.delete(scope);
-        if (boundary.runs.get(scope.runId) === scope)
-          boundary.runs.delete(scope.runId);
-      });
-    }
-  };
-}
-function containStageRejections(stage, scope) {
-  const contained = Object.create(stage);
-  const descriptors = {};
-  for (const name of WATCHED_STAGE_METHODS) {
-    descriptors[name] = {
-      value: (...args) => {
-        const result = Reflect.apply(stage[name], stage, args);
-        return result instanceof Promise ? scope.watch(result) : result;
-      }
-    };
-  }
-  Object.defineProperties(contained, descriptors);
-  return contained;
-}
-function containUiRejections(ui, scope) {
-  return {
-    input: (prompt) => scope.watch(ui.input(prompt)),
-    confirm: (message) => scope.watch(ui.confirm(message)),
-    select: (message, options) => scope.watch(ui.select(message, options)),
-    editor: (initial) => scope.watch(ui.editor(initial)),
-    custom: (factory, options) => scope.watch(ui.custom(factory, options))
-  };
-}
-var EVENT = "unhandledRejection", BOUNDARY_KEY, FLAG = "--unhandled-rejections", MAX_CAUSE_DEPTH4 = 8, MAX_PRIMITIVES_PER_RUN = 64, MAX_STOP_STRINGS = 64, ENDED_RUN_GRACE_MS = 30000, NATIVE_REPORTING_MODES, WATCHED_STAGE_METHODS;
-var init_run_rejection_boundary = __esm(() => {
-  init_prompt_callsite();
-  init_workflow_source();
-  BOUNDARY_KEY = Symbol.for("atomic-workflows/run-rejection-boundary@5");
-  NATIVE_REPORTING_MODES = new Set(["throw", "warn-with-error-code"]);
-  WATCHED_STAGE_METHODS = [
-    "prompt",
-    "complete",
-    "sendUserMessage",
-    "steer",
-    "followUp",
-    "setModel",
-    "setThinkingLevel",
-    "cycleModel",
-    "cycleThinkingLevel",
-    "navigateTree",
-    "compact",
-    "abort"
-  ];
-});
-
 // dist/builtin/workflows/src/engine/run-returned-status.ts
 function classifyReturnedRunStatus(result, runSnapshot) {
   const structuredFailure = runSnapshot !== undefined ? structuredRecoverableWorkflowFailure(runSnapshot) : undefined;
@@ -80076,7 +80085,7 @@ var init_stage_runner_controller = __esm(() => {
 // dist/builtin/workflows/src/runs/foreground/stage-runner-output.ts
 import { createHash as createHash5 } from "node:crypto";
 import { mkdir as mkdir7, writeFile as writeFile10 } from "node:fs/promises";
-import { basename as basename5, dirname as dirname17, isAbsolute as isAbsolute11, join as join32, resolve as resolve18 } from "node:path";
+import { basename as basename5, dirname as dirname17, isAbsolute as isAbsolute11, join as join33, resolve as resolve18 } from "node:path";
 function normalizeMaxOutput2(maxOutput) {
   return {
     bytes: maxOutput?.bytes ?? DEFAULT_MAX_OUTPUT_BYTES,
@@ -80139,7 +80148,7 @@ function formatByteSize(bytes) {
 }
 function transcriptPath(runId, outputPath) {
   const digest = createHash5("sha256").update(outputPath).digest("hex").slice(0, 16);
-  return join32(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename5(outputPath)}.transcript.md`);
+  return join33(workflowArtifactRunPath(runId), "transcripts", `${digest}-${basename5(outputPath)}.transcript.md`);
 }
 function appendContent(lines, content) {
   if (typeof content === "string") {
@@ -81815,6 +81824,7 @@ async function executeRun(def, resolvedInputs, opts) {
     runId,
     ...opts.parentRun !== undefined ? { parentRunId: opts.parentRun.runId } : {},
     ...authoredIn !== undefined ? { source: authoredIn } : {},
+    ...opts.routeConsoleToLog === true ? { consoleLog: true } : {},
     fail: (error) => {
       if (findWorkflowGracefulQuit(error) !== undefined)
         return;
@@ -81823,6 +81833,8 @@ async function executeRun(def, resolvedInputs, opts) {
         ownController.abort(selected.error);
     }
   });
+  const abortOutsideRunScope = ownController.abort.bind(ownController);
+  ownController.abort = (reason) => rejectionScope.run(() => abortOutsideRunScope(reason));
   ownController.signal.addEventListener("abort", () => rejectionScope.ignore(ownController.signal.reason), {
     once: true
   });
@@ -82496,8 +82508,8 @@ var init_workflows_host_module = __esm(() => {
 
 // dist/builtin/workflows/src/workers/pool-journal.ts
 import { createHash as createHash6, randomUUID as randomUUID22 } from "node:crypto";
-import { existsSync as existsSync9, mkdirSync as mkdirSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename6, dirname as dirname18, join as join33, resolve as resolve19 } from "node:path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync10, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { basename as basename6, dirname as dirname18, join as join34, resolve as resolve19 } from "node:path";
 import { storageSelectionKey as storageSelectionKey2 } from "@bastani/atomic/storage";
 function encodeOption(value2) {
   if (typeof value2 === "bigint")
@@ -82551,7 +82563,7 @@ function openDurableJournal(durable) {
   return openSelectedRunJournal(decodeSelection(durable.selection), durable.agentDir);
 }
 function poolStateDirectory(agentDir) {
-  return join33(dirname18(agentDir), "workflows", "pool");
+  return join34(dirname18(agentDir), "workflows", "pool");
 }
 function databaseIdentity(selection, agentDir) {
   return storageSelectionKey2(selection.kind === "adapter" ? { ...selection, secrets: undefined } : selection, agentDir);
@@ -82559,7 +82571,7 @@ function databaseIdentity(selection, agentDir) {
 function coordinationPath(durable) {
   const selection = decodeSelection(durable.selection);
   const identity = createHash6("sha256").update(databaseIdentity(selection, durable.agentDir)).digest("hex");
-  return join33(poolStateDirectory(durable.agentDir), `${identity.slice(0, 24)}.sqlite`);
+  return join34(poolStateDirectory(durable.agentDir), `${identity.slice(0, 24)}.sqlite`);
 }
 function coordinationDatabase(durable) {
   return basename6(coordinationPath(durable), ".sqlite");
@@ -82568,7 +82580,7 @@ function openCoordinationJournal(path) {
   const file = resolve19(path);
   let opened = coordinationJournals.get(file);
   if (opened === undefined) {
-    mkdirSync9(dirname18(file), { recursive: true });
+    mkdirSync10(dirname18(file), { recursive: true });
     opened = resolveRunJournal({ journal: { path: file } });
     coordinationJournals.set(file, opened);
     opened.catch(() => {
@@ -82585,13 +82597,13 @@ function poolJournalFor(journal) {
   return coordinations.get(journal) ?? journal;
 }
 function poolHostId(agentDir) {
-  const file = join33(poolStateDirectory(agentDir), "host-id");
+  const file = join34(poolStateDirectory(agentDir), "host-id");
   try {
     const existing = readFileSync9(file, "utf8").trim();
     if (existing !== "")
       return existing;
   } catch {}
-  mkdirSync9(dirname18(file), { recursive: true });
+  mkdirSync10(dirname18(file), { recursive: true });
   const id = randomUUID22();
   try {
     writeFileSync7(file, `${id}
@@ -82679,18 +82691,18 @@ class CheckpointCatalogIndex {
       stages.push(checkpoint);
       const key = durableStageGroupKey(checkpoint);
       this.groupKeys.set(checkpoint, key);
-      append(this.groups, key, checkpoint);
+      append2(this.groups, key, checkpoint);
       const runId = checkpoint.topology?.run?.runId;
       if (runId !== undefined)
-        append(this.stagesByRunId, runId, checkpoint);
+        append2(this.stagesByRunId, runId, checkpoint);
       if (checkpoint.output !== undefined)
-        append(this.outputsByReplayKey, checkpoint.replayKey, checkpoint);
+        append2(this.outputsByReplayKey, checkpoint.replayKey, checkpoint);
       const boundary = checkpoint.topology?.boundary;
       if (boundary === undefined)
         return;
-      append(this.boundariesByReplayKey, checkpoint.replayKey, checkpoint);
-      append(this.boundariesByStageId, checkpoint.topology.stageId, checkpoint);
-      append(this.boundariesByChildRunId, boundary.child.runId, checkpoint);
+      append2(this.boundariesByReplayKey, checkpoint.replayKey, checkpoint);
+      append2(this.boundariesByStageId, checkpoint.topology.stageId, checkpoint);
+      append2(this.boundariesByChildRunId, boundary.child.runId, checkpoint);
     });
     this.stages = stages;
   }
@@ -82754,7 +82766,7 @@ function hasPrefix(sorted, prefix) {
 function compareCodeUnits(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
-function append(map, key, value2) {
+function append2(map, key, value2) {
   const list = map.get(key);
   if (list === undefined)
     map.set(key, [value2]);
@@ -84487,10 +84499,180 @@ __export(exports_builtin, {
 
 // dist/builtin/workflows/src/extension/extension-factory.ts
 init_store_backend();
-import { registerExtensionContextRetirementEffect as registerExtensionContextRetirementEffect3 } from "@bastani/atomic";
+import { join as join39 } from "node:path";
+import { getAgentDir as getAgentDir8, registerExtensionContextRetirementEffect as registerExtensionContextRetirementEffect3 } from "@bastani/atomic";
+
+// dist/builtin/workflows/src/engine/run-console.ts
+init_run_rejection_boundary();
+import { closeSync, mkdirSync, openSync, readdirSync, rmSync, statSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { format } from "node:util";
+var METHODS = ["log", "info", "debug", "warn", "error"];
+var ROUTER_KEY = Symbol.for("atomic-workflows/run-console@4");
+var MAX_RUN_CONSOLE_BYTES = 8 * 1024 * 1024;
+var MAX_PROCESS_CONSOLE_LOG_BYTES = 64 * 1024 * 1024;
+var CONSOLE_LOG_RETENTION_MS = 14 * 24 * 60 * 60 * 1000;
+var MAX_CONSOLE_LOG_DIRECTORY_BYTES = 1024 * 1024 * 1024;
+var MAX_CAUSE_DEPTH2 = 8;
+var LOG_NAME = /^(\d+)-\d+\.log$/;
+function routerBag() {
+  return globalThis;
+}
+function isAbortCancellation(value2, depth = 0) {
+  try {
+    if (!(value2 instanceof Error) || depth > MAX_CAUSE_DEPTH2)
+      return false;
+    if (value2.name === "AbortError")
+      return true;
+    const cause = value2.cause;
+    return cause !== value2 && isAbortCancellation(cause, depth + 1);
+  } catch {
+    return false;
+  }
+}
+function writeAll(fd, text) {
+  const buffer = Buffer.from(text);
+  let offset = 0;
+  while (offset < buffer.length) {
+    const written = writeSync(fd, buffer, offset, buffer.length - offset);
+    if (written <= 0)
+      throw new Error(`wrote ${offset} of ${buffer.length} bytes`);
+    offset += written;
+  }
+  return buffer.length;
+}
+function processLog(state, directory) {
+  if (state.log !== undefined)
+    return state.log;
+  const path = join(directory, `${process.pid}-${Date.now()}.log`);
+  const fd = openSync(path, "wx");
+  state.log = { path, fd, bytes: 0, capped: false };
+  return state.log;
+}
+function append(log, run, method, args) {
+  if (log.capped || run.capped)
+    return false;
+  const stamp = new Date().toISOString();
+  const processMarker = `${stamp} log limit reached; later workflow console output is dropped
+`;
+  const fits = (text) => log.bytes + Buffer.byteLength(text) + Buffer.byteLength(processMarker) <= MAX_PROCESS_CONSOLE_LOG_BYTES;
+  const capProcess = () => {
+    log.capped = true;
+    log.bytes += writeAll(log.fd, processMarker);
+    return false;
+  };
+  const line = `${stamp} ${run.rootRunId} ${method} ${format(...args)}
+`;
+  const size = Buffer.byteLength(line);
+  if (run.bytes + size > MAX_RUN_CONSOLE_BYTES) {
+    run.capped = true;
+    const runMarker = `${stamp} ${run.rootRunId} run log limit reached; its later output is dropped
+`;
+    if (!fits(runMarker))
+      return capProcess();
+    log.bytes += writeAll(log.fd, runMarker);
+    return false;
+  }
+  if (!fits(line))
+    return capProcess();
+  log.bytes += writeAll(log.fd, line);
+  run.bytes += size;
+  return true;
+}
+function write(state, method, args, run, directory) {
+  if (state.failed)
+    return;
+  let log;
+  let written;
+  try {
+    log = processLog(state, directory);
+    written = append(log, run, method, args);
+  } catch (error) {
+    state.failed = true;
+    const path = state.log?.path ?? directory;
+    if (state.log !== undefined) {
+      try {
+        closeSync(state.log.fd);
+      } catch {}
+      state.log = undefined;
+    }
+    const cause = error instanceof Error ? error.message : String(error);
+    state.originals.warn(`atomic-workflows: workflow console output could not be written to ${path} (${cause}); later workflow console output is dropped`);
+    return;
+  }
+  if (written && !run.announced && !args.some((arg) => isAbortCancellation(arg))) {
+    run.announced = true;
+    state.originals.warn(`atomic-workflows: run ${run.rootRunId} console output is in ${log.path}`);
+  }
+}
+function routed(state, method) {
+  return (...args) => {
+    const directory = state.logDirectory;
+    const run = directory === undefined ? undefined : currentRunConsole();
+    if (directory === undefined || run === undefined)
+      state.originals[method](...args);
+    else
+      write(state, method, args, run, directory);
+  };
+}
+function installedRouter() {
+  const bag = routerBag();
+  const existing = bag[ROUTER_KEY];
+  if (existing !== undefined)
+    return existing;
+  const originals = Object.fromEntries(METHODS.map((method) => [method, console[method].bind(console)]));
+  const state = { logDirectory: undefined, log: undefined, failed: false, originals };
+  for (const method of METHODS)
+    console[method] = routed(state, method);
+  bag[ROUTER_KEY] = state;
+  return state;
+}
+function processAlive(pid) {
+  if (pid === process.pid)
+    return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function pruneLogs(directory, now) {
+  const logs = readdirSync(directory).flatMap((name) => {
+    const pid = LOG_NAME.exec(name)?.[1];
+    if (pid === undefined)
+      return [];
+    const path = join(directory, name);
+    try {
+      const { mtimeMs, size } = statSync(path);
+      return [{ path, mtimeMs, size, live: processAlive(Number(pid)) }];
+    } catch {
+      return [];
+    }
+  });
+  let total = logs.reduce((sum, log) => sum + log.size, 0);
+  for (const log of logs.filter(({ live }) => !live).sort((left, right) => left.mtimeMs - right.mtimeMs)) {
+    if (now - log.mtimeMs < CONSOLE_LOG_RETENTION_MS && total <= MAX_CONSOLE_LOG_DIRECTORY_BYTES)
+      break;
+    try {
+      rmSync(log.path, { force: true });
+      total -= log.size;
+    } catch {}
+  }
+}
+function routeWorkflowConsoleOutput(logDirectory, now = Date.now()) {
+  const state = installedRouter();
+  if (state.logDirectory === logDirectory)
+    return;
+  try {
+    mkdirSync(logDirectory, { recursive: true });
+    pruneLogs(logDirectory, now);
+  } catch {}
+  state.logDirectory = logDirectory;
+}
 
 // dist/builtin/workflows/src/intercom/intercom-routing.ts
-import { isStaleExtensionContextError } from "@bastani/atomic";
+import { isStaleExtensionContextError as isStaleExtensionContextError2 } from "@bastani/atomic";
 function toNoticeLevel(raw) {
   if (raw === "warning" || raw === "error")
     return raw;
@@ -84522,7 +84704,7 @@ function buildIntercomCallbacks(deps) {
           accepted
         });
       } catch (error) {
-        if (!isStaleExtensionContextError(error))
+        if (!isStaleExtensionContextError2(error))
           throw error;
       }
       store.ackNotice(noticeId);
@@ -84551,7 +84733,7 @@ function buildIntercomCallbacks(deps) {
 }
 
 // dist/builtin/workflows/src/intercom/result-intercom.ts
-import { isStaleExtensionContextError as isStaleExtensionContextError2 } from "@bastani/atomic";
+import { isStaleExtensionContextError as isStaleExtensionContextError3 } from "@bastani/atomic";
 function subscribeIntercomControl(pi, callbacks) {
   if (typeof pi.events?.on !== "function")
     return null;
@@ -84580,7 +84762,7 @@ function subscribeIntercomControl(pi, callbacks) {
   try {
     unsubscribe = pi.events.on("subagent:control-intercom", handler);
   } catch (error) {
-    if (!isStaleExtensionContextError2(error))
+    if (!isStaleExtensionContextError3(error))
       throw error;
     return null;
   }
@@ -84590,7 +84772,7 @@ function subscribeIntercomControl(pi, callbacks) {
       if (typeof unsubscribe === "function")
         unsubscribe();
     } catch (error) {
-      if (!isStaleExtensionContextError2(error))
+      if (!isStaleExtensionContextError3(error))
         throw error;
     }
   };
@@ -86501,7 +86683,7 @@ function deriveGraphThemeFromPiTheme(theme) {
 }
 
 // dist/builtin/workflows/src/tui/inline-form-overlay.ts
-import { isStaleExtensionContextError as isStaleExtensionContextError3 } from "@bastani/atomic";
+import { isStaleExtensionContextError as isStaleExtensionContextError4 } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/tui/header.ts
 function pillFor(run, theme) {
@@ -88219,7 +88401,7 @@ async function openInlineInputsForm(pi, ctx, opts) {
       try {
         return getEditor.call(ctx.ui) === installedFactory;
       } catch (err) {
-        if (isStaleExtensionContextError3(err)) {
+        if (isStaleExtensionContextError4(err)) {
           return false;
         }
         return true;
@@ -94960,7 +95142,7 @@ function buildGraphOverlayAdapter(pi, store, buildOpts = {}) {
 import {
   decideReactiveWidgetAction,
   installReactiveWidget,
-  isStaleExtensionContextError as isStaleExtensionContextError4
+  isStaleExtensionContextError as isStaleExtensionContextError5
 } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/tui/widget.ts
@@ -95816,7 +95998,7 @@ function installStoreWidget(pi, storeInstance, timers = defaultTimerApi, clock =
     render: (snap, { theme, width, now }) => buildThemedWidgetLines(snap, theme, width, now, layout),
     getNextRefreshDelayMs: (snap, now) => nextWidgetRefreshDelayMs(snap, now),
     requestRenderOnStateNoop: false,
-    isStaleError: isStaleExtensionContextError4,
+    isStaleError: isStaleExtensionContextError5,
     onMountError: (error) => {
       reportWidgetFailure(ui, `Workflow progress widget could not mount: ${error.message}`);
     }
@@ -97672,7 +97854,7 @@ function installCompactionHook(api, store) {
   });
 }
 // dist/builtin/workflows/src/extension/config-loader.ts
-import { isAbsolute as isAbsolute12, join as join34 } from "node:path";
+import { isAbsolute as isAbsolute12, join as join35 } from "node:path";
 import { CONFIG_DIR_NAME as CONFIG_DIR_NAME2, getAgentDir as getAgentDir6 } from "@bastani/atomic";
 // dist/builtin/workflows/src/extension/lifecycle-notifications.ts
 init_returned_run_status();
@@ -98589,7 +98771,7 @@ function resolveWorkflowPaths(workflows, baseDir) {
   }
   return Object.fromEntries(Object.entries(workflows).map(([name, entry]) => [
     name,
-    isAbsolute12(entry.path) ? entry.path : join34(baseDir, entry.path)
+    isAbsolute12(entry.path) ? entry.path : join35(baseDir, entry.path)
   ]));
 }
 function workflowAgentDirs(opts) {
@@ -98597,12 +98779,12 @@ function workflowAgentDirs(opts) {
     return opts.agentDirs;
   if (opts.homeDir !== undefined) {
     const homeDir = opts.homeDir;
-    return [join34(homeDir, CONFIG_DIR_NAME2, "agent")];
+    return [join35(homeDir, CONFIG_DIR_NAME2, "agent")];
   }
   return [getAgentDir6()];
 }
 function toScopedDiscoveryConfig(globalConfig, projectConfig, opts) {
-  const globalBase = opts.agentDir ?? (opts.homeDir === undefined ? getAgentDir6() : join34(opts.homeDir, CONFIG_DIR_NAME2, "agent"));
+  const globalBase = opts.agentDir ?? (opts.homeDir === undefined ? getAgentDir6() : join35(opts.homeDir, CONFIG_DIR_NAME2, "agent"));
   const projectBase = opts.projectRoot;
   const result = {};
   const projectWorkflows = resolveWorkflowPaths(projectConfig?.workflows, projectBase);
@@ -98612,7 +98794,7 @@ function toScopedDiscoveryConfig(globalConfig, projectConfig, opts) {
   if (hasWorkflows(globalConfig)) {
     const projectKeys = new Set(Object.keys(projectWorkflows ?? {}));
     const globalEntries = Object.entries(globalConfig.workflows).filter(([name]) => !projectKeys.has(name)).map(([name, entry]) => {
-      return [name, isAbsolute12(entry.path) ? entry.path : join34(globalBase, entry.path)];
+      return [name, isAbsolute12(entry.path) ? entry.path : join35(globalBase, entry.path)];
     });
     if (globalEntries.length > 0) {
       result.globalWorkflows = Object.fromEntries(globalEntries);
@@ -98623,8 +98805,8 @@ function toScopedDiscoveryConfig(globalConfig, projectConfig, opts) {
 async function loadWorkflowConfig(opts = {}) {
   const projectRoot = opts.projectRoot ?? process.cwd();
   const diagnostics = [];
-  const globalCandidates = workflowAgentDirs(opts).map((agentDir) => join34(agentDir, "extensions", "workflow", "config.json"));
-  const projectCandidates = [join34(projectRoot, CONFIG_DIR_NAME2, "extensions", "workflow", "config.json")];
+  const globalCandidates = workflowAgentDirs(opts).map((agentDir) => join35(agentDir, "extensions", "workflow", "config.json"));
+  const projectCandidates = [join35(projectRoot, CONFIG_DIR_NAME2, "extensions", "workflow", "config.json")];
   let globalConfig = null;
   for (let i = globalCandidates.length - 1;i >= 0; i--) {
     const globalPath = globalCandidates[i];
@@ -100316,7 +100498,7 @@ init_possible_stages();
 import { registerExtensionContextRetirementEffect as registerExtensionContextRetirementEffect2 } from "@bastani/atomic";
 
 // dist/builtin/workflows/src/extension/discovery.ts
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 import { CONFIG_DIR_NAME as CONFIG_DIR_NAME3, getAgentDir as getAgentDir7 } from "@bastani/atomic";
 
 // dist/builtin/workflows/builtin/index.ts
@@ -100337,12 +100519,12 @@ init_registry();
 // dist/builtin/workflows/src/extension/discovery-loaders.ts
 init_workflow_module_loader();
 import { readdir as readdir2, stat as stat2 } from "node:fs/promises";
-import { extname, isAbsolute as isAbsolute13, join as join35, resolve as resolve21 } from "node:path";
+import { extname, isAbsolute as isAbsolute13, join as join36, resolve as resolve21 } from "node:path";
 async function scanWorkflowDir(dir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     const WORKFLOW_EXTS = new Set([".ts", ".js", ".mjs", ".cjs"]);
-    return entries.filter((e) => e.isFile() && WORKFLOW_EXTS.has(extname(e.name))).map((e) => join35(dir, e.name)).sort();
+    return entries.filter((e) => e.isFile() && WORKFLOW_EXTS.has(extname(e.name))).map((e) => join36(dir, e.name)).sort();
   } catch {
     return null;
   }
@@ -100412,7 +100594,7 @@ function workflowAgentDirs2(options) {
     return options.agentDirs;
   if (options?.homeDir !== undefined) {
     const homeDir = options.homeDir;
-    return [join36(homeDir, CONFIG_DIR_NAME3, "agent")];
+    return [join37(homeDir, CONFIG_DIR_NAME3, "agent")];
   }
   return [getAgentDir7()];
 }
@@ -100568,7 +100750,7 @@ async function discoverWorkflows(options) {
       registry = await applyBatch(candidates, registry, sources, diagnostics);
     }
   }
-  for (const dir of [join36(cwd, CONFIG_DIR_NAME3, "workflows")]) {
+  for (const dir of [join37(cwd, CONFIG_DIR_NAME3, "workflows")]) {
     const candidates = await loadFromDir(dir, "project-local", diagnostics, getWorkflowHostModules);
     registry = await applyBatch(candidates, registry, sources, diagnostics);
   }
@@ -100580,7 +100762,7 @@ async function discoverWorkflows(options) {
       registry = await applyBatch(candidates, registry, sources, diagnostics);
     }
   }
-  for (const dir of agentDirs.map((agentDir) => join36(agentDir, "workflows")).reverse()) {
+  for (const dir of agentDirs.map((agentDir) => join37(agentDir, "workflows")).reverse()) {
     const candidates = await loadFromDir(dir, "user-global", diagnostics, getWorkflowHostModules);
     registry = await applyBatch(candidates, registry, sources, diagnostics);
   }
@@ -100887,6 +101069,7 @@ async function dispatch(args, opts) {
           budget: args.budget,
           models: opts.models,
           executionMode: policy.mode,
+          ...opts.routeConsoleToLog === true ? { routeConsoleToLog: true } : {},
           cwd: opts.cwd,
           defaultSessionDir: opts.defaultSessionDir,
           ...opts.origin === undefined ? {} : { origin: opts.origin },
@@ -101275,6 +101458,7 @@ function createExtensionRuntime(opts = {}) {
       models,
       ...defaultSessionDir !== undefined ? { defaultSessionDir } : {},
       ...policy !== undefined ? { executionMode: policy.mode } : {},
+      ...opts.routeConsoleToLog === true ? { routeConsoleToLog: true } : {},
       registry,
       cwd: runtimeCwd,
       [hostWorkerBindings]: true
@@ -101425,6 +101609,7 @@ function createExtensionRuntime(opts = {}) {
         config,
         models,
         resolvePossibleStageEntry,
+        ...opts.routeConsoleToLog === true ? { routeConsoleToLog: true } : {},
         policy: options?.policy,
         modelOwner: options?.modelOwner,
         ...options?.origin === undefined ? {} : { origin: options.origin },
@@ -101455,14 +101640,14 @@ function createExtensionRuntime(opts = {}) {
 
 // dist/builtin/workflows/src/extension/status-writer.ts
 import { mkdir as mkdir8, rename as rename2, writeFile as writeFile11 } from "node:fs/promises";
-import { dirname as dirname19, join as join37 } from "node:path";
+import { dirname as dirname19, join as join38 } from "node:path";
 import { CONFIG_DIR_NAME as CONFIG_DIR_NAME4 } from "@bastani/atomic";
-var DEFAULT_STATUS_SUBPATH = join37(CONFIG_DIR_NAME4, "workflows", "status.json");
+var DEFAULT_STATUS_SUBPATH = join38(CONFIG_DIR_NAME4, "workflows", "status.json");
 function resolveStatusFilePath(config, opts = {}) {
   if (config.statusFilePath)
     return config.statusFilePath;
   const root = opts.projectRoot ?? process.cwd();
-  return join37(root, DEFAULT_STATUS_SUBPATH);
+  return join38(root, DEFAULT_STATUS_SUBPATH);
 }
 async function atomicWriteJson(path, content) {
   const dir = dirname19(path);
@@ -102662,7 +102847,7 @@ function createWorkflowExtensionRuntimeState(pi, adapters, options = {}) {
   function runtimeForContext(ctx) {
     const contextTrusted = ctx?.isProjectTrusted?.();
     const models = workflowModelCatalogFromContext(ctx, resolveLiveModelContext);
-    if (models === undefined && !ctx?.generateWorkflowSummary && contextTrusted === undefined)
+    if (models === undefined && !ctx?.generateWorkflowSummary && contextTrusted === undefined && ctx?.mode !== "tui")
       return runtimeProxy;
     return createExtensionRuntime({
       registry: runtimeRef.current.registry,
@@ -102679,7 +102864,8 @@ function createWorkflowExtensionRuntimeState(pi, adapters, options = {}) {
       ...models === undefined ? {} : { models },
       summaryContext: ctx,
       resolveDefaultStageSessionDir,
-      beforeRestoreCompleted
+      beforeRestoreCompleted,
+      ...ctx?.mode === "tui" ? { routeConsoleToLog: true } : {}
     });
   }
   let lazyDiscoveryPromise = null;
@@ -107565,6 +107751,8 @@ function factory(pi) {
   let hostSessionContext;
   pi.on?.("session_start", (_event, ctx) => {
     hostSessionContext = ctx;
+    if (ctx?.mode === "tui")
+      routeWorkflowConsoleOutput(join39(getAgentDir8(), "workflow-logs"));
   });
   const ownerSessionClosing = () => (hostSessionContext?.getCurrentSessionSignal?.() ?? hostSessionContext?.sessionSignal)?.aborted === true;
   const adapters = buildRuntimeAdapters(pi, {