@nathapp/nax 0.83.1 → 0.83.2

package/dist/nax.js

@@ -2668,7 +2668,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.83.1",
+    version: "0.83.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -57251,8 +57251,8 @@ var init_version = __esm(() => {
   NAX_AI_VERSION = CATALOG_VERSION;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("edd97363"))
-        return "edd97363";
+      if (/^[0-9a-f]{6,10}$/.test("bcfcddb0"))
+        return "bcfcddb0";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -92508,6 +92508,78 @@ var init_run_phase = __esm(() => {
   ];
 });
 
+// src/execution/story-orchestrator/review-pair.ts
+function shouldRunReviewsConcurrently(reviewConfig, phases) {
+  const adversarial = reviewConfig?.adversarial;
+  const maxConcurrentSessions = adversarial?.maxConcurrentSessions ?? 2;
+  return adversarial?.parallel === true && maxConcurrentSessions >= 2 && phases.some((phase) => phase.kind === "semantic-review") && phases.some((phase) => phase.kind === "adversarial-review");
+}
+async function runReviewPair(ctx, pair, tracking, isThreeSession = false, progress) {
+  getSafeLogger()?.info("story-orchestrator", "Running semantic-review and adversarial-review concurrently", {
+    storyId: ctx.storyId
+  });
+  const outcomes = await Promise.allSettled(pair.map((phase, index) => _reviewPairDeps.runPhase(ctx, phase.slot, tracking.phaseCosts, tracking.phaseOutputs, isThreeSession, progress ? { index: index === 0 ? progress.indices[0] : progress.indices[1], total: progress.total } : undefined)));
+  const logger = getSafeLogger();
+  for (const [index, outcome] of outcomes.entries()) {
+    if (outcome.status === "rejected") {
+      logger?.error("story-orchestrator", "Phase threw unexpected error", {
+        storyId: ctx.storyId,
+        phase: index === 0 ? pair[0].kind : pair[1].kind,
+        error: errorMessage(outcome.reason)
+      });
+    }
+  }
+  const semanticOutcome = outcomes[0];
+  if (semanticOutcome?.status === "rejected")
+    throw semanticOutcome.reason;
+  const adversarialOutcome = outcomes[1];
+  if (adversarialOutcome?.status === "rejected")
+    throw adversarialOutcome.reason;
+}
+var _reviewPairDeps;
+var init_review_pair = __esm(() => {
+  init_logger2();
+  init_run_phase();
+  _reviewPairDeps = { runPhase };
+});
+
+// src/execution/story-orchestrator/revalidation-reviews.ts
+async function dispatchRevalidationPhase(ctx, phase, phases, tracking, isThreeSession) {
+  const reviewConfig = ctx.config?.review ?? ctx.packageView.config.review;
+  if (phase.kind === "semantic-review" && shouldRunReviewsConcurrently(reviewConfig, phases)) {
+    const semantic = phase;
+    const adversarial = phases.find((candidate) => candidate.kind === "adversarial-review");
+    if (adversarial) {
+      await runReviewPair(ctx, [semantic, adversarial], tracking, isThreeSession);
+      return ["semantic-review", "adversarial-review"];
+    }
+  }
+  await runPhase(ctx, phase.slot, tracking.phaseCosts, tracking.phaseOutputs, isThreeSession);
+  return [phase.kind];
+}
+function phasesForRevalidation(ctx, phases) {
+  const reviewConfig = ctx.config?.review ?? ctx.packageView.config.review;
+  return shouldRunReviewsConcurrently(reviewConfig, phases) ? phases.filter((phase) => phase.kind !== "adversarial-review") : phases;
+}
+function collectPairedReviewFindings(options) {
+  if (options.dispatched.length < 2)
+    return false;
+  const phase = options.phases.find((item) => item.kind === "adversarial-review");
+  if (!phase)
+    return false;
+  const output = options.phaseOutputs[phase.slot.op.name];
+  options.findings.push(...extractPhaseFindings(output));
+  return !phasePassed(phase.slot.op.name, output, options.storyId);
+}
+function isRevalidationFailure(options) {
+  return !phasePassed(options.phase.slot.op.name, options.output, options.storyId) && !options.quarantinedOnly || options.pairedReviewFailed;
+}
+var init_revalidation_reviews = __esm(() => {
+  init_phase_eval();
+  init_review_pair();
+  init_run_phase();
+});
+
 // src/execution/story-orchestrator/rectification.ts
 function shouldSkipPhaseForRectification(input) {
   const { phase, state, phaseOutputs, nbfPath } = input;
@@ -92663,6 +92735,7 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
       const extra = overrides?.extraRevalidationKinds ? validationPhases.filter((p) => overrides.extraRevalidationKinds?.includes(p.kind) && !selected.some((s) => s.kind === p.kind)) : [];
       const selectedWithExtra = [...selected, ...extra];
       const phases = lite ? orderGateLast(selectedWithExtra) : selectedWithExtra;
+      const dispatchPhases = phasesForRevalidation(ctx, phases);
       getSafeLogger()?.debug("story-orchestrator", "rectification validate scope", {
         storyId: ctx.storyId,
         mode: opts?.mode ?? "full",
@@ -92671,8 +92744,8 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
       });
       const findings = [];
       let shortCircuited = false;
-      for (const phase of phases) {
-        await runPhase(ctx, phase.slot, phaseCosts, phaseOutputs, overrides?.isThreeSession);
+      for (const phase of dispatchPhases) {
+        const dispatched = await dispatchRevalidationPhase(ctx, phase, phases, { phaseCosts, phaseOutputs }, overrides?.isThreeSession);
         if (shouldSkipPhaseForRectification({ phase, state, phaseOutputs, nbfPath })) {
           const carvedOutFindings = selectRegressedGateFindings(extractPhaseFindings(phaseOutputs[phase.slot.op.name]), overrides?.gateBaselineKeys ?? new Set, ctx.runtime.quarantineMemo);
           if (carvedOutFindings.length > 0) {
@@ -92699,8 +92772,15 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
         const phaseFindings = extractPhaseFindings(output);
         const blockingFindings = nbfPath ? phaseFindings.filter((finding) => !isQuarantinedFlake(finding, nbfFlakeTriage?.memo ?? ctx.runtime.quarantineMemo)) : phaseFindings;
         findings.push(...blockingFindings);
+        const pairedReviewFailed = collectPairedReviewFindings({
+          dispatched,
+          phases,
+          phaseOutputs,
+          findings,
+          storyId: ctx.storyId
+        });
         const quarantinedOnly = nbfPath && isQuarantinedOnlyGateFailure(phase, phaseFindings, blockingFindings);
-        if (!phasePassed(phase.slot.op.name, output, ctx.storyId) && !quarantinedOnly) {
+        if (isRevalidationFailure({ phase, output, storyId: ctx.storyId, quarantinedOnly, pairedReviewFailed })) {
           getSafeLogger()?.warn("story-orchestrator", "Short-circuiting revalidation on phase failure", {
             storyId: ctx.storyId,
             phase: phase.slot.op.name
@@ -92784,6 +92864,7 @@ var init_rectification = __esm(() => {
   init_nbf_flake_triage();
   init_no_progress_bail();
   init_phase_eval();
+  init_revalidation_reviews();
   init_run_phase();
   init_types12();
 });
@@ -92837,14 +92918,76 @@ async function recordGreenCheckpoint(plan, phaseName) {
     }
   }
 }
+async function runCanonicalReviewPair(options) {
+  const { plan, tracking, semantic, adversarial, indices, total } = options;
+  const { ctx, isThreeSession } = plan;
+  const reviews = [semantic, adversarial];
+  try {
+    await runReviewPair(ctx, reviews, tracking, isThreeSession, { indices, total });
+  } catch (error48) {
+    for (const review of reviews) {
+      const name = review.slot.op.name;
+      if (name in tracking.phaseOutputs && phasePassed(name, tracking.phaseOutputs[name], ctx.storyId)) {
+        await recordGreenCheckpoint(plan, name);
+      }
+    }
+    throw error48;
+  }
+  let shortCircuitPhase;
+  for (const review of reviews) {
+    const name = review.slot.op.name;
+    if (phasePassed(name, tracking.phaseOutputs[name], ctx.storyId)) {
+      await recordGreenCheckpoint(plan, name);
+    } else {
+      shortCircuitPhase = name;
+      if (name !== "semantic-review") {
+        getSafeLogger()?.warn("story-orchestrator", "Short-circuiting on phase failure", {
+          storyId: ctx.storyId,
+          phase: name
+        });
+        break;
+      }
+      getSafeLogger()?.warn("story-orchestrator", "semantic-review failed \u2014 continuing to adversarial-review for a second opinion", { storyId: ctx.storyId, phase: name });
+    }
+  }
+  return shortCircuitPhase;
+}
 async function runCanonicalLoop(plan, tracking, orderedPhases) {
   const { ctx, isThreeSession } = plan;
   const { phaseCosts, phaseOutputs } = tracking;
   const logger = getSafeLogger();
   let shortCircuitPhase;
+  const skippedPhaseIndexes = new Set;
+  const runnablePhases = orderedPhases.filter((phase, index) => {
+    const name = phase.slot.op.name;
+    const alreadyPassed = name in phaseOutputs && phasePassed(name, phaseOutputs[name], ctx.storyId);
+    if (alreadyPassed)
+      skippedPhaseIndexes.add(index);
+    return !alreadyPassed;
+  });
+  const reviewConfig = ctx.config?.review ?? ctx.packageView.config.review;
+  const pairReviews = shouldRunReviewsConcurrently(reviewConfig, runnablePhases);
+  const phasesByKind = new Map(orderedPhases.map((phase, index) => [phase.kind, { phase, index }]));
+  let pairedAdversarialIndex;
   for (const [phaseIndex, phase] of orderedPhases.entries()) {
     const name = phase.slot.op.name;
-    if (name in phaseOutputs && phasePassed(name, phaseOutputs[name], ctx.storyId)) {
+    if (phaseIndex === pairedAdversarialIndex)
+      continue;
+    if (skippedPhaseIndexes.has(phaseIndex))
+      continue;
+    const adversarial = phasesByKind.get("adversarial-review");
+    if (pairReviews && phase.kind === "semantic-review" && adversarial && adversarial.index > phaseIndex) {
+      pairedAdversarialIndex = adversarial.index;
+      shortCircuitPhase = await runCanonicalReviewPair({
+        plan,
+        tracking,
+        semantic: phase,
+        adversarial: adversarial.phase,
+        indices: [phaseIndex + 1, adversarial.index + 1],
+        total: orderedPhases.length
+      });
+      if (shortCircuitPhase === "adversarial-review")
+        break;
       continue;
     }
     try {
@@ -93005,6 +93148,7 @@ var init_execution_plan_phases = __esm(() => {
   init_phase_eval();
   init_phase_state();
   init_rectification();
+  init_review_pair();
   init_run_phase();
 });
 

package/package.json

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