@nathapp/nax 0.56.0 → 0.56.2

package/dist/nax.js

@@ -18275,7 +18275,7 @@ var init_schemas3 = __esm(() => {
     maxIterations: exports_external.number().int().positive({ message: "maxIterations must be > 0" }),
     iterationDelayMs: exports_external.number().int().nonnegative(),
     costLimit: exports_external.number().positive({ message: "costLimit must be > 0" }),
-    sessionTimeoutSeconds: exports_external.number().int().positive({ message: "sessionTimeoutSeconds must be > 0" }),
+    sessionTimeoutSeconds: exports_external.number().int().positive({ message: "sessionTimeoutSeconds must be > 0" }).default(3600),
     verificationTimeoutSeconds: exports_external.number().int().min(1).max(3600).default(300),
     maxStoriesPerFeature: exports_external.number().int().positive(),
     rectification: RectificationConfigSchema,
@@ -18472,9 +18472,9 @@ var init_schemas3 = __esm(() => {
   });
   StorySizeGateConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
-    maxAcCount: exports_external.number().int().min(1).max(50).default(6),
-    maxDescriptionLength: exports_external.number().int().min(100).max(1e4).default(2000),
-    maxBulletPoints: exports_external.number().int().min(1).max(100).default(8),
+    maxAcCount: exports_external.number().int().min(1).max(50).default(10),
+    maxDescriptionLength: exports_external.number().int().min(100).max(1e4).default(3000),
+    maxBulletPoints: exports_external.number().int().min(1).max(100).default(12),
     action: exports_external.enum(["block", "warn", "skip"]).default("block"),
     maxReplanAttempts: exports_external.number().int().min(1).default(3)
   });
@@ -22056,7 +22056,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.56.0",
+    version: "0.56.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22135,8 +22135,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("fa0f6b70"))
-        return "fa0f6b70";
+      if (/^[0-9a-f]{6,10}$/.test("b590070f"))
+        return "b590070f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -22389,6 +22389,18 @@ var DEFAULT_FALLBACK_AGENT = "claude";
 var init_resolvers = () => {};
 
 // src/debate/session.ts
