@nathapp/nax 0.18.2 → 0.18.4

package/test/unit/execution/post-verify-regression.test.ts

@@ -0,0 +1,415 @@
+/**
+ * BUG-026: Regression gate timeout accepts scoped pass instead of escalating
+ *
+ * Tests that runRegressionGate (via runPostAgentVerification):
+ * - Returns passed when regression gate TIMES OUT and acceptOnTimeout=true (default)
+ * - Returns failed when regression gate TIMES OUT and acceptOnTimeout=false
+ * - Returns failed when regression gate returns TEST_FAILURE (existing behavior unchanged)
+ * - Defaults acceptOnTimeout to true when not set in config
+ *
+ * These are behavioral tests that call the actual function with mocked dependencies.
+ * They complement the type-level tests already in post-verify.test.ts.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import type { NaxConfig } from "../../../src/config";
+import type { PRD, UserStory } from "../../../src/prd/types";
+import type { StoryMetrics } from "../../../src/metrics";
+import type { VerificationResult } from "../../../src/verification";
+
+// ---------------------------------------------------------------------------
+// Mock runVerification with call-order-based responses
+// ---------------------------------------------------------------------------
+
+type VerResult = Pick<VerificationResult, "success" | "status" | "countsTowardEscalation" | "output" | "error">;
+
+let _verificationResponses: VerResult[] = [];
+let _verificationCallIndex = 0;
+
+const mockRunVerification = mock(async (): Promise<VerResult> => {
+  const resp =
+    _verificationResponses[_verificationCallIndex] ??
+    _verificationResponses[_verificationResponses.length - 1];
+  _verificationCallIndex++;
+  return resp;
+});
+
+const mockRevertStoriesOnFailure = mock(async ({ prd }: { prd: PRD; [k: string]: unknown }) => prd);
+const mockRunRectificationLoop = mock(async () => false);
+
+// ---------------------------------------------------------------------------
+// Static imports — uses _postVerifyDeps pattern (no mock.module() needed)
+// ---------------------------------------------------------------------------
+
+import { _postVerifyDeps, runPostAgentVerification } from "../../../src/execution/post-verify";
+
+// ── Capture originals for afterEach restoration ───────────────────────────────
+const _origPostVerifyDeps = { ..._postVerifyDeps };
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+/** Run a git command in a directory using Bun-native spawn. */
+function gitSync(args: string[], cwd: string): void {
+  const proc = Bun.spawnSync(["git", ...args], { cwd, stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+  if (proc.exitCode !== 0) {
+    throw new Error(`git ${args[0]} failed in ${cwd}`);
+  }
+}
+
+/** Read stdout from a git command. */
+function gitOutput(args: string[], cwd: string): string {
+  const proc = Bun.spawnSync(["git", ...args], { cwd, stdin: "ignore", stdout: "pipe", stderr: "ignore" });
+  return new TextDecoder().decode(proc.stdout).trim();
+}
+
+/**
+ * Create a temp git repo with two commits so that `git diff storyGitRef HEAD`
+ * returns at least one test file — needed for the regression gate to activate.
+ */
+function makeGitRepo(): { dir: string; storyGitRef: string } {
+  const dir = mkdtempSync(join(tmpdir(), "nax-bug026-"));
+
+  gitSync(["init"], dir);
+  gitSync(["config", "user.email", "test@example.com"], dir);
+  gitSync(["config", "user.name", "test"], dir);
+
+  // Initial commit → becomes storyGitRef
+  writeFileSync(join(dir, "src.ts"), "export const x = 1;");
+  gitSync(["add", "."], dir);
+  gitSync(["commit", "-m", "initial"], dir);
+  const storyGitRef = gitOutput(["rev-parse", "HEAD"], dir);
+
+  // Second commit: adds a test file (changed after storyGitRef)
+  mkdirSync(join(dir, "test"), { recursive: true });
+  writeFileSync(
+    join(dir, "test", "example.test.ts"),
+    'import { test, expect } from "bun:test";\ntest("x", () => expect(1).toBe(1));',
+  );
+  gitSync(["add", "."], dir);
+  gitSync(["commit", "-m", "add test"], dir);
+
+  return { dir, storyGitRef };
+}
+
+function makeConfig(
+  regressionGateOverrides: Partial<NaxConfig["execution"]["regressionGate"]> = {},
+): NaxConfig {
+  return {
+    version: 1,
+    models: {
+      fast: "claude-sonnet-4-5",
+      balanced: "claude-sonnet-4-5",
+      powerful: "claude-opus-4-6",
+    },
+    autoMode: {
+      enabled: true,
+      defaultAgent: "nax-agent-claude",
+      fallbackOrder: ["nax-agent-claude"],
+      complexityRouting: {
+        simple: "fast",
+        medium: "balanced",
+        complex: "powerful",
+        expert: "powerful",
+      },
+      escalation: {
+        enabled: true,
+        tierOrder: [],
+      },
+    },
+    execution: {
+      maxIterations: 100,
+      iterationDelayMs: 0,
+      costLimit: 50,
+      sessionTimeoutSeconds: 600,
+      verificationTimeoutSeconds: 30,
+      maxStoriesPerFeature: 50,
+      smartTestRunner: false,
+      rectification: {
+        enabled: false,
+        maxRetries: 2,
+        fullSuiteTimeoutSeconds: 120,
+        maxFailureSummaryChars: 2000,
+        abortOnIncreasingFailures: true,
+      },
+      regressionGate: {
+        enabled: true,
+        timeoutSeconds: 120,
+        ...regressionGateOverrides,
+      },
+      contextProviderTokenBudget: 2000,
+    },
+    quality: {
+      requireTypecheck: false,
+      requireLint: false,
+      requireTests: true,
+      commands: { test: "bun test" },
+      forceExit: false,
+      detectOpenHandles: false,
+      detectOpenHandlesRetries: 0,
+      gracePeriodMs: 0,
+      drainTimeoutMs: 0,
+      shell: false,
+      stripEnvVars: [],
+      environmentalEscalationDivisor: 3,
+    },
+    tdd: {
+      maxRetries: 2,
+      autoVerifyIsolation: false,
+      strategy: "off",
+      autoApproveVerifier: false,
+    },
+    constitution: { enabled: false, path: "constitution.md", maxTokens: 2000 },
+    analyze: {
+      llmEnhanced: false,
+      model: "balanced",
+      fallbackToKeywords: true,
+      maxCodebaseSummaryTokens: 4000,
+    },
+    review: { enabled: false, checks: [], commands: {} },
+    plan: { model: "balanced", outputPath: "features" },
+    acceptance: { enabled: false, maxRetries: 2, generateTests: false, testPath: "acceptance.test.ts" },
+    routing: { strategy: "keyword" },
+    context: {
+      testCoverage: {
+        enabled: false,
+        detail: "names-only",
+        maxTokens: 500,
+        testPattern: "**/*.test.ts",
+        scopeToStory: false,
+      },
+      autoDetect: { enabled: false, maxFiles: 10, traceImports: false },
+    },
+  } as unknown as NaxConfig;
+}
+
+function makeStory(id = "US-001"): UserStory {
+  return {
+    id,
+    title: "Test story",
+    description: "Test",
+    acceptanceCriteria: [],
+    tags: [],
+    dependencies: [],
+    status: "in-progress",
+    passes: false,
+    escalations: [],
+    attempts: 0,
+    contextFiles: [],
+  } as unknown as UserStory;
+}
+
+function makePRD(story: UserStory): PRD {
+  return {
+    id: "prd-001",
+    title: "Test PRD",
+    userStories: [story],
+    version: "1.0",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  } as unknown as PRD;
+}
+
+function makeOpts(
+  workdir: string,
+  storyGitRef: string,
+  config: NaxConfig,
+  story: UserStory,
+  prd: PRD,
+) {
+  return {
+    config,
+    prd,
+    prdPath: join(workdir, "prd.json"),
+    workdir,
+    story,
+    storiesToExecute: [story],
+    allStoryMetrics: [] as StoryMetrics[],
+    timeoutRetryCountMap: new Map<string, number>(),
+    storyGitRef,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Test lifecycle
+// ---------------------------------------------------------------------------
+
+let tempDir: string;
+let storyGitRef: string;
+
+beforeEach(() => {
+  // Wire _postVerifyDeps to mocks
+  _postVerifyDeps.runVerification = mockRunVerification as typeof _postVerifyDeps.runVerification;
+  _postVerifyDeps.parseTestOutput = () => ({ passCount: 5, failCount: 0, isEnvironmentalFailure: false }) as any;
+  _postVerifyDeps.getEnvironmentalEscalationThreshold = () => 3;
+  _postVerifyDeps.revertStoriesOnFailure = mockRevertStoriesOnFailure as typeof _postVerifyDeps.revertStoriesOnFailure;
+  _postVerifyDeps.runRectificationLoop = mockRunRectificationLoop as typeof _postVerifyDeps.runRectificationLoop;
+  _postVerifyDeps.getExpectedFiles = () => [];
+  _postVerifyDeps.savePRD = mock(async () => {}) as typeof _postVerifyDeps.savePRD;
+  _postVerifyDeps.appendProgress = mock(async () => {}) as typeof _postVerifyDeps.appendProgress;
+  _postVerifyDeps.getTierConfig = () => undefined as any;
+  _postVerifyDeps.parseBunTestOutput = () => ({ failed: 0, passed: 5, failures: [] }) as any;
+  mockRunVerification.mockClear();
+  mockRevertStoriesOnFailure.mockClear();
+  mockRunRectificationLoop.mockClear();
+  _verificationResponses = [];
+  _verificationCallIndex = 0;
+
+  const repo = makeGitRepo();
+  tempDir = repo.dir;
+  storyGitRef = repo.storyGitRef;
+});
+
+afterEach(() => {
+  Object.assign(_postVerifyDeps, _origPostVerifyDeps);
+  mock.restore();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+// ---------------------------------------------------------------------------
+// BUG-026 behavioral tests
+// ---------------------------------------------------------------------------
+
+describe("BUG-026: regression gate TIMEOUT acceptance", () => {
+  test("TIMEOUT + acceptOnTimeout=true → runPostAgentVerification returns passed", async () => {
+    // Call 1: scoped verification passes; Call 2: regression gate times out
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TIMEOUT", countsTowardEscalation: false },
+    ];
+
+    const config = makeConfig({ acceptOnTimeout: true });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    const result = await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(result.passed).toBe(true);
+  });
+
+  test("TIMEOUT + acceptOnTimeout=true → revertStoriesOnFailure is NOT called", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TIMEOUT", countsTowardEscalation: false },
+    ];
+
+    const config = makeConfig({ acceptOnTimeout: true });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(mockRevertStoriesOnFailure).not.toHaveBeenCalled();
+  });
+
+  test("TIMEOUT + acceptOnTimeout=false → runPostAgentVerification returns failed", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TIMEOUT", countsTowardEscalation: false },
+    ];
+
+    const config = makeConfig({ acceptOnTimeout: false });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    const result = await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(result.passed).toBe(false);
+  });
+
+  test("TIMEOUT + acceptOnTimeout=false → revertStoriesOnFailure IS called", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TIMEOUT", countsTowardEscalation: false },
+    ];
+
+    const config = makeConfig({ acceptOnTimeout: false });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(mockRevertStoriesOnFailure).toHaveBeenCalledTimes(1);
+  });
+
+  test("TIMEOUT + acceptOnTimeout not set → defaults to true → returns passed", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TIMEOUT", countsTowardEscalation: false },
+    ];
+
+    // No acceptOnTimeout — should default to true per BUG-026 spec
+    const config = makeConfig({});
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    const result = await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(result.passed).toBe(true);
+  });
+
+  test("TEST_FAILURE in regression gate → returns failed regardless of acceptOnTimeout", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TEST_FAILURE", countsTowardEscalation: true, output: "FAIL 1" },
+    ];
+
+    const config = makeConfig({ acceptOnTimeout: true });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    const result = await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(result.passed).toBe(false);
+  });
+
+  test("TEST_FAILURE in regression gate → revertStoriesOnFailure IS called", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TEST_FAILURE", countsTowardEscalation: true, output: "FAIL 1" },
+    ];
+
+    const config = makeConfig({ acceptOnTimeout: true });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(mockRevertStoriesOnFailure).toHaveBeenCalledTimes(1);
+  });
+
+  test("regression gate runs second → runVerification called twice (scoped + full suite)", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+      { success: false, status: "TIMEOUT", countsTowardEscalation: false },
+    ];
+
+    const config = makeConfig({ acceptOnTimeout: true });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    // Once for scoped verification, once for regression gate
+    expect(mockRunVerification).toHaveBeenCalledTimes(2);
+  });
+
+  test("regression gate disabled → only scoped test runs (one call to runVerification)", async () => {
+    _verificationResponses = [
+      { success: true, status: "SUCCESS", countsTowardEscalation: true, output: "pass 5" },
+    ];
+
+    const config = makeConfig({ enabled: false, timeoutSeconds: 120 });
+    const story = makeStory();
+    const prd = makePRD(story);
+
+    const result = await runPostAgentVerification(makeOpts(tempDir, storyGitRef, config, story, prd));
+
+    expect(result.passed).toBe(true);
+    expect(mockRunVerification).toHaveBeenCalledTimes(1);
+  });
+});

