@nathapp/nax 0.49.3 → 0.49.6

package/src/tdd/rectification-gate.ts

@@ -7,6 +7,7 @@
  */
 
 import type { AgentAdapter } from "../agents";
+import { buildSessionName } from "../agents/acp/adapter";
 import type { ModelTier, NaxConfig } from "../config";
 import { resolveModel } from "../config";
 import { resolvePermissions } from "../config/permissions";
@@ -14,15 +15,23 @@ import type { getLogger } from "../logger";
 import type { UserStory } from "../prd";
 import { autoCommitIfDirty, captureGitRef } from "../utils/git";
 import {
+  type parseBunTestOutput as ParseBunTestOutputType,
   type RectificationState,
-  executeWithTimeout,
-  parseBunTestOutput,
-  shouldRetryRectification,
+  executeWithTimeout as _executeWithTimeout,
+  parseBunTestOutput as _parseBunTestOutput,
+  shouldRetryRectification as _shouldRetryRectification,
 } from "../verification";
 import { cleanupProcessTree } from "./cleanup";
 import { verifyImplementerIsolation } from "./isolation";
 import { buildImplementerRectificationPrompt } from "./prompts";
 
+/** Injectable deps for testability — avoids mock.module() contamination */
+export const _rectificationGateDeps = {
+  executeWithTimeout: _executeWithTimeout,
+  parseBunTestOutput: _parseBunTestOutput,
+  shouldRetryRectification: _shouldRetryRectification,
+};
+
 /**
  * Run full test suite gate before verifier session (v0.11 Rectification).
  */
@@ -49,11 +58,13 @@ export async function runFullSuiteGate(
     timeout: fullSuiteTimeout,
   });
 
