@nathapp/nax 0.50.2 → 0.50.3

package/dist/nax.js

@@ -17874,7 +17874,8 @@ var init_schemas3 = __esm(() => {
     refinement: exports_external.boolean().default(true),
     redGate: exports_external.boolean().default(true),
     testStrategy: exports_external.enum(["unit", "component", "cli", "e2e", "snapshot"]).optional(),
-    testFramework: exports_external.string().min(1, "acceptance.testFramework must be non-empty").optional()
+    testFramework: exports_external.string().min(1, "acceptance.testFramework must be non-empty").optional(),
+    timeoutMs: exports_external.number().int().min(30000).max(3600000).default(1800000)
   });
   TestCoverageConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
@@ -18163,7 +18164,8 @@ var init_defaults = __esm(() => {
       testPath: "acceptance.test.ts",
       model: "fast",
       refinement: true,
-      redGate: true
+      redGate: true,
+      timeoutMs: 1800000
     },
     context: {
       fileInjection: "disabled",
@@ -18725,32 +18727,48 @@ async function generateFromPRD(_stories, refinedCriteria, options) {
   }
   const criteriaList = refinedCriteria.map((c, i) => `AC-${i + 1}: ${c.refined}`).join(`
 `);
-  const strategyInstructions = buildStrategyInstructions(options.testStrategy, options.testFramework);
-  const prompt = `You are a test engineer. Generate acceptance tests for the "${options.featureName}" feature based on the refined acceptance criteria below.
+  const frameworkOverrideLine = options.testFramework ? `
+[FRAMEWORK OVERRIDE: Use ${options.testFramework} as the test framework regardless of what you detect.]` : "";
+  const basePrompt = `You are a senior test engineer. Your task is to generate a complete acceptance test file for the "${options.featureName}" feature.
 
-CODEBASE CONTEXT:
-${options.codebaseContext}
+## Step 1: Understand and Classify the Acceptance Criteria
 
-ACCEPTANCE CRITERIA (refined):
+Read each AC below and classify its verification type:
+- **file-check**: Verify by reading source files (e.g. "no @nestjs/jwt imports", "file exists", "module registered", "uses registerAs pattern")
+- **runtime-check**: Load and invoke code directly, assert on return values or behavior
+- **integration-check**: Requires a running service (e.g. HTTP endpoint returns 200, 11th request returns 429, database query succeeds)
+
+ACCEPTANCE CRITERIA:
 ${criteriaList}
 
-${strategyInstructions}Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
+## Step 2: Explore the Project
 
-Structure example (do NOT wrap in markdown fences \u2014 output raw TypeScript only):
+Before writing any tests, examine the project to understand:
+1. **Language and test framework** \u2014 check dependency manifests (package.json, go.mod, Gemfile, pyproject.toml, Cargo.toml, build.gradle, etc.) to identify the language and test runner
+2. **Existing test patterns** \u2014 read 1-2 existing test files to understand import style, describe/test/it conventions, and available helpers
+3. **Project structure** \u2014 identify relevant source directories to determine correct import or load paths
 
-import { describe, test, expect } from "bun:test";
+${frameworkOverrideLine}
 
-describe("${options.featureName} - Acceptance Tests", () => {
-  test("AC-1: <description>", async () => {
-    // Test implementation
-  });
-});
+## Step 3: Generate the Acceptance Test File
 
-IMPORTANT: Output raw TypeScript code only. Do NOT use markdown code fences (\`\`\`typescript or \`\`\`). Start directly with the import statement.`;
+Write the complete acceptance test file using the framework identified in Step 2.
+
+Rules:
+- **One test per AC**, named exactly "AC-N: <description>"
+- **file-check ACs** \u2192 read source files using the language's standard file I/O, assert with string or regex checks. Do not start the application.
+- **runtime-check ACs** \u2192 load or import the module directly and invoke it, assert on the return value or observable side effects
+- **integration-check ACs** \u2192 use the language's HTTP client or existing test helpers; add a clear setup block (beforeAll/setup/TestMain/etc.) explaining what must be running
+- **NEVER use placeholder assertions** \u2014 no always-passing or always-failing stubs, no TODO comments as the only content, no empty test bodies
+- Every test MUST have real assertions that PASS when the feature is correctly implemented and FAIL when it is broken
+- Output raw code only \u2014 no markdown fences, start directly with the language's import or package declaration`;
+  const prompt = basePrompt;
   logger.info("acceptance", "Generating tests from PRD refined criteria", { count: refinedCriteria.length });
-  const rawOutput = await _generatorPRDDeps.adapter.complete(prompt, {
+  const rawOutput = await (options.adapter ?? _generatorPRDDeps.adapter).complete(prompt, {
     model: options.modelDef.model,
-    config: options.config
+    config: options.config,
+    timeoutMs: options.config?.acceptance?.timeoutMs ?? 1800000,
+    workdir: options.workdir
   });
   const testCode = extractTestCode(rawOutput);
   if (!testCode) {
@@ -18774,40 +18792,6 @@ IMPORTANT: Output raw TypeScript code only. Do NOT use markdown code fences (\`\
   await _generatorPRDDeps.writeFile(join2(options.featureDir, "acceptance-refined.json"), refinedJsonContent);
   return { testCode, criteria };
 }
-function buildStrategyInstructions(strategy, framework) {
-  switch (strategy) {
-    case "component": {
-      const fw = framework ?? "ink-testing-library";
-      if (fw === "react") {
-        return `TEST STRATEGY: component (react)
-Import render and screen from @testing-library/react. Render the component and use screen.getByText to assert on output.
-
-`;
-      }
-      return `TEST STRATEGY: component (ink-testing-library)
-Import render from ink-testing-library. Render the component and use lastFrame() to assert on output.
-
-`;
-    }
-    case "cli":
-      return `TEST STRATEGY: cli
-Use Bun.spawn to run the binary. Read stdout and assert on the text output.
-
-`;
-    case "e2e":
-      return `TEST STRATEGY: e2e
-Use fetch() against http://localhost to call the running service. Assert on response body using response.text() or response.json().
-
-`;
-    case "snapshot":
-      return `TEST STRATEGY: snapshot
-Render the component and use toMatchSnapshot() to capture and compare snapshots.
-
-`;
-    default:
-      return "";
-  }
-}
 function parseAcceptanceCriteria(specContent) {
   const criteria = [];
   const lines = specContent.split(`
@@ -18831,46 +18815,38 @@ function parseAcceptanceCriteria(specContent) {
 function buildAcceptanceTestPrompt(criteria, featureName, codebaseContext) {
   const criteriaList = criteria.map((ac) => `${ac.id}: ${ac.text}`).join(`
 `);
-  return `You are a test engineer. Generate acceptance tests for the "${featureName}" feature based on the acceptance criteria below.
+  return `You are a senior test engineer. Your task is to generate a complete acceptance test file for the "${featureName}" feature.
 
-CODEBASE CONTEXT:
-${codebaseContext}
+## Step 1: Understand and Classify the Acceptance Criteria
+
+Read each AC below and classify its verification type:
+- **file-check**: Verify by reading source files (e.g. "no @nestjs/jwt imports", "file exists", "module registered", "uses registerAs pattern")
+- **runtime-check**: Load and invoke code directly, assert on return values or behavior
+- **integration-check**: Requires a running service (e.g. HTTP endpoint returns 200, 11th request returns 429, database query succeeds)
 
 ACCEPTANCE CRITERIA:
 ${criteriaList}
 
-Generate a complete acceptance.test.ts file using bun:test framework. Follow these rules:
-
-1. **One test per AC**: Each acceptance criterion maps to exactly one test
-2. **Test observable behavior only**: No implementation details, only user-facing behavior
-3. **Independent tests**: No shared state between tests
-4. **Real-implementation**: Tests should use real implementations without mocking (test observable behavior, not internal units)
-5. **Clear test names**: Use format "AC-N: <description>" for test names
-6. **Async where needed**: Use async/await for operations that may be asynchronous
+## Step 2: Explore the Project
 
-Use this structure:
+Before writing any tests, examine the project to understand:
+1. **Language and test framework** \u2014 check dependency manifests (package.json, go.mod, Gemfile, pyproject.toml, Cargo.toml, build.gradle, etc.) to identify the language and test runner
+2. **Existing test patterns** \u2014 read 1-2 existing test files to understand import style, describe/test/it conventions, and available helpers
+3. **Project structure** \u2014 identify relevant source directories to determine correct import or load paths
 
-\`\`\`typescript
-import { describe, test, expect } from "bun:test";
-
-describe("${featureName} - Acceptance Tests", () => {
-  test("AC-1: <description>", async () => {
-    // Test implementation
-  });
 
-  test("AC-2: <description>", async () => {
-    // Test implementation
-  });
-});
-\`\`\`
+## Step 3: Generate the Acceptance Test File
 
-**Important**:
-- Import the feature code being tested
-- Set up any necessary test fixtures
-- Use expect() assertions to verify behavior
-- Clean up resources if needed (close connections, delete temp files)
+Write the complete acceptance test file using the framework identified in Step 2.
 
-Respond with ONLY the TypeScript test code (no markdown code fences, no explanation).`;
+Rules:
+- **One test per AC**, named exactly "AC-N: <description>"
+- **file-check ACs** \u2192 read source files using the language's standard file I/O, assert with string or regex checks. Do not start the application.
+- **runtime-check ACs** \u2192 load or import the module directly and invoke it, assert on the return value or observable side effects
+- **integration-check ACs** \u2192 use the language's HTTP client or existing test helpers; add a clear setup block (beforeAll/setup/TestMain/etc.) explaining what must be running
+- **NEVER use placeholder assertions** \u2014 no always-passing or always-failing stubs, no TODO comments as the only content, no empty test bodies
+- Every test MUST have real assertions that PASS when the feature is correctly implemented and FAIL when it is broken
+- Output raw code only \u2014 no markdown fences, start directly with the language's import or package declaration`;
 }
 async function generateAcceptanceTests(adapter, options) {
   const logger = getLogger();
@@ -18887,7 +18863,9 @@ async function generateAcceptanceTests(adapter, options) {
   try {
     const output = await adapter.complete(prompt, {
       model: options.modelDef.model,
-      config: options.config
+      config: options.config,
+      timeoutMs: options.config?.acceptance?.timeoutMs ?? 1800000,
+      workdir: options.workdir
     });
     const testCode = extractTestCode(output);
     if (!testCode) {
@@ -22351,7 +22329,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.50.2",
+    version: "0.50.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22425,8 +22403,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("c3a5edb"))
-        return "c3a5edb";
+      if (/^[0-9a-f]{6,10}$/.test("684b48b"))
+        return "684b48b";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -24180,7 +24158,105 @@ ${stderr}`;
   };
 });
 
+// src/agents/shared/validation.ts
+function validateAgentForTier(agent, tier) {
+  return agent.capabilities.supportedTiers.includes(tier);
+}
+function validateAgentFeature(agent, feature) {
+  return agent.capabilities.features.has(feature);
+}
+function describeAgentCapabilities(agent) {
+  const tiers = agent.capabilities.supportedTiers.join(",");
+  const features = Array.from(agent.capabilities.features).join(",");
+  const maxTokens = agent.capabilities.maxContextTokens;
+  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
+}
+
+// src/agents/shared/version-detection.ts
+async function getAgentVersion(binaryName) {
+  try {
+    const proc = _versionDetectionDeps.spawn([binaryName, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return null;
+    }
+    const stdout = await new Response(proc.stdout).text();
+    const versionLine = stdout.trim().split(`
+`)[0];
+    const versionMatch = versionLine.match(/v?(\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?)/);
+    if (versionMatch) {
+      return versionMatch[0];
+    }
+    return versionLine || null;
+  } catch {
+    return null;
+  }
+}
+async function getAgentVersions() {
+  const agents = await getInstalledAgents();
+  const agentsByName = new Map(agents.map((a) => [a.name, a]));
+  const { ALL_AGENTS: ALL_AGENTS2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
+  const versions2 = await Promise.all(ALL_AGENTS2.map(async (agent) => {
+    const version2 = agentsByName.has(agent.name) ? await getAgentVersion(agent.binary) : null;
+    return {
+      name: agent.name,
+      displayName: agent.displayName,
+      version: version2,
+      installed: agentsByName.has(agent.name)
+    };
+  }));
+  return versions2;
+}
+var _versionDetectionDeps;
+var init_version_detection = __esm(() => {
+  init_registry();
+  _versionDetectionDeps = {
+    spawn(cmd, opts) {
+      return Bun.spawn(cmd, opts);
+    }
+  };
+});
+
+// src/agents/index.ts
+var exports_agents = {};
+__export(exports_agents, {
+  validateAgentForTier: () => validateAgentForTier,
+  validateAgentFeature: () => validateAgentFeature,
+  parseTokenUsage: () => parseTokenUsage,
+  getInstalledAgents: () => getInstalledAgents,
+  getAllAgentNames: () => getAllAgentNames,
+  getAgentVersions: () => getAgentVersions,
+  getAgentVersion: () => getAgentVersion,
+  getAgent: () => getAgent,
+  formatCostWithConfidence: () => formatCostWithConfidence,
+  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
+  estimateCostFromOutput: () => estimateCostFromOutput,
+  estimateCostByDuration: () => estimateCostByDuration,
+  estimateCost: () => estimateCost,
+  describeAgentCapabilities: () => describeAgentCapabilities,
+  checkAgentHealth: () => checkAgentHealth,
+  MODEL_PRICING: () => MODEL_PRICING,
+  CompleteError: () => CompleteError,
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  COST_RATES: () => COST_RATES
+});
+var init_agents = __esm(() => {
+  init_types2();
+  init_claude();
+  init_registry();
+  init_cost();
+  init_version_detection();
+});
+
 // src/pipeline/stages/acceptance-setup.ts
+var exports_acceptance_setup = {};
+__export(exports_acceptance_setup, {
+  acceptanceSetupStage: () => acceptanceSetupStage,
+  _acceptanceSetupDeps: () => _acceptanceSetupDeps
+});
 import path5 from "path";
 var _acceptanceSetupDeps, acceptanceSetupStage;
 var init_acceptance_setup = __esm(() => {
@@ -24232,6 +24308,8 @@ ${stderr}` };
       if (!fileExists) {
         const allCriteria = ctx.prd.userStories.flatMap((s) => s.acceptanceCriteria);
         totalCriteria = allCriteria.length;
+        const { getAgent: getAgent2 } = await Promise.resolve().then(() => (init_agents(), exports_agents));
+        const agent = (ctx.agentGetFn ?? getAgent2)(ctx.config.autoMode.defaultAgent);
         let refinedCriteria;
         if (ctx.config.acceptance.refinement) {
           refinedCriteria = await _acceptanceSetupDeps.refine(allCriteria, {
@@ -24259,7 +24337,8 @@ ${stderr}` };
           modelDef: resolveModel(ctx.config.models[ctx.config.acceptance.model ?? "fast"]),
           config: ctx.config,
           testStrategy: ctx.config.acceptance.testStrategy,
-          testFramework: ctx.config.acceptance.testFramework
+          testFramework: ctx.config.acceptance.testFramework,
+          adapter: agent ?? undefined
         });
         await _acceptanceSetupDeps.writeFile(testPath, result.testCode);
       }
@@ -24281,99 +24360,6 @@ ${stderr}` };
   };
 });
 
-// src/agents/shared/validation.ts
-function validateAgentForTier(agent, tier) {
-  return agent.capabilities.supportedTiers.includes(tier);
-}
-function validateAgentFeature(agent, feature) {
-  return agent.capabilities.features.has(feature);
-}
-function describeAgentCapabilities(agent) {
-  const tiers = agent.capabilities.supportedTiers.join(",");
-  const features = Array.from(agent.capabilities.features).join(",");
-  const maxTokens = agent.capabilities.maxContextTokens;
-  return `${agent.name}: tiers=[${tiers}], maxTokens=${maxTokens}, features=[${features}]`;
-}
-
-// src/agents/shared/version-detection.ts
-async function getAgentVersion(binaryName) {
-  try {
-    const proc = _versionDetectionDeps.spawn([binaryName, "--version"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      return null;
-    }
-    const stdout = await new Response(proc.stdout).text();
-    const versionLine = stdout.trim().split(`
-`)[0];
-    const versionMatch = versionLine.match(/v?(\d+\.\d+(?:\.\d+)?(?:[-+][\w.]+)?)/);
-    if (versionMatch) {
-      return versionMatch[0];
-    }
-    return versionLine || null;
-  } catch {
-    return null;
-  }
-}
-async function getAgentVersions() {
-  const agents = await getInstalledAgents();
-  const agentsByName = new Map(agents.map((a) => [a.name, a]));
-  const { ALL_AGENTS: ALL_AGENTS2 } = await Promise.resolve().then(() => (init_registry(), exports_registry));
-  const versions2 = await Promise.all(ALL_AGENTS2.map(async (agent) => {
-    const version2 = agentsByName.has(agent.name) ? await getAgentVersion(agent.binary) : null;
-    return {
-      name: agent.name,
-      displayName: agent.displayName,
-      version: version2,
-      installed: agentsByName.has(agent.name)
-    };
-  }));
-  return versions2;
-}
-var _versionDetectionDeps;
-var init_version_detection = __esm(() => {
-  init_registry();
-  _versionDetectionDeps = {
-    spawn(cmd, opts) {
-      return Bun.spawn(cmd, opts);
-    }
-  };
-});
-
-// src/agents/index.ts
-var exports_agents = {};
-__export(exports_agents, {
-  validateAgentForTier: () => validateAgentForTier,
-  validateAgentFeature: () => validateAgentFeature,
-  parseTokenUsage: () => parseTokenUsage,
-  getInstalledAgents: () => getInstalledAgents,
-  getAllAgentNames: () => getAllAgentNames,
-  getAgentVersions: () => getAgentVersions,
-  getAgentVersion: () => getAgentVersion,
-  getAgent: () => getAgent,
-  formatCostWithConfidence: () => formatCostWithConfidence,
-  estimateCostFromTokenUsage: () => estimateCostFromTokenUsage,
-  estimateCostFromOutput: () => estimateCostFromOutput,
-  estimateCostByDuration: () => estimateCostByDuration,
-  estimateCost: () => estimateCost,
-  describeAgentCapabilities: () => describeAgentCapabilities,
-  checkAgentHealth: () => checkAgentHealth,
-  MODEL_PRICING: () => MODEL_PRICING,
-  CompleteError: () => CompleteError,
-  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
-  COST_RATES: () => COST_RATES
-});
-var init_agents = __esm(() => {
-  init_types2();
-  init_claude();
-  init_registry();
-  init_cost();
-  init_version_detection();
-});
-
 // src/pipeline/event-bus.ts
 class PipelineEventBus {
   subscribers = new Map;
@@ -32201,9 +32187,13 @@ var init_crash_recovery = __esm(() => {
 // src/execution/lifecycle/acceptance-loop.ts
 var exports_acceptance_loop = {};
 __export(exports_acceptance_loop, {
-  runAcceptanceLoop: () => runAcceptanceLoop
+  runAcceptanceLoop: () => runAcceptanceLoop,
+  isStubTestFile: () => isStubTestFile
 });
 import path14 from "path";
+function isStubTestFile(content) {
+  return /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*(?:false|true)\s*\)/.test(content);
+}
 async function loadSpecContent(featureDir) {
   if (!featureDir)
     return "";
@@ -32337,6 +32327,25 @@ async function runAcceptanceLoop(ctx) {
       }), ctx.workdir);
       return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
     }
+    if (ctx.featureDir) {
+      const testPath = path14.join(ctx.featureDir, "acceptance.test.ts");
+      const testFile = Bun.file(testPath);
+      if (await testFile.exists()) {
+        const testContent = await testFile.text();
+        if (isStubTestFile(testContent)) {
+          logger?.warn("acceptance", "Stub tests detected \u2014 re-generating acceptance tests");
+          const { unlink: unlink3 } = await import("fs/promises");
+          await unlink3(testPath);
+          const { acceptanceSetupStage: acceptanceSetupStage2 } = await Promise.resolve().then(() => (init_acceptance_setup(), exports_acceptance_setup));
+          await acceptanceSetupStage2.execute(acceptanceContext);
+          const newContent = await Bun.file(testPath).text();
+          if (isStubTestFile(newContent)) {
+            logger?.error("acceptance", "Acceptance test generation failed after retry \u2014 manual implementation required");
+            return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
+          }
+        }
+      }
+    }
     logger?.info("acceptance", "Generating fix stories...");
     const fixStories = await generateAndAddFixStories(ctx, failures, prd);
     if (!fixStories) {
@@ -69630,6 +69639,7 @@ var FIELD_DESCRIPTIONS = {
   "acceptance.maxRetries": "Max retry loops for fix stories",
   "acceptance.generateTests": "Generate acceptance tests during analyze",
   "acceptance.testPath": "Path to acceptance test file (relative to feature dir)",
+  "acceptance.timeoutMs": "Timeout for acceptance test generation in milliseconds (default: 1800000 = 30 min)",
   context: "Context injection configuration",
   "context.fileInjection": "Mode: 'disabled' (default, MCP-aware agents pull context on-demand) | 'keyword' (legacy git-grep injection for non-MCP agents). Set context.fileInjection in config.",
   "context.testCoverage": "Test coverage context settings",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.50.2",
+  "version": "0.50.3",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {

package/src/acceptance/generator.ts

@@ -82,35 +82,53 @@ export async function generateFromPRD(
 
   const criteriaList = refinedCriteria.map((c, i) => `AC-${i + 1}: ${c.refined}`).join("\n");
 
-  const strategyInstructions = buildStrategyInstructions(options.testStrategy, options.testFramework);
+  const frameworkOverrideLine = options.testFramework
+    ? `\n[FRAMEWORK OVERRIDE: Use ${options.testFramework} as the test framework regardless of what you detect.]`
+    : "";
 
-  const prompt = `You are a test engineer. Generate acceptance tests for the "${options.featureName}" feature based on the refined acceptance criteria below.
+  const basePrompt = `You are a senior test engineer. Your task is to generate a complete acceptance test file for the "${options.featureName}" feature.
 
-CODEBASE CONTEXT:
-${options.codebaseContext}
+## Step 1: Understand and Classify the Acceptance Criteria
 
-ACCEPTANCE CRITERIA (refined):
+Read each AC below and classify its verification type:
+- **file-check**: Verify by reading source files (e.g. "no @nestjs/jwt imports", "file exists", "module registered", "uses registerAs pattern")
+- **runtime-check**: Load and invoke code directly, assert on return values or behavior
+- **integration-check**: Requires a running service (e.g. HTTP endpoint returns 200, 11th request returns 429, database query succeeds)
+
+ACCEPTANCE CRITERIA:
 ${criteriaList}
 
-${strategyInstructions}Generate a complete acceptance.test.ts file using bun:test framework. Each AC maps to exactly one test named "AC-N: <description>".
+## Step 2: Explore the Project
 
-Structure example (do NOT wrap in markdown fences — output raw TypeScript only):
+Before writing any tests, examine the project to understand:
+1. **Language and test framework** — check dependency manifests (package.json, go.mod, Gemfile, pyproject.toml, Cargo.toml, build.gradle, etc.) to identify the language and test runner
+2. **Existing test patterns** — read 1-2 existing test files to understand import style, describe/test/it conventions, and available helpers
+3. **Project structure** — identify relevant source directories to determine correct import or load paths
 
-import { describe, test, expect } from "bun:test";
+${frameworkOverrideLine}
 
-describe("${options.featureName} - Acceptance Tests", () => {
-  test("AC-1: <description>", async () => {
-    // Test implementation
-  });
-});
+## Step 3: Generate the Acceptance Test File
+
+Write the complete acceptance test file using the framework identified in Step 2.
 
-IMPORTANT: Output raw TypeScript code only. Do NOT use markdown code fences (\`\`\`typescript or \`\`\`). Start directly with the import statement.`;
+Rules:
+- **One test per AC**, named exactly "AC-N: <description>"
+- **file-check ACs** → read source files using the language's standard file I/O, assert with string or regex checks. Do not start the application.
+- **runtime-check ACs** → load or import the module directly and invoke it, assert on the return value or observable side effects
+- **integration-check ACs** → use the language's HTTP client or existing test helpers; add a clear setup block (beforeAll/setup/TestMain/etc.) explaining what must be running
+- **NEVER use placeholder assertions** — no always-passing or always-failing stubs, no TODO comments as the only content, no empty test bodies
+- Every test MUST have real assertions that PASS when the feature is correctly implemented and FAIL when it is broken
+- Output raw code only — no markdown fences, start directly with the language's import or package declaration`;
+
+  const prompt = basePrompt;
 
   logger.info("acceptance", "Generating tests from PRD refined criteria", { count: refinedCriteria.length });
 
-  const rawOutput = await _generatorPRDDeps.adapter.complete(prompt, {
+  const rawOutput = await (options.adapter ?? _generatorPRDDeps.adapter).complete(prompt, {
     model: options.modelDef.model,
     config: options.config,
+    timeoutMs: options.config?.acceptance?.timeoutMs ?? 1800000,
+    workdir: options.workdir,
   });
   const testCode = extractTestCode(rawOutput);
 
@@ -143,26 +161,6 @@ IMPORTANT: Output raw TypeScript code only. Do NOT use markdown code fences (\`\
   return { testCode, criteria };
 }
 
-function buildStrategyInstructions(strategy?: string, framework?: string): string {
-  switch (strategy) {
-    case "component": {
-      const fw = framework ?? "ink-testing-library";
-      if (fw === "react") {
-        return "TEST STRATEGY: component (react)\nImport render and screen from @testing-library/react. Render the component and use screen.getByText to assert on output.\n\n";
-      }
-      return "TEST STRATEGY: component (ink-testing-library)\nImport render from ink-testing-library. Render the component and use lastFrame() to assert on output.\n\n";
-    }
-    case "cli":
-      return "TEST STRATEGY: cli\nUse Bun.spawn to run the binary. Read stdout and assert on the text output.\n\n";
-    case "e2e":
-      return "TEST STRATEGY: e2e\nUse fetch() against http://localhost to call the running service. Assert on response body using response.text() or response.json().\n\n";
-    case "snapshot":
-      return "TEST STRATEGY: snapshot\nRender the component and use toMatchSnapshot() to capture and compare snapshots.\n\n";
-    default:
-      return "";
-  }
-}
-
 export function parseAcceptanceCriteria(specContent: string): AcceptanceCriterion[] {
   const criteria: AcceptanceCriterion[] = [];
   const lines = specContent.split("\n");
@@ -218,46 +216,38 @@ export function buildAcceptanceTestPrompt(
 ): string {
   const criteriaList = criteria.map((ac) => `${ac.id}: ${ac.text}`).join("\n");
 
-  return `You are a test engineer. Generate acceptance tests for the "${featureName}" feature based on the acceptance criteria below.
+  return `You are a senior test engineer. Your task is to generate a complete acceptance test file for the "${featureName}" feature.
+
+## Step 1: Understand and Classify the Acceptance Criteria
 
-CODEBASE CONTEXT:
-${codebaseContext}
+Read each AC below and classify its verification type:
+- **file-check**: Verify by reading source files (e.g. "no @nestjs/jwt imports", "file exists", "module registered", "uses registerAs pattern")
+- **runtime-check**: Load and invoke code directly, assert on return values or behavior
+- **integration-check**: Requires a running service (e.g. HTTP endpoint returns 200, 11th request returns 429, database query succeeds)
 
 ACCEPTANCE CRITERIA:
 ${criteriaList}
 
-Generate a complete acceptance.test.ts file using bun:test framework. Follow these rules:
-
-1. **One test per AC**: Each acceptance criterion maps to exactly one test
-2. **Test observable behavior only**: No implementation details, only user-facing behavior
-3. **Independent tests**: No shared state between tests
-4. **Real-implementation**: Tests should use real implementations without mocking (test observable behavior, not internal units)
-5. **Clear test names**: Use format "AC-N: <description>" for test names
-6. **Async where needed**: Use async/await for operations that may be asynchronous
-
-Use this structure:
+## Step 2: Explore the Project
 
-\`\`\`typescript
-import { describe, test, expect } from "bun:test";
+Before writing any tests, examine the project to understand:
+1. **Language and test framework** — check dependency manifests (package.json, go.mod, Gemfile, pyproject.toml, Cargo.toml, build.gradle, etc.) to identify the language and test runner
+2. **Existing test patterns** — read 1-2 existing test files to understand import style, describe/test/it conventions, and available helpers
+3. **Project structure** — identify relevant source directories to determine correct import or load paths
 
-describe("${featureName} - Acceptance Tests", () => {
-  test("AC-1: <description>", async () => {
-    // Test implementation
-  });
 
-  test("AC-2: <description>", async () => {
-    // Test implementation
-  });
-});
-\`\`\`
+## Step 3: Generate the Acceptance Test File
 
-**Important**:
-- Import the feature code being tested
-- Set up any necessary test fixtures
-- Use expect() assertions to verify behavior
-- Clean up resources if needed (close connections, delete temp files)
+Write the complete acceptance test file using the framework identified in Step 2.
 
-Respond with ONLY the TypeScript test code (no markdown code fences, no explanation).`;
+Rules:
+- **One test per AC**, named exactly "AC-N: <description>"
+- **file-check ACs** → read source files using the language's standard file I/O, assert with string or regex checks. Do not start the application.
+- **runtime-check ACs** → load or import the module directly and invoke it, assert on the return value or observable side effects
+- **integration-check ACs** → use the language's HTTP client or existing test helpers; add a clear setup block (beforeAll/setup/TestMain/etc.) explaining what must be running
+- **NEVER use placeholder assertions** — no always-passing or always-failing stubs, no TODO comments as the only content, no empty test bodies
+- Every test MUST have real assertions that PASS when the feature is correctly implemented and FAIL when it is broken
+- Output raw code only — no markdown fences, start directly with the language's import or package declaration`;
 }
 
 /**
@@ -313,6 +303,8 @@ export async function generateAcceptanceTests(
     const output = await adapter.complete(prompt, {
       model: options.modelDef.model,
       config: options.config,
+      timeoutMs: options.config?.acceptance?.timeoutMs ?? 1800000,
+      workdir: options.workdir,
     });
 
     // Extract test code from output

package/src/acceptance/types.ts

@@ -4,6 +4,7 @@
  * Types for generating acceptance tests from spec.md acceptance criteria.
  */
 
+import type { AgentAdapter } from "../agents/types";
 import type { AcceptanceTestStrategy, ModelDef, ModelTier, NaxConfig } from "../config/schema";
 
 /**
@@ -94,6 +95,8 @@ export interface GenerateFromPRDOptions {
   testStrategy?: AcceptanceTestStrategy;
   /** Test framework for component/snapshot strategies (e.g. 'ink-testing-library', 'react') */
   testFramework?: string;
+  /** Agent adapter to use for test generation — overrides _generatorPRDDeps.adapter */
+  adapter?: AgentAdapter;
 }
 
 export interface GenerateAcceptanceTestsOptions {

package/src/cli/config-descriptions.ts

@@ -141,6 +141,7 @@ export const FIELD_DESCRIPTIONS: Record<string, string> = {
   "acceptance.maxRetries": "Max retry loops for fix stories",
   "acceptance.generateTests": "Generate acceptance tests during analyze",
   "acceptance.testPath": "Path to acceptance test file (relative to feature dir)",
+  "acceptance.timeoutMs": "Timeout for acceptance test generation in milliseconds (default: 1800000 = 30 min)",
 
   // Context
   context: "Context injection configuration",

package/src/config/defaults.ts

@@ -168,6 +168,7 @@ export const DEFAULT_CONFIG: NaxConfig = {
     model: "fast" as const,
     refinement: true,
     redGate: true,
+    timeoutMs: 1800000,
   },
   context: {
     fileInjection: "disabled",

package/src/config/runtime-types.ts

@@ -262,6 +262,8 @@ export interface AcceptanceConfig {
   testStrategy?: AcceptanceTestStrategy;
   /** Test framework for acceptance tests (default: auto-detect) */
   testFramework?: string;
+  /** Timeout for acceptance test generation in milliseconds (default: 1800000 = 30 min) */
+  timeoutMs: number;
 }
 
 /** Optimizer config (v0.10) */

package/src/config/schemas.ts

@@ -257,6 +257,7 @@ export const AcceptanceConfigSchema = z.object({
   redGate: z.boolean().default(true),
   testStrategy: z.enum(["unit", "component", "cli", "e2e", "snapshot"]).optional(),
   testFramework: z.string().min(1, "acceptance.testFramework must be non-empty").optional(),
+  timeoutMs: z.number().int().min(30000).max(3600000).default(1800000),
 });
 
 const TestCoverageConfigSchema = z.object({

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

@@ -55,6 +55,11 @@ export interface AcceptanceLoopResult {
   prdDirty: boolean;
 }
 
+export function isStubTestFile(content: string): boolean {
+  // Detect skeleton stubs: expect(true).toBe(false) or expect(true).toBe(true) in test bodies
+  return /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*(?:false|true)\s*\)/.test(content);
+}
+
 /** Load spec.md content for AC text */
 async function loadSpecContent(featureDir?: string): Promise<string> {
   if (!featureDir) return "";
@@ -243,6 +248,30 @@ export async function runAcceptanceLoop(ctx: AcceptanceLoopContext): Promise<Acc
       return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
     }
 
+    // Check for stub test file before generating fix stories
+    if (ctx.featureDir) {
+      const testPath = path.join(ctx.featureDir, "acceptance.test.ts");
+      const testFile = Bun.file(testPath);
+      if (await testFile.exists()) {
+        const testContent = await testFile.text();
+        if (isStubTestFile(testContent)) {
+          logger?.warn("acceptance", "Stub tests detected — re-generating acceptance tests");
+          const { unlink } = await import("node:fs/promises");
+          await unlink(testPath);
+          const { acceptanceSetupStage } = await import("../../pipeline/stages/acceptance-setup");
+          await acceptanceSetupStage.execute(acceptanceContext);
+          const newContent = await Bun.file(testPath).text();
+          if (isStubTestFile(newContent)) {
+            logger?.error(
+              "acceptance",
+              "Acceptance test generation failed after retry — manual implementation required",
+            );
+            return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
+          }
+        }
+      }
+    }
+
     // Generate and add fix stories
     logger?.info("acceptance", "Generating fix stories...");
     const fixStories = await generateAndAddFixStories(ctx, failures, prd);

package/src/pipeline/stages/acceptance-setup.ts

@@ -82,6 +82,9 @@ export const acceptanceSetupStage: PipelineStage = {
       const allCriteria: string[] = ctx.prd.userStories.flatMap((s) => s.acceptanceCriteria);
       totalCriteria = allCriteria.length;
 
+      const { getAgent } = await import("../../agents");
+      const agent = (ctx.agentGetFn ?? getAgent)(ctx.config.autoMode.defaultAgent);
+
       let refinedCriteria: RefinedCriterion[];
 
       if (ctx.config.acceptance.refinement) {
@@ -113,6 +116,7 @@ export const acceptanceSetupStage: PipelineStage = {
         config: ctx.config,
         testStrategy: ctx.config.acceptance.testStrategy,
         testFramework: ctx.config.acceptance.testFramework,
+        adapter: agent ?? undefined,
       });
 
       await _acceptanceSetupDeps.writeFile(testPath, result.testCode);