@nathapp/nax 0.18.6 → 0.20.0

package/src/context/injector.ts

@@ -7,7 +7,7 @@
  *           Ruby (Gemfile), Java/Kotlin (pom.xml / build.gradle).
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { NaxConfig } from "../config";
 import type { ProjectMetadata } from "./types";
@@ -68,12 +68,12 @@ async function detectNode(workdir: string): Promise<{ name?: string; lang: strin
 }
 
 /** Go: read go.mod for module name + direct dependencies */
-function detectGo(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+async function detectGo(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
   const goMod = join(workdir, "go.mod");
   if (!existsSync(goMod)) return null;
 
   try {
-    const content = readFileSync(goMod, "utf8");
+    const content = await Bun.file(goMod).text();
     const moduleMatch = content.match(/^module\s+(\S+)/m);
     const name = moduleMatch?.[1];
 
@@ -95,12 +95,12 @@ function detectGo(workdir: string): { name?: string; lang: string; dependencies:
 }
 
 /** Rust: read Cargo.toml for package name + dependencies */
-function detectRust(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+async function detectRust(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
   const cargoPath = join(workdir, "Cargo.toml");
   if (!existsSync(cargoPath)) return null;
 
   try {
-    const content = readFileSync(cargoPath, "utf8");
+    const content = await Bun.file(cargoPath).text();
     const nameMatch = content.match(/^\[package\][^[]*name\s*=\s*"([^"]+)"/ms);
     const name = nameMatch?.[1];
 
@@ -119,7 +119,7 @@ function detectRust(workdir: string): { name?: string; lang: string; dependencie
 }
 
 /** Python: read pyproject.toml or requirements.txt */
-function detectPython(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+async function detectPython(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
   const pyproject = join(workdir, "pyproject.toml");
   const requirements = join(workdir, "requirements.txt");
 
@@ -127,7 +127,7 @@ function detectPython(workdir: string): { name?: string; lang: string; dependenc
 
   try {
     if (existsSync(pyproject)) {
-      const content = readFileSync(pyproject, "utf8");
+      const content = await Bun.file(pyproject).text();
       const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
       const depsSection = content.match(/^\[project\][^[]*dependencies\s*=\s*\[([^\]]*)\]/ms)?.[1] ?? "";
       const deps = depsSection
@@ -139,7 +139,7 @@ function detectPython(workdir: string): { name?: string; lang: string; dependenc
     }
 
     // Fallback: requirements.txt
-    const lines = readFileSync(requirements, "utf8")
+    const lines = (await Bun.file(requirements).text())
       .split("\n")
       .map((l) => l.split(/[>=<!]/)[0].trim())
       .filter((l) => l && !l.startsWith("#"))
@@ -169,12 +169,12 @@ async function detectPhp(workdir: string): Promise<{ name?: string; lang: string
 }
 
 /** Ruby: read Gemfile */
-function detectRuby(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+async function detectRuby(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
   const gemfile = join(workdir, "Gemfile");
   if (!existsSync(gemfile)) return null;
 
   try {
-    const content = readFileSync(gemfile, "utf8");
+    const content = await Bun.file(gemfile).text();
     const gems = [...content.matchAll(/^\s*gem\s+['"]([^'"]+)['"]/gm)].map((m) => m[1]).slice(0, 10);
     return { lang: "Ruby", dependencies: gems };
   } catch {
@@ -183,7 +183,7 @@ function detectRuby(workdir: string): { name?: string; lang: string; dependencie
 }
 
 /** Java/Kotlin: detect from pom.xml or build.gradle */
-function detectJvm(workdir: string): { name?: string; lang: string; dependencies: string[] } | null {
+async function detectJvm(workdir: string): Promise<{ name?: string; lang: string; dependencies: string[] } | null> {
   const pom = join(workdir, "pom.xml");
   const gradle = join(workdir, "build.gradle");
   const gradleKts = join(workdir, "build.gradle.kts");
@@ -192,7 +192,7 @@ function detectJvm(workdir: string): { name?: string; lang: string; dependencies
 
   try {
     if (existsSync(pom)) {
-      const content = readFileSync(pom, "utf8");
+      const content = await Bun.file(pom).text();
       const nameMatch = content.match(/<artifactId>([^<]+)<\/artifactId>/);
       const deps = [...content.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)]
         .map((m) => m[1])
@@ -203,7 +203,7 @@ function detectJvm(workdir: string): { name?: string; lang: string; dependencies
     }
 
     const gradleFile = existsSync(gradleKts) ? gradleKts : gradle;
-    const content = readFileSync(gradleFile, "utf8");
+    const content = await Bun.file(gradleFile).text();
     const lang = gradleFile.endsWith(".kts") ? "Kotlin" : "Java";
     const deps = [...content.matchAll(/implementation[^'"]*['"]([^:'"]+:[^:'"]+)[^'"]*['"]/g)]
       .map((m) => m[1].split(":").pop() ?? m[1])
@@ -223,12 +223,12 @@ function detectJvm(workdir: string): { name?: string; lang: string; dependencies
 export async function buildProjectMetadata(workdir: string, config: NaxConfig): Promise<ProjectMetadata> {
   // Priority: Go > Rust > Python > PHP > Ruby > JVM > Node
   const detected =
-    detectGo(workdir) ??
-    detectRust(workdir) ??
-    detectPython(workdir) ??
+    (await detectGo(workdir)) ??
+    (await detectRust(workdir)) ??
+    (await detectPython(workdir)) ??
     (await detectPhp(workdir)) ??
-    detectRuby(workdir) ??
-    detectJvm(workdir) ??
+    (await detectRuby(workdir)) ??
+    (await detectJvm(workdir)) ??
     (await detectNode(workdir));
 
   return {

package/src/execution/crash-recovery.ts

@@ -1,3 +1,4 @@
+import { appendFileSync } from "node:fs";
 /**
  * Crash Recovery — Signal handlers, heartbeat, and exit summary
  *
@@ -63,9 +64,8 @@ async function writeFatalLog(jsonlFilePath: string | undefined, signal: string,
     };
 
     const line = `${JSON.stringify(fatalEntry)}\n`;
-    // Use appendFileSync from node:fs to ensure file is created if it doesn't exist
-    const { appendFileSync } = await import("node:fs");
-    appendFileSync(jsonlFilePath, line, "utf8");
+    // Use Bun.write with append: true
+    appendFileSync(jsonlFilePath, line);
   } catch (err) {
     console.error("[crash-recovery] Failed to write fatal log:", err);
   }
@@ -107,8 +107,7 @@ async function writeRunComplete(ctx: CrashRecoveryContext, exitReason: string):
     };
 
     const line = `${JSON.stringify(runCompleteEntry)}\n`;
-    const { appendFileSync } = await import("node:fs");
-    appendFileSync(ctx.jsonlFilePath, line, "utf8");
+    appendFileSync(ctx.jsonlFilePath, line);
     logger?.debug("crash-recovery", "run.complete event written", { exitReason });
   } catch (err) {
     console.error("[crash-recovery] Failed to write run.complete event:", err);
@@ -279,8 +278,7 @@ export function startHeartbeat(
           },
         };
         const line = `${JSON.stringify(heartbeatEntry)}\n`;
-        const { appendFileSync } = await import("node:fs");
-        appendFileSync(jsonlFilePath, line, "utf8");
+        appendFileSync(jsonlFilePath, line);
       } catch (err) {
         logger?.warn("crash-recovery", "Failed to write heartbeat", { error: (err as Error).message });
       }
@@ -342,9 +340,8 @@ export async function writeExitSummary(
     };
 
     const line = `${JSON.stringify(summaryEntry)}\n`;
-    // Use appendFileSync from node:fs to ensure file is created if it doesn't exist
-    const { appendFileSync } = await import("node:fs");
-    appendFileSync(jsonlFilePath, line, "utf8");
+    // Use Bun.write with append: true
+    appendFileSync(jsonlFilePath, line);
     logger?.debug("crash-recovery", "Exit summary written");
   } catch (err) {
     logger?.warn("crash-recovery", "Failed to write exit summary", { error: (err as Error).message });

package/src/execution/lifecycle/acceptance-loop.ts

@@ -93,6 +93,7 @@ async function generateAndAddFixStories(
     specContent: await loadSpecContent(ctx.featureDir),
     workdir: ctx.workdir,
     modelDef,
+    config: ctx.config,
   });
   if (fixStories.length === 0) {
     logger?.error("acceptance", "Failed to generate fix stories");

package/src/execution/lifecycle/index.ts

@@ -2,7 +2,6 @@
  * Lifecycle module exports
  */
 
-export { RunLifecycle, type SetupResult, type TeardownOptions } from "./run-lifecycle";
 export { runAcceptanceLoop, type AcceptanceLoopContext, type AcceptanceLoopResult } from "./acceptance-loop";
 export { emitStoryComplete, type StoryCompleteEvent } from "./story-hooks";
 export { outputRunHeader, outputRunFooter, type RunHeaderOptions, type RunFooterOptions } from "./headless-formatter";
@@ -10,3 +9,4 @@ export { handleParallelCompletion, type ParallelCompletionOptions } from "./para
 export { handleRunCompletion, type RunCompletionOptions, type RunCompletionResult } from "./run-completion";
 export { cleanupRun, type RunCleanupOptions } from "./run-cleanup";
 export { setupRun, type RunSetupOptions, type RunSetupResult } from "./run-setup";
+export { runDeferredRegression, type DeferredRegressionOptions, type DeferredRegressionResult } from "./run-regression";

package/src/execution/lifecycle/precheck-runner.ts

@@ -62,7 +62,7 @@ export async function runPrecheckValidation(ctx: PrecheckContext): Promise<void>
       warnings: precheckResult.output.warnings.map((w) => ({ name: w.name, message: w.message })),
       summary: precheckResult.output.summary,
     };
-    appendFileSync(ctx.logFilePath, `${JSON.stringify(precheckLog)}\n`, "utf8");
+    require("node:fs").appendFileSync(ctx.logFilePath, `${JSON.stringify(precheckLog)}\n`);
   }
 
   // Handle blockers (Tier 1 failures)

package/src/execution/lifecycle/run-completion.ts

@@ -2,17 +2,28 @@
  * Run Completion — Final Metrics and Status Updates
  *
  * Handles the final steps after sequential execution completes:
+ * - Run deferred regression gate (if configured)
  * - Save run metrics
  * - Log completion summary with per-story metrics
  * - Update final status
  */
 
+import type { NaxConfig } from "../../config";
 import { getSafeLogger } from "../../logger";
 import type { StoryMetrics } from "../../metrics";
 import { saveRunMetrics } from "../../metrics";
 import { countStories, isComplete, isStalled } from "../../prd";
 import type { PRD } from "../../prd";
 import type { StatusWriter } from "../status-writer";
+import { runDeferredRegression } from "./run-regression";
+
+/**
+ * Injectable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
+ * @internal - test use only.
+ */
+export const _runCompletionDeps = {
+  runDeferredRegression,
+};
 
 export interface RunCompletionOptions {
   runId: string;
@@ -26,6 +37,7 @@ export interface RunCompletionOptions {
   startTime: number;
   workdir: string;
   statusWriter: StatusWriter;
+  config: NaxConfig;
 }
 
 export interface RunCompletionResult {
@@ -57,8 +69,25 @@ export async function handleRunCompletion(options: RunCompletionOptions): Promis
     startTime,
     workdir,
     statusWriter,
+    config,
   } = options;
 
+  // Run deferred regression gate before final metrics
+  const regressionMode = config.execution.regressionGate?.mode;
+  if (regressionMode === "deferred" && config.quality.commands.test) {
+    const regressionResult = await _runCompletionDeps.runDeferredRegression({
+      config,
+      prd,
+      workdir,
+    });
+
+    logger?.info("regression", "Deferred regression gate completed", {
+      success: regressionResult.success,
+      failedTests: regressionResult.failedTests,
+      affectedStories: regressionResult.affectedStories,
+    });
+  }
+
   const durationMs = Date.now() - startTime;
   const runCompletedAt = new Date().toISOString();
 

package/src/execution/lifecycle/run-regression.ts

@@ -0,0 +1,301 @@
+/**
+ * Deferred Regression Gate
+ *
+ * Runs full test suite once after all stories complete, then attempts
+ * targeted rectification per responsible story. Handles edge cases:
+ * - Partial completion: only check stories marked passed
+ * - Overlapping file changes: try last modified story first
+ * - Unmapped tests: warn and mark all passed stories for re-verification
+ */
+
+import type { NaxConfig } from "../../config";
+import { getSafeLogger } from "../../logger";
+import type { PRD, UserStory } from "../../prd";
+import { countStories } from "../../prd";
+import { hasCommitsForStory } from "../../utils/git";
+import { parseBunTestOutput } from "../../verification";
+import { reverseMapTestToSource } from "../../verification/smart-runner";
+import { runRectificationLoop } from "../post-verify-rectification";
+import { runVerification } from "../verification";
+
+/**
+ * Injectable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
+ * @internal - test use only.
+ */
+export const _regressionDeps = {
+  runVerification,
+  runRectificationLoop,
+  parseBunTestOutput,
+  reverseMapTestToSource,
+};
+
+export interface DeferredRegressionOptions {
+  config: NaxConfig;
+  prd: PRD;
+  workdir: string;
+}
+
+export interface DeferredRegressionResult {
+  success: boolean;
+  failedTests: number;
+  passedTests: number;
+  rectificationAttempts: number;
+  affectedStories: string[];
+}
+
+/**
+ * Map a test file to the story responsible for it via git log.
+ *
+ * Searches recent commits for story IDs in the format US-NNN.
+ * Returns the first matching story ID, or undefined if not found.
+ */
+async function findResponsibleStory(
+  testFile: string,
+  workdir: string,
+  passedStories: UserStory[],
+): Promise<UserStory | undefined> {
+  const logger = getSafeLogger();
+
+  // Try each passed story in reverse order (most recent first)
+  for (let i = passedStories.length - 1; i >= 0; i--) {
+    const story = passedStories[i];
+    const hasCommits = await hasCommitsForStory(workdir, story.id, 50);
+    if (hasCommits) {
+      logger?.info("regression", `Mapped test to story ${story.id}`, { testFile });
+      return story;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Run deferred regression gate after all stories complete.
+ *
+ * Steps:
+ * 1. Run full test suite
+ * 2. If failures, reverse-map test files to source files to stories
+ * 3. For each affected story, attempt targeted rectification
+ * 4. Re-run full suite to confirm fixes
+ * 5. Return results with affected story list
+ */
+export async function runDeferredRegression(options: DeferredRegressionOptions): Promise<DeferredRegressionResult> {
+  const logger = getSafeLogger();
+  const { config, prd, workdir } = options;
+
+  // Check if regression gate is deferred
+  const regressionMode = config.execution.regressionGate?.mode ?? "deferred";
+  if (regressionMode === "disabled") {
+    logger?.info("regression", "Deferred regression gate disabled");
+    return {
+      success: true,
+      failedTests: 0,
+      passedTests: 0,
+      rectificationAttempts: 0,
+      affectedStories: [],
+    };
+  }
+
+  if (regressionMode !== "deferred") {
+    logger?.info("regression", "Regression gate mode is not deferred, skipping");
+    return {
+      success: true,
+      failedTests: 0,
+      passedTests: 0,
+      rectificationAttempts: 0,
+      affectedStories: [],
+    };
+  }
+
+  const testCommand = config.quality.commands.test ?? "bun test";
+  const timeoutSeconds = config.execution.regressionGate?.timeoutSeconds ?? 120;
+  const maxRectificationAttempts = config.execution.regressionGate?.maxRectificationAttempts ?? 2;
+
+  // Only check stories that have been marked as passed
+  const counts = countStories(prd);
+  const passedStories = prd.userStories.filter((s) => s.status === "passed");
+
+  if (passedStories.length === 0) {
+    logger?.info("regression", "No passed stories to verify (partial completion)");
+    return {
+      success: true,
+      failedTests: 0,
+      passedTests: 0,
+      rectificationAttempts: 0,
+      affectedStories: [],
+    };
+  }
+
+  logger?.info("regression", "Running deferred full-suite regression gate", {
+    totalStories: counts.total,
+    passedStories: passedStories.length,
+  });
+
+  // Step 1: Run full test suite
+  const fullSuiteResult = await _regressionDeps.runVerification({
+    workingDirectory: workdir,
+    command: testCommand,
+    timeoutSeconds,
+    forceExit: config.quality.forceExit,
+    detectOpenHandles: config.quality.detectOpenHandles,
+    detectOpenHandlesRetries: config.quality.detectOpenHandlesRetries,
+    timeoutRetryCount: 0,
+    gracePeriodMs: config.quality.gracePeriodMs,
+    drainTimeoutMs: config.quality.drainTimeoutMs,
+    shell: config.quality.shell,
+    stripEnvVars: config.quality.stripEnvVars,
+  });
+
+  if (fullSuiteResult.success) {
+    logger?.info("regression", "Full suite passed");
+    return {
+      success: true,
+      failedTests: 0,
+      passedTests: fullSuiteResult.passCount ?? 0,
+      rectificationAttempts: 0,
+      affectedStories: [],
+    };
+  }
+
+  // Handle timeout
+  const acceptOnTimeout = config.execution.regressionGate?.acceptOnTimeout ?? true;
+  if (fullSuiteResult.status === "TIMEOUT" && acceptOnTimeout) {
+    logger?.warn("regression", "Full-suite regression gate timed out (accepted as pass)");
+    return {
+      success: true,
+      failedTests: 0,
+      passedTests: 0,
+      rectificationAttempts: 0,
+      affectedStories: [],
+    };
+  }
+
+  if (!fullSuiteResult.output) {
+    logger?.error("regression", "Full suite failed with no output");
+    return {
+      success: false,
+      failedTests: fullSuiteResult.failCount ?? 0,
+      passedTests: fullSuiteResult.passCount ?? 0,
+      rectificationAttempts: 0,
+      affectedStories: [],
+    };
+  }
+
+  // Step 2: Parse failures and map to source files to stories
+  const testSummary = _regressionDeps.parseBunTestOutput(fullSuiteResult.output);
+  const affectedStories = new Set<string>();
+  const affectedStoriesObjs = new Map<string, UserStory>();
+
+  logger?.warn("regression", "Regression detected", {
+    failedTests: testSummary.failed,
+    passedTests: testSummary.passed,
+  });
+
+  // Extract test file paths from failures
+  const testFilesInFailures = new Set<string>();
+  for (const failure of testSummary.failures) {
+    if (failure.file) {
+      testFilesInFailures.add(failure.file);
+    }
+  }
+
+  if (testFilesInFailures.size === 0) {
+    logger?.warn("regression", "No test files found in failures (unmapped)");
+    // Mark all passed stories for re-verification
+    for (const story of passedStories) {
+      affectedStories.add(story.id);
+      affectedStoriesObjs.set(story.id, story);
+    }
+  } else {
+    // Map test files to source files to stories
+    const testFilesArray = Array.from(testFilesInFailures);
+    const sourceFilesArray = _regressionDeps.reverseMapTestToSource(testFilesArray, workdir);
+
+    logger?.info("regression", "Mapped test files to source files", {
+      testFiles: testFilesArray.length,
+      sourceFiles: sourceFilesArray.length,
+    });
+
+    for (const testFile of testFilesArray) {
+      const responsibleStory = await findResponsibleStory(testFile, workdir, passedStories);
+      if (responsibleStory) {
+        affectedStories.add(responsibleStory.id);
+        affectedStoriesObjs.set(responsibleStory.id, responsibleStory);
+      } else {
+        logger?.warn("regression", "Could not map test file to story", { testFile });
+      }
+    }
+  }
+
+  if (affectedStories.size === 0) {
+    logger?.warn("regression", "No stories could be mapped to failures");
+    return {
+      success: false,
+      failedTests: testSummary.failed,
+      passedTests: testSummary.passed,
+      rectificationAttempts: 0,
+      affectedStories: Array.from(affectedStories),
+    };
+  }
+
+  // Step 3: Attempt rectification per story
+  let rectificationAttempts = 0;
+  const affectedStoriesList = Array.from(affectedStoriesObjs.values());
+
+  for (const story of affectedStoriesList) {
+    for (let attempt = 0; attempt < maxRectificationAttempts; attempt++) {
+      rectificationAttempts++;
+
+      logger?.info("regression", `Rectifying story ${story.id} (attempt ${attempt + 1}/${maxRectificationAttempts})`);
+
+      const fixed = await _regressionDeps.runRectificationLoop({
+        config,
+        workdir,
+        story,
+        testCommand,
+        timeoutSeconds,
+        testOutput: fullSuiteResult.output,
+        promptPrefix: `# DEFERRED REGRESSION: Full-Suite Failures\n\nYour story ${story.id} broke tests in the full suite. Fix these regressions.`,
+      });
+
+      if (fixed) {
+        logger?.info("regression", `Story ${story.id} rectified successfully`);
+        break; // Move to next story
+      }
+    }
+  }
+
+  // Step 4: Re-run full suite to confirm
+  logger?.info("regression", "Re-running full suite after rectification");
+  const retryResult = await _regressionDeps.runVerification({
+    workingDirectory: workdir,
+    command: testCommand,
+    timeoutSeconds,
+    forceExit: config.quality.forceExit,
+    detectOpenHandles: config.quality.detectOpenHandles,
+    detectOpenHandlesRetries: config.quality.detectOpenHandlesRetries,
+    timeoutRetryCount: 0,
+    gracePeriodMs: config.quality.gracePeriodMs,
+    drainTimeoutMs: config.quality.drainTimeoutMs,
+    shell: config.quality.shell,
+    stripEnvVars: config.quality.stripEnvVars,
+  });
+
+  const success = retryResult.success || (retryResult.status === "TIMEOUT" && acceptOnTimeout);
+
+  if (success) {
+    logger?.info("regression", "Deferred regression gate passed after rectification");
+  } else {
+    logger?.warn("regression", "Deferred regression gate still failing after rectification", {
+      remainingFailures: retryResult.failCount,
+    });
+  }
+
+  return {
+    success,
+    failedTests: retryResult.failCount ?? 0,
+    passedTests: retryResult.passCount ?? 0,
+    rectificationAttempts,
+    affectedStories: Array.from(affectedStories),
+  };
+}

package/src/execution/lifecycle/run-setup.ts

@@ -122,20 +122,6 @@ export async function setupRun(options: RunSetupOptions): Promise<RunSetupResult
     getStoriesCompleted: options.getStoriesCompleted,
   });
 
-  // Acquire lock to prevent concurrent execution
-  const lockAcquired = await acquireLock(workdir);
-  if (!lockAcquired) {
-    logger?.error("execution", "Another nax process is already running in this directory");
-    logger?.error("execution", "If you believe this is an error, remove nax.lock manually");
-    throw new LockAcquisitionError(workdir);
-  }
-
-  // Load plugins (before try block so it's accessible in finally)
-  const globalPluginsDir = path.join(os.homedir(), ".nax", "plugins");
-  const projectPluginsDir = path.join(workdir, "nax", "plugins");
-  const configPlugins = config.plugins || [];
-  const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir);
-
   // Load PRD (before try block so it's accessible in finally for onRunEnd)
   let prd = await loadPRD(prdPath);
 
@@ -163,6 +149,20 @@ export async function setupRun(options: RunSetupOptions): Promise<RunSetupResult
     logger?.warn("precheck", "Precheck validations skipped (--skip-precheck)");
   }
 
+  // Acquire lock to prevent concurrent execution
+  const lockAcquired = await acquireLock(workdir);
+  if (!lockAcquired) {
+    logger?.error("execution", "Another nax process is already running in this directory");
+    logger?.error("execution", "If you believe this is an error, remove nax.lock manually");
+    throw new LockAcquisitionError(workdir);
+  }
+
+  // Load plugins (before try block so it's accessible in finally)
+  const globalPluginsDir = path.join(os.homedir(), ".nax", "plugins");
+  const projectPluginsDir = path.join(workdir, "nax", "plugins");
+  const configPlugins = config.plugins || [];
+  const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir);
+
   // Log plugins loaded
   logger?.info("plugins", `Loaded ${pluginRegistry.plugins.length} plugins`, {
     plugins: pluginRegistry.plugins.map((p) => ({ name: p.name, version: p.version, provides: p.provides })),

package/src/execution/parallel.ts

@@ -18,7 +18,7 @@ import type { PipelineContext, RoutingResult } from "../pipeline/types";
 import type { PluginRegistry } from "../plugins/registry";
 import type { PRD, UserStory } from "../prd";
 import { markStoryFailed, markStoryPassed, savePRD } from "../prd";
-import { routeTask } from "../routing";
+import { routeTask, tryLlmBatchRoute } from "../routing";
 import { WorktreeManager } from "../worktree/manager";
 import { MergeEngine, type StoryDependencies } from "../worktree/merge";
 

package/src/execution/pipeline-result-handler.ts

@@ -83,7 +83,6 @@ export async function handlePipelineSuccess(
     storiesToExecute: ctx.storiesToExecute,
     allStoryMetrics: ctx.allStoryMetrics,
     timeoutRetryCountMap: ctx.timeoutRetryCountMap,
-    storyGitRef: ctx.storyGitRef ?? undefined,
   });
   const verificationPassed = verifyResult.passed;
   prd = verifyResult.prd;