@nathapp/nax 0.59.0 → 0.59.2

package/dist/nax.js

@@ -18269,7 +18269,16 @@ var init_schemas3 = __esm(() => {
     modelTier: ModelTierSchema.default("balanced"),
     rules: exports_external.array(exports_external.string()).default([]),
     timeoutMs: exports_external.number().int().positive().default(600000),
-    excludePatterns: exports_external.array(exports_external.string()).default([":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"])
+    excludePatterns: exports_external.array(exports_external.string()).default([
+      ":!test/",
+      ":!tests/",
+      ":!*_test.go",
+      ":!*.test.ts",
+      ":!*.spec.ts",
+      ":!**/__tests__/",
+      ":!.nax/",
+      ":!.nax-pids"
+    ])
   });
   ReviewDialogueConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
@@ -18614,7 +18623,16 @@ var init_schemas3 = __esm(() => {
         modelTier: "balanced",
         rules: [],
         timeoutMs: 600000,
-        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
+        excludePatterns: [
+          ":!test/",
+          ":!tests/",
+          ":!*_test.go",
+          ":!*.test.ts",
+          ":!*.spec.ts",
+          ":!**/__tests__/",
+          ":!.nax/",
+          ":!.nax-pids"
+        ]
       },
       dialogue: {
         enabled: false,
@@ -19242,11 +19260,15 @@ class AcpAgentAdapter {
       }
       runState.succeeded = !timedOut && lastResponse?.stopReason === "end_turn";
     } finally {
+      const isSessionBroken = !runState.succeeded && lastResponse?.stopReason === "error";
       if (runState.succeeded && !options.keepSessionOpen) {
         await closeAcpSession(session);
         if (options.featureName && options.storyId) {
           await clearAcpSession(options.workdir, options.featureName, options.storyId, options.sessionRole);
         }
+      } else if (isSessionBroken) {
+        getSafeLogger()?.debug("acp-adapter", "Closing broken session for retry", { sessionName });
+        await closeAcpSession(session);
       } else if (!runState.succeeded) {
         getSafeLogger()?.info("acp-adapter", "Keeping session open for retry", { sessionName });
       } else {
@@ -19495,7 +19517,7 @@ class AcpAgentAdapter {
       this.markUnavailable(this.name);
       throw new Error("[acp-adapter] plan() returned empty spec content");
     }
-    return { specContent };
+    return { specContent, costUsd: result.estimatedCost };
   }
   async decompose(options) {
     const model = options.modelDef?.model;
@@ -21453,7 +21475,10 @@ function majorityResolver(proposals, failOpen) {
   return passCount > failCount ? "passed" : "failed";
 }
 async function synthesisResolver(proposals, critiques, opts) {
-  const prompt = buildSynthesisPrompt(proposals, critiques);
+  const base = buildSynthesisPrompt(proposals, critiques);
+  const prompt = opts.promptSuffix ? `${base}
+
+${opts.promptSuffix}` : base;
   return opts.adapter.complete(prompt, opts.completeOptions);
 }
 async function judgeResolver(proposals, critiques, resolverConfig, opts) {
@@ -21521,25 +21546,89 @@ function pipelineStageForDebate(stage) {
   }
 }
 function resolveModelDefForDebater(debater, tier, config2) {
-  if (debater.model && !isTierLabel(debater.model)) {
-    return resolveModel(debater.model);
+  const modelOverride = debater.model;
+  let effectiveTier = tier;
+  if (modelOverride) {
+    const aliasedTier = MODEL_SHORTHAND_TIERS[modelOverride.toLowerCase()];
+    if (aliasedTier) {
+      effectiveTier = aliasedTier;
+    } else if (!isTierLabel(modelOverride)) {
+      return resolveModel(modelOverride);
+    }
   }
   const configModels = config2?.models ?? DEFAULT_CONFIG.models;
   const configDefaultAgent = config2?.autoMode?.defaultAgent ?? DEFAULT_CONFIG.autoMode.defaultAgent;
   try {
-    return resolveModelForAgent(configModels, debater.agent, tier, configDefaultAgent);
+    return resolveModelForAgent(configModels, debater.agent, effectiveTier, configDefaultAgent);
   } catch {}
   try {
-    return resolveModelForAgent(DEFAULT_CONFIG.models, DEFAULT_CONFIG.autoMode.defaultAgent, tier, DEFAULT_CONFIG.autoMode.defaultAgent);
+    return resolveModelForAgent(DEFAULT_CONFIG.models, DEFAULT_CONFIG.autoMode.defaultAgent, effectiveTier, DEFAULT_CONFIG.autoMode.defaultAgent);
   } catch {
     return resolveModelForAgent(configModels, debater.agent, "fast", configDefaultAgent);
   }
 }
-async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, config2, storyId, timeoutMs, workdir, featureName) {
+async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, config2, storyId, timeoutMs, workdir, featureName, reviewerSession, resolverContext, promptSuffix) {
   const resolverConfig = stageConfig.resolver;
   const logger = _debateSessionDeps.getSafeLogger();
+  if (reviewerSession && resolverContext) {
+    try {
+      const debateCtx = {
+        resolverType: resolverConfig.type
+      };
+      if (resolverConfig.type === "majority-fail-closed" || resolverConfig.type === "majority-fail-open") {
+        const failOpen = resolverConfig.type === "majority-fail-open";
+        const rawOutcome = majorityResolver(proposalOutputs, failOpen);
+        let passCount = 0;
+        let failCount = 0;
+        for (const proposal of proposalOutputs) {
+          try {
+            const stripped = proposal.trim().replace(/^```(?:json)?\s*\n?/, "").replace(/\n?```\s*$/, "");
+            const parsed = JSON.parse(stripped);
+            if (typeof parsed.passed === "boolean" && parsed.passed)
+              passCount++;
+            else if (failOpen)
+              passCount++;
+            else
+              failCount++;
+          } catch {
+            if (failOpen)
+              passCount++;
+            else
+              failCount++;
+          }
+        }
+        debateCtx.majorityVote = { passed: rawOutcome === "passed", passCount, failCount };
+      }
+      const story = {
+        id: resolverContext.story.id,
+        title: resolverContext.story.title,
+        description: "",
+        acceptanceCriteria: resolverContext.story.acceptanceCriteria
+      };
+      let dialogueResult;
+      if (resolverContext.isReReview) {
+        dialogueResult = await reviewerSession.reReviewDebate(resolverContext.labeledProposals, critiqueOutputs, resolverContext.diff, debateCtx);
+      } else {
+        dialogueResult = await reviewerSession.resolveDebate(resolverContext.labeledProposals, critiqueOutputs, resolverContext.diff, story, resolverContext.semanticConfig, debateCtx);
+      }
+      const outcome = dialogueResult.checkResult.success ? "passed" : "failed";
+      return {
+        outcome,
+        resolverCostUsd: dialogueResult.cost ?? 0,
+        dialogueResult
+      };
+    } catch (err) {
+      logger?.warn("debate", "ReviewerSession.resolveDebate() failed \u2014 falling back to stateless resolver", {
+        storyId,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (reviewerSession && !resolverContext) {
+    logger?.warn("debate", "ReviewerSession provided but resolverContext is undefined \u2014 falling back to stateless resolver", { storyId });
+  }
   if (resolverConfig.type === "majority-fail-closed" || resolverConfig.type === "majority-fail-open") {
-    if (workdir !== undefined) {
+    if (workdir !== undefined && !reviewerSession) {
       logger?.warn("debate", "majority resolver does not support implementer session resumption \u2014 switch to synthesis or custom resolver for context-aware semantic review");
     }
     return {
@@ -21547,31 +21636,36 @@ async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, con
       resolverCostUsd: 0
     };
   }
-  const implementerSessionName = workdir !== undefined ? buildSessionName(workdir, featureName, storyId, "implementer") : undefined;
   if (resolverConfig.type === "synthesis") {
     const agentName = resolverConfig.agent ?? RESOLVER_FALLBACK_AGENT;
     const adapter = _debateSessionDeps.getAgent(agentName, config2);
     if (adapter) {
+      const synthesisSessionName = workdir !== undefined ? buildSessionName(workdir, featureName, storyId, "synthesis") : undefined;
       const resolverResult = await synthesisResolver(proposalOutputs, critiqueOutputs, {
         adapter,
+        promptSuffix,
         completeOptions: {
           model: resolveDebaterModel({ agent: agentName }, config2),
           config: config2,
           storyId,
+          featureName,
+          workdir,
           sessionRole: "synthesis",
           timeoutMs,
-          ...implementerSessionName !== undefined && { sessionName: implementerSessionName }
+          ...synthesisSessionName !== undefined && { sessionName: synthesisSessionName }
         }
       });
       return {
         outcome: "passed",
-        resolverCostUsd: resolverResult.costUsd
+        resolverCostUsd: resolverResult.costUsd,
+        output: resolverResult.output
       };
     }
     return { outcome: "passed", resolverCostUsd: 0 };
   }
   if (resolverConfig.type === "custom") {
     const agentName = resolverConfig.agent ?? RESOLVER_FALLBACK_AGENT;
+    const judgeSessionName = workdir !== undefined ? buildSessionName(workdir, featureName, storyId, "judge") : undefined;
     const resolverResult = await judgeResolver(proposalOutputs, critiqueOutputs, resolverConfig, {
       getAgent: (name) => _debateSessionDeps.getAgent(name, config2),
       defaultAgentName: RESOLVER_FALLBACK_AGENT,
@@ -21579,19 +21673,22 @@ async function resolveOutcome(proposalOutputs, critiqueOutputs, stageConfig, con
         model: resolveDebaterModel({ agent: agentName }, config2),
         config: config2,
         storyId,
+        featureName,
+        workdir,
         sessionRole: "judge",
         timeoutMs,
-        ...implementerSessionName !== undefined && { sessionName: implementerSessionName }
+        ...judgeSessionName !== undefined && { sessionName: judgeSessionName }
       }
     });
     return {
       outcome: "passed",
-      resolverCostUsd: resolverResult.costUsd
+      resolverCostUsd: resolverResult.costUsd,
+      output: resolverResult.output
     };
   }
   return { outcome: "passed", resolverCostUsd: 0 };
 }
-var RESOLVER_FALLBACK_AGENT = "synthesis", _debateSessionDeps;
+var RESOLVER_FALLBACK_AGENT = "synthesis", _debateSessionDeps, MODEL_SHORTHAND_TIERS;
 var init_session_helpers = __esm(() => {
   init_adapter();
   init_registry();
@@ -21603,6 +21700,11 @@ var init_session_helpers = __esm(() => {
     getSafeLogger,
     readFile: (path) => Bun.file(path).text()
   };
+  MODEL_SHORTHAND_TIERS = {
+    haiku: "fast",
+    sonnet: "balanced",
+    opus: "powerful"
+  };
 });
 
 // src/debate/concurrency.ts
@@ -21788,7 +21890,11 @@ async function runStateful(ctx, prompt) {
     critiqueOutputs = critiqueSettled.filter((r) => r.status === "fulfilled").map((r) => r.value.output);
   }
   const proposalOutputs = successfulProposals.map((s) => s.output);
-  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000, ctx.workdir, ctx.featureName);
+  const fullResolverContext = ctx.resolverContextInput ? {
+    ...ctx.resolverContextInput,
+    labeledProposals: successfulProposals.map((s) => ({ debater: s.debater.agent, output: s.output }))
+  } : undefined;
+  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000, ctx.workdir, ctx.featureName, ctx.reviewerSession, fullResolverContext);
   totalCostUsd += outcome.resolverCostUsd;
   const proposals = successfulProposals.map((s) => ({
     debater: s.debater,
@@ -21815,6 +21921,50 @@ var init_session_stateful = __esm(() => {
 });
 
 // src/debate/session-hybrid.ts
+async function runRebuttalLoop(ctx, proposals, originalPrompt, sessionRolePrefix) {
+  const logger = _debateSessionDeps.getSafeLogger();
+  const config2 = ctx.stageConfig;
+  const rebuttals = [];
+  let costUsd = 0;
+  const proposalList = proposals.map((s) => ({ debater: s.debater, output: s.output }));
+  try {
+    for (let round = 1;round <= config2.rounds; round++) {
+      const priorRebuttals = rebuttals.filter((r) => r.round < round).map((r) => r.output);
+      for (let debaterIdx = 0;debaterIdx < proposals.length; debaterIdx++) {
+        const proposal = proposals[debaterIdx];
+        const sessionRole = `${sessionRolePrefix}-${debaterIdx}`;
+        logger?.info("debate:rebuttal-start", "debate:rebuttal-start", {
+          storyId: ctx.storyId,
+          round,
+          debaterIndex: debaterIdx
+        });
+        const rebuttalPrompt = buildRebuttalContext(originalPrompt, proposalList, priorRebuttals, debaterIdx);
+        try {
+          const turnResult = await runStatefulTurn(ctx, proposal.adapter, proposal.debater, rebuttalPrompt, sessionRole, true);
+          costUsd += turnResult.cost;
+          rebuttals.push({ debater: proposal.debater, round, output: turnResult.output });
+        } catch (err) {
+          logger?.warn("debate", "debate:rebuttal-failed", {
+            storyId: ctx.storyId,
+            round,
+            debaterIndex: debaterIdx,
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
+  } finally {
+    for (let debaterIdx = 0;debaterIdx < proposals.length; debaterIdx++) {
+      const proposal = proposals[debaterIdx];
+      const sessionRole = `${sessionRolePrefix}-${debaterIdx}`;
+      try {
+        const closeCost = await closeStatefulSession(ctx, proposal.adapter, proposal.debater, sessionRole);
+        costUsd += closeCost;
+      } catch {}
+    }
+  }
+  return { rebuttals, costUsd };
+}
 async function runHybrid(ctx, prompt) {
   const logger = _debateSessionDeps.getSafeLogger();
   const config2 = ctx.stageConfig;
@@ -21883,45 +22033,14 @@ async function runHybrid(ctx, prompt) {
   }
   const proposalOutputs = successfulProposals.map((s) => s.output);
   const proposalList = successfulProposals.map((s) => ({ debater: s.debater, output: s.output }));
-  const rebuttals = [];
-  try {
-    for (let round = 1;round <= config2.rounds; round++) {
-      const priorRebuttals = rebuttals.filter((r) => r.round < round).map((r) => r.output);
-      for (let debaterIdx = 0;debaterIdx < successfulProposals.length; debaterIdx++) {
-        const proposal = successfulProposals[debaterIdx];
-        const sessionRole = `debate-hybrid-${debaterIdx}`;
-        logger?.info("debate:rebuttal-start", "debate:rebuttal-start", {
-          storyId: ctx.storyId,
-          round,
-          debaterIndex: debaterIdx
-        });
-        const rebuttalPrompt = buildRebuttalContext(prompt, proposalList, priorRebuttals, debaterIdx);
-        try {
-          const turnResult = await runStatefulTurn(ctx, proposal.adapter, proposal.debater, rebuttalPrompt, sessionRole, true);
-          totalCostUsd += turnResult.cost;
-          rebuttals.push({ debater: proposal.debater, round, output: turnResult.output });
-        } catch (err) {
-          logger?.warn("debate", "debate:rebuttal-failed", {
-            storyId: ctx.storyId,
-            round,
-            debaterIndex: debaterIdx,
-            error: err instanceof Error ? err.message : String(err)
-          });
-        }
-      }
-    }
-  } finally {
-    for (let debaterIdx = 0;debaterIdx < successfulProposals.length; debaterIdx++) {
-      const proposal = successfulProposals[debaterIdx];
-      const sessionRole = `debate-hybrid-${debaterIdx}`;
-      try {
-        const closeCost = await closeStatefulSession(ctx, proposal.adapter, proposal.debater, sessionRole);
-        totalCostUsd += closeCost;
-      } catch {}
-    }
-  }
+  const { rebuttals, costUsd: rebuttalCost } = await runRebuttalLoop(ctx, successfulProposals, prompt, "debate-hybrid");
+  totalCostUsd += rebuttalCost;
   const critiqueOutputs = rebuttals.map((r) => r.output);
-  const resolveResult = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000);
+  const fullResolverContext = ctx.resolverContextInput ? {
+    ...ctx.resolverContextInput,
+    labeledProposals: successfulProposals.map((s) => ({ debater: s.debater.agent, output: s.output }))
+  } : undefined;
+  const resolveResult = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutSeconds * 1000, ctx.workdir, ctx.featureName, ctx.reviewerSession, fullResolverContext);
   totalCostUsd += resolveResult.resolverCostUsd;
   return {
     storyId: ctx.storyId,
@@ -22064,7 +22183,11 @@ async function runOneShot(ctx, prompt) {
     critiqueOutputs = critiqueSettled.filter((r) => r.status === "fulfilled").map((r) => r.value.output);
   }
   const proposalOutputs = successful.map((p) => p.output);
-  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutMs);
+  const fullResolverContext = ctx.resolverContextInput ? {
+    ...ctx.resolverContextInput,
+    labeledProposals: successful.map((p) => ({ debater: p.debater.agent, output: p.output }))
+  } : undefined;
+  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, ctx.timeoutMs, ctx.workdir, ctx.featureName, ctx.reviewerSession, fullResolverContext);
   totalCostUsd += outcome.resolverCostUsd;
   const proposals = successful.map((p) => ({
     debater: p.debater,
@@ -22096,7 +22219,7 @@ async function runPlan2(ctx, basePrompt, opts) {
   const logger = _debateSessionDeps.getSafeLogger();
   const config2 = ctx.stageConfig;
   const debaters = config2.debaters ?? [];
-  const totalCostUsd = 0;
+  let totalCostUsd = 0;
   const resolved = [];
   for (const debater of debaters) {
     const adapter = _debateSessionDeps.getAgent(debater.agent, ctx.config);
@@ -22119,13 +22242,16 @@ async function runPlan2(ctx, basePrompt, opts) {
 
 Write the PRD JSON directly to this file path: ${tempOutputPath}
 Do NOT output the JSON to the conversation. Write the file, then reply with a brief confirmation.`;
-    await adapter.plan({
+    const modelTier = modelTierFromDebater(debater);
+    const modelDef = resolveModelDefForDebater(debater, modelTier, ctx.config);
+    const planResult = await adapter.plan({
       prompt: debaterPrompt,
       workdir: opts.workdir,
       interactive: false,
       timeoutSeconds: opts.timeoutSeconds,
       config: ctx.config,
-      modelTier: debater.model ?? "balanced",
+      modelTier,
+      modelDef,
       dangerouslySkipPermissions: opts.dangerouslySkipPermissions,
       maxInteractionTurns: opts.maxInteractionTurns,
       featureName: opts.feature,
@@ -22133,13 +22259,14 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
       sessionRole: `plan-${i}`
     });
     const output = await _debateSessionDeps.readFile(tempOutputPath);
-    return { debater, adapter, output, cost: 0 };
+    return { debater, adapter, output, cost: planResult.costUsd ?? 0 };
   }), concurrencyLimit);
   const successful = [];
   for (let i = 0;i < settled.length; i++) {
     const res = settled[i];
     if (res.status === "fulfilled") {
       successful.push(res.value);
+      totalCostUsd += res.value.cost;
     } else {
       const { debater } = resolved[i];
       logger?.warn("debate", "debate:debater-failed", {
@@ -22191,9 +22318,31 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
     };
   }
   const proposalOutputs = successful.map((p) => p.output);
+  const mode = ctx.stageConfig.mode ?? "panel";
+  const sessionMode = ctx.stageConfig.sessionMode ?? "one-shot";
+  let critiqueOutputs = [];
+  let rebuttalList;
+  if (mode === "hybrid" && sessionMode === "stateful") {
+    const hybridCtx = {
+      storyId: ctx.storyId,
+      stage: ctx.stage,
+      stageConfig: ctx.stageConfig,
+      config: ctx.config,
+      workdir: opts.workdir,
+      featureName: opts.feature,
+      timeoutSeconds: opts.timeoutSeconds ?? 600
+    };
+    const { rebuttals, costUsd } = await runRebuttalLoop(hybridCtx, successful, basePrompt, "plan-hybrid");
+    critiqueOutputs = rebuttals.map((r) => r.output);
+    rebuttalList = rebuttals;
+    totalCostUsd += costUsd;
+  } else if (mode === "hybrid") {
+    logger?.warn("debate", "hybrid mode requires sessionMode: stateful for plan \u2014 running as panel");
+  }
   const resolverTimeoutMs = (ctx.stageConfig.timeoutSeconds ?? 600) * 1000;
-  const outcome = await resolveOutcome(proposalOutputs, [], ctx.stageConfig, ctx.config, ctx.storyId, resolverTimeoutMs);
-  const winningOutput = successful[0].output;
+  const planSynthesisSuffix = "IMPORTANT: Your response must be a single valid JSON object in PRD format (with project, feature, branchName, userStories array, etc.). Do NOT wrap it in markdown fences. Output raw JSON only.";
+  const outcome = await resolveOutcome(proposalOutputs, critiqueOutputs, ctx.stageConfig, ctx.config, ctx.storyId, resolverTimeoutMs, opts.workdir, opts.feature, undefined, undefined, planSynthesisSuffix);
+  const winningOutput = outcome.output ?? successful[0].output;
   const proposals = successful.map((p) => ({ debater: p.debater, output: p.output }));
   logger?.info("debate", "debate:result", {
     storyId: ctx.storyId,
@@ -22204,16 +22353,18 @@ Do NOT output the JSON to the conversation. Write the file, then reply with a br
     storyId: ctx.storyId,
     stage: ctx.stage,
     outcome: outcome.outcome,
-    rounds: 1,
+    rounds: rebuttalList ? config2.rounds : 1,
     debaters: successful.map((p) => p.debater.agent),
     resolverType: config2.resolver.type,
     proposals,
+    rebuttals: rebuttalList,
     output: winningOutput,
     totalCostUsd
   };
 }
 var init_session_plan = __esm(() => {
   init_session_helpers();
+  init_session_hybrid();
 });
 
 // src/debate/session.ts
@@ -22225,6 +22376,8 @@ class DebateSession {
   workdir;
   featureName;
   timeoutSeconds;
+  reviewerSession;
+  resolverContextInput;
   get timeoutMs() {
     return this.timeoutSeconds * 1000;
   }
@@ -22236,6 +22389,8 @@ class DebateSession {
     this.workdir = opts.workdir ?? process.cwd();
     this.featureName = opts.featureName ?? opts.stage;
     this.timeoutSeconds = opts.timeoutSeconds ?? opts.stageConfig.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
+    this.reviewerSession = opts.reviewerSession;
+    this.resolverContextInput = opts.resolverContextInput;
   }
   async run(prompt) {
     const sessionMode = this.stageConfig.sessionMode ?? "one-shot";
@@ -22249,7 +22404,9 @@ class DebateSession {
           config: this.config,
           workdir: this.workdir,
           featureName: this.featureName,
-          timeoutSeconds: this.timeoutSeconds
+          timeoutSeconds: this.timeoutSeconds,
+          reviewerSession: this.reviewerSession,
+          resolverContextInput: this.resolverContextInput
         }, prompt);
       }
       const logger = _debateSessionDeps.getSafeLogger();
@@ -22259,7 +22416,11 @@ class DebateSession {
         stage: this.stage,
         stageConfig: this.stageConfig,
         config: this.config,
-        timeoutMs: this.timeoutMs
+        timeoutMs: this.timeoutMs,
+        workdir: this.workdir,
+        featureName: this.featureName,
+        reviewerSession: this.reviewerSession,
+        resolverContextInput: this.resolverContextInput
       }, prompt);
     }
     if (sessionMode === "stateful") {
@@ -22270,7 +22431,9 @@ class DebateSession {
         config: this.config,
         workdir: this.workdir,
         featureName: this.featureName,
-        timeoutSeconds: this.timeoutSeconds
+        timeoutSeconds: this.timeoutSeconds,
+        reviewerSession: this.reviewerSession,
+        resolverContextInput: this.resolverContextInput
       }, prompt);
     }
     return runOneShot({
@@ -22278,7 +22441,11 @@ class DebateSession {
       stage: this.stage,
       stageConfig: this.stageConfig,
       config: this.config,
-      timeoutMs: this.timeoutMs
+      timeoutMs: this.timeoutMs,
+      workdir: this.workdir,
+      featureName: this.featureName,
+      reviewerSession: this.reviewerSession,
+      resolverContextInput: this.resolverContextInput
     }, prompt);
   }
   async runPlan(basePrompt, opts) {
@@ -22613,30 +22780,41 @@ class CLIInteractionPlugin {
   }
   async send(request) {
     this.pendingRequests.set(request.id, request);
-    console.log(`
-${"=".repeat(80)}`);
-    console.log(`[INTERACTION] ${request.stage.toUpperCase()} \u2014 ${request.type.toUpperCase()}`);
-    console.log("=".repeat(80));
-    console.log(`
+    process.stdout.write(`
+${"=".repeat(80)}
+`);
+    process.stdout.write(`[INTERACTION] ${request.stage.toUpperCase()} \u2014 ${request.type.toUpperCase()}
+`);
+    process.stdout.write(`${"=".repeat(80)}
+`);
+    process.stdout.write(`
 ${request.summary}
+
 `);
     if (request.detail) {
-      console.log(request.detail);
-      console.log("");
+      process.stdout.write(`${request.detail}
+`);
+      process.stdout.write(`
+`);
     }
     if (request.options && request.options.length > 0) {
-      console.log("Options:");
+      process.stdout.write(`Options:
+`);
       for (const opt of request.options) {
         const desc = opt.description ? ` \u2014 ${opt.description}` : "";
-        console.log(`  [${opt.key}] ${opt.label}${desc}`);
+        process.stdout.write(`  [${opt.key}] ${opt.label}${desc}
+`);
       }
-      console.log("");
+      process.stdout.write(`
+`);
     }
     if (request.timeout) {
       const timeoutSec = Math.floor(request.timeout / 1000);
-      console.log(`[Timeout: ${timeoutSec}s | Fallback: ${request.fallback}]`);
+      process.stdout.write(`[Timeout: ${timeoutSec}s | Fallback: ${request.fallback}]
+`);
     }
-    console.log(`${"=".repeat(80)}
+    process.stdout.write(`${"=".repeat(80)}
+
 `);
   }
   async receive(requestId, timeout = 60000) {
@@ -26414,59 +26592,6 @@ ${stderr}` };
   };
 });
 
-// src/agents/claude/index.ts
-var init_claude = __esm(() => {
-  init_adapter3();
-  init_execution();
-});
-
-// src/agents/shared/validation.ts
-function validateAgentForTier(agent, tier) {
-  return agent.capabilities.supportedTiers.includes(tier);
-}
-function validateAgentFeature(agent, feature) {
-  return agent.capabilities.features.has(feature);
-}
-function describeAgentCapabilities(agent) {
-  const tiers = agent.capabilities.supportedTiers.join(",");
-  const features = Array.from(agent.capabilities.features).join(",");
-  const maxTokens = agent.capabilities.maxContextTokens;
-  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
-}
-
-// src/agents/index.ts
-var exports_agents = {};
-__export(exports_agents, {
-  validateAgentForTier: () => validateAgentForTier,
-  validateAgentFeature: () => validateAgentFeature,
-  parseTokenUsage: () => parseTokenUsage,
-  getInstalledAgents: () => getInstalledAgents,
-  getAllAgentNames: () => getAllAgentNames,
-  getAgentVersions: () => getAgentVersions,
-  getAgentVersion: () => getAgentVersion,
-  getAgent: () => getAgent,
-  formatCostWithConfidence: () => formatCostWithConfidence,
-  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
-  estimateCostFromOutput: () => estimateCostFromOutput,
-  estimateCostByDuration: () => estimateCostByDuration,
-  estimateCost: () => estimateCost,
-  describeAgentCapabilities: () => describeAgentCapabilities,
-  checkAgentHealth: () => checkAgentHealth,
-  MODEL_PRICING: () => MODEL_PRICING,
-  CompleteError: () => CompleteError,
-  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
-  COST_RATES: () => COST_RATES,
-  AllAgentsUnavailableError: () => AllAgentsUnavailableError
-});
-var init_agents = __esm(() => {
-  init_types2();
-  init_claude();
-  init_registry();
-  init_cost();
-  init_version_detection();
-  init_errors();
-});
-
 // src/quality/runner.ts
 var {spawn: spawn2 } = globalThis.Bun;
 async function runQualityCommand(opts) {
@@ -26769,7 +26894,60 @@ Do NOT add new features \u2014 only fix the identified issues.
 Commit your fixes when done.${scopeConstraint}`;
 }
 
-// src/review/dialogue.ts
+// src/agents/claude/index.ts
+var init_claude = __esm(() => {
+  init_adapter3();
+  init_execution();
+});
+
+// src/agents/shared/validation.ts
+function validateAgentForTier(agent, tier) {
+  return agent.capabilities.supportedTiers.includes(tier);
+}
+function validateAgentFeature(agent, feature) {
+  return agent.capabilities.features.has(feature);
+}
+function describeAgentCapabilities(agent) {
+  const tiers = agent.capabilities.supportedTiers.join(",");
+  const features = Array.from(agent.capabilities.features).join(",");
+  const maxTokens = agent.capabilities.maxContextTokens;
+  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
+}
+
+// src/agents/index.ts
+var exports_agents = {};
+__export(exports_agents, {
+  validateAgentForTier: () => validateAgentForTier,
+  validateAgentFeature: () => validateAgentFeature,
+  parseTokenUsage: () => parseTokenUsage,
+  getInstalledAgents: () => getInstalledAgents,
+  getAllAgentNames: () => getAllAgentNames,
+  getAgentVersions: () => getAgentVersions,
+  getAgentVersion: () => getAgentVersion,
+  getAgent: () => getAgent,
+  formatCostWithConfidence: () => formatCostWithConfidence,
+  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
+  estimateCostFromOutput: () => estimateCostFromOutput,
+  estimateCostByDuration: () => estimateCostByDuration,
+  estimateCost: () => estimateCost,
+  describeAgentCapabilities: () => describeAgentCapabilities,
+  checkAgentHealth: () => checkAgentHealth,
+  MODEL_PRICING: () => MODEL_PRICING,
+  CompleteError: () => CompleteError,
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  COST_RATES: () => COST_RATES,
+  AllAgentsUnavailableError: () => AllAgentsUnavailableError
+});
+var init_agents = __esm(() => {
+  init_types2();
+  init_claude();
+  init_registry();
+  init_cost();
+  init_version_detection();
+  init_errors();
+});
+
+// src/review/dialogue-prompts.ts
 function buildReviewPrompt(diff, story, _semanticConfig) {
   const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
 `);
@@ -26803,6 +26981,98 @@ function buildReReviewPrompt(updatedDiff, previousFindings) {
   ].join(`
 `);
 }
+function buildProposalsSection(proposals) {
+  return proposals.map((p) => `### ${p.debater}
+${p.output}`).join(`
+
+`);
+}
+function buildCritiquesSection(critiques) {
+  if (critiques.length === 0)
+    return "";
+  return `
+
+## Critiques
+${critiques.map((c, i) => `### Critique ${i + 1}
+${c}`).join(`
+
+`)}`;
+}
+function buildVoteTallyLine(ctx) {
+  if (!ctx.majorityVote)
+    return "";
+  const { passCount, failCount } = ctx.majorityVote;
+  const failOpenNote = ctx.resolverType === "majority-fail-open" ? " (unparseable proposals count as pass)" : " (unparseable proposals count as fail)";
+  return `
+
+The preliminary majority vote is: **${passCount} passed, ${failCount} failed**${failOpenNote}. Verify the failing findings with tools before giving your authoritative verdict.`;
+}
+function buildResolverFraming(ctx) {
+  switch (ctx.resolverType) {
+    case "majority-fail-closed":
+    case "majority-fail-open":
+      return "You are the authoritative reviewer resolving a debate. A preliminary vote was taken \u2014 see tally below. Verify disputed findings using tools (READ files, GREP for usage) and give your final verdict.";
+    case "synthesis":
+      return "You are a synthesis reviewer. Synthesize the debater proposals into a single, coherent, tool-verified verdict. Use READ and GREP to verify claims before ruling.";
+    case "custom":
+      return "You are the judge. Evaluate the debater proposals independently. Verify claims with tools (READ, GREP) and give your final authoritative verdict.";
+    default:
+      return "You are the reviewer. Evaluate the debater proposals and give your final authoritative verdict.";
+  }
+}
+function buildDebateResolverPrompt(proposals, critiques, diff, story, _semanticConfig, resolverContext) {
+  const criteria = story.acceptanceCriteria.map((c) => `- ${c}`).join(`
+`);
+  const framing = buildResolverFraming(resolverContext);
+  const voteTally = buildVoteTallyLine(resolverContext);
+  const proposalsSection = buildProposalsSection(proposals);
+  const critiquesSection = buildCritiquesSection(critiques);
+  return [
+    framing,
+    "",
+    `## Story ${story.id}: ${story.title}`,
+    "",
+    "## Acceptance Criteria",
+    criteria,
+    "",
+    "## Debater Proposals",
+    proposalsSection,
+    critiquesSection,
+    "",
+    "## Diff",
+    diff,
+    voteTally,
+    "",
+    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string } }"
+  ].filter((line) => line !== undefined).join(`
+`);
+}
+function buildDebateReReviewPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext) {
+  const framing = buildResolverFraming(resolverContext);
+  const findingsList = previousFindings.length > 0 ? previousFindings.map((f) => `- ${f.ruleId}: ${f.message}`).join(`
+`) : "(none)";
+  const proposalsSection = buildProposalsSection(proposals);
+  const critiquesSection = buildCritiquesSection(critiques);
+  return [
+    `${framing} This is a re-review after implementer changes.`,
+    "",
+    "## Previous Findings",
+    findingsList,
+    "",
+    "## Updated Debater Proposals",
+    proposalsSection,
+    critiquesSection,
+    "",
+    "## Updated Diff",
+    updatedDiff,
+    "",
+    "Respond with JSON: { passed: boolean, findings: [...], findingReasoning: { [id]: string }, deltaSummary: string }",
+    "deltaSummary should describe which previous findings are resolved vs still present."
+  ].filter((line) => line !== undefined).join(`
+`);
+}
+
+// src/review/dialogue.ts
 function extractDeltaSummary(rawOutput, previousFindings, newFindings) {
   try {
     const parsed = JSON.parse(rawOutput);
@@ -26874,6 +27144,7 @@ function createReviewerSession(agent, storyId, workdir, featureName, _config) {
   let lastCheckResult = null;
   let lastStory = null;
   let lastSemanticConfig = null;
+  let lastWasDebateResolve = false;
   const sessionState = {
     generation: 1,
     pendingCompactionContext: null
@@ -26936,6 +27207,7 @@ ${prompt}`,
       lastCheckResult = reviewResult;
       lastStory = story;
       lastSemanticConfig = semanticConfig;
+      lastWasDebateResolve = false;
       return reviewResult;
     },
     async reReview(updatedDiff) {
@@ -27005,6 +27277,76 @@ ${prompt}`,
       history.push({ role: "reviewer", content: result.output });
       return result.output;
     },
+    async resolveDebate(proposals, critiques, diff, story, semanticConfig, resolverContext) {
+      if (!active) {
+        throw new NaxError(`[dialogue] ReviewerSession for story ${storyId} has been destroyed`, "REVIEWER_SESSION_DESTROYED", { stage: "review", storyId, featureName });
+      }
+      const prompt = buildDebateResolverPrompt(proposals, critiques, diff, story, semanticConfig, resolverContext);
+      const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(semanticConfig);
+      const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
+      const result = await agent.run({
+        prompt: effectivePrompt,
+        workdir,
+        modelTier,
+        modelDef,
+        timeoutSeconds,
+        sessionRole: "reviewer",
+        keepSessionOpen: true,
+        pipelineStage: "review",
+        config: _config,
+        storyId,
+        featureName,
+        acpSessionName
+      });
+      history.push({ role: "implementer", content: prompt });
+      history.push({ role: "reviewer", content: result.output });
+      const parsed = parseReviewResponse(result.output);
+      const reviewResult = { ...parsed, cost: result.estimatedCost ?? 0 };
+      lastCheckResult = reviewResult;
+      lastStory = story;
+      lastSemanticConfig = semanticConfig;
+      lastWasDebateResolve = true;
+      return reviewResult;
+    },
+    async reReviewDebate(proposals, critiques, updatedDiff, resolverContext) {
+      if (!active) {
+        throw new NaxError(`[dialogue] ReviewerSession for story ${storyId} has been destroyed`, "REVIEWER_SESSION_DESTROYED", { stage: "review", storyId, featureName });
+      }
+      if (!lastCheckResult || !lastSemanticConfig || !lastWasDebateResolve) {
+        throw new NaxError(`[dialogue] reReviewDebate() called before any resolveDebate() on story ${storyId}`, "NO_REVIEW_RESULT", { stage: "review", storyId });
+      }
+      const previousFindings = lastCheckResult.checkResult.findings;
+      const prompt = buildDebateReReviewPrompt(proposals, critiques, updatedDiff, previousFindings, resolverContext);
+      const { modelTier, modelDef, timeoutSeconds } = resolveRunParams(lastSemanticConfig);
+      const { effectivePrompt, acpSessionName } = buildEffectiveRunArgs(prompt);
+      const result = await agent.run({
+        prompt: effectivePrompt,
+        workdir,
+        modelTier,
+        modelDef,
+        timeoutSeconds,
+        sessionRole: "reviewer",
+        keepSessionOpen: true,
+        pipelineStage: "review",
+        config: _config,
+        storyId,
+        featureName,
+        acpSessionName
+      });
+      history.push({ role: "implementer", content: prompt });
+      history.push({ role: "reviewer", content: result.output });
+      const parsed = parseReviewResponse(result.output);
+      const deltaSummary = extractDeltaSummary(result.output, previousFindings, parsed.checkResult.findings);
+      const dialogueResult = { ...parsed, deltaSummary, cost: result.estimatedCost ?? 0 };
+      lastCheckResult = dialogueResult;
+      const maxMessages = _config.review?.dialogue?.maxDialogueMessages ?? 20;
+      if (history.length > maxMessages) {
+        const compactedSummary = compactHistory(history);
+        sessionState.generation++;
+        sessionState.pendingCompactionContext = compactedSummary;
+      }
+      return dialogueResult;
+    },
     getVerdict() {
       if (!lastCheckResult || !lastStory) {
         throw new NaxError(`[dialogue] getVerdict() called before any review() on story ${storyId}`, "NO_REVIEW_RESULT", { stage: "review", storyId });
@@ -27240,10 +27582,8 @@ var init_language_commands = __esm(() => {
 // src/review/semantic.ts
 var {spawn: spawn3 } = globalThis.Bun;
 async function collectDiff(workdir, storyGitRef, excludePatterns) {
-  const cmd = ["git", "diff", "--unified=3", `${storyGitRef}..HEAD`];
-  if (excludePatterns.length > 0) {
-    cmd.push("--", ".", ...excludePatterns);
-  }
+  const merged = [...new Set([...excludePatterns, ...ALWAYS_EXCLUDED])];
+  const cmd = ["git", "diff", "--unified=3", `${storyGitRef}..HEAD`, "--", ".", ...merged];
   const proc = _semanticDeps.spawn({
     cmd,
     cwd: workdir,
@@ -27403,7 +27743,7 @@ function toReviewFindings(findings) {
     source: "semantic-review"
   }));
 }
-async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, modelResolver, naxConfig, featureName) {
+async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, modelResolver, naxConfig, featureName, resolverSession) {
   const startTime = Date.now();
   const logger = getSafeLogger();
   if (featureName === undefined) {
@@ -27473,6 +27813,7 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
   const reviewDebateEnabled = naxConfig?.debate?.enabled && naxConfig?.debate?.stages?.review?.enabled;
   if (reviewDebateEnabled) {
     const reviewStageConfig = naxConfig?.debate?.stages.review;
+    const isReReview = resolverSession !== undefined && resolverSession.history.length > 0;
     const debateSession = _semanticDeps.createDebateSession({
       storyId: story.id,
       stage: "review",
@@ -27480,26 +27821,69 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
       config: naxConfig ?? DEFAULT_CONFIG,
       workdir,
       featureName,
-      timeoutSeconds: naxConfig?.execution?.sessionTimeoutSeconds
+      timeoutSeconds: naxConfig?.execution?.sessionTimeoutSeconds,
+      reviewerSession: resolverSession,
+      resolverContextInput: resolverSession ? {
+        diff,
+        story: { id: story.id, title: story.title, acceptanceCriteria: story.acceptanceCriteria },
+        semanticConfig,
+        resolverType: reviewStageConfig.resolver.type,
+        isReReview
+      } : undefined
     });
+    const historyLenBefore = resolverSession?.history.length ?? 0;
     const debateResult = await debateSession.run(prompt);
     const debateCost = debateResult.totalCostUsd ?? 0;
-    let passCount = 0;
-    let failCount = 0;
+    const sessionUsed = resolverSession && resolverSession.history.length > historyLenBefore;
+    if (sessionUsed) {
+      const durationMs3 = Date.now() - startTime;
+      try {
+        const verdict = resolverSession.getVerdict();
+        const findings = verdict.findings ?? [];
+        if (!verdict.passed && findings.length > 0) {
+          logger?.warn("review", `Semantic review failed (debate+dialogue): ${findings.length} findings`, {
+            storyId: story.id,
+            durationMs: durationMs3
+          });
+          return {
+            check: "semantic",
+            success: false,
+            command: "",
+            exitCode: 1,
+            output: `Semantic review failed:
+
+${findings.map((f) => `${f.ruleId}: ${f.message}`).join(`
+`)}`,
+            durationMs: durationMs3,
+            findings,
+            cost: debateCost
+          };
+        }
+        const label = verdict.passed ? "Semantic review passed (debate+dialogue)" : "Semantic review passed (debate+dialogue, all findings non-blocking)";
+        logger?.info("review", label, { storyId: story.id, durationMs: durationMs3 });
+        return {
+          check: "semantic",
+          success: true,
+          command: "",
+          exitCode: 0,
+          output: label,
+          durationMs: durationMs3,
+          cost: debateCost
+        };
+      } catch {
+        logger?.warn("review", "getVerdict() failed after debate+dialogue \u2014 falling back to stateless verdict", {
+          storyId: story.id
+        });
+      }
+    }
+    const resolverPassed = debateResult.outcome === "passed";
     const allFindings = [];
     for (const p of debateResult.proposals) {
       const parsed2 = parseLLMResponse(p.output);
       if (parsed2) {
-        if (parsed2.passed)
-          passCount++;
-        else
-          failCount++;
         allFindings.push(...parsed2.findings);
-      } else {
-        failCount++;
       }
     }
-    const majorityPassed = passCount > failCount;
     const seen = new Set;
     const deduped = [];
     for (const f of allFindings) {
@@ -27511,7 +27895,7 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
     }
     const debateBlocking = deduped.filter((f) => isBlockingSeverity(f.severity));
     const durationMs2 = Date.now() - startTime;
-    if (!majorityPassed) {
+    if (!resolverPassed) {
       if (debateBlocking.length > 0) {
         logger?.warn("review", `Semantic review failed (debate): ${debateBlocking.length} findings`, {
           storyId: story.id,
@@ -27710,7 +28094,7 @@ ${formatFindings(blockingFindings)}`;
     cost: llmCost
   };
 }
-var _semanticDeps, DIFF_CAP_BYTES = 51200;
+var _semanticDeps, DIFF_CAP_BYTES = 51200, ALWAYS_EXCLUDED;
 var init_semantic = __esm(() => {
   init_adapter();
   init_config();
@@ -27724,6 +28108,7 @@ var init_semantic = __esm(() => {
     createDebateSession: (opts) => new DebateSession(opts),
     readAcpSession
   };
+  ALWAYS_EXCLUDED = [":!.nax/", ":!.nax-pids"];
 });
 
 // src/review/runner.ts
@@ -27808,7 +28193,7 @@ async function getUncommittedFilesImpl(workdir) {
     return [];
   }
 }
-async function runReview(config2, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName) {
+async function runReview(config2, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName, resolverSession) {
   const startTime = Date.now();
   const logger = getSafeLogger();
   const checks3 = [];
@@ -27865,10 +28250,19 @@ Stage and commit these files before running review.`
         modelTier: "balanced",
         rules: [],
         timeoutMs: 600000,
-        excludePatterns: [":!test/", ":!tests/", ":!*_test.go", ":!*.test.ts", ":!*.spec.ts", ":!**/__tests__/"]
+        excludePatterns: [
+          ":!test/",
+          ":!tests/",
+          ":!*_test.go",
+          ":!*.test.ts",
+          ":!*.spec.ts",
+          ":!**/__tests__/",
+          ":!.nax/",
+          ":!.nax-pids"
+        ]
       };
       const runSemantic = _reviewSemanticDeps.runSemanticReview;
-      const result2 = featureName !== undefined ? await runSemantic(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null), naxConfig, featureName) : await runSemantic(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null), naxConfig);
+      const result2 = await runSemantic(workdir, storyGitRef, semanticStory, semanticCfg, modelResolver ?? (() => null), naxConfig, featureName, resolverSession);
       checks3.push(result2);
       if (!result2.success && !firstFailure) {
         firstFailure = `${checkName} failed`;
@@ -27950,9 +28344,9 @@ async function getChangedFiles(workdir, baseRef) {
 }
 
 class ReviewOrchestrator {
-  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix, qualityCommands, storyId, story, modelResolver, naxConfig, retrySkipChecks, featureName) {
+  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix, qualityCommands, storyId, story, modelResolver, naxConfig, retrySkipChecks, featureName, resolverSession) {
     const logger = getSafeLogger();
-    const builtIn = await runReview(reviewConfig, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName);
+    const builtIn = await runReview(reviewConfig, workdir, executionConfig, qualityCommands, storyId, storyGitRef, story, modelResolver, naxConfig, retrySkipChecks, featureName, resolverSession);
     if (!builtIn.success) {
       return { builtIn, success: false, failureReason: builtIn.failureReason, pluginFailed: false };
     }
@@ -28019,12 +28413,14 @@ class ReviewOrchestrator {
     const agentResolver = ctx.agentGetFn ?? undefined;
     const agentName = ctx.rootConfig.autoMode?.defaultAgent;
     const modelResolver = agentName ? (_tier) => agentResolver ? agentResolver(agentName) ?? null : null : undefined;
+    const reviewDebateEnabled = ctx.rootConfig?.debate?.enabled && ctx.rootConfig?.debate?.stages?.review?.enabled;
+    const resolverSession = reviewDebateEnabled ? ctx.reviewerSession : undefined;
     return this.review(ctx.config.review, ctx.workdir, ctx.config.execution, ctx.plugins, ctx.storyGitRef, ctx.story.workdir, ctx.config.quality?.commands, ctx.story.id, {
       id: ctx.story.id,
       title: ctx.story.title,
       description: ctx.story.description,
       acceptanceCriteria: ctx.story.acceptanceCriteria
-    }, modelResolver, ctx.config, retrySkipChecks, ctx.prd.feature);
+    }, modelResolver, ctx.config, retrySkipChecks, ctx.prd.feature, resolverSession);
   }
 }
 var _orchestratorDeps, reviewOrchestrator;
@@ -28053,11 +28449,12 @@ var init_review = __esm(() => {
     enabled: (ctx) => ctx.config.review.enabled,
     async execute(ctx) {
       const logger = getLogger();
+      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 });
       const agentResolver = ctx.agentGetFn ?? getAgent;
       const agentName = ctx.rootConfig.autoMode?.defaultAgent;
-      if (dialogueEnabled && ctx.reviewerSession) {
+      if (dialogueEnabled && !reviewDebateEnabled && ctx.reviewerSession) {
         try {
           const diff = ctx.storyGitRef ?? "";
           const reReviewResult = await ctx.reviewerSession.reReview(diff);
@@ -28095,47 +28492,49 @@ var init_review = __esm(() => {
       if (dialogueEnabled && !ctx.reviewerSession) {
         const agent = agentName ? agentResolver(agentName) ?? null : null;
         ctx.reviewerSession = _reviewDeps.createReviewerSession(agent ?? null, ctx.story.id, ctx.workdir, ctx.prd.feature ?? "", ctx.config);
-        const semanticConfig = ctx.config.review?.semantic;
-        if (semanticConfig && agent) {
-          try {
-            const diff = ctx.storyGitRef ?? "";
-            const story = {
-              id: ctx.story.id,
-              title: ctx.story.title,
-              description: ctx.story.description,
-              acceptanceCriteria: ctx.story.acceptanceCriteria
-            };
-            const sessionResult = await ctx.reviewerSession.review(diff, story, semanticConfig);
-            const passed = sessionResult.checkResult.success;
-            ctx.reviewResult = {
-              success: passed,
-              checks: passed ? [] : [
-                {
-                  check: "semantic",
-                  success: false,
-                  command: "reviewer-session-review",
-                  exitCode: 1,
-                  output: sessionResult.checkResult.findings.map((f) => f.message).join(`
+        if (!reviewDebateEnabled) {
+          const semanticConfig = ctx.config.review?.semantic;
+          if (semanticConfig && agent) {
+            try {
+              const diff = ctx.storyGitRef ?? "";
+              const story = {
+                id: ctx.story.id,
+                title: ctx.story.title,
+                description: ctx.story.description,
+                acceptanceCriteria: ctx.story.acceptanceCriteria
+              };
+              const sessionResult = await ctx.reviewerSession.review(diff, story, semanticConfig);
+              const passed = sessionResult.checkResult.success;
+              ctx.reviewResult = {
+                success: passed,
+                checks: passed ? [] : [
+                  {
+                    check: "semantic",
+                    success: false,
+                    command: "reviewer-session-review",
+                    exitCode: 1,
+                    output: sessionResult.checkResult.findings.map((f) => f.message).join(`
 `),
-                  durationMs: 0,
-                  findings: sessionResult.checkResult.findings
-                }
-              ],
-              totalDurationMs: 0
-            };
-            const dialogueCost = sessionResult.cost ?? 0;
-            if (passed) {
-              logger.info("review", "Review passed (dialogue session)", { storyId: ctx.story.id });
-            } else {
-              logger.warn("review", "Review failed (dialogue session) \u2014 handing off to autofix", {
+                    durationMs: 0,
+                    findings: sessionResult.checkResult.findings
+                  }
+                ],
+                totalDurationMs: 0
+              };
+              const dialogueCost = sessionResult.cost ?? 0;
+              if (passed) {
+                logger.info("review", "Review passed (dialogue session)", { storyId: ctx.story.id });
+              } else {
+                logger.warn("review", "Review failed (dialogue session) \u2014 handing off to autofix", {
+                  storyId: ctx.story.id
+                });
+              }
+              return { action: "continue", cost: dialogueCost || undefined };
+            } catch (err) {
+              logger.warn("review", "ReviewerSession.review() failed \u2014 falling back to one-shot review", {
                 storyId: ctx.story.id
               });
             }
-            return { action: "continue", cost: dialogueCost || undefined };
-          } catch (err) {
-            logger.warn("review", "ReviewerSession.review() failed \u2014 falling back to one-shot review", {
-              storyId: ctx.story.id
-            });
           }
         }
       }
@@ -28239,7 +28638,7 @@ async function runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWor
   }
   const remainingBudget = maxTotal - consumed;
   const maxAttempts = Math.min(maxPerCycle, remainingBudget);
-  const agentGetFn = ctx.agentGetFn ?? _autofixDeps.getAgent;
+  const agentGetFn = ctx.agentGetFn ?? ((name) => _autofixDeps.getAgent(name, ctx.rootConfig));
   const loopState = {
     attempt: 0,
     failedChecks
@@ -28382,7 +28781,7 @@ async function runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWor
 }
 var CLARIFY_REGEX, autofixStage, _autofixDeps;
 var init_autofix = __esm(() => {
-  init_agents();
+  init_registry();
   init_config();
   init_loader();
   init_logger2();
@@ -28458,6 +28857,14 @@ var init_autofix = __esm(() => {
         const recheckPassed = await _autofixDeps.recheckReview(ctx);
         pipelineEventBus.emit({ type: "autofix:completed", storyId: ctx.story.id, fixed: recheckPassed });
         if (recheckPassed) {
+          const passedChecks = (ctx.reviewResult?.checks ?? []).filter((c) => c.success).map((c) => c.check);
+          if (passedChecks.length > 0) {
+            ctx.retrySkipChecks = new Set(passedChecks);
+            logger.debug("autofix", "Skipping already-passed checks on retry", {
+              storyId: ctx.story.id,
+              skippedChecks: passedChecks
+            });
+          }
           logger.info("autofix", "Mechanical autofix succeeded \u2014 retrying review", { storyId: ctx.story.id });
           return { action: "retry", fromStage: "review" };
         }
@@ -28489,7 +28896,7 @@ var init_autofix = __esm(() => {
     }
   };
   _autofixDeps = {
-    getAgent,
+    getAgent: (name, config2) => createAgentRegistry(config2).getAgent(name),
     runQualityCommand,
     recheckReview,
     runAgentRectification: (ctx, lintFixCmd, formatFixCmd, effectiveWorkdir) => runAgentRectification(ctx, lintFixCmd, formatFixCmd, effectiveWorkdir),
@@ -28583,7 +28990,7 @@ var init_completion = __esm(() => {
       const logger = getLogger();
       const isBatch = ctx.stories.length > 1;
       const sessionCost = ctx.agentResult?.estimatedCost || 0;
-      const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
+      const prdPath = ctx.prdPath ?? (ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`);
       const storyStartTime = ctx.storyStartTime || new Date().toISOString();
       if (isBatch) {
         ctx.storyMetrics = collectBatchMetrics(ctx, storyStartTime);
@@ -28634,7 +29041,7 @@ var init_completion = __esm(() => {
         };
         await _completionDeps.persistSemanticVerdict(ctx.featureDir, ctx.story.id, verdict);
       }
-      await savePRD(ctx.prd, prdPath);
+      await _completionDeps.savePRD(ctx.prd, prdPath);
       const updatedCounts = countStories(ctx.prd);
       logger.info("completion", "Progress update", {
         storyId: ctx.story.id,
@@ -28653,7 +29060,8 @@ var init_completion = __esm(() => {
   };
   _completionDeps = {
     checkReviewGate,
-    persistSemanticVerdict
+    persistSemanticVerdict,
+    savePRD
   };
 });
 
@@ -35735,7 +36143,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.59.0",
+    version: "0.59.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -35815,8 +36223,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("13990b5b"))
-        return "13990b5b";
+      if (/^[0-9a-f]{6,10}$/.test("d42d47be"))
+        return "d42d47be";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -40496,7 +40904,7 @@ function validateStoryCount(counts, config2) {
 }
 function logActiveProtocol(config2) {
   const logger = getSafeLogger();
-  const protocol = config2.agent?.protocol ?? "cli";
+  const protocol = config2.agent?.protocol;
   logger?.info("run-initialization", `Agent protocol: ${protocol}`, { protocol });
 }
 async function initializeRun(ctx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.59.0",
+  "version": "0.59.2",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {