@nathapp/nax 0.36.0 → 0.36.2

package/src/tdd/prompts.ts

@@ -2,213 +2,6 @@ import type { RectificationConfig } from "../config";
 import type { TestFailure } from "../execution/test-output-parser";
 import type { UserStory } from "../prd";
 import { createRectificationPrompt } from "../verification/rectification";
-import type { TddSessionRole } from "./types";
-
-/**
- * Prompt to build the TDD agent's role definition
- */
-export function buildTddRolePrompt(
-  role: TddSessionRole,
-  story: UserStory,
-  config?: { projectRoot: string },
-  currentBranch?: string,
-): string {
-  const common = `You are a TDD agent (role: ${role}) working on the story: "${story.title}".${config ? `\nProject root: ${config.projectRoot}` : ""}${currentBranch ? `\nCurrent branch: ${currentBranch}` : ""}
-
-STORY DESCRIPTION:
-${story.description}
-
-ACCEPTANCE CRITERIA:
-${story.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
-
----
-`;
-
-  if (role === "test-writer") {
-    return `${common}
-YOUR TASK: Write ONLY test files for this story.
-- Use the existing test framework (Bun test).
-- Tests must fail because the feature is not implemented yet.
-- Do NOT modify any existing source files.
-- Do NOT implement the feature.
-- Name tests consistently (e.g., test/*.test.ts).
-
-IMPORTANT: Only write new test files or update existing ones. Do NOT touch src/*.`;
-  }
-
-  if (role === "implementer") {
-    return `${common}
-YOUR TASK: Implement the feature to make the tests pass.
-- Read the tests in the current branch.
-- Modify source files in src/ as needed.
-- Do NOT modify test files unless there is a bug in the tests.
-- Run tests frequently to check progress.
-- Goal: All tests pass.`;
-  }
-
-  // Verifier
-  return `${common}
-YOUR TASK: Verify the implementation and tests.
-- Ensure all tests pass.
-- Check that the implementation meets all acceptance criteria.
-- Fix any minor bugs or missing edge cases.
-- Do NOT change the behavior unless it violates the criteria.
-- When running tests, run ONLY test files related to your changes (e.g. \`bun test ./test/specific.test.ts\`). NEVER run \`bun test\` without a file filter — full suite output will flood your context window and cause failures.
-- Goal: High-quality implementation and passing tests.`;
-}
-
-/**
- * Prompt to build the verifier's verification instructions (Session 3)
- */
-export function buildVerifierPrompt(story: UserStory): string {
-  return `# Session 3: Verify — "${story.title}"
-
-STORY:
-${story.description}
-
-ACCEPTANCE CRITERIA:
-${story.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
-
----
-
-## TASKS
-
-1. Run all tests and verify they pass.
-   - When running tests, run ONLY test files related to your changes (e.g. \`bun test ./test/specific.test.ts\`). NEVER run \`bun test\` without a file filter — full suite output will flood your context window and cause failures.
-2. Review the implementation for quality and correctness.
-3. Check that the implementation meets all acceptance criteria.
-4. Check if test files were modified by the implementer (make sure they are legitimate fixes, NOT just loosening assertions to mask bugs).
-5. If any issues exist, fix them minimally — do NOT refactor.
-
----
-
-## IMPORTANT — Write Verdict File
-
-After completing your verification, you **MUST** write a verdict file at the **project root**:
-
-**File:** \`.nax-verifier-verdict.json\`
-
-Set \`approved: true\` when ALL of these conditions are met:
-- All tests pass
-- Implementation is clean and follows conventions
-- All acceptance criteria met
-- Any test modifications by implementer are legitimate fixes
-
-Set \`approved: false\` when ANY of these conditions are true:
-- Tests are failing and you cannot fix them
-- The implementer loosened test assertions to mask bugs
-- Critical acceptance criteria are not met
-- Code quality is poor (security issues, severe bugs, etc.)
-
-**Full JSON schema example** (fill in all fields with real values):
-
-\`\`\`json
-{
-  "version": 1,
-  "approved": true,
-  "tests": {
-    "allPassing": true,
-    "passCount": 42,
-    "failCount": 0
-  },
-  "testModifications": {
-    "detected": false,
-    "files": [],
-    "legitimate": true,
-    "reasoning": "No test files were modified by the implementer"
-  },
-  "acceptanceCriteria": {
-    "allMet": true,
-    "criteria": [
-      { "criterion": "Example criterion", "met": true }
-    ]
-  },
-  "quality": {
-    "rating": "good",
-    "issues": []
-  },
-  "fixes": [],
-  "reasoning": "All tests pass, implementation is clean, all acceptance criteria are met."
-}
-\`\`\`
-
-**Field notes:**
-- \`quality.rating\` must be one of: \`"good"\`, \`"acceptable"\`, \`"poor"\`
-- \`testModifications.files\` — list any test files the implementer changed
-- \`fixes\` — list any fixes you applied yourself during this verification session
-- \`reasoning\` — brief summary of your overall assessment
-
-When done, commit any fixes with message: "fix: verify and adjust ${story.title}"`;
-}
-
-/**
- * Prompt for a test-writer session (single-session lite variant)
- */
-export function buildTestWriterPrompt(story: UserStory, contextMarkdown?: string): string {
-  const contextSection = contextMarkdown ? `\n\n---\n\n${contextMarkdown}` : "";
-  return `# Test Writer — "${story.title}"
-
-Your role: Write failing tests ONLY. Do NOT implement any source code.
-
-STORY:
-${story.description}
-
-ACCEPTANCE CRITERIA:
-${story.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
-
-RULES:
-- Only create or modify files in the test/ directory.
-- Tests must fail (feature not implemented yet).
-- Use Bun test (describe/test/expect).
-- Cover all acceptance criteria.
-- When running tests, run ONLY test files related to your changes (e.g. \`bun test ./test/specific.test.ts\`). NEVER run \`bun test\` without a file filter — full suite output will flood your context window and cause failures.${contextSection}`;
-}
-
-/**
- * Prompt for a test-writer lite session (no isolation enforcement)
- */
-export function buildTestWriterLitePrompt(story: UserStory, contextMarkdown?: string): string {
-  const contextSection = contextMarkdown ? `\n\n---\n\n${contextMarkdown}` : "";
-  return `# Test Writer (Lite) — "${story.title}"
-
-Your role: Write failing tests. You MAY read source files and MAY import from source files to ensure correct types/interfaces. You may create minimal stubs in src/ if needed to make imports work, but do NOT implement real logic.
-
-STORY:
-${story.description}
-
-ACCEPTANCE CRITERIA:
-${story.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
-
-RULES:
-- Primarily CREATE test files in the test/ directory.
-- Stub-only src/ files are allowed (empty exports, no logic).
-- Tests must fail for the right reasons (feature not implemented).
-- Use Bun test (describe/test/expect).
-- When running tests, run ONLY test files related to your changes (e.g. \`bun test ./test/specific.test.ts\`). NEVER run \`bun test\` without a file filter — full suite output will flood your context window and cause failures.${contextSection}`;
-}
-
-/**
- * Prompt for an implementer session
- */
-export function buildImplementerPrompt(story: UserStory, contextMarkdown?: string): string {
-  const contextSection = contextMarkdown ? `\n\n---\n\n${contextMarkdown}` : "";
-  return `# Implementer — "${story.title}"
-
-Your role: Make all failing tests pass.
-
-STORY:
-${story.description}
-
-ACCEPTANCE CRITERIA:
-${story.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
-
-RULES:
-- Implement source code in src/ to make tests pass.
-- Do NOT modify test files.
-- Run tests frequently to track progress.
-- When running tests, run ONLY test files related to your changes (e.g. \`bun test ./test/specific.test.ts\`). NEVER run \`bun test\` without a file filter — full suite output will flood your context window and cause failures.
-- Goal: all tests green.${contextSection}`;
-}
 
 /**
  * Build implementer rectification prompt (v0.11)
@@ -219,7 +12,7 @@ RULES:
 export function buildImplementerRectificationPrompt(
   failures: TestFailure[],
   story: UserStory,
-  contextMarkdown?: string,
+  _contextMarkdown?: string,
   config?: RectificationConfig,
 ): string {
   // Reuse the existing rectification prompt builder from R2
@@ -227,29 +20,6 @@ export function buildImplementerRectificationPrompt(
   return createRectificationPrompt(failures, story, config);
 }
 
-/**
- * Prompt for an implementer lite session (combined test + implement)
- */
-export function buildImplementerLitePrompt(story: UserStory, contextMarkdown?: string): string {
-  const contextSection = contextMarkdown ? `\n\n---\n\n${contextMarkdown}` : "";
-  return `# Implementer (Lite) — "${story.title}"
-
-Your role: Write tests AND implement the feature in a single session.
-
-STORY:
-${story.description}
-
-ACCEPTANCE CRITERIA:
-${story.acceptanceCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}
-
-RULES:
-- Write tests first (test/ directory), then implement (src/ directory).
-- All tests must pass by the end.
-- Use Bun test (describe/test/expect).
-- When running tests, run ONLY test files related to your changes (e.g. \`bun test ./test/specific.test.ts\`). NEVER run \`bun test\` without a file filter — full suite output will flood your context window and cause failures.
-- Goal: all tests green, all criteria met.${contextSection}`;
-}
-
 /**
  * Build rectification prompt for retry after test failures
  *

package/src/tdd/session-runner.ts

@@ -83,6 +83,7 @@ export async function runTddSession(
   contextMarkdown?: string,
   lite = false,
   skipIsolation = false,
+  constitution?: string,
 ): Promise<TddSessionResult> {
   const startTime = Date.now();
 
@@ -101,6 +102,7 @@ export async function runTddSession(
         .withLoader(workdir, config)
         .story(story)
         .context(contextMarkdown)
+        .constitution(constitution)
         .build();
       break;
     case "verifier":

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/tdd/verdict.ts

@@ -126,7 +126,12 @@ export function coerceVerdict(obj: Record<string, unknown>): VerifierVerdict | n
   try {
     // Determine approval status
     const verdictStr = String(obj.verdict ?? "").toUpperCase();
-    const approved = verdictStr === "PASS" || verdictStr === "APPROVED" || obj.approved === true;
+    const approved =
+      verdictStr === "PASS" ||
+      verdictStr === "APPROVED" ||
+      verdictStr.startsWith("VERIFIED") ||
+      verdictStr.includes("ALL ACCEPTANCE CRITERIA MET") ||
+      obj.approved === true;
 
     // Parse test results from verification_summary or top-level
     let passCount = 0;
@@ -252,13 +257,26 @@ export async function readVerdict(workdir: string): Promise<VerifierVerdict | nu
       return null;
     }
 
+    // Read as text first so we can log raw content on parse failure
+    let rawText: string;
+    try {
+      rawText = await file.text();
+    } catch (readErr) {
+      logger.warn("tdd", "Failed to read verifier verdict file", {
+        path: verdictPath,
+        error: String(readErr),
+      });
+      return null;
+    }
+
     let parsed: unknown;
     try {
-      parsed = await file.json();
+      parsed = JSON.parse(rawText);
     } catch (parseErr) {
       logger.warn("tdd", "Verifier verdict file is not valid JSON — ignoring", {
         path: verdictPath,
         error: String(parseErr),
+        rawContent: rawText.slice(0, 1000),
       });
       return null;
     }

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;

package/src/verification/parser.ts

@@ -216,15 +216,5 @@ export function parseTestOutput(output: string, exitCode: number): TestOutputAna
   return result;
 }
 
-/**
- * Calculate early escalation threshold for environmental failures.
- *
- * Environmental failures should escalate faster: after ceil(tier.attempts / 2)
- * instead of the full tier budget.
- */
-export function getEnvironmentalEscalationThreshold(tierAttempts: number, divisor = 2): number {
-  return Math.ceil(tierAttempts / divisor);
-}
-
 // Re-export types for consumers that import from this module
 export type { TestFailure, TestSummary } from "./types";

