@nathapp/nax 0.36.1 → 0.37.0

package/src/pipeline/stages/verify.ts

@@ -11,6 +11,7 @@
 
 import type { SmartTestRunnerConfig } from "../../config/types";
 import { getLogger } from "../../logger";
+import { detectRuntimeCrash } from "../../verification/crash-detector";
 import type { VerifyStatus } from "../../verification/orchestrator-types";
 import { regression } from "../../verification/runners";
 import { _smartRunnerDeps } from "../../verification/smart-runner";
@@ -133,7 +134,13 @@ export const verifyStage: PipelineStage = {
     // Store result on context for rectify stage
     ctx.verifyResult = {
       success: result.success,
-      status: (result.status === "TIMEOUT" ? "TIMEOUT" : result.success ? "PASS" : "TEST_FAILURE") as VerifyStatus,
+      status: (result.status === "TIMEOUT"
+        ? "TIMEOUT"
+        : result.success
+          ? "PASS"
+          : detectRuntimeCrash(result.output)
+            ? "RUNTIME_CRASH"
+            : "TEST_FAILURE") as VerifyStatus,
       storyId: ctx.story.id,
       strategy: "scoped",
       passCount: result.passCount ?? 0,

package/src/pipeline/subscribers/reporters.ts

@@ -74,7 +74,7 @@ export function wireReporters(
                 runId,
                 storyId: ev.storyId,
                 status: "completed",
-                durationMs: ev.durationMs,
+                runElapsedMs: ev.runElapsedMs,
                 cost: ev.cost ?? 0,
                 tier: ev.modelTier ?? "balanced",
                 testStrategy: ev.testStrategy ?? "test-after",
@@ -100,7 +100,7 @@ export function wireReporters(
                 runId,
                 storyId: ev.storyId,
                 status: "failed",
-                durationMs: Date.now() - startTime,
+                runElapsedMs: Date.now() - startTime,
                 cost: 0,
                 tier: "balanced",
                 testStrategy: "test-after",
@@ -126,7 +126,7 @@ export function wireReporters(
                 runId,
                 storyId: ev.storyId,
                 status: "paused",
-                durationMs: Date.now() - startTime,
+                runElapsedMs: Date.now() - startTime,
                 cost: 0,
                 tier: "balanced",
                 testStrategy: "test-after",

package/src/pipeline/types.ts

@@ -110,8 +110,12 @@ export interface PipelineContext {
   tddFailureCategory?: FailureCategory;
   /** Set to true when TDD full-suite gate already passed — verify stage skips to avoid redundant run (BUG-054) */
   fullSuiteGatePassed?: boolean;
+  /** Number of runtime crashes (RUNTIME_CRASH verify status) encountered for this story (BUG-070) */
+  storyRuntimeCrashes?: number;
   /** Structured review findings from plugin reviewers — passed to escalation for retry context */
   reviewFindings?: import("../plugins/types").ReviewFinding[];
+  /** Accumulated cost across all prior escalation attempts (BUG-067) */
+  accumulatedAttemptCost?: number;
 }
 
 /**

package/src/plugins/types.ts

@@ -274,7 +274,7 @@ export interface StoryCompleteEvent {
   runId: string;
   storyId: string;
   status: "completed" | "failed" | "skipped" | "paused";
-  durationMs: number;
+  runElapsedMs: number;
   cost: number;
   tier: string;
   testStrategy: string;

package/src/prd/types.ts

@@ -49,6 +49,8 @@ export interface StructuredFailure {
   testFailures?: TestFailureContext[];
   /** Structured review findings from plugin reviewers (e.g., semgrep, eslint) */
   reviewFindings?: import("../plugins/types").ReviewFinding[];
+  /** Estimated cost of this attempt (BUG-067: accumulated across escalations) */
+  cost?: number;
   /** ISO timestamp when failure was recorded */
   timestamp: string;
 }

package/src/review/orchestrator.ts

@@ -15,16 +15,28 @@ import type { PluginRegistry } from "../plugins";
 import { runReview } from "./runner";
 import type { ReviewConfig, ReviewResult } from "./types";
 
-async function getChangedFiles(workdir: string): Promise<string[]> {
+async function getChangedFiles(workdir: string, baseRef?: string): Promise<string[]> {
   try {
-    const [stagedProc, unstagedProc] = [
-      spawn({ cmd: ["git", "diff", "--name-only", "--cached"], cwd: workdir, stdout: "pipe", stderr: "pipe" }),
-      spawn({ cmd: ["git", "diff", "--name-only"], cwd: workdir, stdout: "pipe", stderr: "pipe" }),
+    const diffArgs = ["diff", "--name-only"];
+    const [stagedProc, unstagedProc, baseProc] = [
+      spawn({ cmd: ["git", ...diffArgs, "--cached"], cwd: workdir, stdout: "pipe", stderr: "pipe" }),
+      spawn({ cmd: ["git", ...diffArgs], cwd: workdir, stdout: "pipe", stderr: "pipe" }),
+      baseRef
+        ? spawn({ cmd: ["git", ...diffArgs, `${baseRef}...HEAD`], cwd: workdir, stdout: "pipe", stderr: "pipe" })
+        : null,
     ];
-    await Promise.all([stagedProc.exited, unstagedProc.exited]);
-    const staged = (await new Response(stagedProc.stdout).text()).trim().split("\n").filter(Boolean);
-    const unstaged = (await new Response(unstagedProc.stdout).text()).trim().split("\n").filter(Boolean);
-    return Array.from(new Set([...staged, ...unstaged]));
+
+    await Promise.all([stagedProc.exited, unstagedProc.exited, baseProc?.exited]);
+
+    const [staged, unstaged, based] = await Promise.all([
+      new Response(stagedProc.stdout).text().then((t) => t.trim().split("\n").filter(Boolean)),
+      new Response(unstagedProc.stdout).text().then((t) => t.trim().split("\n").filter(Boolean)),
+      baseProc
+        ? new Response(baseProc.stdout).text().then((t) => t.trim().split("\n").filter(Boolean))
+        : Promise.resolve([]),
+    ]);
+
+    return Array.from(new Set([...staged, ...unstaged, ...based]));
   } catch {
     return [];
   }
@@ -60,7 +72,10 @@ export class ReviewOrchestrator {
     if (plugins) {
       const reviewers = plugins.getReviewers();
       if (reviewers.length > 0) {
-        const changedFiles = await getChangedFiles(workdir);
+        // Use the story's start ref if available to capture auto-committed changes
+        // biome-ignore lint/suspicious/noExplicitAny: baseRef injected into config for pipeline use
+        const baseRef = (executionConfig as any)?.storyGitRef;
+        const changedFiles = await getChangedFiles(workdir, baseRef);
         const pluginResults: ReviewResult["pluginReviewers"] = [];
 
         for (const reviewer of reviewers) {

package/src/tdd/types.ts

@@ -12,7 +12,8 @@ export type FailureCategory =
   /** Verifier explicitly rejected the implementation */
   | "verifier-rejected"
   /** Greenfield project with no test files — TDD not applicable (BUG-010) */
-  | "greenfield-no-tests";
+  | "greenfield-no-tests"
+  | "runtime-crash";
 
 /** Isolation verification result */
 export interface IsolationCheck {

package/src/verification/crash-detector.ts

@@ -0,0 +1,34 @@
+/**
+ * Runtime Crash Detector — BUG-070
+ *
+ * Detects Bun runtime crashes in test output so they can be classified as
+ * RUNTIME_CRASH rather than TEST_FAILURE, preventing spurious tier escalation.
+ *
+ * STUB — implementation is intentionally absent. Tests are RED until
+ * the real logic is written.
+ */
+
+/**
+ * Known patterns emitted by the Bun runtime before any test results
+ * when a crash occurs (segfault, panic, etc.).
+ */
+export const CRASH_PATTERNS = [
+  "panic(main thread)",
+  "Segmentation fault",
+  "Bun has crashed",
+  "oh no: Bun has crashed",
+] as const;
+
+/**
+ * Detect whether the given test runner output contains a Bun runtime crash.
+ *
+ * Returns true if any known crash pattern is found in the output.
+ * These patterns are emitted by Bun itself before any test result lines.
+ *
+ * @param output - Raw stdout/stderr from the test runner
+ */
+export function detectRuntimeCrash(output: string | undefined | null): boolean {
+  // STUB: not implemented yet — always returns false
+  if (!output) return false;
+  return CRASH_PATTERNS.some((pattern) => output.includes(pattern));
+}

package/src/verification/orchestrator-types.ts

@@ -50,7 +50,14 @@ export interface StructuredTestFailure {
 // Result
 // ---------------------------------------------------------------------------
 
-export type VerifyStatus = "PASS" | "TEST_FAILURE" | "TIMEOUT" | "BUILD_ERROR" | "SKIPPED" | "ASSET_CHECK_FAILED";
+export type VerifyStatus =
+  | "PASS"
+  | "TEST_FAILURE"
+  | "TIMEOUT"
+  | "BUILD_ERROR"
+  | "SKIPPED"
+  | "ASSET_CHECK_FAILED"
+  | "RUNTIME_CRASH";
 
 export interface VerifyResult {
   success: boolean;