@nathapp/nax 0.67.0-canary.3 → 0.67.0-canary.5

package/dist/nax.js

@@ -17904,7 +17904,7 @@ function formatConsole(entry) {
   const timestamp = new Date(entry.timestamp).toLocaleTimeString("en-US", {
     hour12: false
   });
-  let levelColor;
+  let levelColor = source_default.gray;
   switch (entry.level) {
     case "error":
       levelColor = source_default.red;
@@ -17916,6 +17916,7 @@ function formatConsole(entry) {
       levelColor = source_default.blue;
       break;
     case "debug":
+    case "silent":
       levelColor = source_default.gray;
       break;
   }
@@ -18064,7 +18065,7 @@ ${JSON.stringify(entry.data, null, 2)}`;
   }
   close() {}
 }
-function initLogger(options = { level: "warn" }) {
+function initLogger(options = { level: "silent" }) {
   if (instance) {
     throw new Error("Logger already initialized. Call getLogger() to access existing instance.");
   }
@@ -18095,12 +18096,13 @@ var init_logger = __esm(() => {
   init_logging();
   init_formatters();
   LOG_LEVEL_PRIORITY = {
+    silent: -1,
     error: 0,
     warn: 1,
     info: 2,
     debug: 3
   };
-  noopLogger = new Logger({ level: "error", useChalk: false, headless: false });
+  noopLogger = new Logger({ level: "silent", useChalk: false, headless: false });
 });
 
 // src/logger/index.ts
@@ -34139,7 +34141,7 @@ var init_autofix_implementer = __esm(() => {
     kind: "run",
     name: "autofix-implementer",
     stage: "rectification",
-    session: { role: "implementer", lifetime: "fresh" },
+    session: { role: "implementer", lifetime: "warm" },
     config: autofixConfigSelector,
     build(input, _ctx) {
       const prompt = RectifierPromptBuilder.reviewRectification(input.failedChecks, input.story);
@@ -34213,6 +34215,7 @@ var init_debate_propose = __esm(() => {
         return "fast";
       return { agent: debater.agent, model: debater.model ?? "fast" };
     },
+    timeoutMs: (_input, ctx) => (ctx.config.debate?.stages?.review?.timeoutSeconds ?? 600) * 1000,
     build(input, _ctx) {
       const builder = new DebatePromptBuilder({ taskContext: input.taskContext, outputFormat: input.outputFormat, stage: input.stage }, { debaters: input.debaters, sessionMode: "one-shot", proposers: input.stageConfig?.proposers });
       return builder.proposeSlot(input.debaterIndex);
@@ -34235,6 +34238,7 @@ var init_debate_judge = __esm(() => {
     jsonMode: false,
     config: debateConfigSelector,
     model: (input) => ({ agent: input.resolverAgent, model: input.resolverModel }),
+    timeoutMs: (input, ctx) => (input.timeoutSeconds ?? ctx.config.debate?.stages?.review?.timeoutSeconds ?? 600) * 1000,
     build(input, _ctx) {
       const prompt = DebatePromptBuilder.resolverJudgePrompt(input.proposals, input.critiques, input.debaters);
       return {
@@ -34260,6 +34264,7 @@ var init_debate_synthesis = __esm(() => {
     jsonMode: false,
     config: debateConfigSelector,
     model: (input) => ({ agent: input.resolverAgent, model: input.resolverModel }),
+    timeoutMs: (input, ctx) => (input.timeoutSeconds ?? ctx.config.debate?.stages?.review?.timeoutSeconds ?? 600) * 1000,
     build(input, _ctx) {
       const base = DebatePromptBuilder.resolverSynthesisPrompt(input.proposals, input.critiques, input.debaters);
       const content = input.promptSuffix ? `${base}
@@ -34293,6 +34298,7 @@ var init_debate_rebut = __esm(() => {
         return "fast";
       return { agent: debater.agent, model: debater.model ?? "fast" };
     },
+    timeoutMs: (_input, ctx) => (ctx.config.debate?.stages?.review?.timeoutSeconds ?? 600) * 1000,
     build(input, _ctx) {
       const builder = new DebatePromptBuilder({ taskContext: input.taskContext, outputFormat: "", stage: input.stage }, { debaters: input.debaters, sessionMode: "one-shot" });
       return builder.rebutSlot(input.debaterIndex, input.proposals);
@@ -34339,6 +34345,7 @@ var init_debate_stateful = __esm(() => {
     session: { role: "debate-stateful", lifetime: "fresh" },
     config: debateConfigSelector,
     model: (input) => ({ agent: input.debater.agent, model: input.debater.model ?? "fast" }),
+    timeoutMs: (_input, ctx) => (ctx.config.debate?.stages?.review?.timeoutSeconds ?? 600) * 1000,
     async hopBody(initialPrompt, ctx) {
       const proposal = ctx.input.turnSemaphore ? await ctx.input.turnSemaphore.run(() => ctx.send(initialPrompt)) : await ctx.send(initialPrompt);
       ctx.input.proposalBarriers[ctx.input.index].resolve(proposal.output);
@@ -34510,7 +34517,8 @@ var RESOLVER_FALLBACK_AGENT = "synthesis", RESOLVER_FALLBACK_MODEL = "fast", jud
     critiques: ctx.critiques,
     debaters: ctx.debaters,
     resolverAgent,
-    resolverModel
+    resolverModel,
+    timeoutSeconds: ctx.stageConfig.timeoutSeconds
   });
   return {
     outcome: output.trim() ? "passed" : "failed",
@@ -34533,7 +34541,8 @@ var RESOLVER_FALLBACK_AGENT2 = "synthesis", RESOLVER_FALLBACK_MODEL2 = "fast", s
     debaters: ctx.debaters,
     resolverAgent,
     resolverModel,
-    promptSuffix: ctx.promptSuffix
+    promptSuffix: ctx.promptSuffix,
+    timeoutSeconds: ctx.stageConfig.timeoutSeconds
   });
   return {
     outcome: output.trim() ? "passed" : "failed",
@@ -34846,6 +34855,7 @@ var init_debate_hybrid = __esm(() => {
     session: { role: "debate-hybrid", lifetime: "fresh" },
     config: debateConfigSelector,
     model: (input) => ({ agent: input.debater.agent, model: input.debater.model ?? "fast" }),
+    timeoutMs: (_input, ctx) => (ctx.config.debate?.stages?.review?.timeoutSeconds ?? 600) * 1000,
     async hopBody(initialPrompt, ctx) {
       const logger = _debateSessionDeps.getSafeLogger();
       let totalCostUsd = 0;
@@ -34909,6 +34919,7 @@ var init_debate_plan = __esm(() => {
     session: { role: "debate-plan", lifetime: "fresh" },
     config: debateConfigSelector,
     model: (input) => ({ agent: input.debater.agent, model: input.debater.model ?? "fast" }),
+    timeoutMs: (_input, ctx) => (ctx.config.debate?.stages?.plan?.timeoutSeconds ?? 600) * 1000,
     fileOutput: (input) => input.outputPath,
     async hopBody(initialPrompt, ctx) {
       const proposal = ctx.input.turnSemaphore ? await ctx.input.turnSemaphore.run(() => ctx.send(initialPrompt)) : await ctx.send(initialPrompt);
@@ -36848,7 +36859,7 @@ function countTotalAttempts(iterations) {
   return iterations.reduce((sum, iter) => sum + iter.fixesApplied.length, 0);
 }
 async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
-  const logger = getSafeLogger();
+  const logger = _deps.logger !== undefined ? _deps.logger : getSafeLogger();
   const doCallOp = _deps.callOp ?? _cycleDeps.callOp;
   const now = _deps.now ?? _cycleDeps.now;
   const storyId = ctx.storyId;
@@ -36978,29 +36989,77 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: totalCostUsd
       };
     }
-    const provisionalIterations = [...cycle.iterations, { fixesApplied }];
-    const allExhausted = group.every((s) => countStrategyAttempts(provisionalIterations, s.name) >= s.maxAttempts);
+    const allExhausted = group.every((s) => {
+      const prior = countStrategyAttempts(cycle.iterations, s.name);
+      const current = fixesApplied.filter((fa) => fa.strategyName === s.name).length;
+      return prior + current >= s.maxAttempts;
+    });
     if (allExhausted) {
+      let liteFindingsAfter;
+      try {
+        liteFindingsAfter = await cycle.validate(ctx, { mode: "lite" });
+      } catch (err) {
+        const finishedAt3 = now();
+        cycle.iterations.push({
+          iterationNum: cycle.iterations.length + 1,
+          findingsBefore,
+          fixesApplied,
+          findingsAfter: cycle.findings,
+          outcome: "unchanged",
+          startedAt,
+          finishedAt: finishedAt3
+        });
+        logger?.warn("findings.cycle", "lite validate failed on terminal exhausted branch", {
+          storyId,
+          packageDir,
+          cycleName,
+          error: errorMessage(err)
+        });
+        return {
+          iterations: cycle.iterations,
+          finalFindings: cycle.findings,
+          exitReason: "max-attempts-per-strategy",
+          exhaustedStrategy: group[0]?.name,
+          costUsd: totalCostUsd
+        };
+      }
+      const outcome2 = classifyOutcome(findingsBefore, liteFindingsAfter);
       const finishedAt2 = now();
       cycle.iterations.push({
         iterationNum: cycle.iterations.length + 1,
         findingsBefore,
         fixesApplied,
-        findingsAfter: cycle.findings,
-        outcome: "unchanged",
+        findingsAfter: liteFindingsAfter,
+        outcome: outcome2,
         startedAt,
         finishedAt: finishedAt2
       });
-      logger?.info("findings.cycle", "cycle exited \u2014 strategy attempt cap reached (skipped final validate)", {
+      cycle.findings = liteFindingsAfter;
+      if (liteFindingsAfter.length === 0) {
+        logger?.info("findings.cycle", "cycle exited \u2014 resolved after terminal lite validate", {
+          storyId,
+          packageDir,
+          cycleName,
+          reason: "resolved"
+        });
+        return {
+          iterations: cycle.iterations,
+          finalFindings: [],
+          exitReason: "resolved",
+          costUsd: totalCostUsd
+        };
+      }
+      logger?.info("findings.cycle", "cycle exited \u2014 strategy attempt cap reached (lite validate)", {
         storyId,
         packageDir,
         cycleName,
         reason: "max-attempts-per-strategy",
-        exhaustedStrategy: group[0]?.name
+        exhaustedStrategy: group[0]?.name,
+        liteFindingsAfterCount: liteFindingsAfter.length
       });
       return {
         iterations: cycle.iterations,
-        finalFindings: cycle.findings,
+        finalFindings: liteFindingsAfter,
         exitReason: "max-attempts-per-strategy",
         exhaustedStrategy: group[0]?.name,
         costUsd: totalCostUsd
@@ -37010,7 +37069,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
     let validatorAttempt = 0;
     for (;; ) {
       try {
-        findingsAfter = await cycle.validate(ctx);
+        findingsAfter = await cycle.validate(ctx, { mode: "full" });
         break;
       } catch (err) {
         if (validatorAttempt >= cycle.config.validatorRetries) {
@@ -39290,8 +39349,486 @@ async function runRetryLoop(input) {
   return { outcome: "exhausted", attempts: input.maxAttempts, finalFailure: currentFailure };
 }
 
+// src/execution/escalation/escalation.ts
+function escalateTier(currentTier, tierOrder) {
+  const getName = (t) => t.tier ?? t.name ?? null;
+  const currentIndex = tierOrder.findIndex((t) => getName(t) === currentTier);
+  if (currentIndex === -1 || currentIndex === tierOrder.length - 1) {
+    return null;
+  }
+  const next = tierOrder[currentIndex + 1];
+  const nextName = getName(next);
+  if (!nextName)
+    return null;
+  return { tier: nextName, agent: next.agent };
+}
+function calculateMaxIterations(tierOrder) {
+  return tierOrder.reduce((sum, t) => sum + t.attempts, 0);
+}
+
+// src/session/naming.ts
+var exports_naming = {};
+__export(exports_naming, {
+  formatSessionName: () => formatSessionName
+});
+var init_naming = __esm(() => {
+  init_session_name();
+});
+
+// src/verification/failure-records.ts
+function truncateUnmappedFailureOutput(output) {
+  const tailLines = output.split(`
+`).slice(-UNMAPPED_FAILURE_OUTPUT_MAX_LINES).join(`
+`);
+  if (tailLines.length <= UNMAPPED_FAILURE_OUTPUT_MAX_CHARS) {
+    return tailLines;
+  }
+  return `... (truncated)
+${tailLines.slice(-UNMAPPED_FAILURE_OUTPUT_MAX_CHARS)}`;
+}
+function buildFailureRecords(testSummary, rawOutput) {
+  if (testSummary.failures.length > 0) {
+    return testSummary.failures.map((failure) => ({
+      test: failure.testName,
+      file: failure.file,
+      message: failure.error,
+      output: failure.stackTrace.length > 0 ? failure.stackTrace.join(`
+`) : undefined
+    }));
+  }
+  if (testSummary.failed === 0) {
+    return [];
+  }
+  return [
+    {
+      test: `Unmapped test failures (${testSummary.failed} detected)`,
+      message: "Structured test failure parsing returned no failure records. Diagnose the regression from the raw test output.",
+      output: rawOutput?.trim() ? truncateUnmappedFailureOutput(rawOutput.trim()) : undefined
+    }
+  ];
+}
+var UNMAPPED_FAILURE_OUTPUT_MAX_LINES = 200, UNMAPPED_FAILURE_OUTPUT_MAX_CHARS = 8000;
+
+// src/verification/rectification-loop.ts
+async function _defaultRunDebate(storyId, stageConfig, prompt, config2, agentManager) {
+  const logger = getSafeLogger();
+  const debaters = stageConfig.debaters ?? [];
+  const manager = agentManager;
+  const resolved = [];
+  for (const debater of debaters) {
+    if (manager.getAgent(debater.agent)) {
+      resolved.push({ debater, agentName: debater.agent });
+    }
+  }
+  if (resolved.length === 0) {
+    return { output: null, totalCostUsd: 0 };
+  }
+  const timeoutMs = (config2.execution?.sessionTimeoutSeconds ?? 600) * 1000;
+  const defaultAgentName = resolveDefaultAgent(config2);
+  const resolvedDebaters = resolved.map(({ debater, agentName }) => {
+    let modelDef;
+    try {
+      modelDef = resolveConfiguredModel(config2.models, agentName, debater.model ?? "balanced", defaultAgentName).modelDef;
+    } catch {
+      modelDef = { provider: "unknown", model: debater.model ?? "default" };
+    }
+    return { debater, agentName, modelDef };
+  });
+  const startMs = Date.now();
+  const proposalSettled = await Promise.allSettled(resolvedDebaters.map(({ agentName, modelDef }) => manager.completeAs(agentName, prompt, {
+    modelDef,
+    workdir: "",
+    storyId,
+    sessionRole: "debate-proposal",
+    timeoutMs
+  }).then((out) => typeof out === "string" ? out : out.output)));
+  const durationMs = Date.now() - startMs;
+  const successful = proposalSettled.filter((r) => r.status === "fulfilled").map((r) => r.value);
+  if (successful.length === 0) {
+    return { output: null, totalCostUsd: 0 };
+  }
+  const successCount = successful.length;
+  const costPerDebater = estimateCostByDuration("balanced", durationMs / successCount);
+  const totalCostUsd = costPerDebater.cost * successCount;
+  logger?.debug("rectification", "debate diagnosis complete", { storyId, successCount, totalCostUsd });
+  const output = successful.join(`
+
+`);
+  return { output, totalCostUsd };
+}
+async function runRectificationLoop(opts) {
+  const loopStartMs = Date.now();
+  const {
+    config: config2,
+    workdir,
+    story,
+    testCommand,
+    timeoutSeconds,
+    testOutput,
+    promptPrefix,
+    featureName,
+    projectDir,
+    testScopedTemplate,
+    sessionId,
+    runtime
+  } = opts;
+  const logger = getSafeLogger();
+  const agentManager = opts.agentManager ?? _rectificationDeps.agentManager;
+  if (!agentManager) {
+    logger?.warn("rectification", "No agentManager threaded \u2014 skipping rectification loop", {
+      storyId: story.id
+    });
+    return { succeeded: false, cost: 0, durationMs: 0 };
+  }
+  const rectificationConfig = config2.execution.rectification;
+  const testSummary = parseTestOutput(testOutput);
+  const label = promptPrefix ? "regression rectification" : "rectification";
+  const rectificationSessionName = formatSessionName({
+    workdir,
+    featureName,
+    storyId: story.id,
+    role: "implementer"
+  });
+  let costAccum = 0;
+  let currentAttempt = 0;
+  let heldHandle;
+  const initialFailure = {
+    testOutput,
+    testSummary
+  };
+  const outcome = await runRetryLoop({
+    stage: "rectification",
+    storyId: story.id,
+    packageDir: workdir,
+    maxAttempts: rectificationConfig.maxRetries,
+    failure: initialFailure,
+    previousAttempts: [],
+    buildPrompt: (failure) => {
+      currentAttempt++;
+      const diagnosisPrefix = null;
+      const debateStageConfig = config2.debate?.stages?.rectification;
+      let debatePromise = Promise.resolve(null);
+      if (debateStageConfig?.enabled) {
+        const failureSummary = formatFailureSummary(failure.testSummary.failures);
+        const diagnosisPrompt = `Analyze the following test failures and identify the root cause:
+
+${failureSummary}`;
+        debatePromise = (async () => {
+          try {
+            const debateResult = await _rectificationDeps.runDebate(story.id, debateStageConfig, diagnosisPrompt, config2, agentManager);
+            if (debateResult.totalCostUsd > 0 && story.routing) {
+              story.routing.estimatedCostUsd = (story.routing.estimatedCostUsd ?? 0) + debateResult.totalCostUsd;
+            }
+            if (debateResult.output !== null) {
+              return `## Root Cause Analysis
+
+${debateResult.output}`;
+            }
+            logger?.info("rectification", "debate diagnosis fallback \u2014 all debaters failed", {
+              storyId: story.id,
+              event: "fallback"
+            });
+            return null;
+          } catch (_error) {
+            logger?.info("rectification", "debate diagnosis fallback \u2014 debate threw error", {
+              storyId: story.id,
+              event: "fallback"
+            });
+            return null;
+          }
+        })();
+      }
+      const failureRecords = buildFailureRecords(failure.testSummary, failure.testOutput);
+      const rectPrompt = RectifierPromptBuilder.regressionFailure({
+        story,
+        failures: failureRecords,
+        testCommand,
+        conventions: true
+      });
+      const rectPromise = Promise.resolve(rectPrompt);
+      return (async () => {
+        const [diagnosis, rectificationPrompt] = await Promise.all([debatePromise, rectPromise]);
+        let finalPrompt = rectificationPrompt;
+        if (diagnosis) {
+          finalPrompt = `${diagnosis}
+
+${finalPrompt}`;
+        }
+        if (promptPrefix) {
+          finalPrompt = `${promptPrefix}
+
+${finalPrompt}`;
+        }
+        return finalPrompt;
+      })();
+    },
+    execute: async (prompt) => {
+      const defaultAgent = agentManager.getDefault();
+      const complexity = story.routing?.complexity ?? "medium";
+      const modelTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
+      const modelDef = resolveModelForAgent(config2.models, story.routing?.agent ?? defaultAgent, modelTier, defaultAgent);
+      let agentResult;
+      {
+        let transportRetries = 0;
+        const maxTransportRetries = config2.execution?.sessionErrorRetryableMaxRetries ?? 3;
+        while (true) {
+          if (!heldHandle) {
+            const existingHandle = runtime.sessionManager.getLiveHandle(rectificationSessionName);
+            if (existingHandle && existingHandle.agentName === defaultAgent) {
+              heldHandle = existingHandle;
+            } else {
+              heldHandle = await runtime.sessionManager.openSession(rectificationSessionName, {
+                agentName: defaultAgent,
+                role: "implementer",
+                workdir,
+                pipelineStage: "rectification",
+                modelDef,
+                timeoutSeconds: config2.execution.sessionTimeoutSeconds,
+                featureName,
+                storyId: story.id,
+                signal: runtime.signal
+              });
+            }
+          }
+          try {
+            const turn = await agentManager.runAsSession(defaultAgent, heldHandle, prompt, {
+              storyId: story.id,
+              featureName,
+              workdir,
+              projectDir,
+              pipelineStage: "rectification",
+              sessionRole: "implementer",
+              signal: runtime.signal,
+              maxTurns: config2.agent?.maxInteractionTurns
+            });
+            agentResult = {
+              success: true,
+              exitCode: 0,
+              output: turn.output,
+              rateLimited: false,
+              durationMs: 0,
+              estimatedCostUsd: turn.estimatedCostUsd,
+              ...turn.exactCostUsd !== undefined && { exactCostUsd: turn.exactCostUsd },
+              ...turn.tokenUsage && { tokenUsage: turn.tokenUsage },
+              ...heldHandle.protocolIds && { protocolIds: heldHandle.protocolIds }
+            };
+            break;
+          } catch (err) {
+            const stale = heldHandle;
+            heldHandle = undefined;
+            await runtime.sessionManager.closeSession(stale).catch(() => {});
+            if (err instanceof SessionTurnError && err.retryable && transportRetries < maxTransportRetries) {
+              transportRetries++;
+              getSafeLogger()?.warn("rectification", "fail-adapter-error: same-agent retry with fresh session", {
+                storyId: story.id,
+                attempt: transportRetries,
+                maxAttempts: maxTransportRetries,
+                retriable: true
+              });
+              continue;
+            }
+            throw err;
+          }
+        }
+      }
+      costAccum += agentResult.estimatedCostUsd ?? 0;
+      if (sessionId && agentResult.protocolIds) {
+        try {
+          runtime.sessionManager.bindHandle(sessionId, rectificationSessionName, agentResult.protocolIds);
+        } catch {}
+      }
+      if (agentResult.success) {
+        logger?.info("rectification", `Agent ${label} session complete`, {
+          storyId: story.id,
+          cost: agentResult.estimatedCostUsd
+        });
+      } else {
+        logger?.warn("rectification", `Agent ${label} session failed`, {
+          storyId: story.id,
+          exitCode: agentResult.exitCode
+        });
+      }
+      return {
+        agentSuccess: agentResult.success,
+        cost: agentResult.estimatedCostUsd ?? 0,
+        protocolIds: agentResult.protocolIds
+      };
+    },
+    shouldAbort: (failure) => {
+      if (rectificationConfig.abortOnIncreasingFailures) {
+        return failure.testSummary.failed > initialFailure.testSummary.failed;
+      }
+      return false;
+    },
+    verify: async (result) => {
+      const retryVerification = await _rectificationDeps.runVerification({
+        workdir,
+        expectedFiles: getExpectedFiles(story),
+        command: testCommand,
+        timeoutSeconds,
+        forceExit: config2.quality.forceExit,
+        detectOpenHandles: config2.quality.detectOpenHandles,
+        detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
+        timeoutRetryCount: 0,
+        gracePeriodMs: config2.quality.gracePeriodMs,
+        drainTimeoutMs: config2.quality.drainTimeoutMs,
+        shell: config2.quality.shell,
+        stripEnvVars: config2.quality.stripEnvVars
+      });
+      if (retryVerification.success) {
+        logger?.info("rectification", `[OK] ${label} succeeded!`, {
+          storyId: story.id,
+          attempt: currentAttempt,
+          initialFailures: initialFailure.testSummary.failed
+        });
+        return { passed: true };
+      }
+      if (retryVerification.output) {
+        const newTestSummary = parseTestOutput(retryVerification.output);
+        if (newTestSummary.failed === 0 && retryVerification.status !== "ENVIRONMENTAL_FAILURE" && (retryVerification.status === "SUCCESS" || newTestSummary.passed > 0)) {
+          logger?.info("rectification", `[OK] ${label} succeeded after parsing retry output`, {
+            storyId: story.id,
+            attempt: currentAttempt,
+            initialFailures: initialFailure.testSummary.failed
+          });
+          return { passed: true };
+        }
+        const failingTests = newTestSummary.failures.slice(0, 10).map((failure) => failure.testName);
+        const logData = {
+          storyId: story.id,
+          attempt: currentAttempt,
+          remainingFailures: newTestSummary.failed,
+          failingTests
+        };
+        if (newTestSummary.failures.length > 10 || newTestSummary.failures.length === 0 && newTestSummary.failed > 0) {
+          logData.totalFailingTests = newTestSummary.failed;
+        }
+        logger?.warn("rectification", `${label} still failing after attempt`, logData);
+        return {
+          passed: false,
+          newFailure: {
+            testOutput: retryVerification.output,
+            testSummary: newTestSummary
+          }
+        };
+      }
+      return {
+        passed: false,
+        newFailure: {
+          testOutput: retryVerification.output ?? "",
+          testSummary: initialFailure.testSummary
+        }
+      };
+    }
+  }).finally(async () => {
+    if (heldHandle) {
+      const stale = heldHandle;
+      heldHandle = undefined;
+      await runtime.sessionManager.closeSession(stale).catch(() => {});
+    }
+  });
+  const succeeded = outcome.outcome === "fixed";
+  if (outcome.outcome === "exhausted") {
+    const finalFailure = outcome.finalFailure;
+    const shouldEscalate = rectificationConfig.escalateOnExhaustion !== false && config2.autoMode?.escalation?.enabled === true && finalFailure.testSummary.failed > 0;
+    if (shouldEscalate) {
+      const complexity = story.routing?.complexity ?? "medium";
+      const currentTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
+      const tierOrder = config2.autoMode.escalation.tierOrder;
+      const escalationResult = _rectificationDeps.escalateTier(currentTier, tierOrder);
+      const escalatedTier = escalationResult?.tier ?? null;
+      const escalatedAgent = escalationResult?.agent;
+      if (escalatedTier !== null) {
+        const escalationManager = agentManager;
+        const agentName = escalatedAgent ?? story.routing?.agent ?? escalationManager.getDefault();
+        if (escalationManager.getAgent(agentName)) {
+          const escalatedModelDef = resolveModelForAgent(config2.models, agentName, escalatedTier, escalationManager.getDefault());
+          let escalationPrompt = RectifierPromptBuilder.escalated(finalFailure.testSummary.failures, story, outcome.attempts, currentTier, escalatedTier, rectificationConfig, testCommand, testScopedTemplate);
+          if (promptPrefix) {
+            escalationPrompt = `${promptPrefix}
+
+${escalationPrompt}`;
+          }
+          const escalationRunResult = await escalationManager.runAs(agentName, {
+            runOptions: {
+              prompt: escalationPrompt,
+              workdir,
+              modelTier: escalatedTier,
+              modelDef: escalatedModelDef,
+              timeoutSeconds: config2.execution.sessionTimeoutSeconds,
+              pipelineStage: "rectification",
+              config: config2,
+              projectDir,
+              maxInteractionTurns: config2.agent?.maxInteractionTurns,
+              featureName,
+              storyId: story.id,
+              sessionRole: "implementer"
+            }
+          });
+          costAccum += escalationRunResult.estimatedCostUsd ?? 0;
+          logger?.info("rectification", "escalated rectification attempt cost", {
+            storyId: story.id,
+            escalatedTier,
+            cost: escalationRunResult.estimatedCostUsd
+          });
+          const escalationVerification = await _rectificationDeps.runVerification({
+            workdir,
+            expectedFiles: getExpectedFiles(story),
+            command: testCommand,
+            timeoutSeconds,
+            forceExit: config2.quality.forceExit,
+            detectOpenHandles: config2.quality.detectOpenHandles,
+            detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
+            timeoutRetryCount: 0,
+            gracePeriodMs: config2.quality.gracePeriodMs,
+            drainTimeoutMs: config2.quality.drainTimeoutMs,
+            shell: config2.quality.shell,
+            stripEnvVars: config2.quality.stripEnvVars
+          });
+          if (escalationVerification.success) {
+            logger?.info("rectification", `${label} escalated from ${currentTier} to ${escalatedTier} and succeeded`, {
+              storyId: story.id,
+              currentTier,
+              escalatedTier
+            });
+            return { succeeded: true, cost: costAccum, durationMs: Date.now() - loopStartMs };
+          }
+          logger?.warn("rectification", "escalated rectification also failed", { storyId: story.id, escalatedTier });
+        }
+      }
+    }
+    logger?.warn("rectification", `${label} exhausted max retries`, {
+      storyId: story.id,
+      attempts: outcome.attempts,
+      remainingFailures: initialFailure.testSummary.failed
+    });
+  }
+  return { succeeded, cost: costAccum, durationMs: Date.now() - loopStartMs };
+}
+var _rectificationDeps;
+var init_rectification_loop = __esm(() => {
+  init_agents();
+  init_cost();
+  init_types3();
+  init_config();
+  init_logger2();
+  init_prd();
+  init_prompts();
+  init_naming();
+  init_parser2();
+  init_parser2();
+  init_runners();
+  _rectificationDeps = {
+    agentManager: undefined,
+    runVerification: fullSuite,
+    escalateTier,
+    runDebate: _defaultRunDebate
+  };
+});
+
 // src/verification/index.ts
 var init_verification = __esm(() => {
+  init_rectification_loop();
   init_executor();
   init_parser2();
   init_runners();
@@ -40856,7 +41393,7 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
         prompt
       };
     } finally {
-      if (hopKind.kind !== "stale-retry") {
+      if (hopKind.kind !== "stale-retry" && !resolvedRunOptions.keepOpen) {
         await sessionManager.closeSession(handle);
       }
     }
@@ -41044,6 +41581,7 @@ async function callOp(ctx, op, input) {
     featureName: ctx.featureName,
     storyId: ctx.storyId,
     callId,
+    ...runOp.session.lifetime === "warm" ? { keepOpen: true } : {},
     ...ctx.scopeId !== undefined ? { scopeId: ctx.scopeId } : {},
     ...ctx.interactionBridge ? { interactionBridge: ctx.interactionBridge } : {},
     ...ctx.maxInteractionTurns !== undefined ? { maxInteractionTurns: ctx.maxInteractionTurns } : {}
@@ -42861,15 +43399,6 @@ var init_manager_sweep = __esm(() => {
   DEFAULT_ORPHAN_TTL_MS = 4 * 60 * 60 * 1000;
 });
 
-// src/session/naming.ts
-var exports_naming = {};
-__export(exports_naming, {
-  formatSessionName: () => formatSessionName
-});
-var init_naming = __esm(() => {
-  init_session_name();
-});
-
 // src/session/types.ts
 var SESSION_TRANSITIONS;
 var init_types7 = __esm(() => {
@@ -45211,7 +45740,11 @@ async function runPlan(ctx, taskContext, outputFormat, opts) {
     const proposalBarriers = resolved.map(() => Promise.withResolvers());
     const rebutBuilder = new DebatePromptBuilder({ taskContext, outputFormat: "", stage: "plan" }, { debaters: resolved.map((e) => e.debater), sessionMode: "stateful" });
     const callOpPromises = resolved.map(({ debater, agentName }, index) => {
-      const debaterCtx = { ...ctx.callContext, agentName };
+      const debaterCtx = {
+        ...ctx.callContext,
+        agentName,
+        sessionOverride: { role: `debate-plan-${index}` }
+      };
       return callOp(debaterCtx, planDebaterOp, {
         debater,
         index,
@@ -45276,7 +45809,11 @@ async function runPlan(ctx, taskContext, outputFormat, opts) {
     const rebuttalBarriers = resolved.map(() => Promise.withResolvers());
     const rebutBuilder = new DebatePromptBuilder({ taskContext, outputFormat: "", stage: "plan" }, { debaters: resolved.map((e) => e.debater), sessionMode: "stateful" });
     const callOpPromisesB = resolved.map(({ debater, agentName }, index) => {
-      const debaterCtx = { ...ctx.callContext, agentName };
+      const debaterCtx = {
+        ...ctx.callContext,
+        agentName,
+        sessionOverride: { role: `debate-plan-${index}` }
+      };
       return callOp(debaterCtx, planDebaterOp, {
         debater,
         index,
@@ -45335,7 +45872,11 @@ async function runPlan(ctx, taskContext, outputFormat, opts) {
     for (const barrier of rebuttalBarriersC)
       barrier.resolve("");
     const settled = await allSettledBounded(resolved.map(({ debater, agentName }, index) => async () => {
-      const debaterCtx = { ...ctx.callContext, agentName };
+      const debaterCtx = {
+        ...ctx.callContext,
+        agentName,
+        sessionOverride: { role: `debate-plan-${index}` }
+      };
       const result = await callOp(debaterCtx, planDebaterOp, {
         debater,
         index,
@@ -50459,42 +51000,8 @@ var init_greenfield = __esm(() => {
   ]);
 });
 
-// src/verification/failure-records.ts
-function truncateUnmappedFailureOutput(output) {
-  const tailLines = output.split(`
-`).slice(-UNMAPPED_FAILURE_OUTPUT_MAX_LINES).join(`
-`);
-  if (tailLines.length <= UNMAPPED_FAILURE_OUTPUT_MAX_CHARS) {
-    return tailLines;
-  }
-  return `... (truncated)
-${tailLines.slice(-UNMAPPED_FAILURE_OUTPUT_MAX_CHARS)}`;
-}
-function buildFailureRecords(testSummary, rawOutput) {
-  if (testSummary.failures.length > 0) {
-    return testSummary.failures.map((failure) => ({
-      test: failure.testName,
-      file: failure.file,
-      message: failure.error,
-      output: failure.stackTrace.length > 0 ? failure.stackTrace.join(`
-`) : undefined
-    }));
-  }
-  if (testSummary.failed === 0) {
-    return [];
-  }
-  return [
-    {
-      test: `Unmapped test failures (${testSummary.failed} detected)`,
-      message: "Structured test failure parsing returned no failure records. Diagnose the regression from the raw test output.",
-      output: rawOutput?.trim() ? truncateUnmappedFailureOutput(rawOutput.trim()) : undefined
-    }
-  ];
-}
-var UNMAPPED_FAILURE_OUTPUT_MAX_LINES = 200, UNMAPPED_FAILURE_OUTPUT_MAX_CHARS = 8000;
-
 // src/tdd/rectification-gate.ts
-async function runFullSuiteGate(story, config2, workdir, agentManager, implementerTier, lite, logger, featureName, projectDir, sessionManager, sessionId, runtime) {
+async function runFullSuiteGate(story, config2, workdir, agentManager, implementerTier, lite, logger, featureName, projectDir, sessionManager, runtime) {
   const rectificationEnabled = config2.execution.rectification?.enabled ?? false;
   if (!rectificationEnabled) {
     return { passed: false, cost: 0, fullSuiteGatePassed: false, status: "disabled" };
@@ -50522,16 +51029,16 @@ async function runFullSuiteGate(story, config2, workdir, agentManager, implement
         });
         return { passed: true, cost: 0, fullSuiteGatePassed: false, status: "deferred-unattributable" };
       }
-      return await runRectificationLoop(story, config2, workdir, agentManager, implementerTier, lite, logger, testSummary, rectificationConfig, effectiveTestCmd, fullSuiteTimeout, fullSuiteResult.output, featureName, projectDir, sessionManager, sessionId, runtime);
+      return await runRectificationLoop2(story, config2, workdir, agentManager, implementerTier, lite, logger, testSummary, rectificationConfig, effectiveTestCmd, fullSuiteTimeout, fullSuiteResult.output, runtime, featureName, projectDir, sessionManager);
     }
     if (testSummary.failures.length > 0) {
-      logger.warn("tdd", "Full suite gate: parser counter mismatch \u2014 routing to rectification using failures.length", {
+      logger.warn("tdd", "Full suite gate: parser counter mismatch \u2014 failing gate (unreliable failure count)", {
         storyId: story.id,
         failedCounter: testSummary.failed,
         failuresLength: testSummary.failures.length,
         exitCode: fullSuiteResult.exitCode
       });
-      return await runRectificationLoop(story, config2, workdir, agentManager, implementerTier, lite, logger, { ...testSummary, failed: Math.max(testSummary.failed, testSummary.failures.length) }, rectificationConfig, effectiveTestCmd, fullSuiteTimeout, fullSuiteResult.output, featureName, projectDir, sessionManager, sessionId, runtime);
+      return { passed: false, cost: 0, fullSuiteGatePassed: false, status: "execution-failed" };
     }
     if (testSummary.passed > 0) {
       logger.info("tdd", "Full suite gate passed (non-zero exit, 0 failures, tests detected)", {
@@ -50559,7 +51066,7 @@ async function runFullSuiteGate(story, config2, workdir, agentManager, implement
   });
   return { passed: false, cost: 0, fullSuiteGatePassed: false, status: "execution-failed" };
 }
-async function runRectificationLoop(story, config2, workdir, agentManager, implementerTier, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, testOutput, featureName, projectDir, sessionManager, sessionId, runtime) {
+async function runRectificationLoop2(story, config2, workdir, agentManager, implementerTier, lite, logger, testSummary, rectificationConfig, testCmd, fullSuiteTimeout, testOutput, runtime, featureName, projectDir, sessionManager) {
   logger.warn("tdd", "Full suite gate detected regressions", {
     storyId: story.id,
     failedTests: testSummary.failed,
@@ -50597,7 +51104,6 @@ async function runRectificationLoop(story, config2, workdir, agentManager, imple
     },
     execute: async (prompt) => {
       currentAttempt++;
-      const isLastAttempt = currentAttempt >= rectificationConfig.maxRetries;
       const rectifyBeforeRef = await captureGitRef(workdir) ?? "HEAD";
       const defaultAgent = agentManager.getDefault();
       const runOptions = {
@@ -50615,11 +51121,14 @@ async function runRectificationLoop(story, config2, workdir, agentManager, imple
         sessionRole: "implementer"
       };
       let rectifyResult;
-      if (runtime) {
-        let transportRetries = 0;
-        const maxTransportRetries = config2.execution?.sessionErrorRetryableMaxRetries ?? 3;
-        while (transportRetries <= maxTransportRetries) {
-          if (!heldHandle) {
+      let transportRetries = 0;
+      const maxTransportRetries = config2.execution?.sessionErrorRetryableMaxRetries ?? 3;
+      while (true) {
+        if (!heldHandle) {
+          const existingHandle = sessionManager?.getLiveHandle(rectificationSessionName);
+          if (existingHandle && existingHandle.agentName === defaultAgent) {
+            heldHandle = existingHandle;
+          } else {
             heldHandle = await runtime.sessionManager.openSession(rectificationSessionName, {
               agentName: defaultAgent,
               role: "implementer",
@@ -50632,54 +51141,50 @@ async function runRectificationLoop(story, config2, workdir, agentManager, imple
               signal: runtime.signal
             });
           }
-          try {
-            const turn = await agentManager.runAsSession(defaultAgent, heldHandle, prompt, {
+        }
+        try {
+          const turn = await agentManager.runAsSession(defaultAgent, heldHandle, prompt, {
+            storyId: story.id,
+            featureName,
+            workdir,
+            projectDir,
+            pipelineStage: "rectification",
+            sessionRole: "implementer",
+            signal: runtime.signal,
+            maxTurns: config2.agent?.maxInteractionTurns
+          });
+          rectifyResult = {
+            success: true,
+            exitCode: 0,
+            output: turn.output,
+            rateLimited: false,
+            durationMs: 0,
+            estimatedCostUsd: turn.estimatedCostUsd,
+            ...turn.exactCostUsd !== undefined && { exactCostUsd: turn.exactCostUsd },
+            ...turn.tokenUsage && { tokenUsage: turn.tokenUsage },
+            ...heldHandle.protocolIds && { protocolIds: heldHandle.protocolIds }
+          };
+          break;
+        } catch (err) {
+          const stale = heldHandle;
+          heldHandle = undefined;
+          await runtime.sessionManager.closeSession(stale).catch(() => {});
+          if (err instanceof SessionTurnError && err.retryable && transportRetries < maxTransportRetries) {
+            transportRetries++;
+            getSafeLogger()?.warn("tdd", "fail-adapter-error: same-agent retry with fresh session", {
               storyId: story.id,
-              featureName,
-              workdir,
-              projectDir,
-              pipelineStage: "rectification",
-              sessionRole: "implementer",
-              signal: runtime.signal,
-              maxTurns: config2.agent?.maxInteractionTurns
+              attempt: transportRetries,
+              maxAttempts: maxTransportRetries,
+              retriable: true
             });
-            rectifyResult = {
-              success: true,
-              exitCode: 0,
-              output: turn.output,
-              rateLimited: false,
-              durationMs: 0,
-              estimatedCostUsd: turn.estimatedCostUsd,
-              ...turn.exactCostUsd !== undefined && { exactCostUsd: turn.exactCostUsd },
-              ...turn.tokenUsage && { tokenUsage: turn.tokenUsage },
-              ...heldHandle.protocolIds && { protocolIds: heldHandle.protocolIds }
-            };
-            break;
-          } catch (err) {
-            const stale = heldHandle;
-            heldHandle = undefined;
-            await runtime.sessionManager.closeSession(stale).catch(() => {});
-            if (err instanceof SessionTurnError && err.retryable && transportRetries < maxTransportRetries) {
-              transportRetries++;
-              getSafeLogger()?.warn("tdd", "fail-adapter-error: same-agent retry with fresh session", {
-                storyId: story.id,
-                attempt: transportRetries,
-                maxAttempts: maxTransportRetries,
-                retriable: true
-              });
-              continue;
-            }
-            throw err;
+            continue;
           }
+          throw err;
         }
-      } else {
-        rectifyResult = await agentManager.run({
-          runOptions: { ...runOptions, keepOpen: !isLastAttempt }
-        });
       }
-      if (sessionManager && sessionId && rectifyResult.protocolIds) {
+      if (sessionManager && heldHandle && rectifyResult.protocolIds) {
         try {
-          sessionManager.bindHandle(sessionId, rectificationSessionName, rectifyResult.protocolIds);
+          sessionManager.bindHandle(heldHandle.id, rectificationSessionName, rectifyResult.protocolIds);
         } catch {}
       }
       if (!rectifyResult.success && rectifyResult.pid) {
@@ -50745,7 +51250,7 @@ async function runRectificationLoop(story, config2, workdir, agentManager, imple
       };
     }
   }).finally(async () => {
-    if (heldHandle && runtime) {
+    if (heldHandle) {
       const stale = heldHandle;
       heldHandle = undefined;
       await runtime.sessionManager.closeSession(stale).catch(() => {});
@@ -51236,7 +51741,7 @@ async function runThreeSessionTdd(options) {
     };
   }
   const implementerBinding = getTddSessionBinding?.("implementer");
-  const fullSuiteGate = await runFullSuiteGate(story, config2, workdir, agentManager, implementerTier, lite, logger, featureName, projectDir, implementerBinding?.sessionManager, implementerBinding?.sessionId, runtime);
+  const fullSuiteGate = await runFullSuiteGate(story, config2, workdir, agentManager, implementerTier, lite, logger, featureName, projectDir, implementerBinding?.sessionManager, runtime);
   const { cost: fullSuiteGateCost, fullSuiteGatePassed } = fullSuiteGate;
   if (fullSuiteGate.status === "rectification-exhausted") {
     const failureCategory = "full-suite-gate-exhausted";
@@ -51522,6 +52027,7 @@ var init_tdd = __esm(() => {
   init_isolation();
   init_orchestrator3();
   init_orchestrator_ctx();
+  init_rectification_gate();
   init_session_op();
   init_cleanup();
   init_verdict();
@@ -51936,9 +52442,9 @@ async function runAgentRectificationV2(ctx, _lintFixCmd, _formatFixCmd, _effecti
       maxAttemptsTotal: maxTotalAttempts,
       validatorRetries: 1
     },
-    async validate(_cycleCtx) {
+    async validate(_cycleCtx, _opts) {
       iterationBeforeRef = await _autofixCycleGuardDeps.captureGitRef(ctx.workdir) ?? iterationBeforeRef;
-      await _autofixDeps.recheckReview(ctx);
+      await _autofixDeps.recheckReview(ctx, { lite: _opts.mode === "lite" });
       const fresh = collectCurrentFindings(ctx);
       const pending = ctx.testEditDeclarations ?? [];
       if (pending.length === 0)
@@ -52734,7 +53240,7 @@ var init_review2 = __esm(() => {
       const reviewDebateEnabled = ctx.rootConfig?.debate?.enabled && ctx.rootConfig?.debate?.stages?.review?.enabled;
       const dialogueEnabled = ctx.config.review?.dialogue?.enabled ?? false;
       logger.info("review", "Running review phase", { storyId: ctx.story.id });
-      if (dialogueEnabled && !reviewDebateEnabled && ctx.reviewerSession) {
+      if (dialogueEnabled && !reviewDebateEnabled && ctx.reviewerSession && !ctx.skipLLMReviewers) {
         try {
           const diff = ctx.storyGitRef ?? "";
           const reReviewResult = await ctx.reviewerSession.reReview(diff);
@@ -52769,7 +53275,7 @@ var init_review2 = __esm(() => {
           });
         }
       }
-      if (dialogueEnabled && !ctx.reviewerSession && ctx.agentManager && ctx.sessionManager) {
+      if (dialogueEnabled && !ctx.reviewerSession && ctx.agentManager && ctx.sessionManager && !ctx.skipLLMReviewers) {
         ctx.reviewerSession = _reviewDeps.createReviewerSession(ctx.agentManager, ctx.sessionManager, ctx.story.id, ctx.workdir, ctx.prd.feature ?? "", ctx.config);
         if (!reviewDebateEnabled) {
           const semanticConfig = ctx.config.review?.semantic;
@@ -52873,16 +53379,36 @@ var init_review2 = __esm(() => {
 });
 
 // src/pipeline/stages/autofix.ts
-async function recheckReview(ctx) {
+async function recheckReview(ctx, opts) {
+  const lite = opts?.lite === true;
+  if (lite) {
+    const origSkipChecks = ctx.retrySkipChecks;
+    const origSkipLLMReviewers = ctx.skipLLMReviewers;
+    ctx.retrySkipChecks = new Set([...ctx.retrySkipChecks ?? [], "adversarial", "semantic"]);
+    ctx.skipLLMReviewers = true;
+    try {
+      await _autofixDeps.runReviewStage(ctx);
+    } finally {
+      ctx.retrySkipChecks = origSkipChecks;
+      ctx.skipLLMReviewers = origSkipLLMReviewers;
+    }
+    return ctx.reviewResult?.success === true;
+  }
   const { reviewStage: reviewStage2 } = await Promise.resolve().then(() => (init_review2(), exports_review));
   if (!reviewStage2.enabled(ctx))
     return true;
-  await reviewStage2.execute(ctx);
+  await _autofixDeps.runReviewStage(ctx);
   const hasFailOpen = (ctx.reviewResult?.checks ?? []).some((c) => c.failOpen);
   if (hasFailOpen)
     return false;
   return ctx.reviewResult?.success === true;
 }
+async function runReviewStage(ctx) {
+  const { reviewStage: reviewStage2 } = await Promise.resolve().then(() => (init_review2(), exports_review));
+  if (!reviewStage2.enabled(ctx))
+    return;
+  await reviewStage2.execute(ctx);
+}
 async function runMechanicalFixes(ctx, failedCheckNames) {
   const commands = resolveMechanicalFixCommands(ctx, failedCheckNames);
   for (const resolved of commands) {
@@ -53146,6 +53672,7 @@ var init_autofix = __esm(() => {
     runQualityCommand,
     recheckReview,
     runAgentRectification: runAgentRectificationV2,
+    runReviewStage,
     runTestWriterRectification: (ctx, testWriterChecks, story, agentManager) => runTestWriterRectification(ctx, testWriterChecks, story, agentManager)
   };
 });
@@ -54780,455 +55307,6 @@ var init_queue_check = __esm(() => {
   };
 });
 
-// src/execution/escalation/escalation.ts
-function escalateTier(currentTier, tierOrder) {
-  const getName = (t) => t.tier ?? t.name ?? null;
-  const currentIndex = tierOrder.findIndex((t) => getName(t) === currentTier);
-  if (currentIndex === -1 || currentIndex === tierOrder.length - 1) {
-    return null;
-  }
-  const next = tierOrder[currentIndex + 1];
-  const nextName = getName(next);
-  if (!nextName)
-    return null;
-  return { tier: nextName, agent: next.agent };
-}
-function calculateMaxIterations(tierOrder) {
-  return tierOrder.reduce((sum, t) => sum + t.attempts, 0);
-}
-
-// src/verification/rectification-loop.ts
-async function _defaultRunDebate(storyId, stageConfig, prompt, config2, agentManager) {
-  const logger = getSafeLogger();
-  const debaters = stageConfig.debaters ?? [];
-  const manager = agentManager;
-  const resolved = [];
-  for (const debater of debaters) {
-    if (manager.getAgent(debater.agent)) {
-      resolved.push({ debater, agentName: debater.agent });
-    }
-  }
-  if (resolved.length === 0) {
-    return { output: null, totalCostUsd: 0 };
-  }
-  const timeoutMs = (config2.execution?.sessionTimeoutSeconds ?? 600) * 1000;
-  const defaultAgentName = resolveDefaultAgent(config2);
-  const resolvedDebaters = resolved.map(({ debater, agentName }) => {
-    let modelDef;
-    try {
-      modelDef = resolveConfiguredModel(config2.models, agentName, debater.model ?? "balanced", defaultAgentName).modelDef;
-    } catch {
-      modelDef = { provider: "unknown", model: debater.model ?? "default" };
-    }
-    return { debater, agentName, modelDef };
-  });
-  const startMs = Date.now();
-  const proposalSettled = await Promise.allSettled(resolvedDebaters.map(({ agentName, modelDef }) => manager.completeAs(agentName, prompt, {
-    modelDef,
-    workdir: "",
-    storyId,
-    sessionRole: "debate-proposal",
-    timeoutMs
-  }).then((out) => typeof out === "string" ? out : out.output)));
-  const durationMs = Date.now() - startMs;
-  const successful = proposalSettled.filter((r) => r.status === "fulfilled").map((r) => r.value);
-  if (successful.length === 0) {
-    return { output: null, totalCostUsd: 0 };
-  }
-  const successCount = successful.length;
-  const costPerDebater = estimateCostByDuration("balanced", durationMs / successCount);
-  const totalCostUsd = costPerDebater.cost * successCount;
-  logger?.debug("rectification", "debate diagnosis complete", { storyId, successCount, totalCostUsd });
-  const output = successful.join(`
-
-`);
-  return { output, totalCostUsd };
-}
-async function runRectificationLoop2(opts) {
-  const loopStartMs = Date.now();
-  const {
-    config: config2,
-    workdir,
-    story,
-    testCommand,
-    timeoutSeconds,
-    testOutput,
-    promptPrefix,
-    featureName,
-    projectDir,
-    testScopedTemplate,
-    sessionManager,
-    sessionId,
-    runtime
-  } = opts;
-  const logger = getSafeLogger();
-  const agentManager = opts.agentManager ?? _rectificationDeps.agentManager;
-  if (!agentManager) {
-    logger?.warn("rectification", "No agentManager threaded \u2014 skipping rectification loop", {
-      storyId: story.id
-    });
-    return { succeeded: false, cost: 0, durationMs: 0 };
-  }
-  const rectificationConfig = config2.execution.rectification;
-  const testSummary = parseTestOutput(testOutput);
-  const label = promptPrefix ? "regression rectification" : "rectification";
-  const rectificationSessionName = formatSessionName({
-    workdir,
-    featureName,
-    storyId: story.id,
-    role: "implementer"
-  });
-  let costAccum = 0;
-  let currentAttempt = 0;
-  let heldHandle;
-  const initialFailure = {
-    testOutput,
-    testSummary
-  };
-  const outcome = await runRetryLoop({
-    stage: "rectification",
-    storyId: story.id,
-    packageDir: workdir,
-    maxAttempts: rectificationConfig.maxRetries,
-    failure: initialFailure,
-    previousAttempts: [],
-    buildPrompt: (failure) => {
-      currentAttempt++;
-      const diagnosisPrefix = null;
-      const debateStageConfig = config2.debate?.stages?.rectification;
-      let debatePromise = Promise.resolve(null);
-      if (debateStageConfig?.enabled) {
-        const failureSummary = formatFailureSummary(failure.testSummary.failures);
-        const diagnosisPrompt = `Analyze the following test failures and identify the root cause:
-
-${failureSummary}`;
-        debatePromise = (async () => {
-          try {
-            const debateResult = await _rectificationDeps.runDebate(story.id, debateStageConfig, diagnosisPrompt, config2, agentManager);
-            if (debateResult.totalCostUsd > 0 && story.routing) {
-              story.routing.estimatedCostUsd = (story.routing.estimatedCostUsd ?? 0) + debateResult.totalCostUsd;
-            }
-            if (debateResult.output !== null) {
-              return `## Root Cause Analysis
-
-${debateResult.output}`;
-            }
-            logger?.info("rectification", "debate diagnosis fallback \u2014 all debaters failed", {
-              storyId: story.id,
-              event: "fallback"
-            });
-            return null;
-          } catch (_error) {
-            logger?.info("rectification", "debate diagnosis fallback \u2014 debate threw error", {
-              storyId: story.id,
-              event: "fallback"
-            });
-            return null;
-          }
-        })();
-      }
-      const failureRecords = buildFailureRecords(failure.testSummary, failure.testOutput);
-      const rectPrompt = RectifierPromptBuilder.regressionFailure({
-        story,
-        failures: failureRecords,
-        testCommand,
-        conventions: true
-      });
-      const rectPromise = Promise.resolve(rectPrompt);
-      return (async () => {
-        const [diagnosis, rectificationPrompt] = await Promise.all([debatePromise, rectPromise]);
-        let finalPrompt = rectificationPrompt;
-        if (diagnosis) {
-          finalPrompt = `${diagnosis}
-
-${finalPrompt}`;
-        }
-        if (promptPrefix) {
-          finalPrompt = `${promptPrefix}
-
-${finalPrompt}`;
-        }
-        return finalPrompt;
-      })();
-    },
-    execute: async (prompt) => {
-      const defaultAgent = agentManager.getDefault();
-      const complexity = story.routing?.complexity ?? "medium";
-      const modelTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
-      const modelDef = resolveModelForAgent(config2.models, story.routing?.agent ?? defaultAgent, modelTier, defaultAgent);
-      const isLastAttempt = currentAttempt >= rectificationConfig.maxRetries;
-      const runOptions = {
-        prompt,
-        workdir,
-        modelTier,
-        modelDef,
-        timeoutSeconds: config2.execution.sessionTimeoutSeconds,
-        pipelineStage: "rectification",
-        config: config2,
-        projectDir,
-        maxInteractionTurns: config2.agent?.maxInteractionTurns,
-        featureName,
-        storyId: story.id,
-        sessionRole: "implementer"
-      };
-      let agentResult;
-      if (runtime) {
-        let transportRetries = 0;
-        const maxTransportRetries = config2.execution?.sessionErrorRetryableMaxRetries ?? 3;
-        while (true) {
-          if (!heldHandle) {
-            heldHandle = await runtime.sessionManager.openSession(rectificationSessionName, {
-              agentName: defaultAgent,
-              role: "implementer",
-              workdir,
-              pipelineStage: "rectification",
-              modelDef,
-              timeoutSeconds: config2.execution.sessionTimeoutSeconds,
-              featureName,
-              storyId: story.id,
-              signal: runtime.signal
-            });
-          }
-          try {
-            const turn = await agentManager.runAsSession(defaultAgent, heldHandle, prompt, {
-              storyId: story.id,
-              featureName,
-              workdir,
-              projectDir,
-              pipelineStage: "rectification",
-              sessionRole: "implementer",
-              signal: runtime.signal,
-              maxTurns: config2.agent?.maxInteractionTurns
-            });
-            agentResult = {
-              success: true,
-              exitCode: 0,
-              output: turn.output,
-              rateLimited: false,
-              durationMs: 0,
-              estimatedCostUsd: turn.estimatedCostUsd,
-              ...turn.exactCostUsd !== undefined && { exactCostUsd: turn.exactCostUsd },
-              ...turn.tokenUsage && { tokenUsage: turn.tokenUsage },
-              ...heldHandle.protocolIds && { protocolIds: heldHandle.protocolIds }
-            };
-            break;
-          } catch (err) {
-            const stale = heldHandle;
-            heldHandle = undefined;
-            await runtime.sessionManager.closeSession(stale).catch(() => {});
-            if (err instanceof SessionTurnError && err.retryable && transportRetries < maxTransportRetries) {
-              transportRetries++;
-              getSafeLogger()?.warn("rectification", "fail-adapter-error: same-agent retry with fresh session", {
-                storyId: story.id,
-                attempt: transportRetries,
-                maxAttempts: maxTransportRetries,
-                retriable: true
-              });
-              continue;
-            }
-            throw err;
-          }
-        }
-      } else {
-        agentResult = await agentManager.run({
-          runOptions: { ...runOptions, keepOpen: !isLastAttempt }
-        });
-      }
-      costAccum += agentResult.estimatedCostUsd ?? 0;
-      if (sessionManager && sessionId && agentResult.protocolIds) {
-        try {
-          sessionManager.bindHandle(sessionId, rectificationSessionName, agentResult.protocolIds);
-        } catch {}
-      }
-      if (agentResult.success) {
-        logger?.info("rectification", `Agent ${label} session complete`, {
-          storyId: story.id,
-          cost: agentResult.estimatedCostUsd
-        });
-      } else {
-        logger?.warn("rectification", `Agent ${label} session failed`, {
-          storyId: story.id,
-          exitCode: agentResult.exitCode
-        });
-      }
-      return {
-        agentSuccess: agentResult.success,
-        cost: agentResult.estimatedCostUsd ?? 0,
-        protocolIds: agentResult.protocolIds
-      };
-    },
-    shouldAbort: (failure) => {
-      if (rectificationConfig.abortOnIncreasingFailures) {
-        return failure.testSummary.failed > initialFailure.testSummary.failed;
-      }
-      return false;
-    },
-    verify: async (result) => {
-      const retryVerification = await _rectificationDeps.runVerification({
-        workdir,
-        expectedFiles: getExpectedFiles(story),
-        command: testCommand,
-        timeoutSeconds,
-        forceExit: config2.quality.forceExit,
-        detectOpenHandles: config2.quality.detectOpenHandles,
-        detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
-        timeoutRetryCount: 0,
-        gracePeriodMs: config2.quality.gracePeriodMs,
-        drainTimeoutMs: config2.quality.drainTimeoutMs,
-        shell: config2.quality.shell,
-        stripEnvVars: config2.quality.stripEnvVars
-      });
-      if (retryVerification.success) {
-        logger?.info("rectification", `[OK] ${label} succeeded!`, {
-          storyId: story.id,
-          attempt: currentAttempt,
-          initialFailures: initialFailure.testSummary.failed
-        });
-        return { passed: true };
-      }
-      if (retryVerification.output) {
-        const newTestSummary = parseTestOutput(retryVerification.output);
-        if (newTestSummary.failed === 0 && retryVerification.status !== "ENVIRONMENTAL_FAILURE" && (retryVerification.status === "SUCCESS" || newTestSummary.passed > 0)) {
-          logger?.info("rectification", `[OK] ${label} succeeded after parsing retry output`, {
-            storyId: story.id,
-            attempt: currentAttempt,
-            initialFailures: initialFailure.testSummary.failed
-          });
-          return { passed: true };
-        }
-        const failingTests = newTestSummary.failures.slice(0, 10).map((failure) => failure.testName);
-        const logData = {
-          storyId: story.id,
-          attempt: currentAttempt,
-          remainingFailures: newTestSummary.failed,
-          failingTests
-        };
-        if (newTestSummary.failures.length > 10 || newTestSummary.failures.length === 0 && newTestSummary.failed > 0) {
-          logData.totalFailingTests = newTestSummary.failed;
-        }
-        logger?.warn("rectification", `${label} still failing after attempt`, logData);
-        return {
-          passed: false,
-          newFailure: {
-            testOutput: retryVerification.output,
-            testSummary: newTestSummary
-          }
-        };
-      }
-      return {
-        passed: false,
-        newFailure: {
-          testOutput: retryVerification.output ?? "",
-          testSummary: initialFailure.testSummary
-        }
-      };
-    }
-  }).finally(async () => {
-    if (heldHandle && runtime) {
-      const stale = heldHandle;
-      heldHandle = undefined;
-      await runtime.sessionManager.closeSession(stale).catch(() => {});
-    }
-  });
-  const succeeded = outcome.outcome === "fixed";
-  if (outcome.outcome === "exhausted") {
-    const finalFailure = outcome.finalFailure;
-    const shouldEscalate = rectificationConfig.escalateOnExhaustion !== false && config2.autoMode?.escalation?.enabled === true && finalFailure.testSummary.failed > 0;
-    if (shouldEscalate) {
-      const complexity = story.routing?.complexity ?? "medium";
-      const currentTier = config2.autoMode.complexityRouting?.[complexity] || config2.autoMode.escalation.tierOrder[0]?.tier || "balanced";
-      const tierOrder = config2.autoMode.escalation.tierOrder;
-      const escalationResult = _rectificationDeps.escalateTier(currentTier, tierOrder);
-      const escalatedTier = escalationResult?.tier ?? null;
-      const escalatedAgent = escalationResult?.agent;
-      if (escalatedTier !== null) {
-        const escalationManager = agentManager;
-        const agentName = escalatedAgent ?? story.routing?.agent ?? escalationManager.getDefault();
-        if (escalationManager.getAgent(agentName)) {
-          const escalatedModelDef = resolveModelForAgent(config2.models, agentName, escalatedTier, escalationManager.getDefault());
-          let escalationPrompt = RectifierPromptBuilder.escalated(finalFailure.testSummary.failures, story, outcome.attempts, currentTier, escalatedTier, rectificationConfig, testCommand, testScopedTemplate);
-          if (promptPrefix) {
-            escalationPrompt = `${promptPrefix}
-
-${escalationPrompt}`;
-          }
-          const escalationRunResult = await escalationManager.runAs(agentName, {
-            runOptions: {
-              prompt: escalationPrompt,
-              workdir,
-              modelTier: escalatedTier,
-              modelDef: escalatedModelDef,
-              timeoutSeconds: config2.execution.sessionTimeoutSeconds,
-              pipelineStage: "rectification",
-              config: config2,
-              projectDir,
-              maxInteractionTurns: config2.agent?.maxInteractionTurns,
-              featureName,
-              storyId: story.id,
-              sessionRole: "implementer"
-            }
-          });
-          costAccum += escalationRunResult.estimatedCostUsd ?? 0;
-          logger?.info("rectification", "escalated rectification attempt cost", {
-            storyId: story.id,
-            escalatedTier,
-            cost: escalationRunResult.estimatedCostUsd
-          });
-          const escalationVerification = await _rectificationDeps.runVerification({
-            workdir,
-            expectedFiles: getExpectedFiles(story),
-            command: testCommand,
-            timeoutSeconds,
-            forceExit: config2.quality.forceExit,
-            detectOpenHandles: config2.quality.detectOpenHandles,
-            detectOpenHandlesRetries: config2.quality.detectOpenHandlesRetries,
-            timeoutRetryCount: 0,
-            gracePeriodMs: config2.quality.gracePeriodMs,
-            drainTimeoutMs: config2.quality.drainTimeoutMs,
-            shell: config2.quality.shell,
-            stripEnvVars: config2.quality.stripEnvVars
-          });
-          if (escalationVerification.success) {
-            logger?.info("rectification", `${label} escalated from ${currentTier} to ${escalatedTier} and succeeded`, {
-              storyId: story.id,
-              currentTier,
-              escalatedTier
-            });
-            return { succeeded: true, cost: costAccum, durationMs: Date.now() - loopStartMs };
-          }
-          logger?.warn("rectification", "escalated rectification also failed", { storyId: story.id, escalatedTier });
-        }
-      }
-    }
-    logger?.warn("rectification", `${label} exhausted max retries`, {
-      storyId: story.id,
-      attempts: outcome.attempts,
-      remainingFailures: initialFailure.testSummary.failed
-    });
-  }
-  return { succeeded, cost: costAccum, durationMs: Date.now() - loopStartMs };
-}
-var _rectificationDeps;
-var init_rectification_loop = __esm(() => {
-  init_agents();
-  init_cost();
-  init_types3();
-  init_config();
-  init_logger2();
-  init_prd();
-  init_prompts();
-  init_naming();
-  init_parser2();
-  init_parser2();
-  init_runners();
-  _rectificationDeps = {
-    agentManager: undefined,
-    runVerification: fullSuite,
-    escalateTier,
-    runDebate: _defaultRunDebate
-  };
-});
-
 // src/pipeline/stages/rectify.ts
 var rectifyStage, _rectifyDeps;
 var init_rectify2 = __esm(() => {
@@ -55327,7 +55405,7 @@ var init_rectify2 = __esm(() => {
     }
   };
   _rectifyDeps = {
-    runRectificationLoop: (ctx, opts) => runRectificationLoop2({
+    runRectificationLoop: (ctx, opts) => runRectificationLoop({
       config: ctx.config,
       workdir: ctx.workdir,
       story: ctx.story,
@@ -55339,7 +55417,7 @@ var init_rectify2 = __esm(() => {
       agentManager: ctx.agentManager,
       projectDir: ctx.projectDir,
       testScopedTemplate: opts.testScopedTemplate,
-      sessionManager: ctx.sessionManager,
+      runtime: ctx.runtime,
       sessionId: ctx.sessionId
     }),
     resolveTestCommands: resolveQualityTestCommands,
@@ -56190,7 +56268,7 @@ async function promptsInitCommand(options) {
   mkdirSync4(templatesDir, { recursive: true });
   const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join50(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
-    console.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
+    _promptsInitDeps.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
     return [];
   }
@@ -56202,9 +56280,9 @@ async function promptsInitCommand(options) {
     await Bun.write(filePath, content);
     written.push(filePath);
   }
-  console.log(`[OK] Written ${written.length} template files to nax/templates/:`);
+  _promptsInitDeps.log(`[OK] Written ${written.length} template files to nax/templates/:`);
   for (const filePath of written) {
-    console.log(`  - ${filePath.replace(`${workdir}/`, "")}`);
+    _promptsInitDeps.log(`  - ${filePath.replace(`${workdir}/`, "")}`);
   }
   if (autoWireConfig) {
     await autoWirePromptsConfig(workdir);
@@ -56225,7 +56303,7 @@ async function autoWirePromptsConfig(workdir) {
         }
       }
     }, null, 2);
-    console.log(`
+    _promptsInitDeps.log(`
 No nax.config.json found. To activate overrides, create nax/config.json with:
 ${exampleConfig}`);
     return;
@@ -56234,7 +56312,7 @@ ${exampleConfig}`);
   const configContent = await configFile.text();
   const config2 = JSON.parse(configContent);
   if (config2.prompts?.overrides && Object.keys(config2.prompts.overrides).length > 0) {
-    console.log(`[INFO] prompts.overrides already configured in nax.config.json. Skipping auto-wiring.
+    _promptsInitDeps.log(`[INFO] prompts.overrides already configured in nax.config.json. Skipping auto-wiring.
 ` + "       To reset overrides, remove the prompts.overrides section and re-run this command.");
     return;
   }
@@ -56251,7 +56329,7 @@ ${exampleConfig}`);
   config2.prompts.overrides = overrides;
   const updatedConfig = formatConfigJson(config2);
   await Bun.write(configPath, updatedConfig);
-  console.log("[OK] Auto-wired prompts.overrides in nax.config.json");
+  _promptsInitDeps.log("[OK] Auto-wired prompts.overrides in nax.config.json");
 }
 function formatConfigJson(config2) {
   const lines = ["{"];
@@ -56276,7 +56354,7 @@ function formatConfigJson(config2) {
   return lines.join(`
 `);
 }
-var TEMPLATE_ROLES, TEMPLATE_HEADER = `<!--
+var _promptsInitDeps, TEMPLATE_ROLES, TEMPLATE_HEADER = `<!--
   This file controls the role-body section of the nax prompt for this role.
   Edit the content below to customize the task instructions given to the agent.
 
@@ -56292,6 +56370,10 @@ var TEMPLATE_ROLES, TEMPLATE_HEADER = `<!--
 `;
 var init_prompts_init = __esm(() => {
   init_role_task();
+  _promptsInitDeps = {
+    log: console.log.bind(console),
+    warn: console.warn.bind(console)
+  };
   TEMPLATE_ROLES = [
     { file: "test-writer.md", role: "test-writer" },
     { file: "implementer.md", role: "implementer", variant: "standard" },
@@ -56878,7 +56960,8 @@ __export(exports_init, {
   validateProjectName: () => validateProjectName,
   initProject: () => initProject,
   initCommand: () => initCommand,
-  checkInitCollision: () => checkInitCollision
+  checkInitCollision: () => checkInitCollision,
+  _initDeps: () => _initDeps
 });
 import { existsSync as existsSync24 } from "fs";
 import { mkdir as mkdir10 } from "fs/promises";
@@ -57105,20 +57188,20 @@ async function initProject(projectRoot, options) {
   }
   await updateGitignore(projectRoot);
   await promptsInitCommand({ workdir: projectRoot, force: false, autoWireConfig: false });
-  console.log(`
+  _initDeps.log(`
 [OK] nax init complete. Created files:`);
-  console.log("  - .nax/config.json");
-  console.log("  - .nax/context.md");
-  console.log("  - .nax/constitution.md");
-  console.log("  - .nax/hooks/");
-  console.log("  - .nax/templates/");
-  console.log(`
+  _initDeps.log("  - .nax/config.json");
+  _initDeps.log("  - .nax/context.md");
+  _initDeps.log("  - .nax/constitution.md");
+  _initDeps.log("  - .nax/hooks/");
+  _initDeps.log("  - .nax/templates/");
+  _initDeps.log(`
 Next steps:`);
-  console.log("  1. Review .nax/context.md and fill in TODOs");
-  console.log("  2. Review .nax/config.json and adjust quality commands");
-  console.log("  3. Run: nax generate");
-  console.log("  4. Run: nax plan");
-  console.log("  5. Run: nax run");
+  _initDeps.log("  1. Review .nax/context.md and fill in TODOs");
+  _initDeps.log("  2. Review .nax/config.json and adjust quality commands");
+  _initDeps.log("  3. Run: nax generate");
+  _initDeps.log("  4. Run: nax plan");
+  _initDeps.log("  5. Run: nax run");
   logger.info("init", "Project config initialized successfully", { path: projectDir });
 }
 async function initCommand(options = {}) {
@@ -57127,19 +57210,19 @@ async function initCommand(options = {}) {
   } else if (options.package) {
     const projectRoot = options.projectRoot ?? process.cwd();
     await initPackage(projectRoot, options.package);
-    console.log(`
+    _initDeps.log(`
 [OK] Package scaffold created.`);
-    console.log(`  Created: .nax/mono/${options.package}/context.md`);
-    console.log(`
+    _initDeps.log(`  Created: .nax/mono/${options.package}/context.md`);
+    _initDeps.log(`
 Next steps:`);
-    console.log(`  1. Review .nax/mono/${options.package}/context.md and fill in TODOs`);
-    console.log(`  2. Run: nax generate --package ${options.package}`);
+    _initDeps.log(`  1. Review .nax/mono/${options.package}/context.md and fill in TODOs`);
+    _initDeps.log(`  2. Run: nax generate --package ${options.package}`);
   } else {
     const projectRoot = options.projectRoot ?? process.cwd();
     await initProject(projectRoot, { name: options.name, force: options.force });
   }
 }
-var MINIMAL_GLOBAL_CONFIG;
+var _initDeps, MINIMAL_GLOBAL_CONFIG;
 var init_init2 = __esm(() => {
   init_paths();
   init_errors();
@@ -57149,6 +57232,9 @@ var init_init2 = __esm(() => {
   init_init_context();
   init_init_detect();
   init_prompts2();
+  _initDeps = {
+    log: console.log.bind(console)
+  };
   MINIMAL_GLOBAL_CONFIG = {
     version: 1
   };
@@ -58789,7 +58875,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.67.0-canary.3",
+    version: "0.67.0-canary.5",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -58799,7 +58885,7 @@ var init_package = __esm(() => {
       prepare: "git config core.hooksPath .githooks",
       dev: "bun run bin/nax.ts",
       build: 'bun build bin/nax.ts --outdir dist --target bun --define "GIT_COMMIT=\\"$(git rev-parse --short HEAD)\\""',
-      typecheck: "bun x tsc --noEmit",
+      typecheck: "bun x tsc --noEmit && bun x tsc --noEmit -p tsconfig.contracts.json",
       lint: "bun x biome check src/ bin/ && bun run check:no-real-global-nax && bun run check:alias-internals && bun run check:deep-relatives && bun run check:nax-error && bun run check:logger-storyid",
       "lint:json": "bun x biome check src/ bin/ --reporter json && bun run check:nax-error 1>&2 && bun run check:logger-storyid 1>&2",
       "lint:fix": "bun x biome check --write src/ bin/",
@@ -58812,8 +58898,10 @@ var init_package = __esm(() => {
       "check:logger-storyid": "bun run scripts/check-logger-storyid.ts",
       "check:logger-storyid:update": "bun run scripts/check-logger-storyid.ts --update-baseline",
       release: "bun scripts/release.ts",
-      test: "bun run scripts/run-tests.ts",
-      "test:bail": "bun run scripts/run-tests.ts --bail",
+      test: "AGENT=1 bun run scripts/run-tests.ts",
+      "test:verbose": "bun run scripts/run-tests.ts",
+      "test:bail": "AGENT=1 bun run scripts/run-tests.ts --bail",
+      "test:bail-verbose": "bun run scripts/run-tests.ts --bail",
       "test:no-wrap": "bun test test/unit/ --timeout=5000 && bun test test/integration/ --timeout=5000 && bun test test/ui/ --timeout=5000",
       "test:watch": "bun test --watch",
       "test:unit": "bun test ./test/unit/ --timeout=60000",
@@ -58882,8 +58970,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("1ca4b2e1"))
-        return "1ca4b2e1";
+      if (/^[0-9a-f]{6,10}$/.test("9cf63261"))
+        return "9cf63261";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -59607,7 +59695,7 @@ async function runAcceptanceFixCycle(ctx, prd, initialFailures, diagnosis, accep
         coRun: "co-run-sequential"
       }
     ],
-    validate: async (_ctx) => {
+    validate: async (_ctx, _opts) => {
       const result = await runAcceptanceTestsOnce(ctx, prd);
       if (result.passed)
         return [];
@@ -59825,7 +59913,7 @@ async function findResponsibleStory(testFile, workdir, passedStories) {
 }
 async function runDeferredRegression(options) {
   const logger = getSafeLogger();
-  const { config: config2, prd, workdir, agentManager } = options;
+  const { config: config2, prd, workdir, runtime } = options;
   const regressionMode = config2.execution.regressionGate?.mode ?? "deferred";
   if (regressionMode === "disabled") {
     logger?.info("regression", "Deferred regression gate disabled");
@@ -60015,8 +60103,9 @@ async function runDeferredRegression(options) {
         promptPrefix: `# DEFERRED REGRESSION: Full-Suite Failures
 
 Your story ${story.id} broke tests in the full suite. Fix these regressions.`,
-        agentManager,
-        featureName: prd.feature
+        agentManager: runtime.agentManager,
+        featureName: prd.feature,
+        runtime
       });
       storyCostAccum[story.id] = (storyCostAccum[story.id] ?? 0) + rectResult.cost;
       storyDurationAccum[story.id] = (storyDurationAccum[story.id] ?? 0) + rectResult.durationMs;
@@ -60095,7 +60184,7 @@ var init_run_regression = __esm(() => {
   init_runners();
   _regressionDeps = {
     runVerification: fullSuite,
-    runRectificationLoop: runRectificationLoop2,
+    runRectificationLoop,
     parseTestOutput
   };
 });
@@ -60149,7 +60238,7 @@ async function handleRunCompletion(options) {
         config: config2,
         prd,
         workdir,
-        agentManager: options.agentManager
+        runtime: options.runtime
       });
       const lastRunAt = new Date().toISOString();
       logger?.info("regression", "Deferred regression gate completed", {
@@ -98394,6 +98483,7 @@ async function extractRunSummary(filePath) {
 
 // src/commands/logs-formatter.ts
 var LOG_LEVEL_PRIORITY2 = {
+  silent: -1,
   debug: 0,
   info: 1,
   warn: 2,
@@ -99277,6 +99367,13 @@ init_helpers();
 init_crash_recovery();
 init_pid_registry();
 
+// src/execution/lifecycle/index.ts
+init_acceptance_loop();
+init_headless_formatter();
+init_run_completion();
+init_run_cleanup();
+init_run_setup();
+init_run_regression();
 // bin/nax.ts
 init_hooks();
 init_logger2();