+function resolveDebaterModel(debater, config2) {
+  const tier = debater.model ?? "fast";
+  if (!config2?.models)
+    return debater.model;
+  try {
+    const defaultAgent = config2.autoMode?.defaultAgent ?? debater.agent;
+    const modelDef = resolveModelForAgent(config2.models, debater.agent, tier, defaultAgent);
+    return modelDef.model;
+  } catch {
+    return debater.model;
+  }
+}
 function buildFailedResult(storyId, stage, stageConfig, totalCostUsd = 0) {
   return {
     storyId,
@@ -22411,10 +22423,12 @@ class DebateSession {
   storyId;
   stage;
   stageConfig;
+  config;
   constructor(opts) {
     this.storyId = opts.storyId;
     this.stage = opts.stage;
     this.stageConfig = opts.stageConfig;
+    this.config = opts.config;
   }
   async run(prompt) {
     const sessionMode = this.stageConfig.sessionMode ?? "one-shot";
@@ -22437,11 +22451,17 @@ class DebateSession {
       }
       resolved.push({ debater, adapter });
     }
+    logger?.info("debate", "debate:start", {
+      storyId: this.storyId,
+      stage: this.stage,
+      debaters: resolved.map((r) => r.debater.agent)
+    });
     const sessions = [];
     try {
       for (let i = 0;i < resolved.length; i++) {
         const { debater, adapter } = resolved[i];
-        const cmdStr = `acpx --model ${debater.model} ${debater.agent}`;
+        const resolvedModel = resolveDebaterModel(debater, this.config);
+        const cmdStr = resolvedModel ? `acpx --model ${resolvedModel} ${debater.agent}` : `acpx ${debater.agent}`;
         const client = _debateSessionDeps.createSpawnAcpClient(cmdStr);
         const sessionName = `nax-debate-${this.storyId}-${i}`;
         try {
@@ -22457,9 +22477,19 @@ class DebateSession {
       }
       if (sessions.length < 2) {
         if (sessions.length === 1) {
+          logger?.warn("debate", "debate:fallback", {
+            storyId: this.storyId,
+            stage: this.stage,
+            reason: "only 1 session created"
+          });
           const solo = sessions[0];
           const response = await solo.session.prompt(prompt);
           const output = extractSessionOutput(response);
+          logger?.info("debate", "debate:result", {
+            storyId: this.storyId,
+            stage: this.stage,
+            outcome: "passed"
+          });
           return {
             storyId: this.storyId,
             stage: this.stage,
@@ -22471,6 +22501,11 @@ class DebateSession {
             totalCostUsd
           };
         }
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "no sessions created"
+        });
         return buildFailedResult(this.storyId, this.stage, config2, totalCostUsd);
       }
       const proposalSettled = await Promise.allSettled(sessions.map(({ session }) => session.prompt(prompt)));
@@ -22486,8 +22521,22 @@ class DebateSession {
         }
       }
       if (successfulSessions.length < 2) {
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "fewer than 2 proposal rounds succeeded"
+        });
         return buildFailedResult(this.storyId, this.stage, config2, totalCostUsd);
       }
+      for (let i = 0;i < successfulSessions.length; i++) {
+        const s = successfulSessions[i];
+        logger?.info("debate", "debate:proposal", {
+          storyId: this.storyId,
+          stage: this.stage,
+          debaterIndex: i,
+          agent: s.entry.debater.agent
+        });
+      }
       let critiqueOutputs = [];
       if (config2.rounds > 1) {
         const proposalOutputs2 = successfulSessions.map((s) => s.output);
@@ -22506,6 +22555,11 @@ class DebateSession {
         debater: s.entry.debater,
         output: s.output
       }));
+      logger?.info("debate", "debate:result", {
+        storyId: this.storyId,
+        stage: this.stage,
+        outcome
+      });
       return {
         storyId: this.storyId,
         stage: this.stage,
@@ -22534,16 +22588,40 @@ class DebateSession {
       }
       resolved.push({ debater, adapter });
     }
-    const proposalSettled = await Promise.allSettled(resolved.map(({ debater, adapter }) => adapter.complete(prompt, { model: debater.model }).then((output) => ({ debater, adapter, output, cost: 0 }))));
+    logger?.info("debate", "debate:start", {
+      storyId: this.storyId,
+      stage: this.stage,
+      debaters: resolved.map((r) => r.debater.agent)
+    });
+    const proposalSettled = await Promise.allSettled(resolved.map(({ debater, adapter }) => adapter.complete(prompt, { model: resolveDebaterModel(debater, this.config) }).then((output) => ({ debater, adapter, output, cost: 0 }))));
     const successful = proposalSettled.filter((r) => r.status === "fulfilled").map((r) => r.value);
     for (const r of proposalSettled) {
       if (r.status === "fulfilled") {
         totalCostUsd += r.value.cost;
       }
     }
+    for (let i = 0;i < successful.length; i++) {
+      logger?.info("debate", "debate:proposal", {
+        storyId: this.storyId,
+        stage: this.stage,
+        debaterIndex: i,
+        agent: successful[i].debater.agent,
+        model: resolveDebaterModel(successful[i].debater, this.config)
+      });
+    }
     if (successful.length < 2) {
       if (successful.length === 1) {
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "only 1 debater succeeded"
+        });
         const solo = successful[0];
+        logger?.info("debate", "debate:result", {
+          storyId: this.storyId,
+          stage: this.stage,
+          outcome: "passed"
+        });
         return {
           storyId: this.storyId,
           stage: this.stage,
@@ -22557,8 +22635,20 @@ class DebateSession {
       }
       if (resolved.length > 0) {
         const { adapter: fallbackAdapter, debater: fallbackDebater } = resolved[0];
+        logger?.warn("debate", "debate:fallback", {
+          storyId: this.storyId,
+          stage: this.stage,
+          reason: "all debaters failed \u2014 retrying with first adapter"
+        });
         try {
-          const fallbackOutput = await fallbackAdapter.complete(prompt, { model: fallbackDebater.model });
+          const fallbackOutput = await fallbackAdapter.complete(prompt, {
+            model: resolveDebaterModel(fallbackDebater, this.config)
+          });
+          logger?.info("debate", "debate:result", {
+            storyId: this.storyId,
+            stage: this.stage,
+            outcome: "passed"
+          });
           return {
             storyId: this.storyId,
             stage: this.stage,
@@ -22577,7 +22667,7 @@ class DebateSession {
     if (config2.rounds > 1) {
       const proposalOutputs2 = successful.map((p) => p.output);
       const critiqueSettled = await Promise.allSettled(successful.map(({ debater, adapter }, i) => adapter.complete(buildCritiquePrompt(prompt, proposalOutputs2, i), {
-        model: debater.model
+        model: resolveDebaterModel(debater, this.config)
       })));
       for (const r of critiqueSettled) {
         if (r.status === "fulfilled") {
@@ -22593,6 +22683,11 @@ class DebateSession {
       debater: p.debater,
       output: p.output
     }));
+    logger?.info("debate", "debate:result", {
+      storyId: this.storyId,
+      stage: this.stage,
+      outcome
+    });
     return {
       storyId: this.storyId,
       stage: this.stage,
@@ -22604,7 +22699,7 @@ class DebateSession {
       totalCostUsd
     };
   }
-  async resolve(proposalOutputs, critiqueOutputs, successful) {
+  async resolve(proposalOutputs, critiqueOutputs, _successful) {
     const resolverConfig = this.stageConfig.resolver;
     if (resolverConfig.type === "majority-fail-closed" || resolverConfig.type === "majority-fail-open") {
       return majorityResolver(proposalOutputs, resolverConfig.type === "majority-fail-open");
@@ -22631,6 +22726,7 @@ var RESOLVER_FALLBACK_AGENT = "synthesis", _debateSessionDeps;
 var init_session = __esm(() => {
   init_spawn_client();
   init_registry();
+  init_config();
   init_logger2();
   init_resolvers();
   _debateSessionDeps = {
@@ -23500,6 +23596,11 @@ class WebhookInteractionPlugin {
   serverStartPromise = null;
   pendingResponses = new Map;
   receiveCallbacks = new Map;
+  get callbackServerPort() {
+    if (!this.server)
+      return null;
+    return this.server.port;
+  }
   async init(config2) {
     const cfg = WebhookConfigSchema.parse(config2);
     this.config = {
@@ -23675,7 +23776,9 @@ var init_webhook = __esm(() => {
   init_bun_deps();
   WebhookConfigSchema = exports_external.object({
     url: exports_external.string().url().optional(),
-    callbackPort: exports_external.number().int().min(1024).max(65535).optional(),
+    callbackPort: exports_external.number().int().refine((p) => p === 0 || p >= 1024 && p <= 65535, {
+      message: "Port must be 0 (auto-assign) or between 1024 and 65535"
+    }).optional(),
     secret: exports_external.string().optional(),
     maxPayloadBytes: exports_external.number().int().positive().optional()
   });
@@ -26269,7 +26372,8 @@ async function runSemanticReview(workdir, storyGitRef, story, semanticConfig, mo
     const debateSession = _semanticDeps.createDebateSession({
       storyId: story.id,
       stage: "review",
-      stageConfig: reviewStageConfig
+      stageConfig: reviewStageConfig,
+      config: naxConfig
     });
     const debateResult = await debateSession.run(prompt);
     let passCount = 0;
@@ -28788,11 +28892,26 @@ function shouldRetryRectification(state, config2) {
   return true;
 }
 function buildEscalationPreamble(attempt, config2) {
+  const logger = getSafeLogger();
   const rethinkAt = Math.min(config2.rethinkAtAttempt ?? 2, config2.maxRetries);
   const urgencyAt = Math.min(config2.urgencyAtAttempt ?? 3, config2.maxRetries);
   if (attempt < rethinkAt)
     return "";
   const isUrgent = attempt >= urgencyAt;
+  if (isUrgent) {
+    logger?.info("rectification", "Progressive prompt escalation: urgency + rethink injected", {
+      attempt,
+      urgencyAtAttempt: urgencyAt,
+      rethinkAtAttempt: rethinkAt,
+      maxRetries: config2.maxRetries
+    });
+  } else {
+    logger?.info("rectification", "Progressive prompt escalation: rethink injected", {
+      attempt,
+      rethinkAtAttempt: rethinkAt,
+      maxRetries: config2.maxRetries
+    });
+  }
   const rethinkSection = `## \u26A0\uFE0F Previous Attempt Did Not Fix the Failures
 
 Your previous fix attempt (attempt ${attempt}) did not resolve all failures. **Step back and reconsider your approach.**
@@ -28934,7 +29053,9 @@ ${testCommands}
 - When running tests, run ONLY the failing test files shown above \u2014 NEVER run \`bun test\` without a file filter.
 `;
 }
-var init_rectification = () => {};
+var init_rectification = __esm(() => {
+  init_logger2();
+});
 
 // src/verification/index.ts
 var init_verification = __esm(() => {
@@ -30552,6 +30673,10 @@ Category: ${tddResult.failureCategory ?? "unknown"}`,
                 });
               }
             }
+            return {
+              action: "pause",
+              reason: tddResult.reviewReason || `Human review needed: ${tddResult.failureCategory ?? "unknown"}`
+            };
           }
           return routeTddFailure(tddResult.failureCategory, isLiteMode, ctx, tddResult.reviewReason);
         }
@@ -69425,78 +69550,75 @@ async function planCommand(workdir, config2, options) {
         autoModel = resolveModelForAgent2(config2.models, defaultAgent, planTier, defaultAgent).model;
       }
     } catch {}
-    if (isAcp) {
-      logger?.info("plan", "Starting ACP auto planning session", {
-        agent: agentName,
-        model: autoModel ?? config2?.plan?.model ?? "balanced",
-        workdir,
-        feature: options.feature,
-        timeoutSeconds
-      });
-      const pidRegistry = new PidRegistry(workdir);
-      try {
-        await adapter.plan({
-          prompt,
+    const runSingleAgentPlan = async () => {
+      if (isAcp) {
+        logger?.info("plan", "Starting ACP auto planning session", {
+          agent: agentName,
+          model: autoModel ?? config2?.plan?.model ?? "balanced",
           workdir,
-          interactive: false,
-          timeoutSeconds,
-          config: config2,
-          modelTier: config2?.plan?.model ?? "balanced",
-          dangerouslySkipPermissions: resolvePermissions(config2, "plan").skipPermissions,
-          maxInteractionTurns: config2?.agent?.maxInteractionTurns,
-          featureName: options.feature,
-          pidRegistry,
-          sessionRole: "plan"
-        });
-      } finally {
-        await pidRegistry.killAll().catch(() => {});
-      }
-      if (!_planDeps.existsSync(outputPath)) {
-        throw new Error(`[plan] ACP agent did not write PRD to ${outputPath}. Check agent logs for errors.`);
-      }
-      rawResponse = await _planDeps.readFile(outputPath);
-    } else {
-      const debateEnabled = config2?.debate?.enabled && config2?.debate?.stages?.plan?.enabled;
-      if (debateEnabled) {
-        const planStageConfig = config2.debate?.stages.plan;
-        const debateSession = _planDeps.createDebateSession({
-          storyId: options.feature,
-          stage: "plan",
-          stageConfig: planStageConfig
+          feature: options.feature,
+          timeoutSeconds
         });
-        const debateResult = await debateSession.run(prompt);
-        if (debateResult.outcome !== "failed" && debateResult.output) {
-          rawResponse = debateResult.output;
-        } else {
-          logger?.warn("debate", "All debaters failed \u2014 falling back to single agent", {
-            stage: "debate",
-            event: "fallback"
-          });
-          rawResponse = await adapter.complete(prompt, {
-            model: autoModel,
-            jsonMode: true,
+        const pidRegistry = new PidRegistry(workdir);
+        try {
+          await adapter.plan({
+            prompt,
             workdir,
+            interactive: false,
+            timeoutSeconds,
             config: config2,
+            modelTier: config2?.plan?.model ?? "balanced",
+            dangerouslySkipPermissions: resolvePermissions(config2, "plan").skipPermissions,
+            maxInteractionTurns: config2?.agent?.maxInteractionTurns,
             featureName: options.feature,
+            pidRegistry,
             sessionRole: "plan"
           });
+        } finally {
+          await pidRegistry.killAll().catch(() => {});
         }
-      } else {
-        rawResponse = await adapter.complete(prompt, {
-          model: autoModel,
-          jsonMode: true,
-          workdir,
-          config: config2,
-          featureName: options.feature,
-          sessionRole: "plan"
-        });
+        if (!_planDeps.existsSync(outputPath)) {
+          throw new Error(`[plan] ACP agent did not write PRD to ${outputPath}. Check agent logs for errors.`);
+        }
+        return await _planDeps.readFile(outputPath);
       }
+      let result = await adapter.complete(prompt, {
+        model: autoModel,
+        jsonMode: true,
+        workdir,
+        config: config2,
+        featureName: options.feature,
+        sessionRole: "plan"
+      });
       try {
-        const envelope = JSON.parse(rawResponse);
+        const envelope = JSON.parse(result);
         if (envelope?.type === "result" && typeof envelope?.result === "string") {
-          rawResponse = envelope.result;
+          result = envelope.result;
         }
       } catch {}
+      return result;
+    };
+    const debateEnabled = config2?.debate?.enabled && config2?.debate?.stages?.plan?.enabled;
+    if (debateEnabled) {
+      const planStageConfig = config2?.debate?.stages.plan;
+      const debateSession = _planDeps.createDebateSession({
+        storyId: options.feature,
+        stage: "plan",
+        stageConfig: planStageConfig,
+        config: config2
+      });
+      const debateResult = await debateSession.run(prompt);
+      if (debateResult.outcome !== "failed" && debateResult.output) {
+        rawResponse = debateResult.output;
+      } else {
+        logger?.warn("debate", "All debaters failed \u2014 falling back to single agent", {
+          stage: "debate",
+          event: "fallback"
+        });
+        rawResponse = await runSingleAgentPlan();
+      }
+    } else {
+      rawResponse = await runSingleAgentPlan();
     }
   } else {
     const prompt = buildPlanningPrompt(specContent, codebaseContext, outputPath, relativePackages, packageDetails, config2?.project);
@@ -69868,12 +69990,34 @@ async function planDecomposeCommand(workdir, config2, options) {
     if (debateResult.outcome !== "failed" && debateResult.output) {
       rawResponse = debateResult.output;
     } else {
-      rawResponse = await adapter.complete(prompt, { jsonMode: true });
+      rawResponse = await adapter.complete(prompt, {
+        jsonMode: true,
+        workdir,
+        sessionRole: "decompose",
+        featureName: options.feature,
+        storyId: options.storyId
+      });
     }
   } else {
-    rawResponse = await adapter.complete(prompt, { jsonMode: true });
+    rawResponse = await adapter.complete(prompt, {
+      jsonMode: true,
+      workdir,
+      sessionRole: "decompose",
+      featureName: options.feature,
+      storyId: options.storyId
+    });
+  }
+  const jsonMatch = rawResponse.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+  const cleanedResponse = jsonMatch ? jsonMatch[1] : rawResponse;
+  let parsed;
+  try {
+    parsed = JSON.parse(cleanedResponse.trim());
+  } catch (err) {
+    throw new NaxError(`Failed to parse decompose response as JSON: ${err.message}
+
+Response (first 500 chars):
+${rawResponse.slice(0, 500)}`, "DECOMPOSE_PARSE_FAILED", { stage: "decompose", storyId: options.storyId });
   }
-  const parsed = JSON.parse(rawResponse);
   const subStories = parsed.subStories;
   const maxAcCount = config2?.precheck?.storySizeGate?.maxAcCount ?? Number.POSITIVE_INFINITY;
   for (const sub of subStories) {

package/package.json

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