@nathapp/nax 0.77.1 → 0.77.2

package/dist/nax.js

@@ -16865,7 +16865,10 @@ var init_schemas_execution = __esm(() => {
     maxFailureSummaryChars: exports_external.number().int().min(500).max(1e4).default(2000),
     abortOnIncreasingFailures: exports_external.boolean().default(true),
     consecutiveIncreasesToBail: exports_external.number().int().min(1).max(10).default(2),
+    abortOnNoProgress: exports_external.boolean().default(true),
+    consecutiveNoProgressToBail: exports_external.number().int().min(1).max(10).default(3),
     escalateOnExhaustion: exports_external.boolean().optional().default(true),
+    storyScopedFixBudget: exports_external.boolean().default(true),
     rethinkAtAttempt: exports_external.number().int().min(1).default(2),
     urgencyAtAttempt: exports_external.number().int().min(1).default(3)
   });
@@ -17531,7 +17534,10 @@ var init_schemas3 = __esm(() => {
         maxFailureSummaryChars: 2000,
         abortOnIncreasingFailures: true,
         consecutiveIncreasesToBail: 2,
+        abortOnNoProgress: true,
+        consecutiveNoProgressToBail: 3,
         escalateOnExhaustion: true,
+        storyScopedFixBudget: true,
         rethinkAtAttempt: 2,
         urgencyAtAttempt: 3
       },
@@ -43779,8 +43785,8 @@ var init_cycle_iteration_log = __esm(() => {
 });
 
 // src/findings/cycle-retirement.ts
-function createDeclineLedger() {
-  const declinedByStrategy = new Map;
+function createDeclineLedger(backing) {
+  const declinedByStrategy = backing ?? new Map;
   const hasDeclined = (strategyName, finding) => declinedByStrategy.get(strategyName)?.has(findingKey(finding)) === true;
   const isRetiredFor = (strategy, findings) => {
     const claimed = findings.filter((f) => strategy.appliesTo(f));
@@ -43872,13 +43878,14 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
   const storyId = ctx.storyId;
   const packageDir = ctx.packageDir;
   let totalCostUsd = 0;
-  const declines = createDeclineLedger();
+  const declines = createDeclineLedger(_deps.declineBacking);
   let unresolvedDetail;
   const finish = (result) => unresolvedDetail !== undefined && result.unresolvedDetail === undefined ? { ...result, unresolvedDetail } : result;
   for (;; ) {
     if (cycle.findings.length === 0 && cycle.verdict === undefined) {
       return { iterations: cycle.iterations, finalFindings: [], exitReason: "resolved", costUsd: totalCostUsd };
     }
+    const history = cycle.priorIterations ? [...cycle.priorIterations, ...cycle.iterations] : cycle.iterations;
     const selectable = cycle.strategies.filter((s) => !declines.isRetiredFor(s, cycle.findings));
     const active = selectActiveStrategies(selectable, cycle.findings, cycle.verdict);
     if (active.length === 0) {
@@ -43900,9 +43907,9 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: totalCostUsd
       });
     }
-    const uncappedActive = active.filter((s) => countStrategyAttempts(cycle.iterations, s.name) < s.maxAttempts);
+    const uncappedActive = active.filter((s) => countStrategyAttempts(history, s.name) < s.maxAttempts);
     if (uncappedActive.length === 0) {
-      const exhaustedStrategy = active.find((s) => countStrategyAttempts(cycle.iterations, s.name) >= s.maxAttempts);
+      const exhaustedStrategy = active.find((s) => countStrategyAttempts(history, s.name) >= s.maxAttempts);
       logger?.info("findings.cycle", "cycle exited \u2014 all active strategies exhausted", {
         storyId,
         packageDir,
@@ -43918,7 +43925,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: totalCostUsd
       });
     }
-    const totalAttempts = countTotalAttempts(cycle.iterations);
+    const totalAttempts = countTotalAttempts(history);
     if (totalAttempts >= cycle.config.maxAttemptsTotal) {
       logger?.info("findings.cycle", "cycle exited \u2014 total attempt cap reached", {
         storyId,
@@ -43936,7 +43943,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
       });
     }
     for (const strategy of uncappedActive) {
-      const bailReason = strategy.bailWhen?.(cycle.iterations) ?? null;
+      const bailReason = strategy.bailWhen?.(history) ?? null;
       if (bailReason !== null) {
         logger?.info("findings.cycle", "cycle exited \u2014 bail predicate fired", {
           storyId,
@@ -44024,7 +44031,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
       });
     }
     const allExhausted = group.every((s) => {
-      const prior = countStrategyAttempts(cycle.iterations, s.name);
+      const prior = countStrategyAttempts(history, s.name);
       const current = fixesApplied.filter((fa) => fa.strategyName === s.name).length;
       return prior + current >= s.maxAttempts;
     });
@@ -44192,6 +44199,55 @@ var init_cycle = __esm(() => {
   };
 });
 
+// src/findings/bail-marker.ts
+function markNaxBailWrapper(predicate) {
+  Object.assign(predicate, { [NAX_BAIL_WRAPPER]: true });
+  return predicate;
+}
+function isNaxBailWrapper(predicate) {
+  if (!predicate)
+    return false;
+  return predicate[NAX_BAIL_WRAPPER] === true;
+}
+var NAX_BAIL_WRAPPER = "__naxBailWrapper";
+
+// src/findings/story-fix-history.ts
+function createStoryFixHistory() {
+  return new Map;
+}
+function storyFixKey(storyId, tier) {
+  return `${storyId}::${tier ?? "default"}`;
+}
+function getStoryFixState(store, key) {
+  let existing = store.get(key);
+  if (!existing) {
+    existing = { iterations: [], declines: new Map };
+    store.set(key, existing);
+  }
+  return existing;
+}
+function appendStoryFixIterations(store, key, iterations) {
+  const existing = store.get(key);
+  if (existing) {
+    store.set(key, {
+      iterations: [...existing.iterations, ...iterations],
+      declines: existing.declines
+    });
+  } else {
+    store.set(key, {
+      iterations: [...iterations],
+      declines: new Map
+    });
+  }
+}
+function mergeStoryFixDeclines(store, key, declines) {
+  const existing = store.get(key);
+  store.set(key, {
+    iterations: existing?.iterations ?? [],
+    declines: new Map([...declines].map(([name, keys]) => [name, new Set(keys)]))
+  });
+}
+
 // src/findings/index.ts
 var init_findings = __esm(() => {
   init_types6();
@@ -44199,6 +44255,7 @@ var init_findings = __esm(() => {
   init_path_utils();
   init_cycle();
   init_cycle_iteration_log();
+  init_cycle_retirement();
 });
 
 // src/review/review-iteration-store.ts
@@ -44685,7 +44742,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.77.1",
+    version: "0.77.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -44789,8 +44846,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("a50be624"))
-        return "a50be624";
+      if (/^[0-9a-f]{6,10}$/.test("888b55c1"))
+        return "888b55c1";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -51912,6 +51969,7 @@ function createRuntime(config2, workdir, opts) {
   const adversarialIterations = new Map;
   const semanticIterations = new Map;
   const rectificationOscillations = new Map;
+  const storyFixHistory = createStoryFixHistory();
   const mutationSummaries = new Map;
   const dirtyWorktrees = new Set;
   let closed = false;
@@ -51938,6 +51996,7 @@ function createRuntime(config2, workdir, opts) {
     adversarialIterations,
     semanticIterations,
     rectificationOscillations,
+    storyFixHistory,
     mutationSummaries,
     dirtyWorktrees,
     get signal() {
@@ -51985,6 +52044,7 @@ var init_runtime = __esm(() => {
   init_config();
   init_errors();
   init_pid_registry();
+  init_findings();
   init_logger2();
   init_review_audit();
   init_session();
@@ -61274,6 +61334,45 @@ function countOscillationOutcomes(iterations) {
   return count;
 }
 
+// src/execution/story-orchestrator/no-progress-bail.ts
+function madeNoProgress(iteration) {
+  if (iteration.findingsBefore.length === 0)
+    return false;
+  const after = new Set(iteration.findingsAfter.map(findingKey));
+  return iteration.findingsBefore.every((finding) => after.has(findingKey(finding)));
+}
+function withNoProgressBail(strategies, enabled, consecutiveNoProgress) {
+  if (!enabled)
+    return strategies;
+  const threshold = Math.max(1, consecutiveNoProgress);
+  return strategies.map((strategy) => {
+    const innerBail = strategy.bailWhen;
+    const isUserBail = innerBail !== undefined && !isNaxBailWrapper(innerBail);
+    return {
+      ...strategy,
+      bailWhen: markNaxBailWrapper((iterations) => {
+        if (isUserBail) {
+          const userReason = innerBail(iterations);
+          if (userReason !== null)
+            return userReason;
+        }
+        if (iterations.length >= threshold) {
+          const trailing = iterations.slice(-threshold);
+          if (trailing.every(madeNoProgress)) {
+            return `no finding resolved for ${threshold} consecutive iteration(s); ${trailing.at(-1)?.findingsBefore.length ?? 0} finding(s) persisted`;
+          }
+        }
+        if (!isUserBail && innerBail)
+          return innerBail(iterations);
+        return null;
+      })
+    };
+  });
+}
+var init_no_progress_bail = __esm(() => {
+  init_findings();
+});
+
 // src/execution/checkpoint/resume-plan.ts
 function buildResumePlan(cp, current) {
   if (!cp) {
@@ -61806,7 +61905,7 @@ function withIncreasingFailuresBail(strategies, enabled, consecutiveIncreases) {
   const threshold = Math.max(1, consecutiveIncreases);
   return strategies.map((strategy) => ({
     ...strategy,
-    bailWhen: (iterations) => {
+    bailWhen: markNaxBailWrapper((iterations) => {
       const userReason = strategy.bailWhen?.(iterations) ?? null;
       if (userReason !== null)
         return userReason;
@@ -61820,7 +61919,7 @@ function withIncreasingFailuresBail(strategies, enabled, consecutiveIncreases) {
         return `failure count increased for ${threshold} consecutive iteration(s): ${first.findingsBefore.length} -> ${last.findingsAfter.length}`;
       }
       return null;
-    }
+    })
   }));
 }
 var _storyOrchestratorDeps, ALL_FINDING_SEVERITIES;
@@ -61986,6 +62085,12 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   if (!ctx.storyId) {
     return {};
   }
+  const storyFixBudgetEnabled = !nbfPath && ctx.runtime.configLoader.current().execution?.rectification?.storyScopedFixBudget === true;
+  const store = ctx.runtime.storyFixHistory;
+  const fixKey = storyFixBudgetEnabled ? storyFixKey(ctx.storyId, ctx.phaseTelemetry?.tier) : undefined;
+  const fixState = fixKey !== undefined && store ? getStoryFixState(store, fixKey) : undefined;
+  const priorIterationCount = fixState?.iterations.length ?? 0;
+  const declineSnapshot = fixState ? new Map([...fixState.declines].map(([name, keys]) => [name, new Set(keys)])) : undefined;
   const fixOpPhaseOutputs = {};
   const wrappedCallOp = async (cycleCtx, op, input) => {
     const slot = { op, input };
@@ -61994,7 +62099,8 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   const cycle = {
     findings: [...initialFindings],
     iterations: [],
-    strategies: withIncreasingFailuresBail(overrides?.strategies ?? rectification2.strategies, rectification2.abortOnIncreasingFailures, rectification2.consecutiveIncreasesToBail ?? 1),
+    priorIterations: fixState?.iterations,
+    strategies: withNoProgressBail(withIncreasingFailuresBail(overrides?.strategies ?? rectification2.strategies, rectification2.abortOnIncreasingFailures, rectification2.consecutiveIncreasesToBail ?? 1), rectification2.abortOnNoProgress ?? true, rectification2.consecutiveNoProgressToBail ?? 3),
     config: { maxAttemptsTotal: overrides?.maxAttempts ?? rectification2.maxAttempts, validatorRetries: 1 },
     validate: async (_validateCtx, opts) => {
       if (ctx.runtime.signal?.aborted)
@@ -62055,15 +62161,22 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
       return { findings: validated, shortCircuited };
     }
   };
-  const cycleResult = await _storyOrchestratorDeps.runFixCycle(cycle, ctx, "story-orchestrator-rectification", { callOp: wrappedCallOp });
+  const cycleResult = await _storyOrchestratorDeps.runFixCycle(cycle, ctx, "story-orchestrator-rectification", { callOp: wrappedCallOp, declineBacking: declineSnapshot });
+  if (fixKey !== undefined && store && cycleResult.iterations.length > 0) {
+    appendStoryFixIterations(store, fixKey, cycleResult.iterations);
+  }
+  if (fixKey !== undefined && store && declineSnapshot) {
+    mergeStoryFixDeclines(store, fixKey, declineSnapshot);
+  }
   const oscillationCount = countOscillationOutcomes(cycleResult.iterations);
   if (oscillationCount > 0) {
     recordOscillations(ctx.runtime.rectificationOscillations, ctx.storyId, oscillationCount);
   }
+  const reportedExitReason = cycleResult.exitReason === "validate-short-circuit" && priorIterationCount > 0 ? "max-attempts-per-strategy" : cycleResult.exitReason;
   phaseOutputs.rectification = {
     success: cycleResult.exitReason === "resolved",
     iterationCount: cycleResult.iterations.length,
-    exitReason: cycleResult.exitReason,
+    exitReason: reportedExitReason,
     finalFindingsCount: cycleResult.finalFindings.length
   };
   const rectLogger = getSafeLogger();
@@ -62072,7 +62185,7 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
     initialFindingsCount: initialFindings.length,
     iterationCount: cycleResult.iterations.length,
     finalFindingsCount: cycleResult.finalFindings.length,
-    exitReason: cycleResult.exitReason,
+    exitReason: reportedExitReason,
     costUsd: cycleResult.costUsd
   };
   if (cycleResult.exitReason === "resolved") {
@@ -62098,8 +62211,10 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   return {};
 }
 var init_rectification = __esm(() => {
+  init_findings();
   init_logger2();
   init_nbf_flake_triage();
+  init_no_progress_bail();
   init_phase_eval();
   init_phase_eval();
   init_run_phase();
@@ -62453,6 +62568,7 @@ var init_story_orchestrator = __esm(() => {
   init_phase_eval();
   init_rectification();
   init_nbf_flake_triage();
+  init_no_progress_bail();
   init_run_phase();
   init_review_decision();
   init_types9();
@@ -62873,7 +62989,9 @@ async function assemblePlanInputsFromCtx(ctx) {
     maxAttempts: ctx.config.execution.rectification.maxAttemptsTotal,
     strategies: [],
     abortOnIncreasingFailures: ctx.config.execution.rectification.abortOnIncreasingFailures,
-    consecutiveIncreasesToBail: ctx.config.execution.rectification.consecutiveIncreasesToBail
+    consecutiveIncreasesToBail: ctx.config.execution.rectification.consecutiveIncreasesToBail,
+    abortOnNoProgress: ctx.config.execution.rectification.abortOnNoProgress,
+    consecutiveNoProgressToBail: ctx.config.execution.rectification.consecutiveNoProgressToBail
   } : undefined;
   const mutationCheckInput = ctx.config.execution?.mutationCheck?.enabled === true ? {
     story,
@@ -76417,6 +76535,7 @@ var init_lifecycle = __esm(() => {
 var exports_execution = {};
 __export(exports_execution, {
   writeExitSummary: () => writeExitSummary,
+  withNoProgressBail: () => withNoProgressBail,
   withIncreasingFailuresBail: () => withIncreasingFailuresBail,
   toReviewDecisionPayload: () => toReviewDecisionPayload,
   synthesizeBackfillMetric: () => synthesizeBackfillMetric,
@@ -107607,6 +107726,8 @@ var FIELD_DESCRIPTIONS = {
   "execution.rectification.maxFailureSummaryChars": "Max characters in failure summary",
   "execution.rectification.abortOnIncreasingFailures": "Abort if failure count increases",
   "execution.rectification.consecutiveIncreasesToBail": "Consecutive regressing iterations required before abortOnIncreasingFailures bails (default: 2; 1 = legacy behaviour)",
+  "execution.rectification.abortOnNoProgress": "Abort rectification when no progress is made for several consecutive iterations (default: true)",
+  "execution.rectification.consecutiveNoProgressToBail": "Consecutive no-progress iterations required before abortOnNoProgress bails (default: 3; one higher than the count bail's 2 because the no-progress predicate fires on a wider shape)",
   "execution.rectification.escalateOnExhaustion": "Enable model tier escalation when attempts are exhausted with remaining failures",
   "execution.rectification.rethinkAtAttempt": "Attempt number at which 'rethink your approach' language is injected into the prompt (default: 2)",
   "execution.rectification.urgencyAtAttempt": "Attempt number at which 'final chance before escalation' urgency is added (default: 3)",

package/package.json

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