package/src/verification/rectification-loop.ts

@@ -10,12 +10,10 @@
 import { getAgent } from "../agents";
 import type { NaxConfig } from "../config";
 import { resolveModel } from "../config";
-import { appendProgress } from "../execution/progress";
 import { parseBunTestOutput } from "../execution/test-output-parser";
 import { getSafeLogger } from "../logger";
-import type { StoryMetrics } from "../metrics";
-import type { PRD, StructuredFailure, UserStory } from "../prd";
-import { getExpectedFiles, savePRD } from "../prd";
+import type { UserStory } from "../prd";
+import { getExpectedFiles } from "../prd";
 import { type RectificationState, createRectificationPrompt, shouldRetryRectification } from "./rectification";
 import { fullSuite as runVerification } from "./runners";
 
@@ -147,50 +145,3 @@ export async function runRectificationLoop(opts: RectificationLoopOptions): Prom
 
   return false;
 }
-
-export interface RevertStoriesOptions {
-  prd: PRD;
-  prdPath: string;
-  story: UserStory;
-  storiesToExecute: UserStory[];
-  allStoryMetrics: StoryMetrics[];
-  featureDir?: string;
-  diagnosticContext: string;
-  countsTowardEscalation: boolean;
-  priorFailure?: StructuredFailure;
-}
-
-/** Revert stories to pending on verification failure and save PRD. */
-export async function revertStoriesOnFailure(opts: RevertStoriesOptions): Promise<PRD> {
-  const storyIds = new Set(opts.storiesToExecute.map((s) => s.id));
-
-  for (let i = opts.allStoryMetrics.length - 1; i >= 0; i--) {
-    if (storyIds.has(opts.allStoryMetrics[i].storyId)) opts.allStoryMetrics.splice(i, 1);
-  }
-
-  opts.prd.userStories = opts.prd.userStories.map((s) =>
-    storyIds.has(s.id)
-      ? {
-          ...s,
-          priorErrors: [...(s.priorErrors || []), opts.diagnosticContext],
-          priorFailures: opts.priorFailure ? [...(s.priorFailures || []), opts.priorFailure] : s.priorFailures,
-          status: "pending" as const,
-          passes: false,
-        }
-      : s,
-  );
-
-  if (opts.countsTowardEscalation) {
-    opts.prd.userStories = opts.prd.userStories.map((s) =>
-      s.id === opts.story.id ? { ...s, attempts: s.attempts + 1 } : s,
-    );
-  }
-
-  await savePRD(opts.prd, opts.prdPath);
-
-  if (opts.featureDir) {
-    await appendProgress(opts.featureDir, opts.story.id, "failed", `${opts.story.title} -- ${opts.diagnosticContext}`);
-  }
-
-  return opts.prd;
-}

