@nathapp/nax 0.50.1 → 0.50.3

package/README.md

@@ -522,12 +522,16 @@ The hermetic requirement is injected into all code-writing prompts (test-writer,
 
 ### Configuration
 
+Configured under `quality.testing` — supports **per-package override** in monorepos.
+
 ```json
 {
-  "testing": {
-    "hermetic": true,
-    "externalBoundaries": ["claude", "acpx", "redis", "grpc"],
-    "mockGuidance": "Use injectable deps for CLI spawning, ioredis-mock for Redis"
+  "quality": {
+    "testing": {
+      "hermetic": true,
+      "externalBoundaries": ["claude", "acpx", "redis", "grpc"],
+      "mockGuidance": "Use injectable deps for CLI spawning, ioredis-mock for Redis"
+    }
   }
 }
 ```
@@ -540,7 +544,9 @@ The hermetic requirement is injected into all code-writing prompts (test-writer,
 
 > **Tip:** `externalBoundaries` and `mockGuidance` complement `context.md`. nax provides the rule ("mock all I/O"), while `context.md` provides project-specific knowledge ("use `ioredis-mock` for Redis"). Use both for best results.
 
-> **Opt-out:** Set `testing.hermetic: false` if your project requires real integration calls (e.g. live database tests against a local dev container).
+> **Monorepo:** Each package can override `quality.testing` in its own `packages/<name>/nax/config.json`. For example, `packages/api` can specify Redis boundaries while `packages/web` specifies HTTP-only.
+
+> **Opt-out:** Set `quality.testing.hermetic: false` if your project requires real integration calls (e.g. live database tests against a local dev container).
 
 ---
 

package/dist/nax.js

@@ -17678,7 +17678,7 @@ var init_zod = __esm(() => {
 });
 
 // src/config/schemas.ts
-var TokenPricingSchema, ModelDefSchema, ModelEntrySchema, ModelMapSchema, ModelTierSchema, TierConfigSchema, AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema, AnalyzeConfigSchema, ReviewConfigSchema, PlanConfigSchema, AcceptanceConfigSchema, TestCoverageConfigSchema, ContextAutoDetectConfigSchema, ContextConfigSchema, AdaptiveRoutingConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, TestingConfigSchema, DecomposeConfigSchema, NaxConfigSchema;
+var TokenPricingSchema, ModelDefSchema, ModelEntrySchema, ModelMapSchema, ModelTierSchema, TierConfigSchema, AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema, AnalyzeConfigSchema, ReviewConfigSchema, PlanConfigSchema, AcceptanceConfigSchema, TestCoverageConfigSchema, ContextAutoDetectConfigSchema, ContextConfigSchema, AdaptiveRoutingConfigSchema, LlmRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, DecomposeConfigSchema, NaxConfigSchema;
 var init_schemas3 = __esm(() => {
   init_zod();
   TokenPricingSchema = exports_external.object({
@@ -17818,7 +17818,12 @@ var init_schemas3 = __esm(() => {
       "SENTRY_AUTH_TOKEN",
       "DATADOG_API_KEY"
     ]),
-    environmentalEscalationDivisor: exports_external.number().min(1).max(10).default(2)
+    environmentalEscalationDivisor: exports_external.number().min(1).max(10).default(2),
+    testing: exports_external.object({
+      hermetic: exports_external.boolean().default(true),
+      externalBoundaries: exports_external.array(exports_external.string()).optional(),
+      mockGuidance: exports_external.string().optional()
+    }).optional()
   });
   TddConfigSchema = exports_external.object({
     maxRetries: exports_external.number().int().nonnegative(),
@@ -17869,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),
@@ -17965,11 +17971,6 @@ var init_schemas3 = __esm(() => {
       message: "Role must be one of: test-writer, implementer, verifier, single-session, tdd-simple"
     }), exports_external.string().min(1, "Override path must be non-empty")).optional()
   });
-  TestingConfigSchema = exports_external.object({
-    hermetic: exports_external.boolean().default(true),
-    externalBoundaries: exports_external.array(exports_external.string()).optional(),
-    mockGuidance: exports_external.string().optional()
-  });
   DecomposeConfigSchema = exports_external.object({
     trigger: exports_external.enum(["auto", "confirm", "disabled"]).default("auto"),
     maxAcceptanceCriteria: exports_external.number().int().min(1).default(6),
@@ -18000,8 +18001,7 @@ var init_schemas3 = __esm(() => {
     agent: AgentConfigSchema.optional(),
     precheck: PrecheckConfigSchema.optional(),
     prompts: PromptsConfigSchema.optional(),
-    decompose: DecomposeConfigSchema.optional(),
-    testing: TestingConfigSchema.optional()
+    decompose: DecomposeConfigSchema.optional()
   }).refine((data) => data.version === 1, {
     message: "Invalid version: expected 1",
     path: ["version"]
@@ -18118,7 +18118,10 @@ var init_defaults = __esm(() => {
         "SENTRY_AUTH_TOKEN",
         "DATADOG_API_KEY"
       ],
-      environmentalEscalationDivisor: 2
+      environmentalEscalationDivisor: 2,
+      testing: {
+        hermetic: true
+      }
     },
     tdd: {
       maxRetries: 2,
@@ -18161,7 +18164,8 @@ var init_defaults = __esm(() => {
       testPath: "acceptance.test.ts",
       model: "fast",
       refinement: true,
-      redGate: true
+      redGate: true,
+      timeoutMs: 1800000
     },
     context: {
       fileInjection: "disabled",
@@ -18206,9 +18210,6 @@ var init_defaults = __esm(() => {
       maxSubstoryComplexity: "medium",
       maxRetries: 2,
       model: "balanced"
-    },
-    testing: {
-      hermetic: true
     }
   };
 });
@@ -18726,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
+
+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 (refined):
+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
+
+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** \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) {
@@ -18775,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(`
@@ -18832,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:
+## Step 2: Explore the Project
 
-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
+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
 
-Use this structure:
 
-\`\`\`typescript
-import { describe, test, expect } from "bun:test";
+## Step 3: Generate the Acceptance Test File
 
-describe("${featureName} - Acceptance Tests", () => {
-  test("AC-1: <description>", async () => {
-    // Test implementation
-  });
+Write the complete acceptance test file using the framework identified in Step 2.
 
-  test("AC-2: <description>", async () => {
-    // Test implementation
-  });
-});
-\`\`\`
-
-**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)
-
-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();
@@ -18888,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) {
@@ -20827,7 +20804,8 @@ function mergePackageConfig(root, packageOverride) {
       commands: {
         ...root.quality.commands,
         ...packageOverride.quality?.commands
-      }
+      },
+      testing: packageOverride.quality?.testing !== undefined ? { ...root.quality.testing, ...packageOverride.quality.testing } : root.quality.testing
     },
     context: {
       ...root.context,
@@ -22351,7 +22329,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.50.1",
+    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("5ff4e09"))
-        return "5ff4e09";
+      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;
@@ -27659,13 +27645,13 @@ async function runTddSession(role, agent, story, config2, workdir, modelTier, be
   } else {
     switch (role) {
       case "test-writer":
-        prompt = await PromptBuilder.for("test-writer", { isolation: lite ? "lite" : "strict" }).withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).testCommand(config2.quality?.commands?.test).hermeticConfig(config2.testing).build();
+        prompt = await PromptBuilder.for("test-writer", { isolation: lite ? "lite" : "strict" }).withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).testCommand(config2.quality?.commands?.test).hermeticConfig(config2.quality?.testing).build();
         break;
       case "implementer":
-        prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" }).withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).testCommand(config2.quality?.commands?.test).hermeticConfig(config2.testing).build();
+        prompt = await PromptBuilder.for("implementer", { variant: lite ? "lite" : "standard" }).withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).testCommand(config2.quality?.commands?.test).hermeticConfig(config2.quality?.testing).build();
         break;
       case "verifier":
-        prompt = await PromptBuilder.for("verifier").withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).testCommand(config2.quality?.commands?.test).hermeticConfig(config2.testing).build();
+        prompt = await PromptBuilder.for("verifier").withLoader(workdir, config2).story(story).context(contextMarkdown).constitution(constitution).testCommand(config2.quality?.commands?.test).hermeticConfig(config2.quality?.testing).build();
         break;
     }
   }
@@ -28788,11 +28774,11 @@ var init_prompt = __esm(() => {
       const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
       let prompt;
       if (isBatch) {
-        const builder = PromptBuilder.for("batch").withLoader(ctx.workdir, ctx.config).stories(ctx.stories).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(effectiveConfig.quality?.commands?.test).hermeticConfig(effectiveConfig.testing);
+        const builder = PromptBuilder.for("batch").withLoader(ctx.workdir, ctx.config).stories(ctx.stories).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(effectiveConfig.quality?.commands?.test).hermeticConfig(effectiveConfig.quality?.testing);
         prompt = await builder.build();
       } else {
         const role = "tdd-simple";
-        const builder = PromptBuilder.for(role).withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(effectiveConfig.quality?.commands?.test).hermeticConfig(effectiveConfig.testing);
+        const builder = PromptBuilder.for(role).withLoader(ctx.workdir, ctx.config).story(ctx.story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(effectiveConfig.quality?.commands?.test).hermeticConfig(effectiveConfig.quality?.testing);
         prompt = await builder.build();
       }
       ctx.prompt = prompt;
@@ -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",
@@ -69678,10 +69688,10 @@ var FIELD_DESCRIPTIONS = {
   agent: "Agent protocol configuration (ACP-003)",
   "agent.protocol": "Protocol for agent communication: 'acp' | 'cli' (default: 'acp')",
   "agent.maxInteractionTurns": "Max turns in multi-turn interaction loop when interactionBridge is active (default: 10)",
-  testing: "Hermetic test enforcement configuration (ENH-010)",
-  "testing.hermetic": "Inject hermetic test requirement into prompts \u2014 never call real external services in tests (default: true)",
-  "testing.externalBoundaries": "Project-specific CLI tools/clients to mock (e.g. ['claude', 'acpx', 'redis'])",
-  "testing.mockGuidance": "Project-specific mocking guidance injected verbatim into the prompt"
+  "quality.testing": "Hermetic test enforcement \u2014 per-package overridable (ENH-010)",
+  "quality.testing.hermetic": "Inject hermetic test requirement into prompts \u2014 never call real external services in tests (default: true)",
+  "quality.testing.externalBoundaries": "Project-specific CLI tools/clients to mock (e.g. ['claude', 'acpx', 'redis'])",
+  "quality.testing.mockGuidance": "Project-specific mocking guidance injected verbatim into the prompt"
 };
 
 // src/cli/config-diff.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.50.1",
+  "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",
@@ -209,10 +210,10 @@ export const FIELD_DESCRIPTIONS: Record<string, string> = {
   "agent.protocol": "Protocol for agent communication: 'acp' | 'cli' (default: 'acp')",
   "agent.maxInteractionTurns":
     "Max turns in multi-turn interaction loop when interactionBridge is active (default: 10)",
-  // Testing
-  testing: "Hermetic test enforcement configuration (ENH-010)",
-  "testing.hermetic":
+  // quality.testing (ENH-010) — per-package overridable
+  "quality.testing": "Hermetic test enforcement — per-package overridable (ENH-010)",
+  "quality.testing.hermetic":
     "Inject hermetic test requirement into prompts — never call real external services in tests (default: true)",
-  "testing.externalBoundaries": "Project-specific CLI tools/clients to mock (e.g. ['claude', 'acpx', 'redis'])",
-  "testing.mockGuidance": "Project-specific mocking guidance injected verbatim into the prompt",
+  "quality.testing.externalBoundaries": "Project-specific CLI tools/clients to mock (e.g. ['claude', 'acpx', 'redis'])",
+  "quality.testing.mockGuidance": "Project-specific mocking guidance injected verbatim into the prompt",
 };

package/src/config/defaults.ts

@@ -121,6 +121,9 @@ export const DEFAULT_CONFIG: NaxConfig = {
       "DATADOG_API_KEY",
     ],
     environmentalEscalationDivisor: 2,
+    testing: {
+      hermetic: true,
+    },
   },
   tdd: {
     maxRetries: 2,
@@ -165,6 +168,7 @@ export const DEFAULT_CONFIG: NaxConfig = {
     model: "fast" as const,
     refinement: true,
     redGate: true,
+    timeoutMs: 1800000,
   },
   context: {
     fileInjection: "disabled",
@@ -211,7 +215,4 @@ export const DEFAULT_CONFIG: NaxConfig = {
     maxRetries: 2,
     model: "balanced",
   },
-  testing: {
-    hermetic: true,
-  },
 };

package/src/config/merge.ts

@@ -15,7 +15,7 @@ import type { NaxConfig } from "./schema";
  * - execution: smartTestRunner, regressionGate (deep), verificationTimeoutSeconds
  * - review: enabled, checks, commands (deep), pluginMode
  * - acceptance: enabled, generateTests, testPath
- * - quality: requireTests, requireTypecheck, requireLint, commands (deep)
+ * - quality: requireTests, requireTypecheck, requireLint, commands (deep), testing (deep)
  * - context: testCoverage (deep)
  *
  * All other sections (models, autoMode, routing, agent, generate, tdd,
@@ -89,6 +89,11 @@ export function mergePackageConfig(root: NaxConfig, packageOverride: Partial<Nax
         ...root.quality.commands,
         ...packageOverride.quality?.commands,
       },
+      // ENH-010: deep-merge testing config so per-package overrides work
+      testing:
+        packageOverride.quality?.testing !== undefined
+          ? { ...root.quality.testing, ...packageOverride.quality.testing }
+          : root.quality.testing,
     },
     context: {
       ...root.context,

package/src/config/runtime-types.ts

@@ -160,6 +160,8 @@ export interface QualityConfig {
   stripEnvVars: string[];
   /** Divisor for environmental failure early escalation (default: 2 = half the tier budget) */
   environmentalEscalationDivisor: number;
+  /** Hermetic test enforcement settings (ENH-010). Supports per-package override. */
+  testing?: TestingConfig;
 }
 
 /** TDD config */
@@ -260,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) */
@@ -495,8 +499,6 @@ export interface NaxConfig {
   decompose?: DecomposeConfig;
   /** Agent protocol settings (ACP-003) */
   agent?: AgentConfig;
-  /** Hermetic test enforcement settings (ENH-010) */
-  testing?: TestingConfig;
   /** Generate settings */
   generate?: GenerateConfig;
 }

package/src/config/schemas.ts

@@ -175,6 +175,29 @@ const QualityConfigSchema = z.object({
       "DATADOG_API_KEY",
     ]),
   environmentalEscalationDivisor: z.number().min(1).max(10).default(2),
+  testing: z
+    .object({
+      /**
+       * When true (default), nax injects a hermetic test requirement into all code-writing prompts.
+       * Instructs the AI to mock all I/O boundaries (HTTP, CLI spawning, databases, etc.)
+       * and never invoke real external processes or services during test execution.
+       * Set to false only if your project requires real integration calls in tests.
+       */
+      hermetic: z.boolean().default(true),
+      /**
+       * Project-specific external boundaries the AI should watch for and mock.
+       * E.g. ["claude", "acpx", "redis", "grpc"] — any CLI tools, clients, or services
+       * the project uses that should never be called from tests.
+       */
+      externalBoundaries: z.array(z.string()).optional(),
+      /**
+       * Project-specific guidance on how to mock external dependencies.
+       * Injected verbatim into the hermetic requirement section of the prompt.
+       * E.g. "Use injectable deps for CLI spawning, ioredis-mock for Redis"
+       */
+      mockGuidance: z.string().optional(),
+    })
+    .optional(),
 });
 
 const TddConfigSchema = z.object({
@@ -234,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({
@@ -362,28 +386,6 @@ export const PromptsConfigSchema = z.object({
     .optional(),
 });
 
-const TestingConfigSchema = z.object({
-  /**
-   * When true (default), nax injects a hermetic test requirement into all code-writing prompts.
-   * Instructs the AI to mock all I/O boundaries (HTTP, CLI spawning, databases, etc.)
-   * and never invoke real external processes or services during test execution.
-   * Set to false only if your project requires real integration calls in tests.
-   */
-  hermetic: z.boolean().default(true),
-  /**
-   * Project-specific external boundaries the AI should watch for and mock.
-   * E.g. ["claude", "acpx", "redis", "grpc"] — any CLI tools, clients, or services
-   * the project uses that should never be called from tests.
-   */
-  externalBoundaries: z.array(z.string()).optional(),
-  /**
-   * Project-specific guidance on how to mock external dependencies.
-   * Injected verbatim into the hermetic requirement section of the prompt.
-   * E.g. "Use injectable deps for CLI spawning, ioredis-mock for Redis"
-   */
-  mockGuidance: z.string().optional(),
-});
-
 const DecomposeConfigSchema = z.object({
   trigger: z.enum(["auto", "confirm", "disabled"]).default("auto"),
   maxAcceptanceCriteria: z.number().int().min(1).default(6),
@@ -417,7 +419,6 @@ export const NaxConfigSchema = z
     precheck: PrecheckConfigSchema.optional(),
     prompts: PromptsConfigSchema.optional(),
     decompose: DecomposeConfigSchema.optional(),
-    testing: TestingConfigSchema.optional(),
   })
   .refine((data) => data.version === 1, {
     message: "Invalid version: expected 1",

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);

package/src/pipeline/stages/prompt.ts

@@ -45,7 +45,7 @@ export const promptStage: PipelineStage = {
         .context(ctx.contextMarkdown)
         .constitution(ctx.constitution?.content)
         .testCommand(effectiveConfig.quality?.commands?.test)
-        .hermeticConfig(effectiveConfig.testing);
+        .hermeticConfig(effectiveConfig.quality?.testing);
       prompt = await builder.build();
     } else {
       // Both test-after and tdd-simple use the tdd-simple prompt (RED/GREEN/REFACTOR)
@@ -56,7 +56,7 @@ export const promptStage: PipelineStage = {
         .context(ctx.contextMarkdown)
         .constitution(ctx.constitution?.content)
         .testCommand(effectiveConfig.quality?.commands?.test)
-        .hermeticConfig(effectiveConfig.testing);
+        .hermeticConfig(effectiveConfig.quality?.testing);
       prompt = await builder.build();
     }
 

package/src/tdd/session-runner.ts

@@ -133,7 +133,7 @@ export async function runTddSession(
           .context(contextMarkdown)
           .constitution(constitution)
           .testCommand(config.quality?.commands?.test)
-          .hermeticConfig(config.testing)
+          .hermeticConfig(config.quality?.testing)
           .build();
         break;
       case "implementer":
@@ -143,7 +143,7 @@ export async function runTddSession(
           .context(contextMarkdown)
           .constitution(constitution)
           .testCommand(config.quality?.commands?.test)
-          .hermeticConfig(config.testing)
+          .hermeticConfig(config.quality?.testing)
           .build();
         break;
       case "verifier":
@@ -153,7 +153,7 @@ export async function runTddSession(
           .context(contextMarkdown)
           .constitution(constitution)
           .testCommand(config.quality?.commands?.test)
-          .hermeticConfig(config.testing)
+          .hermeticConfig(config.quality?.testing)
           .build();
         break;
     }