package/test/{execution → unit/execution}/post-verify.test.ts

@@ -8,7 +8,7 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import type { RegressionGateConfig } from "../../src/config/schema";
+import type { RegressionGateConfig } from "../../../src/config/schema";
 
 describe("RegressionGateConfig", () => {
   test("should have correct default values", () => {
@@ -146,6 +146,38 @@ describe("Regression Gate Timeout", () => {
     expect(regressionGateTimeoutSeconds).not.toBe(verificationTimeoutSeconds);
     expect(regressionGateTimeoutSeconds).toBeLessThan(verificationTimeoutSeconds);
   });
+
+  test("should have acceptOnTimeout config option (BUG-026)", () => {
+    const regressionGateConfig: RegressionGateConfig = {
+      enabled: true,
+      timeoutSeconds: 120,
+      acceptOnTimeout: true,
+    };
+
+    expect(regressionGateConfig.acceptOnTimeout).toBe(true);
+  });
+
+  test("should default acceptOnTimeout to true (BUG-026)", () => {
+    const regressionGateConfig: RegressionGateConfig = {
+      enabled: true,
+      timeoutSeconds: 120,
+      // acceptOnTimeout not specified - should default to true
+    };
+
+    // When acceptOnTimeout is undefined, it should be treated as true
+    const acceptOnTimeout = regressionGateConfig.acceptOnTimeout ?? true;
+    expect(acceptOnTimeout).toBe(true);
+  });
+
+  test("should allow disabling acceptOnTimeout (BUG-026)", () => {
+    const regressionGateConfig: RegressionGateConfig = {
+      enabled: true,
+      timeoutSeconds: 120,
+      acceptOnTimeout: false,
+    };
+
+    expect(regressionGateConfig.acceptOnTimeout).toBe(false);
+  });
 });
 
 describe("Story State After Regression Failure", () => {

package/test/unit/pipeline/routing-partial-override.test.ts

@@ -6,13 +6,14 @@
  * a fresh classification.
  */
 
-import { beforeEach, afterEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { initLogger, resetLogger } from "../../../src/logger";
-import type { PipelineContext } from "../../../src/pipeline/types";
+import { _routingDeps, routingStage } from "../../../src/pipeline/stages/routing";
 import type { NaxConfig } from "../../../src/config";
+import type { PipelineContext } from "../../../src/pipeline/types";
 import type { UserStory } from "../../../src/prd/types";
 
-// ── Module mocks (must be declared before dynamic imports) ────────────────────
+// ── Mock functions ────────────────────────────────────────────────────────────
 
 const mockRouteStory = mock(async () => ({
   complexity: "medium",
@@ -22,26 +23,11 @@ const mockRouteStory = mock(async () => ({
 }));
 
 const mockComplexityToModelTier = mock((_complexity: string, _config: unknown) => "balanced" as const);
+const mockIsGreenfieldStory = mock(async () => false);
 
-mock.module("../../../src/routing", () => ({
-  routeStory: mockRouteStory,
-  complexityToModelTier: mockComplexityToModelTier,
-}));
-
-// Greenfield check: return false so it never interferes with test strategy
-mock.module("../../../src/context/greenfield", () => ({
-  isGreenfieldStory: mock(async () => false),
-}));
-
-// LLM batch cache is not relevant here
-mock.module("../../../src/routing/strategies/llm", () => ({
-  clearCache: mock(() => {}),
-  routeBatch: mock(async () => []),
-}));
-
-// ── Dynamic imports after mocks ───────────────────────────────────────────────
+// ── Capture originals for afterEach restoration ───────────────────────────────
 
-const { routingStage } = await import("../../../src/pipeline/stages/routing");
+const _origDeps = { ..._routingDeps };
 
 // ── Fixtures ──────────────────────────────────────────────────────────────────
 
@@ -58,11 +44,9 @@ function makeStory(routingOverride?: Partial<UserStory["routing"]>): UserStory {
     tags: [],
     dependencies: [],
   };
-
   if (routingOverride !== undefined) {
     story.routing = routingOverride as UserStory["routing"];
   }
-
   return story;
 }
 
@@ -82,16 +66,22 @@ function makeCtx(story: UserStory): PipelineContext {
   } as PipelineContext;
 }
 
-// ── Logger setup ──────────────────────────────────────────────────────────────
+// ── Lifecycle ─────────────────────────────────────────────────────────────────
 
 beforeEach(() => {
   resetLogger();
   initLogger({ level: "error", useChalk: false });
+  _routingDeps.routeStory = mockRouteStory as typeof _routingDeps.routeStory;
+  _routingDeps.complexityToModelTier = mockComplexityToModelTier as typeof _routingDeps.complexityToModelTier;
+  _routingDeps.isGreenfieldStory = mockIsGreenfieldStory as typeof _routingDeps.isGreenfieldStory;
   mockRouteStory.mockClear();
   mockComplexityToModelTier.mockClear();
+  mockIsGreenfieldStory.mockClear();
 });
 
 afterEach(() => {
+  Object.assign(_routingDeps, _origDeps);
+  mock.restore();
   resetLogger();
 });
 
@@ -99,42 +89,31 @@ afterEach(() => {
 
 describe("routing stage — partial override (FIX-001)", () => {
   test("(1) partial override with only testStrategy preserves LLM complexity", async () => {
-    // Story sets only testStrategy — complexity should come from LLM
     const story = makeStory({ testStrategy: "test-after", complexity: undefined as any, reasoning: "manual" });
     const ctx = makeCtx(story);
 
     await routingStage.execute(ctx);
 
-    // testStrategy is overridden by the story field
     expect(ctx.routing.testStrategy).toBe("test-after");
-    // complexity should remain from the LLM result ("medium"), not undefined
     expect(ctx.routing.complexity).toBe("medium");
   });
 
   test("(2) LLM-classified complexity is preserved when story.routing has no complexity", async () => {
-    // story.routing is present but complexity is undefined (falsy)
     const story = makeStory({ testStrategy: "test-after", complexity: undefined as any, reasoning: "" });
     const ctx = makeCtx(story);
 
     await routingStage.execute(ctx);
 
-    // LLM returned "medium" — it must not be overwritten with undefined
     expect(ctx.routing.complexity).toBe("medium");
     expect(ctx.routing.complexity).not.toBeUndefined();
   });
 
   test("(3) full override works when both complexity and testStrategy are set", async () => {
-    // Story has explicit values for both fields
-    const story = makeStory({
-      complexity: "simple",
-      testStrategy: "test-after",
-      reasoning: "manual override",
-    });
+    const story = makeStory({ complexity: "simple", testStrategy: "test-after", reasoning: "manual override" });
     const ctx = makeCtx(story);
 
     await routingStage.execute(ctx);
 
-    // Both fields should be overridden from the story
     expect(ctx.routing.complexity).toBe("simple");
     expect(ctx.routing.testStrategy).toBe("test-after");
   });

package/test/unit/pipeline/verify-smart-runner.test.ts

@@ -23,20 +23,18 @@ import type { PRD, UserStory } from "../../../src/prd/types";
 
 const mockRegression = mock(async () => ({ success: true, status: "SUCCESS" as const }));
 
-mock.module("../../../src/verification/gate", () => ({
-  regression: mockRegression,
-}));
+// ---- Static imports — no mock.module() needed (uses _deps pattern) ----------
+import { _verifyDeps, verifyStage } from "../../../src/pipeline/stages/verify";
 
 // ---- Capture originals for afterEach restoration ----------------------------
 const _origDeps = { ..._smartRunnerDeps };
-
-// ---- Dynamic import after gate mock -----------------------------------------
-const { verifyStage } = await import("../../../src/pipeline/stages/verify");
+const _origVerifyDeps = { ..._verifyDeps };
 
 // ---- Mock functions ---------------------------------------------------------
 
 const mockGetChangedSourceFiles = mock(async (_workdir: string) => [] as string[]);
 const mockMapSourceToTests = mock(async (_files: string[], _workdir: string) => [] as string[]);
+const mockImportGrepFallback = mock(async (_files: string[], _workdir: string, _patterns: string[]) => [] as string[]);
 const mockBuildSmartTestCommand = mock((testFiles: string[], baseCommand: string) => {
   if (testFiles.length === 0) return baseCommand;
   return `${baseCommand.split(" ").slice(0, -1).join(" ")} ${testFiles.join(" ")}`;
@@ -157,16 +155,20 @@ describe("Verify Stage --- Smart Runner Integration", () => {
     initLogger({ level: "error", useChalk: false });
     _smartRunnerDeps.getChangedSourceFiles = mockGetChangedSourceFiles;
     _smartRunnerDeps.mapSourceToTests = mockMapSourceToTests;
+    _smartRunnerDeps.importGrepFallback = mockImportGrepFallback;
     _smartRunnerDeps.buildSmartTestCommand = mockBuildSmartTestCommand;
+    _verifyDeps.regression = mockRegression as typeof _verifyDeps.regression;
     mockRegression.mockClear();
     mockGetChangedSourceFiles.mockClear();
     mockMapSourceToTests.mockClear();
+    mockImportGrepFallback.mockClear();
     mockBuildSmartTestCommand.mockClear();
   });
 
   afterEach(() => {
     resetLogger();
     Object.assign(_smartRunnerDeps, _origDeps);
+    Object.assign(_verifyDeps, _origVerifyDeps);
   });
 
   describe("AC1: uses scoped test command when smart runner finds test files", () => {

package/test/unit/prd-get-next-story.test.ts

@@ -183,4 +183,32 @@ describe("getNextStory() — run order S1-I1 -> S1-I2 (retry) -> S2-I1", () => {
     const pick2 = getNextStory(prd, lastId, maxRetries);
     expect(pick2?.id).toBe("US-002");
   });
+
+  test("BUG-029: prioritizes escalated story (pending + attempts > 0) over other pending stories", () => {
+    const prd = makePrd([makeStory("US-001"), makeStory("US-002"), makeStory("US-003")]);
+    const maxRetries = 2;
+
+    // Simulate: US-001 was escalated — status reset to "pending" but has prior attempts
+    prd.userStories[0].status = "pending";
+    prd.userStories[0].attempts = 1;
+    prd.userStories[0].routing = { complexity: "simple", modelTier: "balanced", testStrategy: "test-after" };
+
+    // getNextStory should prioritize US-001 (escalated, pending with attempts)
+    const pick = getNextStory(prd, "US-001", maxRetries);
+    expect(pick?.id).toBe("US-001");
+  });
+
+  test("BUG-029: does not reprioritize story with 0 attempts (fresh pending)", () => {
+    const prd = makePrd([makeStory("US-001"), makeStory("US-002")]);
+    const maxRetries = 2;
+
+    // US-001 is fresh pending (no prior attempts) — normal ordering applies
+    prd.userStories[0].status = "pending";
+    prd.userStories[0].attempts = 0;
+
+    // Should still pick US-001 (first pending), but via normal path not escalation path
+    const pick = getNextStory(prd, "US-002", maxRetries);
+    expect(pick?.id).toBe("US-001");
+  });
+
 });