package/src/worktree/dispatcher.ts

@@ -1,65 +1,6 @@
-import type { UserStory } from "../prd/types";
-import type { WorktreeManager } from "./manager";
-
 export interface DispatchResult {
   storyId: string;
   success: boolean;
   worktreePath: string;
   error?: string;
 }
-
-export class ParallelDispatcher {
-  constructor(
-    private worktreeManager: WorktreeManager,
-    private runPipeline: (args: { workdir: string; story: UserStory }) => Promise<boolean>,
-  ) {}
-
-  async dispatch(projectRoot: string, stories: UserStory[], maxConcurrency: number): Promise<DispatchResult[]> {
-    const results: DispatchResult[] = [];
-    const independentBatches = this.getBatches(stories);
-
-    for (const batch of independentBatches) {
-      const batchPromises = batch.map(async (story) => {
-        const worktreePath = `${projectRoot}/.nax-wt/${story.id}`;
-        try {
-          await this.worktreeManager.create(projectRoot, story.id);
-          const success = await this.runPipeline({ workdir: worktreePath, story });
-          return { storyId: story.id, success, worktreePath };
-        } catch (err) {
-          return {
-            storyId: story.id,
-            success: false,
-            worktreePath,
-            error: err instanceof Error ? err.message : String(err),
-          };
-        }
-      });
-
-      const batchResults = await pLimit(maxConcurrency, batchPromises);
-      results.push(...batchResults);
-    }
-
-    return results;
-  }
-
-  private getBatches(stories: UserStory[]): UserStory[][] {
-    // TODO: Implement dependency-aware batching
-    return [stories];
-  }
-}
-
-// Helper for concurrency limiting (Simplified p-limit)
-async function pLimit<T>(concurrency: number, promises: Promise<T>[]): Promise<T[]> {
-  const results: T[] = [];
-  const executing: Promise<void>[] = [];
-  for (const p of promises) {
-    const e = p.then((r) => {
-      results.push(r);
-      executing.splice(executing.indexOf(e), 1);
-    });
-    executing.push(e);
-    if (executing.length >= concurrency) await Promise.race(executing);
-  }
-  await Promise.all(executing);
-  return results;
-}