@nathapp/nax 0.83.0-canary.1 → 0.83.0-canary.2

package/dist/nax.js

@@ -2668,7 +2668,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.83.0-canary.1",
+    version: "0.83.0-canary.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -17962,7 +17962,8 @@ var init_schemas_sandbox = __esm(() => {
     backend: exports_external.enum(["srt"]).default("srt"),
     filesystem: exports_external.object({
       allowWrite: exports_external.array(literalPath).default([]),
-      denyRead: exports_external.array(literalPath).default([])
+      denyRead: exports_external.array(literalPath).default([]),
+      allowSharedTmp: exports_external.boolean().default(false)
     }).prefault({}),
     network: exports_external.object({
       allowedDomains: exports_external.array(exports_external.string()).optional()
@@ -18278,8 +18279,8 @@ function describeNetwork(network) {
     return "network access is disabled";
   return `network access is limited to ${network.join(", ")}`;
 }
-function sandboxSentence(network) {
-  return "inside an OS sandbox: writes are allowed only under the repository root, the system temp directories and " + "package-manager caches -- and nothing under .nax/ except .nax/scratchpad/, since .nax/ is nax's own state " + "(change a feature's acceptance test with the Edit tool); credential files (~/.ssh, ~/.aws, ~/.npmrc, nax credentials and similar) are unreadable; " + `${describeNetwork(network)}. A write anywhere else fails with "Operation not permitted" or "Read-only file system" ` + "-- that is the sandbox, not a bug in your command.";
+function sandboxSentence(network, sharedTmp = true) {
+  return `inside an OS sandbox: writes are allowed only under the repository root, ${tempRootsPhrase(sharedTmp)} and ` + "package-manager caches -- and nothing under .nax/ except .nax/scratchpad/, since .nax/ is nax's own state " + "(change a feature's acceptance test with the Edit tool); credential files (~/.ssh, ~/.aws, ~/.npmrc, nax credentials and similar) are unreadable; " + `${describeNetwork(network)}. A write anywhere else fails with "Operation not permitted" or "Read-only file system" ` + "-- that is the sandbox, not a bug in your command.";
 }
 function unsandboxedSentence(reason) {
   return `Commands are NOT sandboxed on this machine (${reason}).`;
@@ -18287,10 +18288,11 @@ function unsandboxedSentence(reason) {
 function rawBashRefusalReason(reason) {
   return `sandbox unavailable (${reason}): raw bash requires the sandbox when execution.sandbox.enabled is true -- ` + "set this stage's bashApproval to gated or escalate, or disable the sandbox.";
 }
-function denialHintLine(writeRoots) {
-  return `note: this command ran in the nax sandbox; that failure may be a sandbox denial -- writable roots: ${writeRoots.join(", ")}.`;
+function denialHintLine(writeRoots, sharedTmp = false) {
+  const tempClause = sharedTmp ? "" : " For temporary files use $TMPDIR or .nax/scratchpad/, not /tmp.";
+  return `note: this command ran in the nax sandbox; that failure may be a sandbox denial -- writable roots: ${writeRoots.join(", ")}.` + tempClause;
 }
-var LIKELY_SANDBOX_DENIAL;
+var LIKELY_SANDBOX_DENIAL, tempRootsPhrase = (sharedTmp) => sharedTmp ? "the system temp directories" : "this run's temp directory ($TMPDIR)";
 var init_messages = __esm(() => {
   LIKELY_SANDBOX_DENIAL = /Operation not permitted|Read-only file system/;
 });
@@ -18325,22 +18327,22 @@ async function ensureTmpDir(tmpDir) {
     return false;
   }
 }
-async function runUnwrapped(req, sandbox, tmpDir) {
+async function runUnwrapped(req, sandbox, env2) {
   const argv = logicalArgv(req);
-  const env2 = withTmpEnv(req, tmpDir);
+  const overlay = env2.tmpDir !== undefined ? withTmpEnv(req, env2.tmpDir) : req.env;
   const result = await _launcherDeps.runArgv({
     argv,
     cwd: req.cwd,
     timeoutMs: req.timeoutMs,
     stripEnvVars: [...req.stripEnvVars],
-    ...env2 !== undefined ? { env: env2 } : {},
+    ...overlay !== undefined ? { env: overlay } : {},
     ...req.signal !== undefined ? { signal: req.signal } : {}
   });
   return { ...result, executed: argv, sandbox };
 }
-async function runWrapped(req, backend, policy, tmpDir) {
+async function runWrapped(req, backend, policy, env2) {
   const rawCommand = req.spec.kind === "shell" ? req.spec.command : quoteArgvForShell(req.spec.argv);
-  const command = tmpDir !== undefined ? `${tmpEnvPrefix(tmpDir)}${rawCommand}` : rawCommand;
+  const command = env2.tmpDir !== undefined ? `${tmpEnvPrefix(env2.tmpDir)}${rawCommand}` : rawCommand;
   const shell = req.spec.kind === "shell" ? req.spec.shell : "/bin/sh";
   const commandId = _launcherDeps.newCommandId();
   let argv;
@@ -18365,7 +18367,10 @@ async function runWrapped(req, backend, policy, tmpDir) {
     });
     const denied = result.exitCode !== 0 && LIKELY_SANDBOX_DENIAL.test(result.stderr);
     const violations = backend.annotate(commandId, result.stderr);
-    const extra = [...denied ? [denialHintLine(policy.writeRoots)] : [], ...violations !== "" ? [violations] : []];
+    const extra = [
+      ...denied ? [denialHintLine(policy.writeRoots, env2.sharedTmp)] : [],
+      ...violations !== "" ? [violations] : []
+    ];
     return {
       ...result,
       stderr: extra.length > 0 ? `${result.stderr}
@@ -18385,14 +18390,18 @@ ${extra.join(`
 }
 function createCommandLauncher(opts) {
   const { state } = opts;
+  const env2 = {
+    tmpDir: opts.tmpDir,
+    sharedTmp: state.kind !== "available" || state.sharedTmp !== false
+  };
   return {
     state,
     async run(req) {
-      const tmpDir = opts.tmpDir !== undefined && await ensureTmpDir(opts.tmpDir) ? opts.tmpDir : undefined;
+      const tmpDir = env2.tmpDir !== undefined && await ensureTmpDir(env2.tmpDir) ? env2.tmpDir : undefined;
       if (state.kind === "disabled")
-        return runUnwrapped(req, { backend: "none", wrapped: false }, tmpDir);
+        return runUnwrapped(req, { backend: "none", wrapped: false }, { ...env2, tmpDir });
       if (state.kind === "unavailable") {
-        return runUnwrapped(req, { backend: state.backend, wrapped: false, reason: state.reason }, tmpDir);
+        return runUnwrapped(req, { backend: state.backend, wrapped: false, reason: state.reason }, { ...env2, tmpDir });
       }
       if (opts.backend === undefined || opts.policyFor === undefined) {
         throw new NaxError("[sandbox] an available launcher needs a backend and a policy", "SANDBOX_NOT_CONFIGURED", {
@@ -18400,7 +18409,7 @@ function createCommandLauncher(opts) {
         });
       }
       try {
-        return await runWrapped(req, opts.backend, await opts.policyFor(req.root), tmpDir);
+        return await runWrapped(req, opts.backend, await opts.policyFor(req.root), { ...env2, tmpDir });
       } finally {
         await opts.afterWrapped?.();
       }
@@ -19239,7 +19248,11 @@ async function listCredentialFiles() {
 function defaultTempRoots() {
   return [_policyInputDeps.tmpdir(), "/tmp"];
 }
-var GIT_LAYOUT_TIMEOUT_MS = 1e4, _policyInputDeps;
+function runTempRoots(opts) {
+  const shared = SHARED_TMP_ROOTS.some((root) => opts.tmpdir === root || opts.tmpdir.startsWith(`${root}/`));
+  return shared ? [opts.runTmpRoot] : [opts.tmpdir, opts.runTmpRoot];
+}
+var GIT_LAYOUT_TIMEOUT_MS = 1e4, _policyInputDeps, SHARED_TMP_ROOTS;
 var init_policy_inputs = __esm(() => {
   init_paths();
   init_schemas_sandbox();
@@ -19252,6 +19265,7 @@ var init_policy_inputs = __esm(() => {
     tmpdir,
     platform: () => process.platform
   };
+  SHARED_TMP_ROOTS = ["/tmp", "/private/tmp"];
 });
 
 // src/sandbox/probe.ts
@@ -19442,16 +19456,45 @@ var init_registry = __esm(() => {
 });
 
 // src/sandbox/session-tmp.ts
-function sanitizePart(part) {
-  return part.replace(/[^A-Za-z0-9_-]/g, "_");
+import { accessSync, constants, lstatSync } from "fs";
+function isUsableSharedParent() {
+  try {
+    const stats = _sessionTmpDeps.lstat(SHARED_TMP_PARENT);
+    if (!stats.isDirectory() || stats.isSymbolicLink())
+      return false;
+  } catch (err) {
+    return err.code === "ENOENT";
+  }
+  try {
+    _sessionTmpDeps.access(SHARED_TMP_PARENT, constants.W_OK | constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function runTmpRoot(runId) {
-  return `${RUN_TMP_PARENT}/nax-${sanitizePart(runId)}`;
+function tmpParent() {
+  return isUsableSharedParent() ? SHARED_TMP_PARENT : `${TMP_ROOT}/nax-${_sessionTmpDeps.uid()}`;
 }
-function sessionTmpDir(runId, sessionName) {
-  return `${runTmpRoot(runId)}/${sanitizePart(sessionName)}`;
+function sanitizePart(part) {
+  return part.replace(/[^A-Za-z0-9_.-]/g, "_").replace(/^\.+$/, "_");
 }
-var RUN_TMP_PARENT = "/tmp";
+function runTmpRoot(runId) {
+  return `${tmpParent()}/${sanitizePart(runId)}`;
+}
+function sessionTmpDirUnder(root, sessionName) {
+  return `${root}/${sanitizePart(sessionName)}`;
+}
+var TMP_ROOT = "/tmp", SHARED_TMP_PARENT, _sessionTmpDeps;
+var init_session_tmp = __esm(() => {
+  SHARED_TMP_PARENT = `${TMP_ROOT}/nax`;
+  _sessionTmpDeps = {
+    lstat: (path) => lstatSync(path),
+    access: (path, mode) => {
+      accessSync(path, mode);
+    },
+    uid: () => process.getuid?.() ?? 0
+  };
+});
 
 // src/sandbox/index.ts
 var init_sandbox = __esm(() => {
@@ -19462,6 +19505,7 @@ var init_sandbox = __esm(() => {
   init_policy_inputs();
   init_probe();
   init_registry();
+  init_session_tmp();
   init_srt_backend();
 });
 
@@ -19645,14 +19689,14 @@ function bashToolDescription(shell, opts) {
   const state = opts.launcher?.state ?? { kind: "disabled" };
   if (opts.bashApproval === "raw") {
     if (state.kind === "available")
-      return rawDescription(shell, `The command runs from the repository root ${sandboxSentence(state.network)} `);
+      return rawDescription(shell, `The command runs from the repository root ${sandboxSentence(state.network, state.sharedTmp !== false)} `);
     if (state.kind === "unavailable")
       return rawUnavailableDescription(shell, state.reason);
     return rawDescription(shell);
   }
   const policyDescription = opts.bashApproval === "escalate" && opts.humanApproval === true ? escalateDescription(shell, opts.patterns) : gatedDescription(shell, opts.patterns);
   if (state.kind === "available") {
-    return `${policyDescription} Commands that pass run ${sandboxSentence(state.network)}`;
+    return `${policyDescription} Commands that pass run ${sandboxSentence(state.network, state.sharedTmp !== false)}`;
   }
   if (state.kind === "unavailable")
     return `${policyDescription} ${unsandboxedSentence(state.reason)}`;
@@ -23681,7 +23725,7 @@ function otherCommandsDeclaring(declared, key, currentCommand) {
 function execSandboxNote(launcher) {
   const state = launcher?.state;
   if (state?.kind === "available")
-    return ` An "argv" call runs ${sandboxSentence(state.network)}`;
+    return ` An "argv" call runs ${sandboxSentence(state.network, state.sharedTmp !== false)}`;
   if (state?.kind === "unavailable")
     return ` ${unsandboxedSentence(state.reason)}`;
   return "";
@@ -24009,11 +24053,14 @@ function resolveTarget(target, frame) {
     return posix2.normalize(target.text);
   return frame === undefined ? undefined : posix2.normalize(posix2.join(frame, target.text));
 }
+function isNaxTempTree(path, root) {
+  return path.startsWith(`${root}/${NAX_PARENT_SEGMENT}/`) || path.startsWith(`${root}/${NAX_FALLBACK_SEGMENT}`);
+}
 function isTmpPath(path) {
   for (const root of TEMP_ROOTS) {
     if (path !== root && !path.startsWith(`${root}/`))
       continue;
-    return !path.startsWith(`${root}/${NAX_PREFIX}`);
+    return !isNaxTempTree(path, root);
   }
   return false;
 }
@@ -24037,7 +24084,7 @@ function detectTmpWrite(command, cwd) {
   }
   return false;
 }
-var TEMP_ROOTS, NAX_PREFIX = "nax-", ARG_TARGET_COMMANDS, LAST_TARGET_COMMANDS;
+var TEMP_ROOTS, NAX_PARENT_SEGMENT = "nax", NAX_FALLBACK_SEGMENT = "nax-", ARG_TARGET_COMMANDS, LAST_TARGET_COMMANDS;
 var init_tmp_write = __esm(() => {
   init_permissions();
   TEMP_ROOTS = ["/tmp", "/private/tmp"];
@@ -26494,7 +26541,7 @@ var init_package_config_cache = __esm(() => {
 });
 
 // src/config/path-security.ts
-import { existsSync as existsSync4, lstatSync, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync4, lstatSync as lstatSync2, realpathSync as realpathSync2 } from "fs";
 import { basename as basename3, isAbsolute as isAbsolute8, normalize, relative as relative9, resolve as resolve15 } from "path";
 function validateDirectory(dirPath, baseDir) {
   const resolved = resolve15(dirPath);
@@ -26516,7 +26563,7 @@ function validateDirectory(dirPath, baseDir) {
   }
   let isDirectory;
   try {
-    isDirectory = lstatSync(realPath).isDirectory();
+    isDirectory = lstatSync2(realPath).isDirectory();
   } catch (error48) {
     throw new NaxError(`Failed to stat path: ${dirPath} (${errorMessage(error48)})`, "PATH_DIRECTORY_STAT_FAILED", {
       stage: "config",
@@ -30479,6 +30526,14 @@ function buildToolResult(args) {
   };
 }
 
+// src/utils/thenable.ts
+function isThenable(value) {
+  if (value === null)
+    return false;
+  const type = typeof value;
+  return (type === "object" || type === "function") && typeof value.then === "function";
+}
+
 // src/agents/native/session/loop-events/payload-guard.ts
 function snapshotArrays(payload) {
   return Object.entries(payload).flatMap(([field, value]) => Array.isArray(value) ? [{ field, array: value, saved: [...value] }] : []);
@@ -30513,18 +30568,43 @@ function pickPatchFields(returned, fields) {
   }
   return picked;
 }
+function isBeforeToolOutcome(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const kind = value.kind;
+  return typeof kind === "string" && BEFORE_TOOL_KINDS.includes(kind);
+}
+function isCompleteBeforeToolOutcome(value) {
+  if (!isBeforeToolOutcome(value))
+    return false;
+  const outcome = value;
+  if (value.kind === "block" || value.kind === "terminate")
+    return typeof outcome.content === "string";
+  if (value.kind === "nudge")
+    return typeof outcome.text === "string";
+  return true;
+}
+function asOutcome(returned, tool) {
+  if (isBeforeToolOutcome(returned))
+    return returned;
+  getSafeLogger()?.warn("native-loop-events", "before_tool handler answered no valid outcome; treating it as allow", {
+    tool
+  });
+  return { kind: "allow" };
+}
 async function dispatchBeforeTool(handlers, payload) {
   const { call, tools } = payload;
   let input;
   let nudgeText2;
   for (const [index, handler] of handlers.entries()) {
-    let outcome;
+    let returned;
     const snapshot = snapshotArrays({ tools });
     try {
-      outcome = await handler({
+      const candidate = handler({
         call: { ...call, input: input ?? call.input },
         tools
       });
+      returned = isThenable(candidate) ? await candidate : candidate;
     } catch (err) {
       getSafeLogger()?.warn("native-loop-events", "before_tool handler threw; skipping it", {
         tool: call.name,
@@ -30534,6 +30614,7 @@ async function dispatchBeforeTool(handlers, payload) {
     } finally {
       restoreMutated(snapshot, "before_tool", index);
     }
+    const outcome = asOutcome(returned, call.name);
     if (outcome.kind === "block" || outcome.kind === "terminate")
       return outcome;
     if (outcome.kind === "nudge")
@@ -30599,7 +30680,7 @@ function createLoopEventRegistry() {
     }
   };
 }
-var PATCHABLE_FIELDS;
+var PATCHABLE_FIELDS, LOOP_EVENTS, BEFORE_TOOL_KINDS;
 var init_registry3 = __esm(() => {
   init_logger2();
   init_payload_guard();
@@ -30613,10 +30694,123 @@ var init_registry3 = __esm(() => {
     before_compaction: ["decline", "summary"],
     before_turn_end: ["followUp"]
   };
+  LOOP_EVENTS = Object.freeze(Object.keys(PATCHABLE_FIELDS));
+  BEFORE_TOOL_KINDS = ["allow", "nudge", "block", "terminate"];
+});
+
+// src/agents/native/session/loop-events/external-handler.ts
+function raceSettlement(entry, payload, deps) {
+  const timeoutMs = _externalHandlerDeps.timeoutMs;
+  return new Promise((resolve17) => {
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      deps.signal.removeEventListener("abort", onAbort);
+      resolve17(result);
+    };
+    const onAbort = () => finish({ ok: false, reason: "aborted before it settled" });
+    timer = setTimeout(() => finish({ ok: false, reason: `did not settle within ${timeoutMs}ms` }), timeoutMs);
+    deps.signal.addEventListener("abort", onAbort, { once: true });
+    let ctx;
+    try {
+      ctx = deps.getCtx();
+    } catch (err) {
+      finish({ ok: false, reason: `reading the handler context failed: ${errorMessage(err)}` });
+      return;
+    }
+    let returned;
+    try {
+      returned = entry.handler(payload, ctx);
+    } catch (err) {
+      finish({ ok: false, reason: errorMessage(err) });
+      return;
+    }
+    Promise.resolve(returned).then((value) => finish({ ok: true, value }), (err) => finish({ ok: false, reason: errorMessage(err) }));
+  });
+}
+function failure(entry, payload, reason) {
+  const logger = getSafeLogger();
+  if (entry.event === "before_tool") {
+    const tool = payload?.call?.name;
+    logger?.warn("native-loop-events", `plugin '${entry.plugin}' failed on before_tool; blocking the call`, {
+      plugin: entry.plugin,
+      event: entry.event,
+      ...tool !== undefined ? { tool } : {},
+      error: reason
+    });
+    return {
+      kind: "block",
+      isError: true,
+      content: `Blocked: loop handler from plugin '${entry.plugin}' failed (${reason}).`
+    };
+  }
+  logger?.warn("native-loop-events", `plugin '${entry.plugin}' failed on ${entry.event}`, {
+    plugin: entry.plugin,
+    event: entry.event,
+    error: reason
+  });
+  return {};
+}
+function tracePatch(entry, value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  const patch = value;
+  const fields = TRACED_PATCH_FIELDS.filter((field) => patch[field] !== undefined);
+  if (fields.length === 0)
+    return;
+  getSafeLogger()?.debug("native-loop-events", `plugin '${entry.plugin}' patched ${entry.event}`, {
+    plugin: entry.plugin,
+    event: entry.event,
+    fields
+  });
+}
+function describeValue(value) {
+  if (value === null)
+    return "null";
+  if (Array.isArray(value))
+    return "an array";
+  if (typeof value === "object")
+    return "an object whose kind is not a before_tool outcome";
+  return `a ${typeof value} value`;
+}
+function settled(entry, payload, value) {
+  if (entry.event === "before_tool") {
+    if (value === undefined)
+      return { kind: "allow" };
+    if (!isCompleteBeforeToolOutcome(value))
+      return failure(entry, payload, `returned ${describeValue(value)}`);
+    return value;
+  }
+  if (value === undefined)
+    return {};
+  tracePatch(entry, value);
+  return value;
+}
+function wrapExternalHandler(entry, getCtx, signal) {
+  return async (payload) => {
+    const settlement = await raceSettlement(entry, payload, { getCtx, signal });
+    const answer = settlement.ok ? settled(entry, payload, settlement.value) : failure(entry, payload, settlement.reason);
+    return answer;
+  };
+}
+var LOOP_HANDLER_TIMEOUT_MS = 1e4, _externalHandlerDeps, TRACED_PATCH_FIELDS;
+var init_external_handler = __esm(() => {
+  init_logger2();
+  init_registry3();
+  _externalHandlerDeps = {
+    timeoutMs: LOOP_HANDLER_TIMEOUT_MS
+  };
+  TRACED_PATCH_FIELDS = ["seed", "history", "messages", "summary"];
 });
 
 // src/agents/native/session/loop-events/index.ts
 var init_loop_events = __esm(() => {
+  init_external_handler();
   init_registry3();
 });
 
@@ -30696,6 +30890,16 @@ var init_truncation_handler = __esm(() => {
 });
 
 // src/agents/native/session/loop-handlers.ts
+function contextFor(state) {
+  return state.current.loopHandlerContext ?? { sessionName: state.current.sessionName };
+}
+function turnSignalView(state) {
+  const current = () => state.current.signal ?? NEVER_ABORTED;
+  return {
+    addEventListener: (...args) => current().addEventListener(...args),
+    removeEventListener: (...args) => current().removeEventListener(...args)
+  };
+}
 function registerBuiltinLoopHandlers(registry3, deps) {
   const installed = turnStateByRegistry.get(registry3);
   if (installed !== undefined) {
@@ -30706,6 +30910,9 @@ function registerBuiltinLoopHandlers(registry3, deps) {
   turnStateByRegistry.set(registry3, state);
   registry3.register("before_tool", ({ call, tools }) => repairInvalidCall(state, call, tools));
   registry3.register("before_tool", ({ call }) => observeSpin(state, call));
+  for (const entry of deps.loopHandlers ?? []) {
+    registry3.register(entry.event, wrapExternalHandler(entry, () => contextFor(state), turnSignalView(state)));
+  }
   registry3.register("after_tool", (payload) => createTruncationHandler(state.current.sessionName)(payload));
 }
 function repairInvalidCall(state, call, tools) {
@@ -30732,11 +30939,13 @@ function observeSpin(state, call) {
     return { kind: "nudge", text: verdict.text };
   return { kind: "allow" };
 }
-var turnStateByRegistry;
+var NEVER_ABORTED, turnStateByRegistry;
 var init_loop_handlers = __esm(() => {
   init_spin_breaker();
   init_handle_invalid_tool_call();
+  init_loop_events();
   init_truncation_handler();
+  NEVER_ABORTED = new AbortController().signal;
   turnStateByRegistry = new WeakMap;
 });
 
@@ -31704,6 +31913,9 @@ async function runNativeTurn(handle, prompt, opts, deps) {
     sessionName: handle.id,
     budget: invalidCallBudget,
     ...deps.spinBreaker !== undefined ? { spinBreaker: deps.spinBreaker } : {},
+    ...deps.loopHandlers !== undefined ? { loopHandlers: deps.loopHandlers } : {},
+    ...deps.loopHandlerContext !== undefined ? { loopHandlerContext: deps.loopHandlerContext } : {},
+    ...deps.signal !== undefined ? { signal: deps.signal } : {},
     onSpinStop: () => {
       spinFlags.warned = true;
     }
@@ -31854,6 +32066,12 @@ An earlier summary of still-older history follows. Merge it into your summary `
 
 ${previousSummary}`;
 }
+function loopHandlerDeps(opts) {
+  return {
+    ...opts.loopHandlers !== undefined ? { loopHandlers: opts.loopHandlers } : {},
+    ...opts.loopHandlerContext !== undefined ? { loopHandlerContext: opts.loopHandlerContext } : {}
+  };
+}
 
 class NativeAgentAdapter {
   catalogOverrides;
@@ -31983,6 +32201,7 @@ class NativeAgentAdapter {
         ...nativeSessionTransportRetry.get(handle.id) !== undefined ? { transportRetry: nativeSessionTransportRetry.get(handle.id) } : {},
         ...nativeSessionSpinBreaker.get(handle.id) !== undefined ? { spinBreaker: nativeSessionSpinBreaker.get(handle.id) } : {},
         ...opts.loopEvents !== undefined ? { loopEvents: opts.loopEvents } : {},
+        ...loopHandlerDeps(opts),
         signal: turnSignal,
         onWaiting: () => {},
         pricingSource,
@@ -35439,7 +35658,7 @@ function killProcessTree(pid, graceMs, exited) {
     killProcessGroup(pid, "SIGTERM");
     getSafeLogger()?.debug("acp-adapter", `Sent SIGTERM to process group ${pid}`);
   } catch {}
-  let settled = false;
+  let settled2 = false;
   const timer = { id: undefined };
   const gracePromise = new Promise((resolve17) => {
     timer.id = setTimeout(() => resolve17("grace"), graceMs);
@@ -35450,9 +35669,9 @@ function killProcessTree(pid, graceMs, exited) {
   const raced = exitedPromise !== undefined ? Promise.race([gracePromise, exitedPromise]) : gracePromise;
   raced.then((outcome) => {
     clearTimeout(timer.id);
-    if (settled)
+    if (settled2)
       return;
-    settled = true;
+    settled2 = true;
     activeKillTimers.delete(pid);
     if (outcome === "exited")
       return;
@@ -35464,7 +35683,7 @@ function killProcessTree(pid, graceMs, exited) {
   });
   const handle = {
     cancel: () => {
-      settled = true;
+      settled2 = true;
       clearTimeout(timer.id);
       activeKillTimers.delete(pid);
     }
@@ -37422,13 +37641,13 @@ var init_interaction_handler = __esm(() => {
 function failurePolicyFor(outcome) {
   return POLICIES[outcome];
 }
-function resolveCooldownExpiry(failure, now) {
-  const { cooldown } = failurePolicyFor(failure.outcome);
+function resolveCooldownExpiry(failure2, now) {
+  const { cooldown } = failurePolicyFor(failure2.outcome);
   if (cooldown === "none")
     return null;
   if (cooldown === "run")
     return "run";
-  const retryAfter = failure.retryAfterSeconds;
+  const retryAfter = failure2.retryAfterSeconds;
   const fromProvider = retryAfter !== undefined && Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter * 1000 : undefined;
   return now + (fromProvider ?? cooldown.ms);
 }
@@ -37530,10 +37749,10 @@ var init_failure_policy = __esm(() => {
 });
 
 // src/agents/swap-decision.ts
-function decideSwap(failure, hopsSoFar, fallback) {
-  if (!failure)
+function decideSwap(failure2, hopsSoFar, fallback) {
+  if (!failure2)
     return { swap: false, reason: "no-failure" };
-  const policy = failurePolicyFor(failure.outcome);
+  const policy = failurePolicyFor(failure2.outcome);
   if (policy.swap === "never")
     return { swap: false, reason: "outcome-refused" };
   if (!fallback?.enabled)
@@ -37617,12 +37836,12 @@ var MAX_RETRIES = 3, defaultRetryStrategy;
 var init_default_strategy = __esm(() => {
   init_failure_policy();
   defaultRetryStrategy = {
-    shouldRetry(failure, attempt, _ctx) {
+    shouldRetry(failure2, attempt, _ctx) {
       if (attempt >= MAX_RETRIES)
         return { retry: false };
-      if (failure instanceof Error)
+      if (failure2 instanceof Error)
         return { retry: false };
-      const af = failure;
+      const af = failure2;
       if (af.retriable === false)
         return { retry: false };
       if (!failurePolicyFor(af.outcome).terminalBackoff)
@@ -38569,6 +38788,9 @@ function createTestFileClassifier(resolved) {
 }
 
 // src/test-runners/compile-crash.ts
+function isCommandNotRunnable(exitCode) {
+  return exitCode === 126 || exitCode === 127;
+}
 function isGoMissingSymbol(message) {
   const msg = message.trim();
   if (msg.startsWith("undefined: "))
@@ -38737,11 +38959,11 @@ async function listFilesInDir(workdir, dir) {
     const stdoutPromise = new Response(proc.stdout).text().catch(() => "");
     const stderrPromise = new Response(proc.stderr).text().catch(() => "");
     const exitCode = await new Promise((resolve17) => {
-      let settled = false;
+      let settled2 = false;
       const finish = (code) => {
-        if (settled)
+        if (settled2)
           return;
-        settled = true;
+        settled2 = true;
         clearTimeout(timer);
         resolve17(code);
       };
@@ -38853,11 +39075,11 @@ async function gitLsFiles(workdir) {
     const stdoutPromise = new Response(proc.stdout).text().catch(() => "");
     const stderrPromise = new Response(proc.stderr).text().catch(() => "");
     const exitCode = await new Promise((resolve17) => {
-      let settled = false;
+      let settled2 = false;
       const finish = (code) => {
-        if (settled)
+        if (settled2)
           return;
-        settled = true;
+        settled2 = true;
         clearTimeout(timer);
         resolve17(code);
       };
@@ -40114,11 +40336,11 @@ function parsePytestOutput(output) {
   }
   failures.push(...errorByFile.values());
   const verboseStacks = parsePytestVerboseStacks(output);
-  for (const failure of failures) {
-    const leafName = failure.testName.split(" > ").pop() ?? failure.testName;
-    const stack = verboseStacks.get(leafName) ?? verboseStacks.get(failure.testName) ?? verboseStacks.get(failure.testName.replace(/ > /g, "."));
+  for (const failure2 of failures) {
+    const leafName = failure2.testName.split(" > ").pop() ?? failure2.testName;
+    const stack = verboseStacks.get(leafName) ?? verboseStacks.get(failure2.testName) ?? verboseStacks.get(failure2.testName.replace(/ > /g, "."));
     if (stack && stack.length > 0) {
-      failure.stackTrace = stack;
+      failure2.stackTrace = stack;
     }
   }
   return {
@@ -40229,11 +40451,11 @@ function formatFailureSummary(failures, maxChars = 2000) {
   const lines = [];
   let totalChars = 0;
   for (let i = 0;i < failures.length; i++) {
-    const failure = failures[i];
+    const failure2 = failures[i];
     const num = i + 1;
-    const header = `${num}. ${failure.file} > ${failure.testName}`;
-    const errorLine = `   Error: ${failure.error}`;
-    const stackTrace = failure.stackTrace ?? [];
+    const header = `${num}. ${failure2.file} > ${failure2.testName}`;
+    const errorLine = `   Error: ${failure2.error}`;
+    const stackTrace = failure2.stackTrace ?? [];
     const stackLine = stackTrace.length > 0 ? `   ${stackTrace[0]}` : "";
     const blockLines = [header, errorLine];
     if (stackLine)
@@ -40971,6 +41193,7 @@ __export(exports_test_runners, {
   formatFailureSummary: () => formatFailureSummary,
   globsToPathspec: () => globsToPathspec,
   globsToTestRegex: () => globsToTestRegex,
+  isCommandNotRunnable: () => isCommandNotRunnable,
   isMonorepoOrchestratorCommand: () => isMonorepoOrchestratorCommand,
   isTestFile: () => isTestFile,
   isTestFileByPatterns: () => isTestFileByPatterns,
@@ -41835,17 +42058,17 @@ var init_lint = __esm(() => {
   init_path_utils();
 });
 // src/findings/adapters/test-failure.ts
-function testFailureToFinding(failure) {
-  const frames = (failure.stackTrace ?? []).slice(0, MAX_FRAMES_IN_MESSAGE);
-  const message = frames.length > 0 ? `${failure.error}
+function testFailureToFinding(failure2) {
+  const frames = (failure2.stackTrace ?? []).slice(0, MAX_FRAMES_IN_MESSAGE);
+  const message = frames.length > 0 ? `${failure2.error}
 ${frames.join(`
-`)}` : failure.error;
+`)}` : failure2.error;
   return {
     source: "test-runner",
     severity: "error",
     category: "failed-test",
-    rule: failure.testName,
-    file: failure.file,
+    rule: failure2.testName,
+    file: failure2.file,
     message
   };
 }
@@ -42747,11 +42970,15 @@ async function validateRecordAndDecide(frame, state, it) {
       break;
     } catch (err) {
       if (validatorAttempt >= cycle.config.validatorRetries) {
+        const iterationCostUsd2 = fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
+        state.totalCostUsd += iterationCostUsd2;
         logger?.error("findings.cycle", "cycle exited \u2014 validator error", {
           storyId: logCtx.storyId,
           packageDir: logCtx.packageDir,
           cycleName: logCtx.cycleName,
           reason: "validator-error",
+          strategiesRun: group.map((s) => s.name),
+          iterationCostUsd: iterationCostUsd2,
           error: errorMessage(err)
         });
         return {
@@ -43662,8 +43889,12 @@ To try a snippet that imports project code or dependencies, write it under \`${d
 project's package names or path aliases where it has them. A script written outside the repository,
 such as in \`/tmp\`, cannot resolve the project's modules, and the file tools cannot write there.
 
-Shell commands run with \`$TMPDIR\` set to a temp directory for this session, which nax deletes when
-the run ends. Put temporary files there (\`$TMPDIR\` or \`mktemp\`), not in \`/tmp\` directly.
+Use the scratchpad as your temp folder. Files you make while working \u2014 command output you want to
+re-read, generated inputs, one-off scripts \u2014 go under \`${dir}\`: the shell, the file tools
+and the scratchpad tools can all reach it, and it is cleared after the run. For throwaway files a
+command creates on its own, shell commands run with \`$TMPDIR\` set to this run's temp directory; use
+\`$TMPDIR\` or \`mktemp\` for those. Never write to \`/tmp\` directly: in the sandbox, \`/tmp\` outside
+\`$TMPDIR\` is not writable and the write fails.
 
 \`${dir}\` is the one directory under \`.nax/\` you may write to. Every other path under \`.nax/\`
 must still never be moved, renamed, or deleted.`;
@@ -47167,18 +47398,18 @@ function formatPriorFailures(failures) {
     return "";
   }
   const parts = [];
-  for (const failure of failures) {
-    parts.push(`### Attempt ${failure.attempt} \u2014 ${failure.modelTier}`);
-    if (failure.agent) {
-      const profilePart = failure.agentProfileId ? ` (profile: ${failure.agentProfileId})` : "";
-      parts.push(`**Agent:** ${failure.agent}${profilePart}`);
-    }
-    parts.push(`**Stage:** ${failure.stage}`);
-    parts.push(`**Summary:** ${failure.summary}`);
-    if (failure.testFailures && failure.testFailures.length > 0) {
+  for (const failure2 of failures) {
+    parts.push(`### Attempt ${failure2.attempt} \u2014 ${failure2.modelTier}`);
+    if (failure2.agent) {
+      const profilePart = failure2.agentProfileId ? ` (profile: ${failure2.agentProfileId})` : "";
+      parts.push(`**Agent:** ${failure2.agent}${profilePart}`);
+    }
+    parts.push(`**Stage:** ${failure2.stage}`);
+    parts.push(`**Summary:** ${failure2.summary}`);
+    if (failure2.testFailures && failure2.testFailures.length > 0) {
       parts.push(`
 **Test Failures:**`);
-      for (const testFailure of failure.testFailures) {
+      for (const testFailure of failure2.testFailures) {
         parts.push(`
 - **File:** \`${testFailure.file}\``);
         parts.push(`  **Test:** ${testFailure.testName}`);
@@ -47188,10 +47419,10 @@ function formatPriorFailures(failures) {
         }
       }
     }
-    if (failure.reviewFindings && failure.reviewFindings.length > 0) {
+    if (failure2.reviewFindings && failure2.reviewFindings.length > 0) {
       parts.push(`
 **Review Findings (fix these issues):**`);
-      for (const finding of failure.reviewFindings) {
+      for (const finding of failure2.reviewFindings) {
         const source = finding.source ? ` (${finding.source})` : "";
         const loc = finding.file ? `${finding.file}:${finding.line ?? 0}` : "global";
         parts.push(`
@@ -50179,6 +50410,37 @@ function decideReuse(live, descriptor, requested) {
   return sameEndpoint(live.modelDef, requested.modelDef) ? "reuse" : "close-then-reopen";
 }
 
+// src/session/loop-handler-forwarding.ts
+function buildLoopHandlerTurnOpts(input) {
+  if (input.set.length === 0 || input.handle.agentName !== NATIVE_AGENT_NAME) {
+    return {};
+  }
+  return {
+    loopHandlers: input.set,
+    loopHandlerContext: buildLoopHandlerContext(input.handle, input.descriptor)
+  };
+}
+function buildLoopHandlerContext(handle, descriptor) {
+  const role = descriptor ? descriptor.role : handle.role;
+  const modelDef = handle.modelDef;
+  return Object.freeze({
+    sessionName: handle.id,
+    ...role !== undefined ? { role } : {},
+    ...descriptor?.storyId !== undefined ? { storyId: descriptor.storyId } : {},
+    ...descriptor?.featureName !== undefined ? { feature: descriptor.featureName } : {},
+    ...descriptor?.workdir !== undefined ? { workdir: descriptor.workdir } : {},
+    ...modelDef?.model !== undefined ? { model: modelDef.model } : {},
+    ...modelDef?.provider !== undefined ? { provider: modelDef.provider } : {}
+  });
+}
+function shouldLogNativeOnlyScope(set2, handle, alreadyLogged) {
+  return !alreadyLogged && set2.length > 0 && handle.agentName !== NATIVE_AGENT_NAME;
+}
+var LOOP_HANDLERS_NATIVE_ONLY_MESSAGE = "loop handlers apply to the native agent only";
+var init_loop_handler_forwarding = __esm(() => {
+  init_config();
+});
+
 // src/session/manager-deps.ts
 import { randomUUID as randomUUID8 } from "crypto";
 import { mkdir as mkdir12 } from "fs/promises";
@@ -50202,9 +50464,23 @@ function deriveNativeTranscriptDir(opts) {
     return;
   return join34(opts.transcriptRoot, "features", opts.featureName, "sessions");
 }
+function persistDescriptor(descriptor) {
+  if (!descriptor.scratchDir)
+    return;
+  const projectDir = resolveProjectDirFromScratchDir(descriptor.scratchDir);
+  _sessionManagerDeps.writeDescriptor(descriptor.scratchDir, descriptor, projectDir).catch((err) => {
+    getLogger().warn("session", "Failed to re-persist session descriptor", {
+      storyId: descriptor.storyId,
+      sessionId: descriptor.id,
+      scratchDir: descriptor.scratchDir,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  });
+}
 var _sessionManagerDeps;
 var init_manager_deps = __esm(() => {
   init_config();
+  init_logger2();
   _sessionManagerDeps = {
     now: () => new Date().toISOString(),
     nowMs: () => Date.now(),
@@ -50368,6 +50644,29 @@ var init_types6 = __esm(() => {
   };
 });
 
+// src/session/watchdog-cancel-tracker.ts
+class WatchdogCancelTracker {
+  _cancelledCallsBySession = new Map;
+  buildOnActiveCall(sessionName, registry3) {
+    if (!registry3)
+      return;
+    return (callId, cancel) => {
+      registry3.set(callId, async () => {
+        const cancelledCalls = this._cancelledCallsBySession.get(sessionName) ?? new Set;
+        cancelledCalls.add(callId);
+        this._cancelledCallsBySession.set(sessionName, cancelledCalls);
+        await cancel();
+      });
+    };
+  }
+  hasCancelled(sessionName) {
+    return (this._cancelledCallsBySession.get(sessionName)?.size ?? 0) > 0;
+  }
+  clear(sessionName) {
+    this._cancelledCallsBySession.delete(sessionName);
+  }
+}
+
 // src/session/watchdog-turn-classification.ts
 function isWatchdogCancelledTurn(input) {
   const { watchdogFired, err, signalAborted } = input;
@@ -50395,7 +50694,9 @@ class SessionManager {
   _watchdogControllerRegistry;
   _transcriptRoot;
   _onStreamActivity;
-  _watchdogCancelledCallsBySession = new Map;
+  _loopHandlers = NO_LOOP_HANDLERS;
+  _loopHandlerScopeLogged = false;
+  _watchdogCancels = new WatchdogCancelTracker;
   _agentStreamUnsubscribe;
   constructor(opts) {
     this._getAdapter = opts?.getAdapter ?? (() => {
@@ -50425,34 +50726,8 @@ class SessionManager {
       });
     }
   }
-  _buildOnActiveCall(sessionName) {
-    const registry3 = this._watchdogControllerRegistry;
-    if (!registry3)
-      return;
-    return (callId, cancel) => {
-      registry3.set(callId, async () => {
-        const cancelledCalls = this._watchdogCancelledCallsBySession.get(sessionName) ?? new Set;
-        cancelledCalls.add(callId);
-        this._watchdogCancelledCallsBySession.set(sessionName, cancelledCalls);
-        await cancel();
-      });
-    };
-  }
-  _clearWatchdogCancelledCalls(sessionName) {
-    this._watchdogCancelledCallsBySession.delete(sessionName);
-  }
-  _persistDescriptor(descriptor) {
-    if (!descriptor.scratchDir)
-      return;
-    const projectDir = resolveProjectDirFromScratchDir(descriptor.scratchDir);
-    _sessionManagerDeps.writeDescriptor(descriptor.scratchDir, descriptor, projectDir).catch((err) => {
-      getLogger().warn("session", "Failed to re-persist session descriptor", {
-        storyId: descriptor.storyId,
-        sessionId: descriptor.id,
-        scratchDir: descriptor.scratchDir,
-        error: err instanceof Error ? err.message : String(err)
-      });
-    });
+  configureLoopHandlers(set2) {
+    this._loopHandlers = set2;
   }
   create(options) {
     const now = _sessionManagerDeps.now();
@@ -50523,7 +50798,7 @@ class SessionManager {
       updated.completedStages = [...session.completedStages, options.completedStage];
     }
     this._sessions.set(id, updated);
-    this._persistDescriptor(updated);
+    persistDescriptor(updated);
     getLogger().debug("session", "Session transitioned", {
       storyId: session.storyId,
       sessionId: id,
@@ -50547,7 +50822,7 @@ class SessionManager {
       lastActivityAt: _sessionManagerDeps.now()
     };
     this._sessions.set(id, updated);
-    this._persistDescriptor(updated);
+    persistDescriptor(updated);
     getLogger().debug("session", "Session handle bound", {
       storyId: session.storyId,
       sessionId: id,
@@ -50569,7 +50844,7 @@ class SessionManager {
       lastActivityAt: _sessionManagerDeps.now()
     };
     this._sessions.set(id, updated);
-    this._persistDescriptor(updated);
+    persistDescriptor(updated);
     getLogger().info("session", "Session handed off to fallback agent", {
       storyId: session.storyId,
       sessionId: id,
@@ -50604,7 +50879,7 @@ class SessionManager {
       if (terminal.includes(session.state))
         continue;
       const updated = { ...session, state: "COMPLETED", lastActivityAt: now };
-      this._persistDescriptor(updated);
+      persistDescriptor(updated);
       this._sessions.delete(id);
       if (updated.handle)
         this._liveHandles.delete(updated.handle);
@@ -50688,7 +50963,7 @@ class SessionManager {
       onSessionEstablished: opts.onSessionEstablished,
       signal: opts.signal,
       resume,
-      onActiveCall: this._buildOnActiveCall(name),
+      onActiveCall: this._watchdogCancels.buildOnActiveCall(name, this._watchdogControllerRegistry),
       onStreamActivity: this._onStreamActivity,
       transcriptDir: opts.transcriptDir ?? deriveNativeTranscriptDir({ featureName: opts.featureName, transcriptRoot: this._transcriptRoot }),
       ...opts.transcriptOwner !== undefined ? { transcriptOwner: opts.transcriptOwner } : {},
@@ -50717,7 +50992,7 @@ class SessionManager {
         lastActivityAt: _sessionManagerDeps.now()
       };
       this._sessions.set(existingDescriptor.id, updated);
-      this._persistDescriptor(updated);
+      persistDescriptor(updated);
     } else {
       getLogger().warn("session", "openSession called on already-RUNNING session", {
         storyId: opts.storyId,
@@ -50752,7 +51027,7 @@ class SessionManager {
     }
     this._busySessions.delete(handle.id);
     this._cancelledSessions.delete(handle.id);
-    this._clearWatchdogCancelledCalls(handle.id);
+    this._watchdogCancels.clear(handle.id);
   }
   async sendPrompt(handle, prompt, opts) {
     if (this._cancelledSessions.has(handle.id)) {
@@ -50769,16 +51044,22 @@ class SessionManager {
     if (!adapter) {
       throw new NaxError(`SessionManager.sendPrompt: no adapter found for agent "${handle.agentName}"`, "ADAPTER_NOT_FOUND", { stage: "session", agentName: handle.agentName });
     }
+    const loopHandlerOpts = buildLoopHandlerTurnOpts({ handle, descriptor: terminalDesc, set: this._loopHandlers });
+    if (shouldLogNativeOnlyScope(this._loopHandlers, handle, this._loopHandlerScopeLogged)) {
+      this._loopHandlerScopeLogged = true;
+      getLogger().info("plugins", LOOP_HANDLERS_NATIVE_ONLY_MESSAGE, { sessionName: handle.id });
+    }
     this._busySessions.add(handle.id);
     try {
       const result = await adapter.sendTurn(handle, prompt, {
         ...opts,
-        interactionHandler: opts?.interactionHandler ?? NO_OP_INTERACTION_HANDLER
+        interactionHandler: opts?.interactionHandler ?? NO_OP_INTERACTION_HANDLER,
+        ...loopHandlerOpts
       });
       return { ...result, protocolIds: result.protocolIds ?? handle.protocolIds };
     } catch (err) {
       if (isWatchdogCancelledTurn({
-        watchdogFired: (this._watchdogCancelledCallsBySession.get(handle.id)?.size ?? 0) > 0,
+        watchdogFired: this._watchdogCancels.hasCancelled(handle.id),
         err,
         signalAborted: opts?.signal?.aborted === true
       })) {
@@ -50799,7 +51080,7 @@ class SessionManager {
       }
       throw err;
     } finally {
-      this._clearWatchdogCancelledCalls(handle.id);
+      this._watchdogCancels.clear(handle.id);
       this._busySessions.delete(handle.id);
     }
   }
@@ -50822,7 +51103,7 @@ class SessionManager {
     this._agentStreamUnsubscribe = undefined;
   }
 }
-var NULL_PROTOCOL_IDS;
+var NULL_PROTOCOL_IDS, NO_LOOP_HANDLERS;
 var init_manager = __esm(() => {
   init_types2();
   init_config();
@@ -50830,6 +51111,7 @@ var init_manager = __esm(() => {
   init_errors();
   init_logger2();
   init_no_op_interaction_handler();
+  init_loop_handler_forwarding();
   init_manager_deps();
   init_manager_sweep();
   init_naming();
@@ -50838,6 +51120,7 @@ var init_manager = __esm(() => {
   init_watchdog_turn_classification();
   init_manager_deps();
   NULL_PROTOCOL_IDS = { recordId: null, sessionId: null };
+  NO_LOOP_HANDLERS = Object.freeze([]);
 });
 
 // src/session/reopen-handoff.ts
@@ -52782,12 +53065,12 @@ function toContextChunk(packed) {
     ...packed.staleCandidate && { staleCandidate: true }
   };
 }
-function buildFailureNoteChunk(priorAgentId, newAgentId, failure) {
+function buildFailureNoteChunk(priorAgentId, newAgentId, failure2) {
   const lines = [
     "## Agent swap (availability fallback)",
     "",
     `Prior agent: ${priorAgentId} became unavailable.`,
-    `Reason: ${failure.outcome} \u2014 ${failure.message}`,
+    `Reason: ${failure2.outcome} \u2014 ${failure2.message}`,
     "",
     `Continuing as: ${newAgentId}`,
     "",
@@ -52798,7 +53081,7 @@ function buildFailureNoteChunk(priorAgentId, newAgentId, failure) {
 `);
   const tokens = Math.ceil(content.length / 4);
   return {
-    id: `failure-note:${priorAgentId}:${newAgentId}:${failure.outcome}`,
+    id: `failure-note:${priorAgentId}:${newAgentId}:${failure2.outcome}`,
     providerId: "orchestrator",
     kind: "session",
     scope: "session",
@@ -52977,7 +53260,7 @@ function toPackedChunks(prior, newAgentId, targetAgentId) {
   });
 }
 function rebuild(prior, options = {}, deps = DEFAULT_REBUILD_DEPS) {
-  const { newAgentId, failure, priorStageDigest, storyId } = options;
+  const { newAgentId, failure: failure2, priorStageDigest, storyId } = options;
   const targetAgentId = newAgentId ?? prior.agentId ?? DEFAULT_REBUILD_AGENT_ID;
   const logger = deps.getLogger();
   if (newAgentId && !AGENT_PROFILES[newAgentId]) {
@@ -52993,8 +53276,8 @@ function rebuild(prior, options = {}, deps = DEFAULT_REBUILD_DEPS) {
   const rebuiltPullTools = targetProfile.caps.supportsToolCalls ? prior.pullTools : [];
   const effectiveBudget = Math.min(prior.manifest.effectiveBudget ?? Number.POSITIVE_INFINITY, targetProfile.caps.preferredPromptTokens);
   let failureNoteChunk;
-  if (failure && newAgentId && !prior.manifest.rebuildInfo) {
-    failureNoteChunk = buildFailureNoteChunk(prior.agentId || "unknown", newAgentId, failure);
+  if (failure2 && newAgentId && !prior.manifest.rebuildInfo) {
+    failureNoteChunk = buildFailureNoteChunk(prior.agentId || "unknown", newAgentId, failure2);
     packedChunks.push(failureNoteChunk);
   }
   let packResult = packChunks(packedChunks, effectiveBudget);
@@ -53021,11 +53304,11 @@ function rebuild(prior, options = {}, deps = DEFAULT_REBUILD_DEPS) {
   const newDigestContent = priorStageDigest?.trim();
   const digestContribution = newDigestContent ? Math.ceil(newDigestContent.length / 4) : 0;
   const usedTokens = packResult.usedTokens + digestContribution;
-  const rebuildInfo = failure && newAgentId ? {
+  const rebuildInfo = failure2 && newAgentId ? {
     priorAgentId: prior.agentId ?? "unknown",
     newAgentId: targetAgentId,
-    failureCategory: failure.category,
-    failureOutcome: failure.outcome,
+    failureCategory: failure2.category,
+    failureOutcome: failure2.outcome,
     priorChunkIds,
     newChunkIds: orderedChunks.map((c) => c.id),
     chunkIdMap: [
@@ -55116,8 +55399,8 @@ var init_version = __esm(() => {
   NAX_AI_VERSION = CATALOG_VERSION;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("bff0ca3b"))
-        return "bff0ca3b";
+      if (/^[0-9a-f]{6,10}$/.test("1c7aa52e"))
+        return "1c7aa52e";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -56519,16 +56802,16 @@ var init_factory = __esm(() => {
 import { existsSync as existsSync8 } from "fs";
 function boundedProcRead(proc, timeoutMs) {
   return new Promise((resolve25) => {
-    let settled = false;
+    let settled2 = false;
     const finish = (exitCode, stdout) => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       clearTimeout(timer);
       resolve25({ exitCode, stdout });
     };
     const timer = setTimeout(() => {
-      if (settled)
+      if (settled2)
         return;
       try {
         proc.kill("SIGKILL");
@@ -56540,26 +56823,26 @@ function boundedProcRead(proc, timeoutMs) {
 }
 function awaitProcExit(proc, timeoutMs) {
   return new Promise((resolve25) => {
-    let settled = false;
+    let settled2 = false;
     const timer = setTimeout(() => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       try {
         proc.kill("SIGKILL");
       } catch {}
       resolve25(-1);
     }, timeoutMs);
     proc.exited.then((code) => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       clearTimeout(timer);
       resolve25(code);
     }, () => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       clearTimeout(timer);
       resolve25(-1);
     });
@@ -59302,11 +59585,11 @@ var require_codegen = __commonJS(function(exports) {
       const rhs = this.rhs === undefined ? "" : ` = ${this.rhs}`;
       return `${varKind} ${this.name}${rhs};` + _n;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       if (!names[this.name.str])
         return;
       if (this.rhs)
-        this.rhs = optimizeExpr(this.rhs, names, constants);
+        this.rhs = optimizeExpr(this.rhs, names, constants2);
       return this;
     }
     get names() {
@@ -59324,10 +59607,10 @@ var require_codegen = __commonJS(function(exports) {
     render({ _n }) {
       return `${this.lhs} = ${this.rhs};` + _n;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       if (this.lhs instanceof code_1.Name && !names[this.lhs.str] && !this.sideEffects)
         return;
-      this.rhs = optimizeExpr(this.rhs, names, constants);
+      this.rhs = optimizeExpr(this.rhs, names, constants2);
       return this;
     }
     get names() {
@@ -59393,8 +59676,8 @@ var require_codegen = __commonJS(function(exports) {
     optimizeNodes() {
       return `${this.code}` ? this : undefined;
     }
-    optimizeNames(names, constants) {
-      this.code = optimizeExpr(this.code, names, constants);
+    optimizeNames(names, constants2) {
+      this.code = optimizeExpr(this.code, names, constants2);
       return this;
     }
     get names() {
@@ -59424,12 +59707,12 @@ var require_codegen = __commonJS(function(exports) {
       }
       return nodes.length > 0 ? this : undefined;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       const { nodes } = this;
       let i = nodes.length;
       while (i--) {
         const n = nodes[i];
-        if (n.optimizeNames(names, constants))
+        if (n.optimizeNames(names, constants2))
           continue;
         subtractNames(names, n.names);
         nodes.splice(i, 1);
@@ -59486,12 +59769,12 @@ var require_codegen = __commonJS(function(exports) {
         return;
       return this;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       var _a2;
-      this.else = (_a2 = this.else) === null || _a2 === undefined ? undefined : _a2.optimizeNames(names, constants);
-      if (!(super.optimizeNames(names, constants) || this.else))
+      this.else = (_a2 = this.else) === null || _a2 === undefined ? undefined : _a2.optimizeNames(names, constants2);
+      if (!(super.optimizeNames(names, constants2) || this.else))
         return;
-      this.condition = optimizeExpr(this.condition, names, constants);
+      this.condition = optimizeExpr(this.condition, names, constants2);
       return this;
     }
     get names() {
@@ -59516,10 +59799,10 @@ var require_codegen = __commonJS(function(exports) {
     render(opts) {
       return `for(${this.iteration})` + super.render(opts);
     }
-    optimizeNames(names, constants) {
-      if (!super.optimizeNames(names, constants))
+    optimizeNames(names, constants2) {
+      if (!super.optimizeNames(names, constants2))
         return;
-      this.iteration = optimizeExpr(this.iteration, names, constants);
+      this.iteration = optimizeExpr(this.iteration, names, constants2);
       return this;
     }
     get names() {
@@ -59557,10 +59840,10 @@ var require_codegen = __commonJS(function(exports) {
     render(opts) {
       return `for(${this.varKind} ${this.name} ${this.loop} ${this.iterable})` + super.render(opts);
     }
-    optimizeNames(names, constants) {
-      if (!super.optimizeNames(names, constants))
+    optimizeNames(names, constants2) {
+      if (!super.optimizeNames(names, constants2))
         return;
-      this.iterable = optimizeExpr(this.iterable, names, constants);
+      this.iterable = optimizeExpr(this.iterable, names, constants2);
       return this;
     }
     get names() {
@@ -59605,11 +59888,11 @@ var require_codegen = __commonJS(function(exports) {
       (_b = this.finally) === null || _b === undefined || _b.optimizeNodes();
       return this;
     }
-    optimizeNames(names, constants) {
+    optimizeNames(names, constants2) {
       var _a2, _b;
-      super.optimizeNames(names, constants);
-      (_a2 = this.catch) === null || _a2 === undefined || _a2.optimizeNames(names, constants);
-      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants);
+      super.optimizeNames(names, constants2);
+      (_a2 = this.catch) === null || _a2 === undefined || _a2.optimizeNames(names, constants2);
+      (_b = this.finally) === null || _b === undefined || _b.optimizeNames(names, constants2);
       return this;
     }
     get names() {
@@ -59883,7 +60166,7 @@ var require_codegen = __commonJS(function(exports) {
   function addExprNames(names, from) {
     return from instanceof code_1._CodeOrName ? addNames(names, from.names) : names;
   }
-  function optimizeExpr(expr, names, constants) {
+  function optimizeExpr(expr, names, constants2) {
     if (expr instanceof code_1.Name)
       return replaceName(expr);
     if (!canOptimize(expr))
@@ -59898,14 +60181,14 @@ var require_codegen = __commonJS(function(exports) {
       return items;
     }, []));
     function replaceName(n) {
-      const c = constants[n.str];
+      const c = constants2[n.str];
       if (c === undefined || names[n.str] !== 1)
         return n;
       delete names[n.str];
       return c;
     }
     function canOptimize(e) {
-      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants[c.str] !== undefined);
+      return e instanceof code_1._Code && e._items.some((c) => c instanceof code_1.Name && names[c.str] === 1 && constants2[c.str] !== undefined);
     }
   }
   function subtractNames(names, from) {
@@ -67337,8 +67620,8 @@ function createMcpPool(opts) {
       closed = true;
       const pending = [...entries.values()];
       entries.clear();
-      const settled = await Promise.allSettled(pending);
-      await Promise.allSettled(settled.map(async (result) => {
+      const settled2 = await Promise.allSettled(pending);
+      await Promise.allSettled(settled2.map(async (result) => {
         if (result.status !== "fulfilled" || result.value === undefined)
           return;
         const { connection } = result.value;
@@ -67478,9 +67761,9 @@ function probeRanNoTests(output) {
 function escapeRegex2(input) {
   return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function buildIsolationCommand(baseCommand, failure, framework) {
-  const file2 = failure.file;
-  const name = failure.testName;
+function buildIsolationCommand(baseCommand, failure2, framework) {
+  const file2 = failure2.file;
+  const name = failure2.testName;
   switch (framework) {
     case "pytest":
       return `${baseCommand} ${shellQuoteArg(`${file2}::${name}`)}`;
@@ -67498,15 +67781,15 @@ function buildIsolationCommand(baseCommand, failure, framework) {
   }
 }
 async function runFlakeProbe(input) {
-  const { framework, baseCommand, failure, cwd, probeRuns, probeTimeoutSeconds } = input;
+  const { framework, baseCommand, failure: failure2, cwd, probeRuns, probeTimeoutSeconds } = input;
   const logger = getSafeLogger();
-  if (failure.file === "unknown" || framework === "unknown") {
+  if (failure2.file === "unknown" || framework === "unknown") {
     return {
       verdict: "unprobeable",
-      reason: failure.file === "unknown" && framework === "unknown" ? "unknown file and framework" : failure.file === "unknown" ? "unknown file" : "unknown framework"
+      reason: failure2.file === "unknown" && framework === "unknown" ? "unknown file and framework" : failure2.file === "unknown" ? "unknown file" : "unknown framework"
     };
   }
-  const command = buildIsolationCommand(baseCommand, failure, framework);
+  const command = buildIsolationCommand(baseCommand, failure2, framework);
   let probePasses = 0;
   let attributableRuns = 0;
   for (let i = 0;i < probeRuns; i += 1) {
@@ -67534,8 +67817,8 @@ async function runFlakeProbe(input) {
   if (attributableRuns === 0) {
     const reason = `all ${probeRuns} probe run(s) were environmental (executor crash, timeout, or non-attributable) \u2014 no attributable pass or fail`;
     logger?.warn("flake-probe", `Unprobeable \u2014 ${reason}`, {
-      file: failure.file,
-      testName: failure.testName,
+      file: failure2.file,
+      testName: failure2.testName,
       probeRuns
     });
     return { verdict: "unprobeable", reason };
@@ -67589,8 +67872,8 @@ var init_flake_triage_telemetry = __esm(() => {
 });
 
 // src/verification/flake-triage.ts
-function flakeMemoKey(failure) {
-  return `${failure.file ?? ""}::${failure.rule ?? ""}`;
+function flakeMemoKey(failure2) {
+  return `${failure2.file ?? ""}::${failure2.rule ?? ""}`;
 }
 function createQuarantineMemo() {
   const keys = new Set;
@@ -67651,7 +67934,7 @@ async function triageFlakyFindings(input) {
       result.push(copy);
       continue;
     }
-    const failure = {
+    const failure2 = {
       file: copy.file ?? "unknown",
       testName: copy.rule ?? "",
       error: copy.message,
@@ -67660,14 +67943,14 @@ async function triageFlakyFindings(input) {
     const probeInput = {
       framework,
       baseCommand,
-      failure,
+      failure: failure2,
       cwd,
       probeRuns: flakeDetection.probeRuns,
       probeTimeoutSeconds: flakeDetection.probeTimeoutSeconds
     };
     let verdict;
     try {
-      verdict = await _flakeTriageDeps.runFlakeProbe({ failure, config: flakeDetection, probeInput });
+      verdict = await _flakeTriageDeps.runFlakeProbe({ failure: failure2, config: flakeDetection, probeInput });
     } catch (err) {
       logger?.warn("flake-triage", `Probe dependency threw for ${key} \u2014 keeping finding blocking`, {
         file: copy.file,
@@ -67780,7 +68063,28 @@ var init_coding_tool_extras = __esm(() => {
 });
 
 // src/agents/coding-tool-sandbox.ts
-import { homedir as homedir5 } from "os";
+import { mkdir as mkdir21 } from "fs/promises";
+import { homedir as homedir5, tmpdir as tmpdir4 } from "os";
+async function sessionTempRoots(args) {
+  const { runTmpRoot: runTmpRoot2, tmpDir } = args;
+  const shared = () => ({ tempRoots: _sessionSandboxDeps.tempRoots(), confined: false });
+  if (args.config.filesystem.allowSharedTmp || runTmpRoot2 === undefined || tmpDir === undefined)
+    return shared();
+  try {
+    await _sessionSandboxDeps.mkdir(tmpDir);
+  } catch (err) {
+    getSafeLogger()?.warn("sandbox", "could not create the session temp dir \u2014 granting the shared temp roots", {
+      storyId: args.storyId ?? "_dispatch",
+      tmpDir,
+      error: errorMessage(err)
+    });
+    return shared();
+  }
+  return {
+    tempRoots: _sessionSandboxDeps.runTempRoots({ runTmpRoot: runTmpRoot2, tmpdir: _sessionSandboxDeps.tmpdir() }),
+    confined: true
+  };
+}
 async function resolveSessionSandbox(args) {
   const config2 = args.config;
   if (config2 === undefined || !config2.enabled || !args.needsLauncher) {
@@ -67801,6 +68105,12 @@ async function resolveSessionSandbox(args) {
   const git = await _sessionSandboxDeps.gitLayout(args.root);
   const credentialFiles = await _sessionSandboxDeps.credentialFiles();
   const approvalsFile = args.outputDir !== undefined ? approvalsPath(args.outputDir) : undefined;
+  const { tempRoots, confined } = await sessionTempRoots({
+    config: config2,
+    storyId: args.storyId,
+    runTmpRoot: args.runTmpRoot,
+    tmpDir: args.tmpDir
+  });
   const policyFor = async (root) => buildSandboxPolicy({
     root,
     git,
@@ -67809,7 +68119,7 @@ async function resolveSessionSandbox(args) {
     credentialFiles,
     ...approvalsFile !== undefined ? { approvalsFile } : {},
     home: _sessionSandboxDeps.homedir(),
-    tempRoots: _sessionSandboxDeps.tempRoots(),
+    tempRoots,
     platform: _sessionSandboxDeps.platform(),
     config: config2
   });
@@ -67821,7 +68131,7 @@ async function resolveSessionSandbox(args) {
   const afterWrapped = await _sessionSandboxDeps.commonDirTripwire(git, args.storyId);
   const network = config2.network.allowedDomains ?? "open";
   return createCommandLauncher({
-    state: { kind: "available", backend: backend2.name, network },
+    state: { kind: "available", backend: backend2.name, network, ...confined ? { sharedTmp: false } : {} },
     backend: backend2,
     policyFor,
     ...afterWrapped !== undefined ? { afterWrapped } : {},
@@ -67851,6 +68161,7 @@ async function literalPolicyError(policyFor, root) {
 var _sessionSandboxDeps;
 var init_coding_tool_sandbox = __esm(() => {
   init_errors();
+  init_logger2();
   init_permissions();
   init_sandbox();
   _sessionSandboxDeps = {
@@ -67863,7 +68174,10 @@ var init_coding_tool_sandbox = __esm(() => {
     credentialFiles: listCredentialFiles,
     tempRoots: defaultTempRoots,
     homedir: homedir5,
-    platform: () => process.platform
+    platform: () => process.platform,
+    mkdir: (path7) => mkdir21(path7, { recursive: true }),
+    tmpdir: () => tmpdir4(),
+    runTempRoots
   };
 });
 
@@ -67990,23 +68304,26 @@ function unionDeclaredTools(declared, providerResult) {
   ];
 }
 function warnDroppedProviders(providerResult, storyId) {
-  for (const failure of providerResult.failures) {
+  for (const failure2 of providerResult.failures) {
     getSafeLogger()?.warn("tools", "[provider] dropped", {
       storyId,
-      providerId: failure.providerId,
-      reason: failure.reason
+      providerId: failure2.providerId,
+      reason: failure2.reason
     });
   }
 }
 async function resolveDispatchLauncher(options, declared, sessionName) {
-  return options.codingToolRoot !== undefined && options.codingToolRoot.trim() !== "" ? await resolveSessionSandbox({
+  if (options.codingToolRoot === undefined || options.codingToolRoot.trim() === "")
+    return;
+  const runRoot = options.runId !== undefined ? runTmpRoot(options.runId) : undefined;
+  return await resolveSessionSandbox({
     config: options.config?.execution?.sandbox,
     root: options.codingToolRoot,
     ...options.outputDir !== undefined ? { outputDir: options.outputDir } : {},
     needsLauncher: declared.includes(BASH_TOOL_NAME) || declared.includes(EXEC_TOOL_NAME),
     ...options.storyId !== undefined ? { storyId: options.storyId } : {},
-    ...options.runId !== undefined ? { tmpDir: sessionTmpDir(options.runId, sessionName) } : {}
-  }) : undefined;
+    ...runRoot !== undefined ? { tmpDir: sessionTmpDirUnder(runRoot, sessionName), runTmpRoot: runRoot } : {}
+  });
 }
 function optionalDispatchArgs(options) {
   return {
@@ -69312,8 +69629,8 @@ async function mayHaveJournal(candidateRoots) {
   return false;
 }
 async function recordInFlight(repoRoot, entry) {
-  const { mkdir: mkdir21 } = await import("fs/promises");
-  await mkdir21(journalDir(repoRoot), { recursive: true });
+  const { mkdir: mkdir22 } = await import("fs/promises");
+  await mkdir22(journalDir(repoRoot), { recursive: true });
   await Bun.write(journalPathFor(repoRoot, entry.storyId), JSON.stringify(entry));
 }
 async function clearInFlight(repoRoot, storyId) {
@@ -69762,7 +70079,7 @@ var init_runners = __esm(() => {
 
 // src/verification/test-baseline.ts
 import { existsSync as existsSync10 } from "fs";
-import { mkdir as mkdir21, readdir as readdir6, rm as rm5 } from "fs/promises";
+import { mkdir as mkdir22, readdir as readdir6, rm as rm5 } from "fs/promises";
 import { join as join57 } from "path";
 function runBaselinePath(root, featureId) {
   return join57(featureDir(root, featureId), RUN_BASELINE_FILENAME);
@@ -69779,7 +70096,7 @@ async function readRunBaseline(root, featureId) {
 }
 async function writeStoryBaseline(root, featureId, storyId, baseline) {
   const path7 = storyBaselinePath(root, featureId, storyId);
-  await mkdir21(join57(featureDir(root, featureId), "stories", storyId), { recursive: true });
+  await mkdir22(join57(featureDir(root, featureId), "stories", storyId), { recursive: true });
   await saveJsonFile(path7, baseline, "test-baseline");
 }
 async function readStoryBaseline(root, featureId, storyId) {
@@ -70143,13 +70460,13 @@ function formatDuration2(ms) {
   return `${minutes}m ${seconds}s`;
 }
 function timeoutRetry(input) {
-  const { prompt, changedFiles, elapsedMs, attempt, failure } = input;
-  if (failure?.outcome === "fail-invalid-tool-call")
-    return invalidToolCallRetry(input, failure);
-  if (failure?.outcome === "fail-spin") {
+  const { prompt, changedFiles, elapsedMs, attempt, failure: failure2 } = input;
+  if (failure2?.outcome === "fail-invalid-tool-call")
+    return invalidToolCallRetry(input, failure2);
+  if (failure2?.outcome === "fail-spin") {
     return nonTimeoutRetry(input, "The previous attempt was stopped because it kept repeating the same tool calls without making progress.", "Do not repeat a call whose result you already have; if a check keeps returning the same result, change the code or the approach before running it again.");
   }
-  if (failure?.outcome === "fail-incomplete") {
+  if (failure2?.outcome === "fail-incomplete") {
     return nonTimeoutRetry(input, "The previous attempt ended its turn before finishing the story.", "Keep working until every acceptance criterion is met, then finish with your final answer.");
   }
   const duration3 = formatDuration2(elapsedMs);
@@ -70193,8 +70510,8 @@ ${state}
 
 ${prompt}`;
 }
-function invalidToolCallRetry(input, failure) {
-  const detail = failure.invalidToolCall;
+function invalidToolCallRetry(input, failure2) {
+  const detail = failure2.invalidToolCall;
   const rejected = detail === undefined ? "The previous attempt was stopped because it kept repeating the same invalid tool call. The tool rejected that input every time and never ran it." : `The previous attempt was stopped because it kept repeating the same invalid \`${detail.tool}\` call: property \`${detail.property}\` expected ${detail.expected}, got ${detail.actual}. The tool rejected that input every time and never ran it.`;
   const fix = detail === undefined ? "Before calling a tool, check its input schema. If an optional property has no value, leave it out entirely." : `Before calling \`${detail.tool}\` again, make \`${detail.property}\` match its schema (${detail.expected}). If it is optional and you have no value for it, leave it out entirely.`;
   return nonTimeoutRetry(input, rejected, fix);
@@ -70557,26 +70874,35 @@ function resolvePytestBin(packageDir) {
   return "pytest";
 }
 function substituteAcceptanceTestPath(command, testPath) {
-  return command.replace(/\{\{files\}\}/g, testPath).replace(/\{\{file\}\}/g, testPath).replace(/\{\{FILE\}\}/g, testPath);
+  return command.replace(/\{\{files\}\}/g, () => testPath).replace(/\{\{file\}\}/g, () => testPath).replace(/\{\{FILE\}\}/g, () => testPath);
 }
 function buildAcceptanceRunCommand(testPath, testFramework, commandOverride, packageDir) {
-  if (commandOverride) {
-    return commandOverride.trim().split(/\s+/).map((part) => substituteAcceptanceTestPath(part, testPath));
+  const trimmedOverride = commandOverride?.trim();
+  if (trimmedOverride) {
+    return substituteAcceptanceTestPath(trimmedOverride, shellQuoteArg(testPath));
   }
+  let defaultArgv;
   switch (testFramework?.toLowerCase()) {
     case "vitest":
-      return ["npx", "vitest", "run", testPath];
+      defaultArgv = ["npx", "vitest", "run", testPath];
+      break;
     case "jest":
-      return ["npx", "jest", testPath];
+      defaultArgv = ["npx", "jest", testPath];
+      break;
     case "pytest":
-      return [resolvePytestBin(packageDir), testPath];
+      defaultArgv = [resolvePytestBin(packageDir), testPath];
+      break;
     case "go-test":
-      return ["go", "test", testPath];
+      defaultArgv = ["go", "test", testPath];
+      break;
     case "cargo-test":
-      return ["cargo", "test", "--test", "acceptance"];
+      defaultArgv = ["cargo", "test", "--test", "acceptance"];
+      break;
     default:
-      return ["bun", "test", testPath, "--timeout=60000"];
+      defaultArgv = ["bun", "test", testPath, "--timeout=60000"];
+      break;
   }
+  return defaultArgv.map(shellQuoteArg).join(" ");
 }
 function parseAcceptanceCriteria(specContent) {
   const criteria = [];
@@ -72005,7 +72331,7 @@ var init_build_hop_callback = __esm(() => {
   init_build_hop_callback_hop();
   init_hop_endpoint();
   _buildHopCallbackDeps = {
-    rebuildForAgent: (prior, newAgentId, failure, storyId) => new ContextOrchestrator([]).rebuildForAgent(prior, { newAgentId, failure, storyId }),
+    rebuildForAgent: (prior, newAgentId, failure2, storyId) => new ContextOrchestrator([]).rebuildForAgent(prior, { newAgentId, failure: failure2, storyId }),
     writeRebuildManifest,
     createContextToolRuntime,
     captureGitRef,
@@ -72161,8 +72487,8 @@ function decideCompleteRetry(args) {
   const { ctx, op, err, attempt, retryStrategy, dispatchAgent, abortSignal } = args;
   if (!retryStrategy)
     return;
-  const failure = err;
-  const decision = retryStrategy.shouldRetry(failure, attempt, {
+  const failure2 = err;
+  const decision = retryStrategy.shouldRetry(failure2, attempt, {
     site: "complete",
     agentName: dispatchAgent,
     stage: op.stage,
@@ -72182,8 +72508,8 @@ function decideCompleteRetry(args) {
     attempt,
     delayMs: decision.delayMs,
     promptTransformed: decision.nextPrompt !== undefined,
-    failureKind: failure instanceof Error ? "error" : failure.outcome,
-    failureMessage: errorMessage(failure)
+    failureKind: failure2 instanceof Error ? "error" : failure2.outcome,
+    failureMessage: errorMessage(failure2)
   });
   return { delayMs: decision.delayMs };
 }
@@ -74591,7 +74917,7 @@ var init_scope = __esm(() => {
 
 // src/review/fix-review/tree-snapshot/index.ts
 import { mkdtemp, rm as rm6 } from "fs/promises";
-import { tmpdir as tmpdir4 } from "os";
+import { tmpdir as tmpdir5 } from "os";
 import { join as join61 } from "path";
 async function runGit(args, cwd, indexOverlay, timeoutMs = _treeSnapshotDeps.gitTimeoutMs) {
   const proc = _treeSnapshotDeps.spawn(hardenedGitArgv(["git", ...args]), {
@@ -74678,7 +75004,7 @@ var init_tree_snapshot = __esm(() => {
     gitTimeoutMs: TREE_SNAPSHOT_GIT_TIMEOUT_MS,
     mkdtemp,
     rm: rm6,
-    tmpdir: tmpdir4
+    tmpdir: tmpdir5
   };
 });
 
@@ -79220,8 +79546,8 @@ function makeParseRetryStrategy(opts) {
   const checkTruncated = opts.looksTruncated ?? looksLikeTruncatedJson;
   const maxAttempts = opts.maxAttempts ?? 2;
   return {
-    shouldRetry(failure, attempt, ctx) {
-      if (!(failure instanceof ParseValidationError)) {
+    shouldRetry(failure2, attempt, ctx) {
+      if (!(failure2 instanceof ParseValidationError)) {
         return { retry: false };
       }
       if (ctx.lastOutput && ctx.lastTurnResult?.adapterFailure) {
@@ -79282,13 +79608,13 @@ var init_parse_retry = __esm(() => {
 // src/agents/retry/presets.ts
 function resolveRetryPreset(preset) {
   return {
-    shouldRetry(failure, attempt, _ctx) {
+    shouldRetry(failure2, attempt, _ctx) {
       if (attempt >= preset.maxAttempts - 1)
         return { retry: false };
       if (preset.preset === "transient-network") {
-        if (failure instanceof Error)
+        if (failure2 instanceof Error)
           return { retry: true, delayMs: preset.baseDelayMs };
-        const af = failure;
+        const af = failure2;
         if (af.retriable)
           return { retry: true, delayMs: preset.baseDelayMs };
         return { retry: false };
@@ -79382,11 +79708,11 @@ function recordAgentFallbacks(ctx, fallbacks) {
   }
   store.set(ctx.storyId, [...fallbacks]);
 }
-function recordAdapterFailure(ctx, failure) {
+function recordAdapterFailure(ctx, failure2) {
   if (!ctx.storyId)
     return;
-  if (failure) {
-    ctx.runtime.lastAdapterFailure.set(ctx.storyId, failure);
+  if (failure2) {
+    ctx.runtime.lastAdapterFailure.set(ctx.storyId, failure2);
     return;
   }
   ctx.runtime.lastAdapterFailure.delete(ctx.storyId);
@@ -79428,12 +79754,12 @@ class CooldownStore {
   constructor(_now) {
     this._now = _now;
   }
-  mark(agent, failure, tier, modelId) {
-    const expiresAt = resolveCooldownExpiry(failure, this._now());
+  mark(agent, failure2, tier, modelId) {
+    const expiresAt = resolveCooldownExpiry(failure2, this._now());
     if (expiresAt === null)
       return;
-    const key = failurePolicyFor(failure.outcome).cooldownScope === "agent" ? agent : identityKey(agent, tier, modelId);
-    this._entries.set(key, { failure, expiresAt });
+    const key = failurePolicyFor(failure2.outcome).cooldownScope === "agent" ? agent : identityKey(agent, tier, modelId);
+    this._entries.set(key, { failure: failure2, expiresAt });
   }
   isCooling(agent, tier, modelId) {
     return this._live(agent, tier, modelId) !== undefined;
@@ -79731,11 +80057,11 @@ var init_manager_dispatch = __esm(() => {
 
 // src/agents/retry/resolve-exhaustion.ts
 async function resolveExhaustion(input) {
-  const { failure, retryStrategy, retryCtx, signal, sleep: sleep2, onExhausted } = input;
+  const { failure: failure2, retryStrategy, retryCtx, signal, sleep: sleep2, onExhausted } = input;
   if (signal?.aborted)
     return "cancelled";
-  if (failure && failurePolicyFor(failure.outcome).terminalBackoff) {
-    const decision = retryStrategy.shouldRetry(failure, input.attempt, retryCtx);
+  if (failure2 && failurePolicyFor(failure2.outcome).terminalBackoff) {
+    const decision = retryStrategy.shouldRetry(failure2, input.attempt, retryCtx);
     if (decision.retry) {
       await sleep2(decision.delayMs, signal);
       return signal?.aborted ? "cancelled" : "retry";
@@ -79965,13 +80291,13 @@ async function runWithFallback(input) {
           dispatchesCompleted
         };
       }
-      const failure = result.adapterFailure ?? unknownFailure();
+      const failure2 = result.adapterFailure ?? unknownFailure();
       const currentTier = currentHopKind.tier;
-      input.markUnavailable(currentAgent, failure, currentTier, dispatchedModel);
+      input.markUnavailable(currentAgent, failure2, currentTier, dispatchedModel);
       const next = input.nextCandidate(primaryAgent, hopsSoFar, currentAgent, currentTier, dispatchedModel);
       if (!next) {
         const outcome = await input.resolveExhaustion({
-          failure,
+          failure: failure2,
           hopsSoFar,
           attempt: rateLimitRetry,
           swapWasPossible: true,
@@ -80004,7 +80330,7 @@ async function runWithFallback(input) {
       currentBundle = updatedBundle;
       currentHopKind = {
         kind: "swap",
-        failure,
+        failure: failure2,
         ...next.tier ? { tier: next.tier } : {},
         ...next.model ? { model: next.model } : {}
       };
@@ -80013,7 +80339,7 @@ async function runWithFallback(input) {
         priorAgent: currentAgent,
         newAgent: next.agent,
         hop: hopsSoFar,
-        failure,
+        failure: failure2,
         costUsd: result.estimatedCostUsd ?? 0
       });
       fallbacks.push(fallback);
@@ -80265,8 +80591,8 @@ class AgentManager {
   resolveFallbackChain(agent, _failure) {
     return this._fallbackIdentity.chain(agent, this._isExcluded);
   }
-  shouldSwap(failure, hopsSoFar) {
-    return decideSwap(failure, hopsSoFar, this._config.agent?.fallback).swap;
+  shouldSwap(failure2, hopsSoFar) {
+    return decideSwap(failure2, hopsSoFar, this._config.agent?.fallback).swap;
   }
   nextCandidate(cur, hops, exclude, tier, model) {
     return this._fallbackIdentity.nextCandidate({ cur, hops, exclude, tier, model }, this._isExcluded);
@@ -80282,7 +80608,7 @@ class AgentManager {
       logger: this._loggerOverride ?? getSafeLogger(),
       getDefault: () => this.getDefault(),
       isUnavailable: (agent, tier, model) => this.isUnavailable(agent, tier, model),
-      markUnavailable: (agent, failure, tier, model) => this.markUnavailable(agent, failure, tier, model),
+      markUnavailable: (agent, failure2, tier, model) => this.markUnavailable(agent, failure2, tier, model),
       nextCandidate: (cur, hops, exclude, tier, model) => this.nextCandidate(cur, hops, exclude, tier, model),
       resolveExhaustion: (options) => this._resolveExhaustion(options),
       emitSwapAttempt: (fallback) => this._emitter.emit("onSwapAttempt", fallback),
@@ -80934,11 +81260,11 @@ async function promptForConfirmation(question) {
     stdin.setRawMode(true);
     stdin.resume();
     stdin.setEncoding("utf8");
-    let settled = false;
+    let settled2 = false;
     const finish = (answer) => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       stdin.setRawMode(false);
       stdin.pause();
       stdin.removeListener("data", onData);
@@ -81197,11 +81523,11 @@ function read(message, echo, onEmptySubmit) {
   _authPromptDeps.write(`${source_default.cyan("?")} ${message} `);
   return new Promise((resolve28, reject) => {
     let buffer = "";
-    let settled = false;
+    let settled2 = false;
     const cleanup = () => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       stdin.removeListener("data", onData);
       stdin.removeListener("end", onEnd);
       stdin.removeListener("error", onEnd);
@@ -81265,7 +81591,7 @@ function promptForSelect(message, choices) {
 `);
   return new Promise((resolve28, reject) => {
     let index = 0;
-    let settled = false;
+    let settled2 = false;
     let drawn = false;
     const render3 = () => {
       if (drawn)
@@ -81280,9 +81606,9 @@ function promptForSelect(message, choices) {
       }
     };
     const cleanup = () => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       stdin.removeListener("data", onData);
       stdin.removeListener("end", onEnd);
       stdin.removeListener("error", onEnd);
@@ -81620,6 +81946,7 @@ var init_config_descriptions = __esm(() => {
     "execution.sandbox.filesystem": "Filesystem policy additions for the sandbox",
     "execution.sandbox.filesystem.allowWrite": "Extra literal paths the sandbox may write (no glob characters)",
     "execution.sandbox.filesystem.denyRead": "Extra literal paths the sandbox may not read (no glob characters)",
+    "execution.sandbox.filesystem.allowSharedTmp": "Also grant the shared temp directories (os.tmpdir(), /tmp) to sandboxed commands. Off by default: temp writes stay inside this run's own temp root",
     "execution.sandbox.network": "Network policy for sandboxed commands",
     "execution.sandbox.network.allowedDomains": "Domains sandboxed commands may reach; absent means open",
     "execution.commandSafety": "Shadow command classifier; observes every command, decides nothing. Root-only (ADR-031)",
@@ -83022,7 +83349,12 @@ async function processPackageGroup(ctx, packageDir, groupStories, language, resu
   }
   await _hardeningDeps.writeFile(suggestedTestPath, testCode);
   const testCmd = buildAcceptanceRunCommand(suggestedTestPath, config2.project?.testFramework, config2.acceptance?.command, packageDir);
-  const proc = _hardeningDeps.spawn(testCmd, { cwd: packageDir, stdout: "pipe", stderr: "pipe", detached: true });
+  const proc = _hardeningDeps.spawn(["/bin/sh", "-c", testCmd], {
+    cwd: packageDir,
+    stdout: "pipe",
+    stderr: "pipe",
+    detached: true
+  });
   let exitedBeforeSigkill = false;
   let sigkillTimer;
   proc.exited.then(() => {
@@ -84233,13 +84565,13 @@ var init_generate = __esm(() => {
 });
 
 // src/cli/init-context.ts
-import { mkdir as mkdir22, readdir as readdir7 } from "fs/promises";
+import { mkdir as mkdir23, readdir as readdir7 } from "fs/promises";
 import { basename as basename11, join as join76, relative as relative25, sep as sep13 } from "path";
 async function bunFileExists(path12) {
   return Bun.file(path12).exists();
 }
 async function mkdirp(path12) {
-  await mkdir22(path12, { recursive: true });
+  await mkdir23(path12, { recursive: true });
 }
 async function findFiles(dir, maxFiles = 200) {
   const files = [];
@@ -84726,7 +85058,7 @@ __export(exports_init, {
   validateProjectName: () => validateProjectName
 });
 import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir23 } from "fs/promises";
+import { mkdir as mkdir24 } from "fs/promises";
 import { join as join78 } from "path";
 function validateProjectName(name) {
   if (!name)
@@ -84854,7 +85186,7 @@ async function initGlobal() {
   const logger = getLogger();
   const globalDir = globalConfigDir();
   if (!existsSync22(globalDir)) {
-    await mkdir23(globalDir, { recursive: true });
+    await mkdir24(globalDir, { recursive: true });
     logger.info("init", "Created global config directory", { path: globalDir });
   }
   const configPath = join78(globalDir, "config.json");
@@ -84874,7 +85206,7 @@ async function initGlobal() {
   }
   const hooksDir = join78(globalDir, "hooks");
   if (!existsSync22(hooksDir)) {
-    await mkdir23(hooksDir, { recursive: true });
+    await mkdir24(hooksDir, { recursive: true });
     logger.info("init", "Created global hooks directory", { path: hooksDir });
   } else {
     logger.info("init", "Global hooks directory already exists", { path: hooksDir });
@@ -84919,7 +85251,7 @@ async function initProject(projectRoot, options) {
     }
   }
   if (!existsSync22(projectDir)) {
-    await mkdir23(projectDir, { recursive: true });
+    await mkdir24(projectDir, { recursive: true });
     logger.info("init", "Created project config directory", { path: projectDir });
   }
   const stack = detectStack(projectRoot);
@@ -84954,7 +85286,7 @@ async function initProject(projectRoot, options) {
     ["features", featuresDir(projectRoot)]
   ]) {
     if (!existsSync22(dir)) {
-      await mkdir23(dir, { recursive: true });
+      await mkdir24(dir, { recursive: true });
       logger.info("init", `Created project ${label} directory`, { path: dir });
     } else {
       logger.info("init", `Project ${label} directory already exists`, { path: dir });
@@ -87696,11 +88028,11 @@ async function runGitBounded2(args, workdir) {
   let timedOut = false;
   let exitCode = -1;
   await new Promise((resolve29) => {
-    let settled = false;
+    let settled2 = false;
     const finish = (code) => {
-      if (settled)
+      if (settled2)
         return;
-      settled = true;
+      settled2 = true;
       clearTimeout(timer);
       exitCode = code;
       resolve29();
@@ -88441,7 +88773,35 @@ function findingFile(file2) {
   return file2;
 }
 async function runFixReview(ctx, req, deps = {}) {
-  const d = { ...DEFAULT_DEPS2, ...deps };
+  const verdict = await evaluateFixReview(ctx, req, { ...DEFAULT_DEPS2, ...deps });
+  logVerdict(ctx.runtime?.logger, req.story.id, verdict);
+  return verdict;
+}
+function logVerdict(logger, storyId, verdict) {
+  if (verdict.kind === "pass") {
+    if (verdict.reviewed) {
+      logger?.info("review", "Fix review passed", { storyId, reason: verdict.reason });
+    } else {
+      logger?.info("review", `Fix review skipped \u2014 ${verdict.reason}`, { storyId });
+    }
+    return;
+  }
+  if (verdict.kind === "error") {
+    logger?.warn("review", "Fix review errored", { storyId, reason: verdict.reason });
+    return;
+  }
+  if (verdict.cause === "scope") {
+    logger?.info("review", "Fix review failed (scope)", { storyId, files: verdict.files, reason: verdict.reason });
+    return;
+  }
+  logger?.info("review", "Fix review failed (contradiction)", {
+    storyId,
+    reason: verdict.reason,
+    acIndex: verdict.acIndex,
+    file: verdict.file
+  });
+}
+async function evaluateFixReview(ctx, req, d) {
   const logger = ctx.runtime?.logger;
   if (req.config.fixReview?.enabled === false) {
     return { kind: "pass", reviewed: false, reason: "fixReview is disabled" };
@@ -88517,6 +88877,11 @@ async function runFixReview(ctx, req, deps = {}) {
     return { kind: "error", reason: `diff failed: ${err instanceof Error ? err.message : String(err)}` };
   }
   const diff = truncateDiff(rawDiff);
+  logger?.info("review", "Running fix review", {
+    storyId: req.story.id,
+    fixFiles: fixFiles.length,
+    storyFiles: storyFiles?.length
+  });
   let output;
   try {
     output = await d.callOp(ctx, fixReviewOp, { story: req.story, diff, findings: req.findings });
@@ -88720,6 +89085,8 @@ function logUnifiedReviewPhaseResult(storyId, opName, output) {
   const payload = toReviewDecisionPayload(opName, output);
   if (!payload)
     return;
+  if (payload.reviewer === "fix")
+    return;
   if (!payload.parsed) {
     if (payload.noDispatch) {
       logger?.warn("review", `${payload.reviewer} review had no dispatch \u2014 failed closed`, { storyId });
@@ -88731,7 +89098,7 @@ function logUnifiedReviewPhaseResult(storyId, opName, output) {
     return;
   }
   const findingsCount = payload.result.findings.length;
-  const title = payload.reviewer === "semantic" ? "Semantic review" : payload.reviewer === "adversarial" ? "Adversarial review" : "Fix review";
+  const title = payload.reviewer === "semantic" ? "Semantic review" : "Adversarial review";
   if (payload.passed) {
     logger?.info("review", `${title} passed`, { storyId });
     return;
@@ -91782,8 +92149,8 @@ var init_ensure_package_dirs = __esm(() => {
       }
     },
     mkdirp: async (p) => {
-      const { mkdir: mkdir24 } = await import("fs/promises");
-      await mkdir24(p, { recursive: true });
+      const { mkdir: mkdir25 } = await import("fs/promises");
+      await mkdir25(p, { recursive: true });
     }
   };
 });
@@ -91940,7 +92307,7 @@ var init_quote_integrity = __esm(() => {
 });
 
 // src/execution/progress.ts
-import { appendFile as appendFile5, mkdir as mkdir24 } from "fs/promises";
+import { appendFile as appendFile5, mkdir as mkdir25 } from "fs/promises";
 import { join as join86 } from "path";
 function getSafeLogger2() {
   try {
@@ -91951,7 +92318,7 @@ function getSafeLogger2() {
 }
 async function appendProgress(featureDir2, storyId, status, message) {
   try {
-    await mkdir24(featureDir2, { recursive: true });
+    await mkdir25(featureDir2, { recursive: true });
     const progressPath = join86(featureDir2, "progress.txt");
     const timestamp = new Date().toISOString();
     const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
@@ -92527,7 +92894,7 @@ var init_lock2 = __esm(() => {
 });
 
 // src/execution/feature-lock.ts
-import { mkdir as mkdir25, rename as rename6, unlink as unlink6 } from "fs/promises";
+import { mkdir as mkdir26, rename as rename6, unlink as unlink6 } from "fs/promises";
 import { hostname as hostname4 } from "os";
 import path14 from "path";
 function validateFeatureId2(featureId) {
@@ -92621,7 +92988,7 @@ function emptyHolder(feature) {
 async function acquireFeatureLock(args) {
   const lockPath = _featureLockDeps.featureLockPath(args.outputDir, args.feature);
   const featureDir2 = path14.dirname(lockPath);
-  await mkdir25(featureDir2, { recursive: true });
+  await mkdir26(featureDir2, { recursive: true });
   const lockFile = Bun.file(lockPath);
   if (await lockFile.exists()) {
     const existingContent = await lockFile.text();
@@ -93183,7 +93550,7 @@ var init_worktree_id = __esm(() => {
 
 // src/worktree/manager.ts
 import { existsSync as existsSync23, symlinkSync } from "fs";
-import { mkdir as mkdir26, stat as stat7 } from "fs/promises";
+import { mkdir as mkdir27, stat as stat7 } from "fs/promises";
 import { join as join89, resolve as resolve30 } from "path";
 async function resolveGitInfoDir(projectRoot) {
   const dotGit = join89(projectRoot, ".git");
@@ -93218,7 +93585,7 @@ class WorktreeManager {
     try {
       const infoDir = await resolveGitInfoDir(projectRoot);
       const excludePath = join89(infoDir, "exclude");
-      await mkdir26(infoDir, { recursive: true });
+      await mkdir27(infoDir, { recursive: true });
       const { withPathFileLock: withPathFileLock2 } = await Promise.resolve().then(() => (init_path_file_lock(), exports_path_file_lock));
       await withPathFileLock2(excludePath, async () => {
         let existing2 = "";
@@ -93832,6 +94199,54 @@ function areAllStoriesComplete(ctx) {
   const totalComplete = counts.passed + counts.failed + counts.skipped;
   return totalComplete === counts.total;
 }
+function recordPackageCrash(params) {
+  const {
+    logger,
+    storyId,
+    exitCode,
+    packageDir,
+    testPath,
+    testFramework,
+    commandOverride,
+    testCmd,
+    output,
+    allFailedACs,
+    allFindings,
+    failedPackages,
+    errorState
+  } = params;
+  const notRunnable = isCommandNotRunnable(exitCode);
+  if (notRunnable) {
+    logger.error("acceptance", "Acceptance command could not run \u2014 check acceptance.command", {
+      storyId,
+      exitCode,
+      cmd: testCmd,
+      packageDir
+    });
+  } else {
+    logger.error("acceptance", "Tests errored with no AC failures parsed", {
+      storyId,
+      exitCode,
+      packageDir
+    });
+  }
+  logTestOutput(logger, "acceptance", output);
+  errorState.anyError = true;
+  errorState.errorExitCode = exitCode;
+  allFailedACs.push("AC-ERROR");
+  allFindings.push(notRunnable ? {
+    ...acSentinelToFinding("AC-ERROR", output),
+    message: `Acceptance command could not run (exit ${exitCode}): ${testCmd}`
+  } : acSentinelToFinding("AC-ERROR", output));
+  failedPackages.push({
+    testPath,
+    packageDir,
+    testFramework,
+    commandOverride,
+    output,
+    failedACs: ["AC-ERROR"]
+  });
+}
 var _acceptanceStageDeps, acceptanceStage;
 var init_acceptance3 = __esm(() => {
   init_acceptance2();
@@ -93888,8 +94303,7 @@ var init_acceptance3 = __esm(() => {
       const failedPackages = [];
       const missingTargets = [];
       const allOutputParts = [];
-      let anyError = false;
-      let errorExitCode = 0;
+      const errorState = { anyError: false, errorExitCode: 0 };
       let hardeningPromoted = 0;
       for (const { testPath, packageDir, testFramework, commandOverride, storyCount, acceptanceEnabled } of testGroups) {
         const testFile = Bun.file(testPath);
@@ -93929,13 +94343,13 @@ var init_acceptance3 = __esm(() => {
         }
         const resolvedFramework = testFramework ?? ctx.config.project?.testFramework;
         const resolvedCommand = commandOverride ?? ctx.config.acceptance.command;
-        const testCmdParts = buildAcceptanceRunCommand(testPath, resolvedFramework, resolvedCommand, packageDir);
+        const testCmd = buildAcceptanceRunCommand(testPath, resolvedFramework, resolvedCommand, packageDir);
         logger.info("acceptance", "Running acceptance command", {
           storyId: ctx.story.id,
-          cmd: testCmdParts.join(" "),
+          cmd: testCmd,
           packageDir
         });
-        const execution = await executeWithTimeout(testCmdParts.map(shellQuoteArg).join(" "), Math.ceil(ctx.config.acceptance.timeoutMs / 1000), undefined, { cwd: packageDir });
+        const execution = await executeWithTimeout(testCmd, Math.ceil(ctx.config.acceptance.timeoutMs / 1000), undefined, { cwd: packageDir });
         const exitCode = execution.exitCode ?? (execution.success ? 0 : 1);
         const output = execution.output ?? "";
         allOutputParts.push(output);
@@ -93951,17 +94365,21 @@ var init_acceptance3 = __esm(() => {
           });
         }
         if (failedACs.length === 0 && exitCode !== 0) {
-          logger.error("acceptance", "Tests errored with no AC failures parsed", {
+          recordPackageCrash({
+            logger,
             storyId: ctx.story.id,
             exitCode,
-            packageDir
+            packageDir,
+            testPath,
+            testFramework,
+            commandOverride,
+            testCmd,
+            output,
+            allFailedACs,
+            allFindings,
+            failedPackages,
+            errorState
           });
-          logTestOutput(logger, "acceptance", output);
-          anyError = true;
-          errorExitCode = exitCode;
-          allFailedACs.push("AC-ERROR");
-          allFindings.push(acSentinelToFinding("AC-ERROR", output));
-          failedPackages.push({ testPath, packageDir, testFramework, commandOverride, output, failedACs: ["AC-ERROR"] });
           continue;
         }
         if (exitCode !== 0 && failedACs.length > 0 && actualFailures.length === 0) {
@@ -93976,8 +94394,8 @@ var init_acceptance3 = __esm(() => {
               acTaggedFailures: taggedFailureCount
             });
             logTestOutput(logger, "acceptance", output);
-            anyError = true;
-            errorExitCode = exitCode;
+            errorState.anyError = true;
+            errorState.errorExitCode = exitCode;
             allFailedACs.push("AC-ERROR");
             allFindings.push(acSentinelToFinding("AC-ERROR", output));
             failedPackages.push({
@@ -94097,10 +94515,10 @@ var init_acceptance3 = __esm(() => {
         hardeningPromoted,
         durationMs
       });
-      if (anyError) {
+      if (errorState.anyError) {
         return {
           action: "fail",
-          reason: `Acceptance tests errored (exit code ${errorExitCode}): syntax error, import failure, or unhandled exception`
+          reason: `Acceptance tests errored (exit code ${errorState.errorExitCode}): syntax error, import failure, or unhandled exception`
         };
       }
       return {
@@ -94165,12 +94583,21 @@ async function runAcceptanceRedGate(ctx, entries, deps) {
     const runCmd = buildAcceptanceRunCommand(testPath, testFramework, commandOverride, packageDir);
     logger?.info("acceptance-setup", "Running acceptance RED gate command", {
       storyId: entry.storyId,
-      cmd: runCmd.join(" "),
+      cmd: runCmd,
       packageDir
     });
     const first = await deps.runTest(testPath, packageDir, runCmd, config2.acceptance.timeoutMs);
     if (first.exitCode === 0)
       continue;
+    if (isCommandNotRunnable(first.exitCode)) {
+      logger?.error("acceptance-setup", "RED gate: acceptance command could not run \u2014 check acceptance.command", {
+        storyId: entry.storyId,
+        cmd: runCmd,
+        exitCode: first.exitCode
+      });
+      redFailCount++;
+      continue;
+    }
     if (isCrash(first.output, first.exitCode)) {
       await handleCrash(ctx, entry, first.output, runCmd, deps);
     }
@@ -94533,7 +94960,7 @@ var init_acceptance_setup = __esm(() => {
     autoCommitIfDirty,
     loadGroupConfig: loadConfigForPackage,
     runTest: async (_testPath, _workdir, _cmd, timeoutMs = 1800000) => {
-      const execution = await executeWithTimeout(_cmd.map(shellQuoteArg).join(" "), Math.ceil(timeoutMs / 1000), undefined, {
+      const execution = await executeWithTimeout(_cmd, Math.ceil(timeoutMs / 1000), undefined, {
         cwd: _workdir
       });
       return {
@@ -96101,11 +96528,11 @@ async function closeStaleAcpSession(worktreePath, sessionName) {
     });
     let timedOut = false;
     await new Promise((resolve31) => {
-      let settled = false;
+      let settled2 = false;
       const finish = () => {
-        if (settled)
+        if (settled2)
           return;
-        settled = true;
+        settled2 = true;
         clearTimeout(timer);
         resolve31();
       };
@@ -102107,11 +102534,11 @@ function renderProposals(proposals, runId, observationCount, provenance) {
 }
 
 // src/plugins/builtin/curator/rollup.ts
-import { appendFile as appendFile7, mkdir as mkdir27, writeFile as writeFile11 } from "fs/promises";
+import { appendFile as appendFile7, mkdir as mkdir28, writeFile as writeFile11 } from "fs/promises";
 import * as path21 from "path";
 async function appendToRollup(observations, rollupPath) {
   const dir = path21.dirname(rollupPath);
-  await mkdir27(dir, { recursive: true }).catch(() => {});
+  await mkdir28(dir, { recursive: true }).catch(() => {});
   const { withPathFileLock: withPathFileLock2 } = await Promise.resolve().then(() => (init_path_file_lock(), exports_path_file_lock));
   await withPathFileLock2(rollupPath, () => appendToRollupUnlocked(observations, rollupPath)).catch(() => {});
 }
@@ -102198,7 +102625,7 @@ var init_rollup2 = __esm(() => {
 });
 
 // src/plugins/builtin/curator/index.ts
-import { mkdir as mkdir28 } from "fs/promises";
+import { mkdir as mkdir29 } from "fs/promises";
 import * as path22 from "path";
 function getCuratorEnabled(context) {
   const cfg = context.config;
@@ -102276,7 +102703,7 @@ var init_curator = __esm(() => {
         if (context.outputDir) {
           const { observationsPath, rollupPath } = resolveCuratorOutputs(curatorContext);
           const runDir = path22.dirname(observationsPath);
-          await mkdir28(runDir, { recursive: true });
+          await mkdir29(runDir, { recursive: true });
           await Bun.write(observationsPath, observations.map((o) => JSON.stringify(o)).join(`
 `) + (observations.length > 0 ? `
 ` : ""));
@@ -102364,10 +102791,52 @@ var init_plugin_logger = __esm(() => {
 });
 
 // src/plugins/registry.ts
+function warnPluginRegistration(pluginName, message, data) {
+  getSafeLogger()?.warn("plugins", `Plugin '${pluginName}' ${message}`, { plugin: pluginName, ...data });
+}
+function stagePluginHandlers(pluginName, provider2) {
+  const staged = [];
+  let failed = false;
+  const on = (event, handler) => {
+    if (!LOOP_EVENT_NAMES.has(event)) {
+      failed = true;
+      warnPluginRegistration(pluginName, `registered a handler for unknown loop event '${event}'`, { event });
+      return;
+    }
+    if (typeof handler !== "function") {
+      failed = true;
+      warnPluginRegistration(pluginName, `registered a non-function handler for '${event}'`, {
+        event,
+        handlerType: typeof handler
+      });
+      return;
+    }
+    staged.push({ plugin: pluginName, event, handler });
+  };
+  let returned;
+  try {
+    returned = provider2.register(on);
+  } catch (err) {
+    failed = true;
+    warnPluginRegistration(pluginName, "loop-handler registration failed; its handlers are skipped", {
+      error: errorMessage(err)
+    });
+  }
+  if (isThenable(returned)) {
+    failed = true;
+    warnPluginRegistration(pluginName, "register() returned a promise; loop-handler registration must be synchronous");
+    returned.then(undefined, (err) => {
+      warnPluginRegistration(pluginName, "async register() rejected", { error: errorMessage(err) });
+    });
+  }
+  return failed ? [] : staged;
+}
+
 class PluginRegistry {
   plugins;
   sources;
   builtinPostRunActions;
+  loopHandlers;
   constructor(loadedPlugins, builtinPostRunActions = []) {
     this.builtinPostRunActions = builtinPostRunActions.map((registration) => ("action" in registration) ? registration : { pluginName: registration.name, action: registration });
     if (loadedPlugins.length > 0 && "plugin" in loadedPlugins[0]) {
@@ -102417,6 +102886,25 @@ class PluginRegistry {
     });
     return [...pluginActions, ...this.builtinPostRunActions];
   }
+  getLoopHandlers() {
+    if (this.loopHandlers !== undefined) {
+      return this.loopHandlers;
+    }
+    const entries = [];
+    for (const plugin of this.plugins) {
+      if (!plugin.provides.includes("loop-handlers")) {
+        continue;
+      }
+      const provider2 = plugin.extensions.loopHandlers;
+      if (provider2 === undefined) {
+        warnPluginRegistration(plugin.name, "provides 'loop-handlers' but declares no loopHandlers extension");
+        continue;
+      }
+      entries.push(...stagePluginHandlers(plugin.name, provider2));
+    }
+    this.loopHandlers = Object.freeze(entries);
+    return this.loopHandlers;
+  }
   async teardownAll() {
     const logger = getSafeLogger();
     for (const plugin of this.plugins) {
@@ -102430,8 +102918,11 @@ class PluginRegistry {
     }
   }
 }
+var LOOP_EVENT_NAMES;
 var init_registry5 = __esm(() => {
+  init_loop_events();
   init_logger2();
+  LOOP_EVENT_NAMES = new Set(LOOP_EVENTS);
 });
 
 // src/plugins/validator.ts
@@ -102507,6 +102998,8 @@ function validateExtension(pluginName, type, extensions) {
       return validateReporter(pluginName, extensions.reporter);
     case "post-run-action":
       return validatePostRunAction(pluginName, extensions.postRunAction);
+    case "loop-handlers":
+      return validateLoopHandlers(pluginName, extensions.loopHandlers);
     default:
       getSafeLogger6()?.warn("plugins", `Plugin '${pluginName}' validation failed: unknown extension type '${type}'`);
       return false;
@@ -102680,6 +103173,17 @@ function validatePostRunAction(pluginName, action) {
   }
   return true;
 }
+function validateLoopHandlers(pluginName, ext) {
+  if (typeof ext !== "object" || ext === null) {
+    getSafeLogger6()?.warn("plugins", `Plugin '${pluginName}' validation failed: loopHandlers extension must be an object`);
+    return false;
+  }
+  if (typeof ext.register !== "function") {
+    getSafeLogger6()?.warn("plugins", `Plugin '${pluginName}' validation failed: loopHandlers.register must be a function`);
+    return false;
+  }
+  return true;
+}
 var VALID_PLUGIN_TYPES;
 var init_validator = __esm(() => {
   init_logger2();
@@ -102690,7 +103194,8 @@ var init_validator = __esm(() => {
     "reviewer",
     "context-provider",
     "reporter",
-    "post-run-action"
+    "post-run-action",
+    "loop-handlers"
   ];
 });
 
@@ -103846,6 +104351,7 @@ async function initializeAfterLock(options) {
     const resolvedPatterns = await resolveTestFilePatterns(config2, workdir);
     const isTestFileFn = (filename) => resolvedPatterns.regex.some((re) => re.test(filename));
     const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins, isTestFileFn, config2.reporters);
+    runtime.sessionManager.configureLoopHandlers(pluginRegistry.getLoopHandlers());
     logger?.info("plugins", `Loaded ${pluginRegistry.plugins.length} plugins`, {
       plugins: pluginRegistry.plugins.map((p) => ({ name: p.name, version: p.version, provides: p.provides }))
     });
@@ -104795,11 +105301,14 @@ var init_logs2 = __esm(() => {
 // src/commands/migrate.ts
 var exports_migrate = {};
 __export(exports_migrate, {
+  _gitDeps: () => _gitDeps,
+  autoMigrateGeneratedContent: () => autoMigrateGeneratedContent,
   detectGeneratedContent: () => detectGeneratedContent,
-  migrateCommand: () => migrateCommand
+  migrateCommand: () => migrateCommand,
+  partitionTrackedCandidates: () => partitionTrackedCandidates
 });
 import { existsSync as existsSync30 } from "fs";
-import { mkdir as mkdir29, readdir as readdir10, rename as rename9 } from "fs/promises";
+import { mkdir as mkdir30, readdir as readdir10, rename as rename9 } from "fs/promises";
 import path25 from "path";
 async function detectGeneratedContent(naxDir) {
   if (!existsSync30(naxDir))
@@ -104868,6 +105377,102 @@ async function detectGeneratedContent(naxDir) {
   }
   return candidates;
 }
+async function partitionTrackedCandidates(workdir, candidates) {
+  const logger = getSafeLogger();
+  let stdout;
+  try {
+    const result = await gitWithTimeout(["ls-files", "-z", "--", ".nax"], workdir);
+    if (result.exitCode !== 0) {
+      logger?.debug("migrate", "partitionTrackedCandidates: git ls-files returned non-zero, treating all candidates as migratable", {
+        storyId: "_migrate",
+        exitCode: result.exitCode,
+        stderr: result.stderr.trim()
+      });
+      return { migratable: [...candidates], tracked: [] };
+    }
+    stdout = result.stdout;
+  } catch (err) {
+    logger?.debug("migrate", "partitionTrackedCandidates: git ls-files failed, treating all candidates as migratable", {
+      storyId: "_migrate",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return { migratable: [...candidates], tracked: [] };
+  }
+  const listedPaths = [];
+  for (const listed of stdout.split("\x00")) {
+    if (!listed || listed === ".nax")
+      continue;
+    if (listed.startsWith(".nax/"))
+      listedPaths.push(listed);
+  }
+  const migratable = [];
+  const trackedOut = [];
+  for (const candidate of candidates) {
+    const normalisedName = candidate.name.split("\\").join("/");
+    const target = `.nax/${normalisedName}`;
+    const targetWithSlash = `${target}/`;
+    const isTracked = listedPaths.some((listed) => listed === target || listed.startsWith(targetWithSlash));
+    if (isTracked) {
+      trackedOut.push(candidate);
+    } else {
+      migratable.push(candidate);
+    }
+  }
+  return { migratable, tracked: trackedOut };
+}
+async function autoMigrateGeneratedContent(workdir) {
+  const logger = getSafeLogger();
+  let candidates;
+  try {
+    candidates = await detectGeneratedContent(path25.join(workdir, ".nax"));
+  } catch (err) {
+    logger?.debug("migrate", "autoMigrateGeneratedContent: detectGeneratedContent failed, skipping migration", {
+      storyId: "_setup",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return;
+  }
+  if (candidates.length === 0)
+    return;
+  let partition;
+  try {
+    partition = await partitionTrackedCandidates(workdir, candidates);
+  } catch (err) {
+    logger?.debug("migrate", "autoMigrateGeneratedContent: partitionTrackedCandidates failed, treating all candidates as migratable", {
+      storyId: "_setup",
+      error: err instanceof Error ? err.message : String(err)
+    });
+    partition = { migratable: candidates, tracked: [] };
+  }
+  const { migratable, tracked } = partition;
+  if (tracked.length > 0) {
+    const paths = tracked.map((candidate) => path25.relative(workdir, candidate.srcPath)).slice(0, 5);
+    const firstPath = paths[0];
+    if (firstPath !== undefined) {
+      logger?.warn("setup", "Skipping git-tracked generated content under .nax/ \u2014 untrack it with git rm -r --cached", {
+        storyId: "_setup",
+        count: tracked.length,
+        paths,
+        fix: `git rm -r --cached ${firstPath}`
+      });
+    }
+  }
+  if (migratable.length === 0)
+    return;
+  logger?.info("setup", "Found generated content under .nax/ \u2014 migrating to output dir", {
+    storyId: "_setup",
+    count: migratable.length
+  });
+  try {
+    await migrateCommand({ workdir });
+    logger?.info("setup", "Auto-migration complete", { storyId: "_setup" });
+  } catch (err) {
+    logger?.warn("setup", "Auto-migration failed \u2014 continuing without migration", {
+      storyId: "_setup",
+      error: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
 async function migrateCommand(options) {
   const logger = getLogger();
   if (options.reclaim) {
@@ -104887,7 +105492,7 @@ async function migrateCommand(options) {
     }
     const archiveBase = path25.join(globalConfigDir(), "_archive");
     const archiveDest = path25.join(archiveBase, `${options.reclaim}-${Date.now()}`);
-    await mkdir29(archiveBase, { recursive: true });
+    await mkdir30(archiveBase, { recursive: true });
     await rename9(src, archiveDest);
     logger.info("migrate", `Reclaimed: archived to ${archiveDest}`, { storyId: "_migrate" });
     return;
@@ -104950,19 +105555,36 @@ async function migrateCommand(options) {
     logger.info("migrate", "Nothing to migrate \u2014 already up to date", { storyId: "_migrate" });
     return;
   }
+  const { migratable, tracked } = await partitionTrackedCandidates(options.workdir, candidates);
+  if (migratable.length === 0) {
+    for (const c of tracked) {
+      const rel = path25.relative(options.workdir, c.srcPath);
+      const msg = options.dryRun ? `[dry-run] Skip (git-tracked): ${rel}` : `Skipping git-tracked: ${rel}`;
+      logger.info("migrate", msg, { storyId: "_migrate" });
+    }
+    return;
+  }
   if (options.dryRun) {
-    for (const c of candidates) {
+    for (const c of tracked) {
+      const rel = path25.relative(options.workdir, c.srcPath);
+      logger.info("migrate", `[dry-run] Skip (git-tracked): ${rel}`, { storyId: "_migrate" });
+    }
+    for (const c of migratable) {
       logger.info("migrate", `[dry-run] Would move: ${c.srcPath} -> ${path25.join(destBase, c.name)}`, {
         storyId: "_migrate"
       });
     }
     return;
   }
-  await mkdir29(destBase, { recursive: true });
+  for (const c of tracked) {
+    const rel = path25.relative(options.workdir, c.srcPath);
+    logger.info("migrate", `Skipping git-tracked: ${rel}`, { storyId: "_migrate" });
+  }
+  await mkdir30(destBase, { recursive: true });
   let moved = 0;
-  for (const candidate of candidates) {
+  for (const candidate of migratable) {
     const dest = path25.join(destBase, candidate.name);
-    await mkdir29(path25.dirname(dest), { recursive: true });
+    await mkdir30(path25.dirname(dest), { recursive: true });
     if (existsSync30(dest)) {
       throw new NaxError(`Migration conflict: destination already exists.
   Source:      ${candidate.srcPath}
@@ -104992,11 +105614,13 @@ async function migrateCommand(options) {
     moved++;
     logger.info("migrate", `Moved: ${candidate.name}`, { storyId: "_migrate" });
   }
-  await Bun.write(path25.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
-  logger.info("migrate", `Migration complete: ${moved} entries moved`, {
-    storyId: "_migrate",
-    destBase
-  });
+  if (moved > 0) {
+    await Bun.write(path25.join(destBase, ".migrated-from"), JSON.stringify({ from: options.workdir, migratedAt: new Date().toISOString() }, null, 2));
+    logger.info("migrate", `Migration complete: ${moved} entries moved`, {
+      storyId: "_migrate",
+      destBase
+    });
+  }
 }
 var GENERATED_NAMES, GENERATED_FEATURE_SUBNAMES;
 var init_migrate = __esm(() => {
@@ -105005,7 +105629,9 @@ var init_migrate = __esm(() => {
   init_errors();
   init_logger2();
   init_runtime2();
+  init_git();
   init_git_env();
+  init_git();
   GENERATED_NAMES = new Set([
     "runs",
     "prompt-audit",
@@ -105780,7 +106406,7 @@ var init_runs = __esm(() => {
 });
 
 // src/commands/unlock.ts
-import { mkdir as mkdir30, unlink as unlink10 } from "fs/promises";
+import { mkdir as mkdir31, unlink as unlink10 } from "fs/promises";
 import { basename as basename14, join as join112 } from "path";
 function logUnlockInfo(message) {
   _unlockDeps.getSafeLogger()?.info(UNLOCK_LOG_STAGE, message);
@@ -105855,7 +106481,7 @@ async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
   if (options.feature !== undefined && options.feature.length > 0) {
     const { outputDir } = await resolveOutputDir(workdir);
-    await mkdir30(join112(outputDir, "features"), { recursive: true });
+    await mkdir31(join112(outputDir, "features"), { recursive: true });
     const outcome = await tryRemoveFeatureLock(outputDir, options.feature, options.force ?? false);
     if (outcome === "skipped" || outcome === "parse-error") {
       process.exit(1);
@@ -105965,6 +106591,7 @@ __export(exports_commands, {
   _curatorCmdDeps: () => _curatorCmdDeps,
   _replayCmdDeps: () => _replayCmdDeps,
   _resumeCmdDeps: () => _resumeCmdDeps,
+  autoMigrateGeneratedContent: () => autoMigrateGeneratedContent,
   curatorCommit: () => curatorCommit,
   curatorDryrun: () => curatorDryrun,
   curatorGc: () => curatorGc,
@@ -105973,6 +106600,7 @@ __export(exports_commands, {
   followLogs: () => followLogs,
   logsCommand: () => logsCommand,
   migrateCommand: () => migrateCommand,
+  partitionTrackedCandidates: () => partitionTrackedCandidates,
   precheckCommand: () => precheckCommand,
   registerReplayCommand: () => registerReplayCommand,
   registerResumeCommand: () => registerResumeCommand,
@@ -106310,26 +106938,7 @@ async function setupRun(options) {
     const prd = await loadPRD(prdPath);
     const interactionChain = await initInteractionChain(config2, headless);
     statusWriter.setPrd(prd);
-    {
-      const { detectGeneratedContent: detectGeneratedContent2, migrateCommand: migrateCommand2 } = await Promise.resolve().then(() => (init_commands(), exports_commands));
-      const naxDir = path27.join(workdir, ".nax");
-      const candidates = await detectGeneratedContent2(naxDir).catch(() => []);
-      if (candidates.length > 0) {
-        logger?.info("setup", "Found generated content under .nax/ \u2014 migrating to output dir", {
-          storyId: "_setup",
-          count: candidates.length
-        });
-        try {
-          await migrateCommand2({ workdir });
-          logger?.info("setup", "Auto-migration complete", { storyId: "_setup" });
-        } catch (err) {
-          logger?.warn("setup", "Auto-migration failed \u2014 continuing without migration", {
-            storyId: "_setup",
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-      }
-    }
+    await _runSetupDeps.autoMigrateGeneratedContent(workdir);
     {
       const { claimProjectIdentity: claimProjectIdentity2 } = await Promise.resolve().then(() => (init_runtime2(), exports_runtime));
       let remoteUrl = null;
@@ -106490,7 +107099,11 @@ var init_run_setup = __esm(() => {
     sweepFeatureTranscripts,
     buildApprovalsSeal,
     acquireLock,
-    acquireFeatureLock
+    acquireFeatureLock,
+    async autoMigrateGeneratedContent(workdir) {
+      const { autoMigrateGeneratedContent: autoMigrateGeneratedContent2 } = await Promise.resolve().then(() => (init_commands(), exports_commands));
+      await autoMigrateGeneratedContent2(workdir);
+    }
   };
 });
 
@@ -108017,7 +108630,7 @@ var init_run_cost_reconcile = __esm(() => {
 });
 
 // src/finish/audit.ts
-import { appendFile as appendFile8, mkdir as mkdir31, readFile as readFile7, writeFile as writeFile12 } from "fs/promises";
+import { appendFile as appendFile8, mkdir as mkdir32, readFile as readFile7, writeFile as writeFile12 } from "fs/promises";
 import { join as join113 } from "path";
 function roundsPath(t) {
   return join113(t.auditDir, `${t.runId}.jsonl`);
@@ -108044,7 +108657,7 @@ async function updateLedger(t, result) {
     finishedAt: new Date().toISOString()
   };
   try {
-    await mkdir31(t.auditDir, { recursive: true });
+    await mkdir32(t.auditDir, { recursive: true });
     await writeFile12(ledgerPath(t.auditDir), `${JSON.stringify(entry, null, 2)}
 `, "utf8");
   } catch {}
@@ -108068,7 +108681,7 @@ async function readLedger(auditDir) {
 }
 async function appendRound(t, round) {
   try {
-    await mkdir31(t.auditDir, { recursive: true });
+    await mkdir32(t.auditDir, { recursive: true });
     await appendFile8(roundsPath(t), `${JSON.stringify(round)}
 `, "utf8");
   } catch {}
@@ -108094,7 +108707,7 @@ async function readRounds(t) {
 async function writeResult(t, result, options = {}) {
   const rounds = await readRounds(t);
   const withRounds = rounds.length > 0 ? { ...result, rounds } : result;
-  await mkdir31(t.auditDir, { recursive: true });
+  await mkdir32(t.auditDir, { recursive: true });
   await writeFile12(resultPath(t), `${JSON.stringify(withRounds, null, 2)}
 `, "utf8");
   if (options.ledger === false)
@@ -110117,7 +110730,7 @@ async function runFinishPhase(ctx) {
   const costBefore = _finishPhaseDeps.snapshotCost(ctx.runtime);
   const { signal, dispose } = phaseSignal(ctx.abortSignal, settings.timeouts.flowMs);
   let result = null;
-  let failure;
+  let failure2;
   let dispatchAsk;
   try {
     const audit = {
@@ -110189,13 +110802,13 @@ async function runFinishPhase(ctx) {
       timeouts: { acceptanceMs: settings.timeouts.acceptanceMs, gateMs: settings.timeouts.gateMs }
     });
   } catch (err) {
-    failure = errorMessage(err);
+    failure2 = errorMessage(err);
   } finally {
     await dispatchAsk?.dispose();
     dispose();
   }
   const costUsd = _finishPhaseDeps.snapshotCost(ctx.runtime) - costBefore;
-  const passed = failure === undefined && result?.status !== "escalated";
+  const passed = failure2 === undefined && result?.status !== "escalated";
   if (result?.skipReason) {
     getSafeLogger()?.info("finish", "Finish phase skipped", {
       reason: result.skipReason,
@@ -110227,8 +110840,8 @@ async function runFinishPhase(ctx) {
       escalationReason: result.escalationReason
     });
   }
-  if (failure) {
-    getSafeLogger()?.warn("finish", "Finish phase could not run", { storyId: "_run", error: failure });
+  if (failure2) {
+    getSafeLogger()?.warn("finish", "Finish phase could not run", { storyId: "_run", error: failure2 });
   }
   pipelineEventBus.emit({
     type: "postrun:phase:completed",
@@ -110660,7 +111273,7 @@ var init_runner_completion = __esm(() => {
 });
 
 // src/pipeline/subscribers/events-writer.ts
-import { appendFile as appendFile9, mkdir as mkdir32 } from "fs/promises";
+import { appendFile as appendFile9, mkdir as mkdir33 } from "fs/promises";
 import { basename as basename15, join as join116 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
@@ -110672,7 +111285,7 @@ function wireEventsWriter(bus, feature, runId, workdir) {
     return (async () => {
       try {
         if (!dirReady) {
-          await mkdir32(eventsDir, { recursive: true });
+          await mkdir33(eventsDir, { recursive: true });
           dirReady = true;
         }
         await appendFile9(eventsFile, `${JSON.stringify(line)}
@@ -110846,7 +111459,7 @@ var init_interaction2 = __esm(() => {
 });
 
 // src/pipeline/subscribers/registry.ts
-import { mkdir as mkdir33, writeFile as writeFile13 } from "fs/promises";
+import { mkdir as mkdir34, writeFile as writeFile13 } from "fs/promises";
 import { basename as basename16, join as join117 } from "path";
 function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const logger = getSafeLogger();
@@ -110856,7 +111469,7 @@ function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
-        await mkdir33(runDir, { recursive: true });
+        await mkdir34(runDir, { recursive: true });
         const meta3 = {
           runId,
           project,
@@ -115829,7 +116442,7 @@ var init_rules_lint = __esm(() => {
 });
 
 // src/cli/rules-cli-deps.ts
-import { mkdir as mkdir34 } from "fs/promises";
+import { mkdir as mkdir35 } from "fs/promises";
 import { join as join129 } from "path";
 var _rulesCLIDeps;
 var init_rules_cli_deps = __esm(() => {
@@ -115850,7 +116463,7 @@ var init_rules_cli_deps = __esm(() => {
       }
     },
     mkdir: async (path32) => {
-      await mkdir34(path32, { recursive: true });
+      await mkdir35(path32, { recursive: true });
     },
     globCanonicalRuleFiles: (workdir) => _rulesLintDeps.globCanonicalRuleFiles(workdir),
     globHasMatch: (pattern, cwd) => _rulesLintDeps.globHasMatch(pattern, cwd),
@@ -119955,7 +120568,7 @@ Error generating stack: ` + x.message + `
         return p0;
       });
     }
-    function describeValue(value, maxLength) {
+    function describeValue2(value, maxLength) {
       switch (typeof value) {
         case "string":
           return value = JSON.stringify(value), value.length > maxLength ? 5 > maxLength ? '"..."' : value.slice(0, maxLength - 4) + '..."' : value;
@@ -119975,7 +120588,7 @@ Error generating stack: ` + x.message + `
                 var jsonPropName = JSON.stringify(propName);
                 jsonPropName !== '"' + propName + '"' && (propName = jsonPropName);
                 maxLength -= propName.length - 2;
-                jsonPropName = describeValue(value[propName], 15 > maxLength ? maxLength : 15);
+                jsonPropName = describeValue2(value[propName], 15 > maxLength ? maxLength : 15);
                 maxLength -= jsonPropName.length;
                 if (0 > maxLength) {
                   name += name === "" ? "..." : ", ...";
@@ -119993,7 +120606,7 @@ Error generating stack: ` + x.message + `
       }
     }
     function describePropValue(value, maxLength) {
-      return typeof value !== "string" || needsEscaping.test(value) ? "{" + describeValue(value, maxLength - 2) + "}" : value.length > maxLength - 2 ? 5 > maxLength ? '"..."' : '"' + value.slice(0, maxLength - 5) + '..."' : '"' + value + '"';
+      return typeof value !== "string" || needsEscaping.test(value) ? "{" + describeValue2(value, maxLength - 2) + "}" : value.length > maxLength - 2 ? 5 > maxLength ? '"..."' : '"' + value.slice(0, maxLength - 5) + '..."' : '"' + value + '"';
     }
     function describeExpandedElement(type, props, rowPrefix) {
       var remainingRowLength = 120 - rowPrefix.length - type.length, properties = [], propName;
@@ -120016,14 +120629,14 @@ Error generating stack: ` + x.message + `
       for (propName in clientObject)
         if (clientObject.hasOwnProperty(propName)) {
           delete remainingServerProperties[propName];
-          var maxLength = 120 - 2 * indent - propName.length - 2, clientPropValue = describeValue(clientObject[propName], maxLength);
-          serverObject.hasOwnProperty(propName) ? (maxLength = describeValue(serverObject[propName], maxLength), properties += added(indent) + propName + ": " + clientPropValue + `
+          var maxLength = 120 - 2 * indent - propName.length - 2, clientPropValue = describeValue2(clientObject[propName], maxLength);
+          serverObject.hasOwnProperty(propName) ? (maxLength = describeValue2(serverObject[propName], maxLength), properties += added(indent) + propName + ": " + clientPropValue + `
 `, properties += removed(indent) + propName + ": " + maxLength + `
 `) : properties += added(indent) + propName + ": " + clientPropValue + `
 `;
         }
       for (var _propName in remainingServerProperties)
-        remainingServerProperties.hasOwnProperty(_propName) && (clientObject = describeValue(remainingServerProperties[_propName], 120 - 2 * indent - _propName.length - 2), properties += removed(indent) + _propName + ": " + clientObject + `
+        remainingServerProperties.hasOwnProperty(_propName) && (clientObject = describeValue2(remainingServerProperties[_propName], 120 - 2 * indent - _propName.length - 2), properties += removed(indent) + _propName + ": " + clientObject + `
 `);
       return properties;
     }
@@ -132398,7 +133011,7 @@ var Wrap = /* @__PURE__ */ function(Wrap2) {
   Wrap2[Wrap2["WrapReverse"] = 2] = "WrapReverse";
   return Wrap2;
 }({});
-var constants = {
+var constants2 = {
   ALIGN_AUTO: Align.Auto,
   ALIGN_FLEX_START: Align.FlexStart,
   ALIGN_CENTER: Align.Center,
@@ -132472,7 +133085,7 @@ var constants = {
   WRAP_WRAP: Wrap.Wrap,
   WRAP_WRAP_REVERSE: Wrap.WrapReverse
 };
-var YGEnums_default = constants;
+var YGEnums_default = constants2;
 
 // node_modules/yoga-layout/dist/src/wrapAssembly.js
 function wrapAssembly(lib) {
@@ -136740,10 +137353,10 @@ async function writeQueueCommand(queueFilePath, command) {
     await withQueueFileLock(queueFilePath, () => appendFile10(queueFilePath, `${commandLine2}
 `, "utf8"));
   });
-  const settled = next.catch(() => {});
-  _writeChains.set(queueFilePath, settled);
-  settled.then(() => {
-    if (_writeChains.get(queueFilePath) === settled)
+  const settled2 = next.catch(() => {});
+  _writeChains.set(queueFilePath, settled2);
+  settled2.then(() => {
+    if (_writeChains.get(queueFilePath) === settled2)
       _writeChains.delete(queueFilePath);
   });
   await next;