-  const fullSuiteResult = await executeWithTimeout(testCmd, fullSuiteTimeout, undefined, { cwd: workdir });
+  const fullSuiteResult = await _rectificationGateDeps.executeWithTimeout(testCmd, fullSuiteTimeout, undefined, {
+    cwd: workdir,
+  });
   const fullSuitePassed = fullSuiteResult.success && fullSuiteResult.exitCode === 0;
 
   if (!fullSuitePassed && fullSuiteResult.output) {
-    const testSummary = parseBunTestOutput(fullSuiteResult.output);
+    const testSummary = _rectificationGateDeps.parseBunTestOutput(fullSuiteResult.output);
 
     if (testSummary.failed > 0) {
       return await runRectificationLoop(
@@ -117,7 +128,7 @@ async function runRectificationLoop(
   contextMarkdown: string | undefined,
   lite: boolean,
   logger: ReturnType<typeof getLogger>,
-  testSummary: ReturnType<typeof parseBunTestOutput>,
+  testSummary: ReturnType<typeof _parseBunTestOutput>,
   rectificationConfig: NonNullable<NaxConfig["execution"]["rectification"]>,
   testCmd: string,
   fullSuiteTimeout: number,
@@ -135,9 +146,19 @@ async function runRectificationLoop(
     passedTests: testSummary.passed,
   });
 
-  while (shouldRetryRectification(rectificationState, rectificationConfig)) {
+  // Build session name once so all rectification attempts share the same ACP session.
+  // This preserves full conversation context across retries (the agent knows what it already tried).
+  const rectificationSessionName = buildSessionName(workdir, featureName, story.id, "implementer");
+  logger.debug("tdd", "Rectification session name (shared across all attempts)", {
+    storyId: story.id,
+    sessionName: rectificationSessionName,
+  });
+
+  while (_rectificationGateDeps.shouldRetryRectification(rectificationState, rectificationConfig)) {
     rectificationState.attempt++;
 
+    const isLastAttempt = rectificationState.attempt >= rectificationConfig.maxRetries;
+
     logger.info(
       "tdd",
       `-> Implementer rectification attempt ${rectificationState.attempt}/${rectificationConfig.maxRetries}`,
@@ -166,6 +187,12 @@ async function runRectificationLoop(
       featureName,
       storyId: story.id,
       sessionRole: "implementer",
+      // Reuse the same ACP session across all rectification attempts so the agent
+      // retains full conversation context (knows what it already tried).
+      acpSessionName: rectificationSessionName,
+      // Keep session open until the last attempt — the session sweep at run end
+      // will handle cleanup. On the last attempt, let the adapter close normally.
+      keepSessionOpen: !isLastAttempt,
     });
 
     if (!rectifyResult.success && rectifyResult.pid) {
@@ -201,7 +228,9 @@ async function runRectificationLoop(
       break;
     }
 
-    const retryFullSuite = await executeWithTimeout(testCmd, fullSuiteTimeout, undefined, { cwd: workdir });
+    const retryFullSuite = await _rectificationGateDeps.executeWithTimeout(testCmd, fullSuiteTimeout, undefined, {
+      cwd: workdir,
+    });
     const retrySuitePassed = retryFullSuite.success && retryFullSuite.exitCode === 0;
 
     if (retrySuitePassed) {
@@ -213,7 +242,7 @@ async function runRectificationLoop(
     }
 
     if (retryFullSuite.output) {
-      const newTestSummary = parseBunTestOutput(retryFullSuite.output);
+      const newTestSummary = _rectificationGateDeps.parseBunTestOutput(retryFullSuite.output);
       rectificationState.currentFailures = newTestSummary.failed;
       testSummary.failures = newTestSummary.failures;
       testSummary.failed = newTestSummary.failed;
@@ -227,7 +256,9 @@ async function runRectificationLoop(
     });
   }
 
-  const finalFullSuite = await executeWithTimeout(testCmd, fullSuiteTimeout, undefined, { cwd: workdir });
+  const finalFullSuite = await _rectificationGateDeps.executeWithTimeout(testCmd, fullSuiteTimeout, undefined, {
+    cwd: workdir,
+  });
   const finalSuitePassed = finalFullSuite.success && finalFullSuite.exitCode === 0;
 
   if (!finalSuitePassed) {

package/src/tdd/session-runner.ts

@@ -12,17 +12,39 @@ import { getLogger } from "../logger";
 import type { UserStory } from "../prd";
 import { PromptBuilder } from "../prompts";
 import { autoCommitIfDirty as _autoCommitIfDirtyFn } from "../utils/git";
-import { cleanupProcessTree } from "./cleanup";
-
+import { captureGitRef as _captureGitRef } from "../utils/git";
+import { cleanupProcessTree as _cleanupProcessTree } from "./cleanup";
 /**
  * Injectable dependencies for session-runner — allows tests to mock
  * autoCommitIfDirty without going through internal git deps.
  * @internal
  */
+import {
+  getChangedFiles as _getChangedFiles,
+  verifyImplementerIsolation as _verifyImplementerIsolation,
+  verifyTestWriterIsolation as _verifyTestWriterIsolation,
+} from "./isolation";
+
 export const _sessionRunnerDeps = {
   autoCommitIfDirty: _autoCommitIfDirtyFn,
+  spawn: Bun.spawn as typeof Bun.spawn,
+  getChangedFiles: _getChangedFiles,
+  verifyTestWriterIsolation: _verifyTestWriterIsolation,
+  verifyImplementerIsolation: _verifyImplementerIsolation,
+  captureGitRef: _captureGitRef,
+  cleanupProcessTree: _cleanupProcessTree,
+  buildPrompt: null as
+    | null
+    | ((
+        role: TddSessionRole,
+        config: NaxConfig,
+        story: UserStory,
+        workdir: string,
+        contextMarkdown?: string,
+        lite?: boolean,
+        constitution?: string,
+      ) => Promise<string>),
 };
-import { getChangedFiles, verifyImplementerIsolation, verifyTestWriterIsolation } from "./isolation";
 import type { IsolationCheck } from "./types";
 import type { TddSessionResult, TddSessionRole } from "./types";
 
@@ -53,7 +75,7 @@ export async function rollbackToRef(workdir: string, ref: string): Promise<void>
   const logger = getLogger();
   logger.warn("tdd", "Rolling back git changes", { ref });
 
-  const resetProc = Bun.spawn(["git", "reset", "--hard", ref], {
+  const resetProc = _sessionRunnerDeps.spawn(["git", "reset", "--hard", ref], {
     cwd: workdir,
     stdout: "pipe",
     stderr: "pipe",
@@ -66,7 +88,7 @@ export async function rollbackToRef(workdir: string, ref: string): Promise<void>
     throw new Error(`Git rollback failed: ${stderr}`);
   }
 
-  const cleanProc = Bun.spawn(["git", "clean", "-fd"], {
+  const cleanProc = _sessionRunnerDeps.spawn(["git", "clean", "-fd"], {
     cwd: workdir,
     stdout: "pipe",
     stderr: "pipe",
@@ -98,41 +120,51 @@ export async function runTddSession(
 ): Promise<TddSessionResult> {
   const startTime = Date.now();
 
-  // Build prompt based on role and mode (lite vs strict)
+  // Build prompt — use injectable buildPrompt if set, otherwise default PromptBuilder
   let prompt: string;
-  switch (role) {
-    case "test-writer":
-      prompt = await PromptBuilder.for("test-writer", { isolation: lite ? "lite" : "strict" })
-        .withLoader(workdir, config)
-        .story(story)
-        .context(contextMarkdown)
-        .constitution(constitution)
-        .testCommand(config.quality?.commands?.test)
-        .build();
-      break;
-    case "implementer":
-      prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" })
-        .withLoader(workdir, config)
-        .story(story)
-        .context(contextMarkdown)
-        .constitution(constitution)
-        .testCommand(config.quality?.commands?.test)
-        .build();
-      break;
-    case "verifier":
-      prompt = await PromptBuilder.for("verifier")
-        .withLoader(workdir, config)
-        .story(story)
-        .context(contextMarkdown)
-        .constitution(constitution)
-        .testCommand(config.quality?.commands?.test)
-        .build();
-      break;
+  if (_sessionRunnerDeps.buildPrompt) {
+    prompt = await _sessionRunnerDeps.buildPrompt(role, config, story, workdir, contextMarkdown, lite, constitution);
+  } else {
+    switch (role) {
+      case "test-writer":
+        prompt = await PromptBuilder.for("test-writer", { isolation: lite ? "lite" : "strict" })
+          .withLoader(workdir, config)
+          .story(story)
+          .context(contextMarkdown)
+          .constitution(constitution)
+          .testCommand(config.quality?.commands?.test)
+          .build();
+        break;
+      case "implementer":
+        prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" })
+          .withLoader(workdir, config)
+          .story(story)
+          .context(contextMarkdown)
+          .constitution(constitution)
+          .testCommand(config.quality?.commands?.test)
+          .build();
+        break;
+      case "verifier":
+        prompt = await PromptBuilder.for("verifier")
+          .withLoader(workdir, config)
+          .story(story)
+          .context(contextMarkdown)
+          .constitution(constitution)
+          .testCommand(config.quality?.commands?.test)
+          .build();
+        break;
+    }
   }
 
   const logger = getLogger();
   logger.info("tdd", `-> Session: ${role}`, { role, storyId: story.id, lite });
 
+  // When rectification is enabled, keep the implementer session open after it finishes.
+  // The rectification gate uses the same session name (buildSessionName + "implementer")
+  // and will resume it directly — so the implementer retains full context of what it built.
+  // The session sweep (or the last rectification attempt) handles final cleanup.
+  const keepSessionOpen = role === "implementer" && (config.execution.rectification?.enabled ?? false);
+
   // Run the agent
   const result = await agent.run({
     prompt,
@@ -147,11 +179,12 @@ export async function runTddSession(
     featureName,
     storyId: story.id,
     sessionRole: role,
+    keepSessionOpen,
   });
 
   // BUG-21 Fix: Clean up orphaned child processes if agent failed
   if (!result.success && result.pid) {
-    await cleanupProcessTree(result.pid);
+    await _sessionRunnerDeps.cleanupProcessTree(result.pid);
   }
 
   if (result.success) {
@@ -178,14 +211,14 @@ export async function runTddSession(
   if (!skipIsolation) {
     if (role === "test-writer") {
       const allowedPaths = config.tdd.testWriterAllowedPaths ?? ["src/index.ts", "src/**/index.ts"];
-      isolation = await verifyTestWriterIsolation(workdir, beforeRef, allowedPaths);
+      isolation = await _sessionRunnerDeps.verifyTestWriterIsolation(workdir, beforeRef, allowedPaths);
     } else if (role === "implementer" || role === "verifier") {
-      isolation = await verifyImplementerIsolation(workdir, beforeRef);
+      isolation = await _sessionRunnerDeps.verifyImplementerIsolation(workdir, beforeRef);
     }
   }
 
   // Get changed files
-  const filesChanged = await getChangedFiles(workdir, beforeRef);
+  const filesChanged = await _sessionRunnerDeps.getChangedFiles(workdir, beforeRef);
 
   const durationMs = Date.now() - startTime;
 

package/src/verification/executor.ts

@@ -9,6 +9,9 @@ import type { Subprocess } from "bun";
 import { errorMessage } from "../utils/errors";
 import type { TestExecutionResult } from "./types";
 
+/** Injectable deps for testability — mock _executorDeps.spawn instead of global Bun.spawn */
+export const _executorDeps = { spawn: Bun.spawn as typeof Bun.spawn };
+
 /**
  * Drain stdout+stderr from a killed Bun subprocess with a hard deadline.
  *
@@ -92,7 +95,7 @@ export async function executeWithTimeout(
   const gracePeriodMs = options?.gracePeriodMs ?? 5000;
   const drainTimeoutMs = options?.drainTimeoutMs ?? 2000;
 
-  const proc = Bun.spawn([shell, "-c", command], {
+  const proc = _executorDeps.spawn([shell, "-c", command], {
     stdout: "pipe",
     stderr: "pipe",
     env: env || normalizeEnvironment(process.env as Record<string, string | undefined>),

package/src/verification/strategies/acceptance.ts

@@ -11,6 +11,9 @@ import { getLogger } from "../../logger";
 import type { IVerificationStrategy, VerifyContext, VerifyResult } from "../orchestrator-types";
 import { makeFailResult, makePassResult, makeSkippedResult } from "../orchestrator-types";
 
+/** Injectable deps for testability */
+export const _acceptanceDeps = { spawn: Bun.spawn as typeof Bun.spawn };
+
 function parseFailedACs(output: string): string[] {
   const failed: string[] = [];
   for (const line of output.split("\n")) {
@@ -51,7 +54,7 @@ export class AcceptanceStrategy implements IVerificationStrategy {
 
     const start = Date.now();
     const timeoutMs = ctx.timeoutSeconds * 1000;
-    const proc = Bun.spawn(["bun", "test", testPath], {
+    const proc = _acceptanceDeps.spawn(["bun", "test", testPath], {
       cwd: ctx.workdir,
       stdout: "pipe",
       stderr: "pipe",