@nathapp/nax 0.50.2 → 0.51.0

package/dist/nax.js

@@ -3246,6 +3246,8 @@ function resolveTestStrategy(raw) {
     return "test-after";
   if (VALID_TEST_STRATEGIES.includes(raw))
     return raw;
+  if (raw === "none")
+    return "no-test";
   if (raw === "tdd")
     return "tdd-simple";
   if (raw === "three-session")
@@ -3256,6 +3258,9 @@ function resolveTestStrategy(raw) {
 }
 var VALID_TEST_STRATEGIES, COMPLEXITY_GUIDE = `## Complexity Classification Guide
 
+- no-test: Config-only changes, documentation, CI/build files, dependency bumps, pure refactors
+  with NO behavioral change. MUST include noTestJustification explaining why tests are unnecessary.
+  If any user-facing behavior changes, use tdd-simple or higher.
 - simple: \u226450 LOC, single-file change, purely additive, no new dependencies \u2192 tdd-simple
 - medium: 50\u2013200 LOC, 2\u20135 files, standard patterns, clear requirements \u2192 three-session-tdd-lite
 - complex: 200\u2013500 LOC, multiple modules, new abstractions or integrations \u2192 three-session-tdd
@@ -3266,6 +3271,9 @@ var VALID_TEST_STRATEGIES, COMPLEXITY_GUIDE = `## Complexity Classification Guid
 Security-critical functions (authentication, cryptography, tokens, sessions, credentials,
 password hashing, access control) must use three-session-tdd regardless of complexity.`, TEST_STRATEGY_GUIDE = `## Test Strategy Guide
 
+- no-test: Stories with zero behavioral change \u2014 config files, documentation, CI/build changes,
+  dependency bumps, pure structural refactors. REQUIRES noTestJustification field. If any runtime
+  behavior changes, use tdd-simple or higher. When in doubt, use tdd-simple.
 - tdd-simple: Simple stories (\u226450 LOC). Write failing tests first, then implement to pass them \u2014 all in one session.
 - three-session-tdd-lite: Medium stories, or complex stories involving UI/CLI/integration. 3 sessions: (1) test-writer writes failing tests and may create minimal src/ stubs for imports, (2) implementer makes tests pass and may replace stubs, (3) verifier confirms correctness.
 - three-session-tdd: Complex/expert stories or security-critical code. 3 sessions with strict isolation: (1) test-writer writes failing tests \u2014 no src/ changes allowed, (2) implementer makes them pass without modifying test files, (3) verifier confirms correctness.
@@ -3283,6 +3291,7 @@ password hashing, access control) must use three-session-tdd regardless of compl
 - Aim for coherent units of value. Maximum recommended stories: 10-15 per feature.`;
 var init_test_strategy = __esm(() => {
   VALID_TEST_STRATEGIES = [
+    "no-test",
     "test-after",
     "tdd-simple",
     "three-session-tdd",
@@ -17874,7 +17883,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),
@@ -17966,8 +17976,8 @@ var init_schemas3 = __esm(() => {
     storySizeGate: StorySizeGateConfigSchema
   });
   PromptsConfigSchema = exports_external.object({
-    overrides: exports_external.record(exports_external.string().refine((key) => ["test-writer", "implementer", "verifier", "single-session", "tdd-simple"].includes(key), {
-      message: "Role must be one of: test-writer, implementer, verifier, single-session, tdd-simple"
+    overrides: exports_external.record(exports_external.string().refine((key) => ["no-test", "test-writer", "implementer", "verifier", "single-session", "tdd-simple"].includes(key), {
+      message: "Role must be one of: no-test, test-writer, implementer, verifier, single-session, tdd-simple"
     }), exports_external.string().min(1, "Override path must be non-empty")).optional()
   });
   DecomposeConfigSchema = exports_external.object({
@@ -18163,7 +18173,8 @@ var init_defaults = __esm(() => {
       testPath: "acceptance.test.ts",
       model: "fast",
       refinement: true,
-      redGate: true
+      redGate: true,
+      timeoutMs: 1800000
     },
     context: {
       fileInjection: "disabled",
@@ -18725,32 +18736,49 @@ 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
+- **Path anchor (CRITICAL)**: This test file will be saved at \`<repo-root>/nax/features/${options.featureName}/acceptance.test.ts\` and will ALWAYS run from the repo root via \`bun test <absolute-path>\`. The repo root is exactly 3 \`../\` levels above \`__dirname\`: \`join(__dirname, '..', '..', '..')\`. Never use 4 or more \`../\` \u2014 that would escape the repo. For monorepo projects, navigate into packages from root (e.g. \`join(root, 'apps/api/src')\`).`;
+  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 +18802,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 +18825,39 @@ 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
+- **Path anchor (CRITICAL)**: This test file will be saved at \`<repo-root>/nax/features/${featureName}/acceptance.test.ts\` and will ALWAYS run from the repo root via \`bun test <absolute-path>\`. The repo root is exactly 3 \`../\` levels above \`__dirname\`: \`join(__dirname, '..', '..', '..')\`. Never use 4 or more \`../\` \u2014 that would escape the repo. For monorepo projects, navigate into packages from root (e.g. \`join(root, 'apps/api/src')\`).`;
 }
 async function generateAcceptanceTests(adapter, options) {
   const logger = getLogger();
@@ -18887,7 +18874,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) {
@@ -18983,7 +18972,34 @@ function findRelatedStories(failedAC, prd) {
   const passedStories = prd.userStories.filter((s) => s.status === "passed").map((s) => s.id);
   return passedStories.slice(0, 5);
 }
-function buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd) {
+function groupACsByRelatedStories(failedACs, prd) {
+  const groups = new Map;
+  for (const ac of failedACs) {
+    const related = findRelatedStories(ac, prd);
+    const key = [...related].sort().join(",");
+    if (!groups.has(key)) {
+      groups.set(key, { acs: [], relatedStories: related });
+    }
+    groups.get(key)?.acs.push(ac);
+  }
+  const result = Array.from(groups.values());
+  while (result.length > MAX_FIX_STORIES) {
+    result.sort((a, b) => a.acs.length - b.acs.length);
+    const smallest = result.shift();
+    if (!smallest)
+      break;
+    result[0].acs.push(...smallest.acs);
+    for (const s of smallest.relatedStories) {
+      if (!result[0].relatedStories.includes(s)) {
+        result[0].relatedStories.push(s);
+      }
+    }
+  }
+  return result;
+}
+function buildFixPrompt(batchedACs, acTextMap, testOutput, relatedStories, prd, testFilePath) {
+  const acList = batchedACs.map((ac) => `${ac}: ${acTextMap[ac] || "No description available"}`).join(`
+`);
   const relatedStoriesText = relatedStories.map((id) => {
     const story = prd.userStories.find((s) => s.id === id);
     if (!story)
@@ -18993,43 +19009,47 @@ function buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd) {
   }).filter(Boolean).join(`
 
 `);
-  return `You are a debugging expert. A feature acceptance test has failed.
-
-FAILED ACCEPTANCE CRITERION:
-${failedAC}: ${acText}
+  const testFileSection = testFilePath ? `
+ACCEPTANCE TEST FILE: ${testFilePath}
+(Read this file first to understand what each test expects)
+` : "";
+  return `You are a debugging expert. Feature acceptance tests have failed.${testFileSection}
+FAILED ACCEPTANCE CRITERIA (${batchedACs.length} total):
+${acList}
 
 TEST FAILURE OUTPUT:
-${testOutput}
+${testOutput.slice(0, 2000)}
 
 RELATED STORIES (implemented this functionality):
 ${relatedStoriesText}
 
-Your task: Generate a fix story description that will make the acceptance test pass.
+Your task: Generate a fix description that will make these acceptance tests pass.
 
 Requirements:
-1. Analyze the test failure to understand the root cause
-2. Identify what needs to change in the code
-3. Write a clear, actionable fix description (2-4 sentences)
-4. Focus on the specific issue, not general improvements
+1. Read the acceptance test file first to understand what each failing test expects
+2. Identify the root cause based on the test failure output
+3. Find and fix the relevant implementation code (do NOT modify the test file)
+4. Write a clear, actionable fix description (2-4 sentences)
 5. Reference the relevant story IDs if needed
 
 Respond with ONLY the fix description (no JSON, no markdown, just the description text).`;
 }
 async function generateFixStories(adapter, options) {
-  const { failedACs, testOutput, prd, specContent, modelDef } = options;
-  const fixStories = [];
-  const acTextMap = parseACTextFromSpec(specContent);
+  const { failedACs, testOutput, prd, specContent, modelDef, testFilePath } = options;
   const logger = getLogger();
-  for (let i = 0;i < failedACs.length; i++) {
-    const failedAC = failedACs[i];
-    const acText = acTextMap[failedAC] || "No description available";
-    logger.info("acceptance", "Generating fix for failed AC", { failedAC });
-    const relatedStories = findRelatedStories(failedAC, prd);
+  const acTextMap = parseACTextFromSpec(specContent);
+  const groups = groupACsByRelatedStories(failedACs, prd);
+  const fixStories = [];
+  for (let i = 0;i < groups.length; i++) {
+    const { acs: batchedACs, relatedStories } = groups[i];
     if (relatedStories.length === 0) {
-      logger.warn("acceptance", "\u26A0 No related stories found for failed AC \u2014 skipping", { failedAC });
+      logger.warn("acceptance", "[WARN] No related stories found for AC group \u2014 skipping", { batchedACs });
       continue;
     }
-    const prompt = buildFixPrompt(failedAC, acText, testOutput, relatedStories, prd);
+    logger.info("acceptance", "Generating fix for AC group", { batchedACs });
+    const prompt = buildFixPrompt(batchedACs, acTextMap, testOutput, relatedStories, prd, testFilePath);
+    const relatedStory = prd.userStories.find((s) => relatedStories.includes(s.id) && s.workdir);
+    const workdir = relatedStory?.workdir;
     try {
       const fixDescription = await adapter.complete(prompt, {
         model: modelDef.model,
@@ -19037,25 +19057,31 @@ async function generateFixStories(adapter, options) {
       });
       fixStories.push({
         id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-        title: `Fix: ${failedAC} \u2014 ${acText.slice(0, 50)}`,
-        failedAC,
+        title: `Fix: ${batchedACs.join(", ")} \u2014 ${(acTextMap[batchedACs[0]] || "").slice(0, 40)}`,
+        failedAC: batchedACs[0],
+        batchedACs,
         testOutput,
         relatedStories,
-        description: fixDescription
+        description: fixDescription,
+        testFilePath,
+        workdir
       });
-      logger.info("acceptance", "\u2713 Generated fix story", { storyId: fixStories[fixStories.length - 1].id });
+      logger.info("acceptance", "[OK] Generated fix story", { storyId: fixStories[fixStories.length - 1].id });
     } catch (error48) {
-      logger.warn("acceptance", "\u26A0 Error generating fix", {
-        failedAC,
+      logger.warn("acceptance", "[WARN] Error generating fix", {
+        batchedACs,
         error: error48.message
       });
       fixStories.push({
         id: `US-FIX-${String(i + 1).padStart(3, "0")}`,
-        title: `Fix: ${failedAC}`,
-        failedAC,
+        title: `Fix: ${batchedACs.join(", ")}`,
+        failedAC: batchedACs[0],
+        batchedACs,
         testOutput,
         relatedStories,
-        description: `Fix the implementation to make ${failedAC} pass. Related stories: ${relatedStories.join(", ")}.`
+        description: `Fix the implementation to make ${batchedACs.join(", ")} pass. Related stories: ${relatedStories.join(", ")}.`,
+        testFilePath,
+        workdir
       });
     }
   }
@@ -19076,20 +19102,40 @@ function parseACTextFromSpec(specContent) {
   return map2;
 }
 function convertFixStoryToUserStory(fixStory) {
+  const batchedACs = fixStory.batchedACs ?? [fixStory.failedAC];
+  const acList = batchedACs.join(", ");
+  const truncatedOutput = fixStory.testOutput.slice(0, 1000);
+  const testFilePath = fixStory.testFilePath ?? "acceptance.test.ts";
+  const enrichedDescription = [
+    fixStory.description,
+    "",
+    `ACCEPTANCE TEST FILE: ${testFilePath}`,
+    `FAILED ACCEPTANCE CRITERIA: ${acList}`,
+    "",
+    "TEST FAILURE OUTPUT:",
+    truncatedOutput,
+    "",
+    "Instructions: Read the acceptance test file first to understand what each failing test expects.",
+    "Then find the relevant source code and fix the implementation.",
+    "Do NOT modify the test file."
+  ].join(`
+`);
   return {
     id: fixStory.id,
     title: fixStory.title,
-    description: fixStory.description,
-    acceptanceCriteria: [`Fix ${fixStory.failedAC}`],
+    description: enrichedDescription,
+    acceptanceCriteria: batchedACs.map((ac) => `Fix ${ac}`),
     tags: ["fix", "acceptance-failure"],
     dependencies: fixStory.relatedStories,
     status: "pending",
     passes: false,
     escalations: [],
     attempts: 0,
-    contextFiles: []
+    contextFiles: [],
+    workdir: fixStory.workdir
   };
 }
+var MAX_FIX_STORIES = 8;
 var init_fix_generator = __esm(() => {
   init_logger2();
 });
@@ -19482,7 +19528,7 @@ async function closeAcpSession(session) {
   }
 }
 function acpSessionsPath(workdir, featureName) {
-  return join3(workdir, "nax", "features", featureName, "acp-sessions.json");
+  return join3(workdir, ".nax", "features", featureName, "acp-sessions.json");
 }
 function sidecarSessionName(entry) {
   return typeof entry === "string" ? entry : entry.sessionName;
@@ -20993,6 +21039,7 @@ import { join as join6, resolve as resolve4 } from "path";
 function globalConfigDir() {
   return join6(homedir3(), ".nax");
 }
+var PROJECT_NAX_DIR = ".nax";
 var init_paths = () => {};
 
 // src/config/loader.ts
@@ -21005,7 +21052,7 @@ function findProjectDir(startDir = process.cwd()) {
   let dir = resolve5(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const candidate = join7(dir, "nax");
+    const candidate = join7(dir, PROJECT_NAX_DIR);
     if (existsSync5(join7(candidate, "config.json"))) {
       return candidate;
     }
@@ -21075,7 +21122,7 @@ async function loadConfigForWorkdir(rootConfigPath, packageDir) {
     return rootConfig;
   }
   const repoRoot = dirname2(rootNaxDir);
-  const packageConfigPath = join7(repoRoot, packageDir, "nax", "config.json");
+  const packageConfigPath = join7(repoRoot, PROJECT_NAX_DIR, "packages", packageDir, "config.json");
   const packageOverride = await loadJsonFile(packageConfigPath, "config");
   if (!packageOverride) {
     return rootConfig;
@@ -22351,7 +22398,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.50.2",
+    version: "0.51.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -22402,8 +22449,6 @@ var init_package = __esm(() => {
     ],
     files: [
       "dist/",
-      "src/",
-      "bin/",
       "README.md",
       "CHANGELOG.md"
     ],
@@ -22425,8 +22470,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("bcb69c6"))
+        return "bcb69c6";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -22575,14 +22620,14 @@ function collectBatchMetrics(ctx, storyStartTime) {
   });
 }
 async function saveRunMetrics(workdir, runMetrics) {
-  const metricsPath = path2.join(workdir, "nax", "metrics.json");
+  const metricsPath = path2.join(workdir, ".nax", "metrics.json");
   const existing = await loadJsonFile(metricsPath, "metrics");
   const allMetrics = Array.isArray(existing) ? existing : [];
   allMetrics.push(runMetrics);
   await saveJsonFile(metricsPath, allMetrics, "metrics");
 }
 async function loadRunMetrics(workdir) {
-  const metricsPath = path2.join(workdir, "nax", "metrics.json");
+  const metricsPath = path2.join(workdir, ".nax", "metrics.json");
   const content = await loadJsonFile(metricsPath, "metrics");
   return Array.isArray(content) ? content : [];
 }
@@ -24180,8 +24225,114 @@ ${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, {
+  computeACFingerprint: () => computeACFingerprint,
+  acceptanceSetupStage: () => acceptanceSetupStage,
+  _acceptanceSetupDeps: () => _acceptanceSetupDeps
+});
 import path5 from "path";
+function computeACFingerprint(criteria) {
+  const sorted = [...criteria].sort().join(`
+`);
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(sorted);
+  return `sha256:${hasher.digest("hex")}`;
+}
 var _acceptanceSetupDeps, acceptanceSetupStage;
 var init_acceptance_setup = __esm(() => {
   init_config();
@@ -24193,6 +24344,27 @@ var init_acceptance_setup = __esm(() => {
     writeFile: async (filePath, content) => {
       await Bun.write(filePath, content);
     },
+    copyFile: async (src, dest) => {
+      const content = await Bun.file(src).text();
+      await Bun.write(dest, content);
+    },
+    deleteFile: async (filePath) => {
+      const { unlink } = await import("fs/promises");
+      await unlink(filePath);
+    },
+    readMeta: async (metaPath) => {
+      const f = Bun.file(metaPath);
+      if (!await f.exists())
+        return null;
+      try {
+        return JSON.parse(await f.text());
+      } catch {
+        return null;
+      }
+    },
+    writeMeta: async (metaPath, meta3) => {
+      await Bun.write(metaPath, JSON.stringify(meta3, null, 2));
+    },
     runTest: async (_testPath, _workdir) => {
       const proc = Bun.spawn(["bun", "test", _testPath], {
         cwd: _workdir,
@@ -24226,12 +24398,25 @@ ${stderr}` };
         return { action: "fail", reason: "[acceptance-setup] featureDir is not set" };
       }
       const testPath = path5.join(ctx.featureDir, "acceptance.test.ts");
-      const fileExists = await _acceptanceSetupDeps.fileExists(testPath);
+      const metaPath = path5.join(ctx.featureDir, "acceptance-meta.json");
+      const allCriteria = ctx.prd.userStories.flatMap((s) => s.acceptanceCriteria);
       let totalCriteria = 0;
       let testableCount = 0;
-      if (!fileExists) {
-        const allCriteria = ctx.prd.userStories.flatMap((s) => s.acceptanceCriteria);
+      const fileExists = await _acceptanceSetupDeps.fileExists(testPath);
+      let shouldGenerate = !fileExists;
+      if (fileExists) {
+        const fingerprint = computeACFingerprint(allCriteria);
+        const meta3 = await _acceptanceSetupDeps.readMeta(metaPath);
+        if (!meta3 || meta3.acFingerprint !== fingerprint) {
+          await _acceptanceSetupDeps.copyFile(testPath, `${testPath}.bak`);
+          await _acceptanceSetupDeps.deleteFile(testPath);
+          shouldGenerate = true;
+        }
+      }
+      if (shouldGenerate) {
         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,9 +24444,18 @@ ${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);
+        const fingerprint = computeACFingerprint(allCriteria);
+        await _acceptanceSetupDeps.writeMeta(metaPath, {
+          generatedAt: new Date().toISOString(),
+          acFingerprint: fingerprint,
+          storyCount: ctx.prd.userStories.length,
+          acCount: totalCriteria,
+          generator: "nax"
+        });
       }
       if (ctx.config.acceptance.redGate === false) {
         ctx.acceptanceSetup = { totalCriteria, testableCount, redFailCount: 0 };
@@ -24281,99 +24475,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;
@@ -24458,7 +24559,7 @@ function hasScript(packageJson, scriptName) {
     return false;
   return scriptName in scripts;
 }
-async function resolveCommand(check2, config2, executionConfig, workdir) {
+async function resolveCommand(check2, config2, executionConfig, workdir, qualityCommands) {
   if (executionConfig) {
     if (check2 === "lint" && executionConfig.lintCommand !== undefined) {
       return executionConfig.lintCommand;
@@ -24470,6 +24571,10 @@ async function resolveCommand(check2, config2, executionConfig, workdir) {
   if (config2.commands[check2]) {
     return config2.commands[check2] ?? null;
   }
+  const qualityCmd = qualityCommands?.[check2];
+  if (qualityCmd) {
+    return qualityCmd;
+  }
   const packageJson = await loadPackageJson(workdir);
   if (hasScript(packageJson, check2)) {
     return `bun run ${check2}`;
@@ -24567,7 +24672,7 @@ async function getUncommittedFilesImpl(workdir) {
     return [];
   }
 }
-async function runReview(config2, workdir, executionConfig) {
+async function runReview(config2, workdir, executionConfig, qualityCommands) {
   const startTime = Date.now();
   const logger = getSafeLogger();
   const checks3 = [];
@@ -24605,7 +24710,7 @@ Stage and commit these files before running review.`
     };
   }
   for (const checkName of config2.checks) {
-    const command = await resolveCommand(checkName, config2, executionConfig, workdir);
+    const command = await resolveCommand(checkName, config2, executionConfig, workdir, qualityCommands);
     if (command === null) {
       getSafeLogger()?.warn("review", `Skipping ${checkName} check (command not configured or disabled)`);
       continue;
@@ -24667,9 +24772,9 @@ async function getChangedFiles(workdir, baseRef) {
 }
 
 class ReviewOrchestrator {
-  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix) {
+  async review(reviewConfig, workdir, executionConfig, plugins, storyGitRef, scopePrefix, qualityCommands) {
     const logger = getSafeLogger();
-    const builtIn = await runReview(reviewConfig, workdir, executionConfig);
+    const builtIn = await runReview(reviewConfig, workdir, executionConfig, qualityCommands);
     if (!builtIn.success) {
       return { builtIn, success: false, failureReason: builtIn.failureReason, pluginFailed: false };
     }
@@ -24759,7 +24864,7 @@ var init_review = __esm(() => {
       const effectiveConfig = ctx.effectiveConfig ?? ctx.config;
       logger.info("review", "Running review phase", { storyId: ctx.story.id });
       const effectiveWorkdir = ctx.story.workdir ? join17(ctx.workdir, ctx.story.workdir) : ctx.workdir;
-      const result = await reviewOrchestrator.review(effectiveConfig.review, effectiveWorkdir, effectiveConfig.execution, ctx.plugins, ctx.storyGitRef, ctx.story.workdir);
+      const result = await reviewOrchestrator.review(effectiveConfig.review, effectiveWorkdir, effectiveConfig.execution, ctx.plugins, ctx.storyGitRef, ctx.story.workdir, effectiveConfig.quality?.commands);
       ctx.reviewResult = result.builtIn;
       if (!result.success) {
         const allFindings = result.builtIn.pluginReviewers?.flatMap((pr) => pr.findings ?? []) ?? [];
@@ -25976,7 +26081,7 @@ function hookCtx(feature, opts) {
   };
 }
 async function loadPackageContextMd(packageWorkdir) {
-  const contextPath = `${packageWorkdir}/nax/context.md`;
+  const contextPath = `${packageWorkdir}/.nax/context.md`;
   const file2 = Bun.file(contextPath);
   if (!await file2.exists())
     return null;
@@ -27158,6 +27263,11 @@ function buildIsolationSection(roleOrMode, mode, testCommand) {
   const footer = `
 
 ${buildTestFilterRule(testCmd)}`;
+  if (role === "no-test") {
+    return `${header}
+
+isolation scope: Implement changes in src/ and other non-test directories. Do NOT create or modify any files in the test/ directory.${footer}`;
+  }
   if (role === "test-writer") {
     const m = mode ?? "strict";
     if (m === "strict") {
@@ -27205,13 +27315,26 @@ function buildTestFrameworkHint(testCommand) {
     return "Use Jest (describe/test/expect)";
   return "Use your project's test framework";
 }
-function buildRoleTaskSection(roleOrVariant, variant, testCommand, isolation) {
+function buildRoleTaskSection(roleOrVariant, variant, testCommand, isolation, noTestJustification) {
   if ((roleOrVariant === "standard" || roleOrVariant === "lite") && variant === undefined) {
     return buildRoleTaskSection("implementer", roleOrVariant, testCommand, isolation);
   }
   const role = roleOrVariant;
   const testCmd = testCommand ?? DEFAULT_TEST_CMD2;
   const frameworkHint = buildTestFrameworkHint(testCmd);
+  if (role === "no-test") {
+    const justification = noTestJustification ?? "No behavioral changes \u2014 tests not required";
+    return `# Role: Implementer (No Tests)
+
+Your task: implement the change as described. This story has no behavioral changes and does not require test modifications.
+
+Instructions:
+- Implement the change as described in the story
+- Do NOT create or modify test files
+- Justification for no tests: ${justification}
+- When done, stage and commit ALL changed files with: git commit -m 'feat: <description>'
+- Goal: change implemented, no test files created or modified, all changes committed`;
+  }
   if (role === "implementer") {
     const v = variant ?? "standard";
     if (v === "standard") {
@@ -27486,6 +27609,7 @@ class PromptBuilder {
   _loaderConfig;
   _testCommand;
   _hermeticConfig;
+  _noTestJustification;
   constructor(role, options = {}) {
     this._role = role;
     this._options = options;
@@ -27529,6 +27653,10 @@ class PromptBuilder {
     this._hermeticConfig = config2;
     return this;
   }
+  noTestJustification(justification) {
+    this._noTestJustification = justification;
+    return this;
+  }
   async build() {
     const sections = [];
     if (this._constitution) {
@@ -27588,7 +27716,7 @@ ${this._contextMd}
     }
     const variant = this._options.variant;
     const isolation = this._options.isolation;
-    return buildRoleTaskSection(this._role, variant, this._testCommand, isolation);
+    return buildRoleTaskSection(this._role, variant, this._testCommand, isolation, this._noTestJustification);
   }
 }
 var SECTION_SEP2 = `
@@ -28791,8 +28919,8 @@ var init_prompt = __esm(() => {
         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.quality?.testing);
+        const role = ctx.routing.testStrategy === "no-test" ? "no-test" : "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.quality?.testing).noTestJustification(ctx.story.routing?.noTestJustification);
         prompt = await builder.build();
       }
       ctx.prompt = prompt;
@@ -30425,8 +30553,7 @@ function generatePackageContextTemplate(packagePath) {
 }
 async function initPackage(repoRoot, packagePath, force = false) {
   const logger = getLogger();
-  const packageDir = join31(repoRoot, packagePath);
-  const naxDir = join31(packageDir, "nax");
+  const naxDir = join31(repoRoot, ".nax", "packages", packagePath);
   const contextPath = join31(naxDir, "context.md");
   if (existsSync20(contextPath) && !force) {
     logger.info("init", "Package context.md already exists (use --force to overwrite)", { path: contextPath });
@@ -30441,7 +30568,7 @@ async function initPackage(repoRoot, packagePath, force = false) {
 }
 async function initContext(projectRoot, options = {}) {
   const logger = getLogger();
-  const naxDir = join31(projectRoot, "nax");
+  const naxDir = join31(projectRoot, ".nax");
   const contextPath = join31(naxDir, "context.md");
   if (existsSync20(contextPath) && !options.force) {
     logger.info("init", "context.md already exists, skipping (use --force to overwrite)", { path: contextPath });
@@ -30458,7 +30585,7 @@ async function initContext(projectRoot, options = {}) {
     content = generateContextTemplate(scan);
   }
   await Bun.write(contextPath, content);
-  logger.info("init", "Generated nax/context.md template from project scan", { path: contextPath });
+  logger.info("init", "Generated .nax/context.md template from project scan", { path: contextPath });
 }
 var _deps6;
 var init_init_context = __esm(() => {
@@ -31029,18 +31156,18 @@ var NAX_RUNTIME_PATTERNS;
 var init_checks_git = __esm(() => {
   NAX_RUNTIME_PATTERNS = [
     /^.{2} nax\.lock$/,
-    /^.{2} nax\/$/,
-    /^.{2} nax\/metrics\.json$/,
-    /^.{2} nax\/features\/$/,
-    /^.{2} nax\/features\/[^/]+\/$/,
-    /^.{2} nax\/features\/[^/]+\/status\.json$/,
-    /^.{2} nax\/features\/[^/]+\/prd\.json$/,
-    /^.{2} nax\/features\/[^/]+\/runs\//,
-    /^.{2} nax\/features\/[^/]+\/plan\//,
-    /^.{2} nax\/features\/[^/]+\/acp-sessions\.json$/,
-    /^.{2} nax\/features\/[^/]+\/interactions\//,
-    /^.{2} nax\/features\/[^/]+\/progress\.txt$/,
-    /^.{2} nax\/features\/[^/]+\/acceptance-refined\.json$/,
+    /^.{2} \.nax\/$/,
+    /^.{2} \.nax\/metrics\.json$/,
+    /^.{2} \.nax\/features\/$/,
+    /^.{2} \.nax\/features\/[^/]+\/$/,
+    /^.{2} \.nax\/features\/[^/]+\/status\.json$/,
+    /^.{2} \.nax\/features\/[^/]+\/prd\.json$/,
+    /^.{2} \.nax\/features\/[^/]+\/runs\//,
+    /^.{2} \.nax\/features\/[^/]+\/plan\//,
+    /^.{2} \.nax\/features\/[^/]+\/acp-sessions\.json$/,
+    /^.{2} \.nax\/features\/[^/]+\/interactions\//,
+    /^.{2} \.nax\/features\/[^/]+\/progress\.txt$/,
+    /^.{2} \.nax\/features\/[^/]+\/acceptance-refined\.json$/,
     /^.{2} \.nax-verifier-verdict\.json$/,
     /^.{2} \.nax-pids$/,
     /^.{2} \.nax-wt\//
@@ -31351,9 +31478,9 @@ async function checkGitignoreCoversNax(workdir) {
   const content = await file2.text();
   const patterns = [
     "nax.lock",
-    "nax/**/runs/",
-    "nax/metrics.json",
-    "nax/features/*/status.json",
+    ".nax/**/runs/",
+    ".nax/metrics.json",
+    ".nax/features/*/status.json",
     ".nax-pids",
     ".nax-wt/"
   ];
@@ -32201,9 +32328,21 @@ var init_crash_recovery = __esm(() => {
 // src/execution/lifecycle/acceptance-loop.ts
 var exports_acceptance_loop = {};
 __export(exports_acceptance_loop, {
-  runAcceptanceLoop: () => runAcceptanceLoop
+  runAcceptanceLoop: () => runAcceptanceLoop,
+  isTestLevelFailure: () => isTestLevelFailure,
+  isStubTestFile: () => isStubTestFile
 });
-import path14 from "path";
+import path14, { join as join45 } from "path";
+function isStubTestFile(content) {
+  return /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*(?:false|true)\s*\)/.test(content);
+}
+function isTestLevelFailure(failedACs, totalACs) {
+  if (failedACs.includes("AC-ERROR"))
+    return true;
+  if (totalACs === 0)
+    return false;
+  return failedACs.length / totalACs > 0.8;
+}
 async function loadSpecContent(featureDir) {
   if (!featureDir)
     return "";
@@ -32223,6 +32362,7 @@ async function generateAndAddFixStories(ctx, failures, prd) {
     return null;
   }
   const modelDef = resolveModel(ctx.config.models[ctx.config.analyze.model]);
+  const testFilePath = ctx.featureDir ? path14.join(ctx.featureDir, "acceptance.test.ts") : undefined;
   const fixStories = await generateFixStories(agent, {
     failedACs: failures.failedACs,
     testOutput: failures.testOutput,
@@ -32230,7 +32370,8 @@ async function generateAndAddFixStories(ctx, failures, prd) {
     specContent: await loadSpecContent(ctx.featureDir),
     workdir: ctx.workdir,
     modelDef,
-    config: ctx.config
+    config: ctx.config,
+    testFilePath
   });
   if (fixStories.length === 0) {
     logger?.error("acceptance", "Failed to generate fix stories");
@@ -32254,9 +32395,10 @@ async function executeFixStory(ctx, story, prd, iterations) {
     agent: ctx.config.autoMode.defaultAgent,
     iteration: iterations
   }), ctx.workdir);
+  const fixEffectiveConfig = story.workdir ? await loadConfigForWorkdir(join45(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
   const fixContext = {
     config: ctx.config,
-    effectiveConfig: ctx.config,
+    effectiveConfig: fixEffectiveConfig,
     prd,
     story,
     stories: [story],
@@ -32276,6 +32418,23 @@ async function executeFixStory(ctx, story, prd, iterations) {
     metrics: result.context.storyMetrics
   };
 }
+async function regenerateAcceptanceTest(testPath, acceptanceContext) {
+  const logger = getSafeLogger();
+  const bakPath = `${testPath}.bak`;
+  const content = await Bun.file(testPath).text();
+  await Bun.write(bakPath, content);
+  logger?.info("acceptance", `Backed up acceptance test -> ${bakPath}`);
+  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);
+  if (!await Bun.file(testPath).exists()) {
+    logger?.error("acceptance", "Acceptance test regeneration failed \u2014 manual intervention required");
+    return false;
+  }
+  logger?.info("acceptance", "Acceptance test regenerated successfully");
+  return true;
+}
 async function runAcceptanceLoop(ctx) {
   const logger = getSafeLogger();
   const maxRetries = ctx.config.acceptance.maxRetries;
@@ -32337,6 +32496,39 @@ 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);
+          }
+          continue;
+        }
+      }
+    }
+    const totalACs = prd.userStories.filter((s) => !s.id.startsWith("US-FIX-")).flatMap((s) => s.acceptanceCriteria).length;
+    if (ctx.featureDir && isTestLevelFailure(failures.failedACs, totalACs)) {
+      logger?.warn("acceptance", `Test-level failure detected (${failures.failedACs.length}/${totalACs} ACs failed) \u2014 regenerating acceptance test`);
+      const testPath = path14.join(ctx.featureDir, "acceptance.test.ts");
+      const testFile = Bun.file(testPath);
+      if (await testFile.exists()) {
+        const regenerated = await regenerateAcceptanceTest(testPath, acceptanceContext);
+        if (!regenerated) {
+          return buildResult(false, prd, totalCost, iterations, storiesCompleted, prdDirty);
+        }
+        continue;
+      }
+    }
     logger?.info("acceptance", "Generating fix stories...");
     const fixStories = await generateAndAddFixStories(ctx, failures, prd);
     if (!fixStories) {
@@ -32367,6 +32559,7 @@ async function runAcceptanceLoop(ctx) {
 }
 var init_acceptance_loop = __esm(() => {
   init_acceptance();
+  init_loader2();
   init_schema();
   init_hooks();
   init_logger2();
@@ -32801,12 +32994,12 @@ __export(exports_manager, {
   WorktreeManager: () => WorktreeManager
 });
 import { existsSync as existsSync32, symlinkSync } from "fs";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 
 class WorktreeManager {
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join45(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join46(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = Bun.spawn(["git", "worktree", "add", worktreePath, "-b", branchName], {
@@ -32831,9 +33024,9 @@ class WorktreeManager {
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const nodeModulesSource = join45(projectRoot, "node_modules");
+    const nodeModulesSource = join46(projectRoot, "node_modules");
     if (existsSync32(nodeModulesSource)) {
-      const nodeModulesTarget = join45(worktreePath, "node_modules");
+      const nodeModulesTarget = join46(worktreePath, "node_modules");
       try {
         symlinkSync(nodeModulesSource, nodeModulesTarget, "dir");
       } catch (error48) {
@@ -32841,9 +33034,9 @@ class WorktreeManager {
         throw new Error(`Failed to symlink node_modules: ${errorMessage(error48)}`);
       }
     }
-    const envSource = join45(projectRoot, ".env");
+    const envSource = join46(projectRoot, ".env");
     if (existsSync32(envSource)) {
-      const envTarget = join45(worktreePath, ".env");
+      const envTarget = join46(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -32854,7 +33047,7 @@ class WorktreeManager {
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join45(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join46(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = Bun.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -33245,7 +33438,7 @@ var init_parallel_worker = __esm(() => {
 
 // src/execution/parallel-coordinator.ts
 import os3 from "os";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 function groupStoriesByDependencies(stories) {
   const batches = [];
   const processed = new Set;
@@ -33324,7 +33517,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
     };
     const worktreePaths = new Map;
     for (const story of batch) {
-      const worktreePath = join46(projectRoot, ".nax-wt", story.id);
+      const worktreePath = join47(projectRoot, ".nax-wt", story.id);
       try {
         await worktreeManager.create(projectRoot, story.id);
         worktreePaths.set(story.id, worktreePath);
@@ -33373,7 +33566,7 @@ async function executeParallel(stories, prdPath, projectRoot, config2, hooks, pl
           });
           logger?.warn("parallel", "Worktree preserved for manual conflict resolution", {
             storyId: mergeResult.storyId,
-            worktreePath: join46(projectRoot, ".nax-wt", mergeResult.storyId)
+            worktreePath: join47(projectRoot, ".nax-wt", mergeResult.storyId)
           });
         }
       }
@@ -33833,12 +34026,12 @@ var init_parallel_executor = __esm(() => {
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile2, mkdir as mkdir2 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { basename as basename5, join as join47 } from "path";
+import { basename as basename5, join as join48 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename5(workdir);
-  const eventsDir = join47(homedir7(), ".nax", "events", project);
-  const eventsFile = join47(eventsDir, "events.jsonl");
+  const eventsDir = join48(homedir7(), ".nax", "events", project);
+  const eventsFile = join48(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     (async () => {
@@ -34012,12 +34205,12 @@ var init_interaction2 = __esm(() => {
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir3, writeFile } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { basename as basename6, join as join48 } from "path";
+import { basename as basename6, join as join49 } from "path";
 function wireRegistry(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename6(workdir);
-  const runDir = join48(homedir8(), ".nax", "runs", `${project}-${feature}-${runId}`);
-  const metaFile = join48(runDir, "meta.json");
+  const runDir = join49(homedir8(), ".nax", "runs", `${project}-${feature}-${runId}`);
+  const metaFile = join49(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     (async () => {
       try {
@@ -34027,8 +34220,8 @@ function wireRegistry(bus, feature, runId, workdir) {
           project,
           feature,
           workdir,
-          statusPath: join48(workdir, "nax", "features", feature, "status.json"),
-          eventsDir: join48(workdir, "nax", "features", feature, "runs"),
+          statusPath: join49(workdir, ".nax", "features", feature, "status.json"),
+          eventsDir: join49(workdir, ".nax", "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile(metaFile, JSON.stringify(meta3, null, 2));
@@ -34455,7 +34648,7 @@ async function handleTierEscalation(ctx) {
   }
   for (const s of storiesToEscalate) {
     const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
-    const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after";
+    const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
     if (shouldSwitchToTestAfter) {
       logger?.warn("escalation", "Switching strategy to test-after (greenfield-no-tests fallback)", {
         storyId: s.id,
@@ -34479,7 +34672,7 @@ async function handleTierEscalation(ctx) {
       if (!shouldEscalate)
         return s;
       const currentTestStrategy = s.routing?.testStrategy ?? ctx.routing.testStrategy;
-      const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after";
+      const shouldSwitchToTestAfter = escalateRetryAsTestAfter && currentTestStrategy !== "test-after" && currentTestStrategy !== "no-test";
       const baseRouting = s.routing ?? { ...ctx.routing };
       const updatedRouting = {
         ...baseRouting,
@@ -34681,7 +34874,7 @@ var init_pipeline_result_handler = __esm(() => {
 });
 
 // src/execution/iteration-runner.ts
-import { join as join49 } from "path";
+import { join as join50 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const logger = getSafeLogger();
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
@@ -34707,7 +34900,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   const storyStartTime = Date.now();
   const storyGitRef = await captureGitRef(ctx.workdir);
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join49(ctx.workdir, "nax", "config.json"), story.workdir) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join50(ctx.workdir, ".nax", "config.json"), story.workdir) : ctx.config;
   const pipelineContext = {
     config: ctx.config,
     effectiveConfig,
@@ -35073,7 +35266,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -35141,7 +35334,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join50(featureDir, "status.json");
+    const featureStatusPath = join51(featureDir, "status.json");
     try {
       const base = this.getSnapshot(totalCost, iterations);
       if (!base) {
@@ -35349,7 +35542,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join51 } from "path";
+import { join as join52 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -35361,7 +35554,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
     if (!hasCommits)
       continue;
     if (story.failureStage === "review" || story.failureStage === "autofix") {
-      const effectiveWorkdir = story.workdir ? join51(workdir, story.workdir) : workdir;
+      const effectiveWorkdir = story.workdir ? join52(workdir, story.workdir) : workdir;
       try {
         const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
         if (!reviewResult.success) {
@@ -35542,7 +35735,7 @@ async function setupRun(options) {
   }
   try {
     const globalPluginsDir = path18.join(os5.homedir(), ".nax", "plugins");
-    const projectPluginsDir = path18.join(workdir, "nax", "plugins");
+    const projectPluginsDir = path18.join(workdir, ".nax", "plugins");
     const configPlugins = config2.plugins || [];
     const pluginRegistry = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins);
     logger?.info("plugins", `Loaded ${pluginRegistry.plugins.length} plugins`, {
@@ -66495,7 +66688,7 @@ var require_jsx_dev_runtime = __commonJS((exports, module) => {
 init_source();
 import { existsSync as existsSync34, mkdirSync as mkdirSync6 } from "fs";
 import { homedir as homedir10 } from "os";
-import { join as join52 } from "path";
+import { join as join53 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -67191,7 +67384,7 @@ function formatMetadataSection(metadata) {
 // src/context/generators/aider.ts
 function generateAiderConfig(context) {
   const header = `# Aider Configuration
-# Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
+# Auto-generated from .nax/context.md \u2014 run \`nax generate\` to regenerate.
 # DO NOT EDIT MANUALLY
 
 # Project instructions
@@ -67215,7 +67408,7 @@ var aiderGenerator = {
 function generateClaudeConfig(context) {
   const header = `# Project Context
 
-This file is auto-generated from \`nax/context.md\`.
+This file is auto-generated from \`.nax/context.md\`.
 DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
 
 ---
@@ -67234,7 +67427,7 @@ var claudeGenerator = {
 function generateCodexConfig(context) {
   const header = `# Codex Instructions
 
-This file is auto-generated from \`nax/context.md\`.
+This file is auto-generated from \`.nax/context.md\`.
 DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
 
 ---
@@ -67253,7 +67446,7 @@ var codexGenerator = {
 function generateCursorRules(context) {
   const header = `# Project Rules
 
-Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
+Auto-generated from .nax/context.md \u2014 run \`nax generate\` to regenerate.
 DO NOT EDIT MANUALLY
 
 ---
@@ -67272,7 +67465,7 @@ var cursorGenerator = {
 function generateGeminiConfig(context) {
   const header = `# Gemini CLI Context
 
-This file is auto-generated from \`nax/context.md\`.
+This file is auto-generated from \`.nax/context.md\`.
 DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
 
 ---
@@ -67291,7 +67484,7 @@ var geminiGenerator = {
 function generateOpencodeConfig(context) {
   const header = `# Agent Instructions
 
-This file is auto-generated from \`nax/context.md\`.
+This file is auto-generated from \`.nax/context.md\`.
 DO NOT EDIT MANUALLY \u2014 run \`nax generate\` to regenerate.
 
 These instructions apply to all AI coding agents in this project.
@@ -67312,7 +67505,7 @@ var opencodeGenerator = {
 function generateWindsurfRules(context) {
   const header = `# Windsurf Project Rules
 
-Auto-generated from nax/context.md \u2014 run \`nax generate\` to regenerate.
+Auto-generated from .nax/context.md \u2014 run \`nax generate\` to regenerate.
 DO NOT EDIT MANUALLY
 
 ---
@@ -67389,10 +67582,10 @@ async function generateAll(options, config2, agentFilter) {
 async function discoverPackages(repoRoot) {
   const packages = [];
   const seen = new Set;
-  for (const pattern of ["*/nax/context.md", "*/*/nax/context.md"]) {
+  for (const pattern of [".nax/packages/*/context.md", ".nax/packages/*/*/context.md"]) {
     const glob = new Bun.Glob(pattern);
-    for await (const match of glob.scan(repoRoot)) {
-      const pkgRelative = match.replace(/\/nax\/context\.md$/, "");
+    for await (const match of glob.scan({ cwd: repoRoot, dot: true })) {
+      const pkgRelative = match.replace(/^\.nax\/packages\//, "").replace(/\/context\.md$/, "");
       const pkgAbsolute = join11(repoRoot, pkgRelative);
       if (!seen.has(pkgAbsolute)) {
         seen.add(pkgAbsolute);
@@ -67470,7 +67663,7 @@ async function discoverWorkspacePackages(repoRoot) {
   return results.sort();
 }
 async function generateForPackage(packageDir, config2, dryRun = false) {
-  const contextPath = join11(packageDir, "nax", "context.md");
+  const contextPath = join11(packageDir, ".nax", "context.md");
   if (!existsSync10(contextPath)) {
     return [
       {
@@ -67587,6 +67780,13 @@ function validateStory(raw, index, allIds) {
   }
   const rawTestStrategy = routing.testStrategy ?? s.testStrategy;
   const testStrategy = resolveTestStrategy(typeof rawTestStrategy === "string" ? rawTestStrategy : undefined);
+  const rawJustification = routing.noTestJustification ?? s.noTestJustification;
+  if (testStrategy === "no-test") {
+    if (!rawJustification || typeof rawJustification !== "string" || rawJustification.trim() === "") {
+      throw new Error(`[schema] story[${index}].routing.noTestJustification is required when testStrategy is "no-test"`);
+    }
+  }
+  const noTestJustification = typeof rawJustification === "string" && rawJustification.trim() !== "" ? rawJustification.trim() : undefined;
   const rawDeps = s.dependencies;
   const dependencies = Array.isArray(rawDeps) ? rawDeps : [];
   for (const dep of dependencies) {
@@ -67626,7 +67826,8 @@ function validateStory(raw, index, allIds) {
     routing: {
       complexity,
       testStrategy,
-      reasoning: "validated from LLM output"
+      reasoning: "validated from LLM output",
+      ...noTestJustification !== undefined ? { noTestJustification } : {}
     },
     ...workdir !== undefined ? { workdir } : {},
     ...contextFiles.length > 0 ? { contextFiles } : {}
@@ -67693,9 +67894,9 @@ var _deps2 = {
   createInteractionBridge: () => createCliInteractionBridge()
 };
 async function planCommand(workdir, config2, options) {
-  const naxDir = join12(workdir, "nax");
+  const naxDir = join12(workdir, ".nax");
   if (!existsSync11(naxDir)) {
-    throw new Error(`nax directory not found. Run 'nax init' first in ${workdir}`);
+    throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
   const logger = getLogger();
   logger?.info("plan", "Reading spec", { from: options.from });
@@ -68029,7 +68230,7 @@ async function acceptCommand(options) {
     logger.error("cli", "Invalid project directory", { error: err.message });
     throw new NaxError("Invalid project directory", "INVALID_DIRECTORY", { error: err.message });
   }
-  const featureDir = path.join(projectDir, "nax", "features", feature);
+  const featureDir = path.join(projectDir, ".nax", "features", feature);
   const prdPath = path.join(featureDir, "prd.json");
   const prdFile = Bun.file(prdPath);
   if (!await prdFile.exists()) {
@@ -68165,29 +68366,29 @@ function resolveProject(options = {}) {
   let configPath;
   if (dir) {
     projectRoot = realpathSync3(resolve6(dir));
-    naxDir = join13(projectRoot, "nax");
+    naxDir = join13(projectRoot, ".nax");
     if (!existsSync12(naxDir)) {
       throw new NaxError(`Directory does not contain a nax project: ${projectRoot}
 Expected to find: ${naxDir}`, "NAX_DIR_NOT_FOUND", { projectRoot, naxDir });
     }
     configPath = join13(naxDir, "config.json");
     if (!existsSync12(configPath)) {
-      throw new NaxError(`nax directory found but config.json is missing: ${naxDir}
+      throw new NaxError(`.nax directory found but config.json is missing: ${naxDir}
 Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
     }
   } else {
     const found = findProjectRoot(process.cwd());
     if (!found) {
-      const cwdNaxDir = join13(process.cwd(), "nax");
+      const cwdNaxDir = join13(process.cwd(), ".nax");
       if (existsSync12(cwdNaxDir)) {
         const cwdConfigPath = join13(cwdNaxDir, "config.json");
-        throw new NaxError(`nax directory found but config.json is missing: ${cwdNaxDir}
+        throw new NaxError(`.nax directory found but config.json is missing: ${cwdNaxDir}
 Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, configPath: cwdConfigPath });
       }
       throw new NaxError("No nax project found. Run this command from within a nax project directory, or use -d flag to specify the project path.", "PROJECT_NOT_FOUND", { cwd: process.cwd() });
     }
     projectRoot = found;
-    naxDir = join13(projectRoot, "nax");
+    naxDir = join13(projectRoot, ".nax");
     configPath = join13(naxDir, "config.json");
   }
   let featureDir;
@@ -68220,7 +68421,7 @@ function findProjectRoot(startDir) {
   let current = resolve6(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const naxDir = join13(current, "nax");
+    const naxDir = join13(current, ".nax");
     const configPath = join13(naxDir, "config.json");
     if (existsSync12(configPath)) {
       return realpathSync3(current);
@@ -68259,7 +68460,7 @@ async function loadStatusFile(featureDir) {
   }
 }
 async function loadProjectStatusFile(projectDir) {
-  const statusPath = join15(projectDir, "nax", "status.json");
+  const statusPath = join15(projectDir, ".nax", "status.json");
   if (!existsSync13(statusPath)) {
     return null;
   }
@@ -68325,7 +68526,7 @@ async function getFeatureSummary(featureName, featureDir) {
   return summary;
 }
 async function displayAllFeatures(projectDir) {
-  const featuresDir = join15(projectDir, "nax", "features");
+  const featuresDir = join15(projectDir, ".nax", "features");
   if (!existsSync13(featuresDir)) {
     console.log(source_default.dim("No features found."));
     return;
@@ -68530,7 +68731,7 @@ async function parseRunLog(logPath) {
 async function runsListCommand(options) {
   const logger = getLogger();
   const { feature, workdir } = options;
-  const runsDir = join16(workdir, "nax", "features", feature, "runs");
+  const runsDir = join16(workdir, ".nax", "features", feature, "runs");
   if (!existsSync14(runsDir)) {
     logger.info("cli", "No runs found for feature", { feature, hint: `Directory not found: ${runsDir}` });
     return;
@@ -68568,7 +68769,7 @@ async function runsListCommand(options) {
 async function runsShowCommand(options) {
   const logger = getLogger();
   const { runId, feature, workdir } = options;
-  const logPath = join16(workdir, "nax", "features", feature, "runs", `${runId}.jsonl`);
+  const logPath = join16(workdir, ".nax", "features", feature, "runs", `${runId}.jsonl`);
   if (!existsSync14(logPath)) {
     logger.error("cli", "Run not found", { runId, feature, logPath });
     throw new NaxError("Run not found", "RUN_NOT_FOUND", { runId, feature, logPath });
@@ -68731,9 +68932,9 @@ ${ctx.contextMarkdown}`;
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join29(workdir, "nax");
+  const naxDir = join29(workdir, ".nax");
   if (!existsSync18(naxDir)) {
-    throw new Error(`nax directory not found. Run 'nax init' first in ${workdir}`);
+    throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
   const featureDir = join29(naxDir, "features", feature);
   const prdPath = join29(featureDir, "prd.json");
@@ -68845,13 +69046,13 @@ var TEMPLATE_HEADER = `<!--
     - Conventions (project coding standards)
 
   To activate overrides, add to your nax/config.json:
-    { "prompts": { "overrides": { "<role>": "nax/templates/<role>.md" } } }
+    { "prompts": { "overrides": { "<role>": ".nax/templates/<role>.md" } } }
 -->
 
 `;
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join30(workdir, "nax", "templates");
+  const templatesDir = join30(workdir, ".nax", "templates");
   mkdirSync4(templatesDir, { recursive: true });
   const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync19(join30(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
@@ -68882,11 +69083,11 @@ async function autoWirePromptsConfig(workdir) {
     const exampleConfig = JSON.stringify({
       prompts: {
         overrides: {
-          "test-writer": "nax/templates/test-writer.md",
-          implementer: "nax/templates/implementer.md",
-          verifier: "nax/templates/verifier.md",
-          "single-session": "nax/templates/single-session.md",
-          "tdd-simple": "nax/templates/tdd-simple.md"
+          "test-writer": ".nax/templates/test-writer.md",
+          implementer: ".nax/templates/implementer.md",
+          verifier: ".nax/templates/verifier.md",
+          "single-session": ".nax/templates/single-session.md",
+          "tdd-simple": ".nax/templates/tdd-simple.md"
         }
       }
     }, null, 2);
@@ -68904,11 +69105,11 @@ ${exampleConfig}`);
     return;
   }
   const overrides = {
-    "test-writer": "nax/templates/test-writer.md",
-    implementer: "nax/templates/implementer.md",
-    verifier: "nax/templates/verifier.md",
-    "single-session": "nax/templates/single-session.md",
-    "tdd-simple": "nax/templates/tdd-simple.md"
+    "test-writer": ".nax/templates/test-writer.md",
+    implementer: ".nax/templates/implementer.md",
+    verifier: ".nax/templates/verifier.md",
+    "single-session": ".nax/templates/single-session.md",
+    "tdd-simple": ".nax/templates/tdd-simple.md"
   };
   if (!config2.prompts) {
     config2.prompts = {};
@@ -68980,7 +69181,7 @@ import * as os2 from "os";
 import * as path13 from "path";
 async function pluginsListCommand(config2, workdir, overrideGlobalPluginsDir) {
   const globalPluginsDir = overrideGlobalPluginsDir ?? path13.join(os2.homedir(), ".nax", "plugins");
-  const projectPluginsDir = path13.join(workdir, "nax", "plugins");
+  const projectPluginsDir = path13.join(workdir, ".nax", "plugins");
   const configPlugins = config2.plugins || [];
   const registry2 = await loadPlugins(globalPluginsDir, projectPluginsDir, configPlugins, workdir, config2.disabledPlugins);
   const plugins = registry2.plugins;
@@ -68989,8 +69190,8 @@ async function pluginsListCommand(config2, workdir, overrideGlobalPluginsDir) {
     console.log(`
 To install plugins:`);
     console.log("  \u2022 Add to global directory: ~/.nax/plugins/");
-    console.log("  \u2022 Add to project directory: ./nax/plugins/");
-    console.log("  \u2022 Configure in nax/config.json");
+    console.log("  \u2022 Add to project directory: ./.nax/plugins/");
+    console.log("  \u2022 Configure in .nax/config.json");
     console.log(`
 See https://github.com/nax/nax#plugins for more details.`);
     return;
@@ -69241,7 +69442,7 @@ function isProcessAlive2(pid) {
   }
 }
 async function loadStatusFile2(workdir) {
-  const statusPath = join34(workdir, "nax", "status.json");
+  const statusPath = join34(workdir, ".nax", "status.json");
   if (!existsSync21(statusPath))
     return null;
   try {
@@ -69288,7 +69489,7 @@ async function diagnoseCommand(options = {}) {
   const workdir = options.workdir ?? process.cwd();
   const naxSubdir = findProjectDir(workdir);
   let projectDir = naxSubdir ? join34(naxSubdir, "..") : null;
-  if (!projectDir && existsSync21(join34(workdir, "nax"))) {
+  if (!projectDir && existsSync21(join34(workdir, ".nax"))) {
     projectDir = workdir;
   }
   if (!projectDir)
@@ -69299,7 +69500,7 @@ async function diagnoseCommand(options = {}) {
     if (status2) {
       feature = status2.run.feature;
     } else {
-      const featuresDir = join34(projectDir, "nax", "features");
+      const featuresDir = join34(projectDir, ".nax", "features");
       if (!existsSync21(featuresDir))
         throw new Error("No features found in project");
       const features = readdirSync5(featuresDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
@@ -69309,7 +69510,7 @@ async function diagnoseCommand(options = {}) {
       logger.info("diagnose", "No feature specified, using first found", { feature });
     }
   }
-  const featureDir = join34(projectDir, "nax", "features", feature);
+  const featureDir = join34(projectDir, ".nax", "features", feature);
   const prdPath = join34(featureDir, "prd.json");
   if (!existsSync21(prdPath))
     throw new Error(`Feature not found: ${feature}`);
@@ -69368,10 +69569,10 @@ async function generateCommand(options) {
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
-    console.log(source_default.blue("\u2192 Discovering packages with nax/context.md..."));
+    console.log(source_default.blue("\u2192 Discovering packages with .nax/packages/*/context.md..."));
     const packages = await discoverPackages(workdir);
     if (packages.length === 0) {
-      console.log(source_default.yellow("  No packages found (no */nax/context.md or */*/nax/context.md)"));
+      console.log(source_default.yellow("  No packages found (no .nax/packages/*/context.md or .nax/packages/*/*/context.md)"));
       return;
     }
     console.log(source_default.blue(`\u2192 Generating agent files for ${packages.length} package(s)...`));
@@ -69416,12 +69617,12 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join35(workdir, options.context) : join35(workdir, "nax/context.md");
+  const contextPath = options.context ? join35(workdir, options.context) : join35(workdir, ".nax/context.md");
   const outputDir = options.output ? join35(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   if (!existsSync22(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
-    console.error(source_default.yellow("  Create nax/context.md first, or run `nax init` to scaffold it."));
+    console.error(source_default.yellow("  Create .nax/context.md first, or run `nax init` to scaffold it."));
     process.exit(1);
   }
   if (options.agent && !VALID_AGENTS.includes(options.agent)) {
@@ -69487,7 +69688,7 @@ async function generateCommand(options) {
       const packages = await discoverPackages(workdir);
       if (packages.length > 0) {
         console.log(source_default.blue(`
-\u2192 Discovered ${packages.length} package(s) with nax/context.md \u2014 generating agent files...`));
+\u2192 Discovered ${packages.length} package(s) with context.md \u2014 generating agent files...`));
         let pkgErrorCount = 0;
         for (const pkgDir of packages) {
           const pkgResults = await generateForPackage(pkgDir, config2, dryRun);
@@ -69630,6 +69831,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",
@@ -70262,7 +70464,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join40(resolved.projectDir, "nax");
+  const naxDir = join40(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -70312,7 +70514,7 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join41(resolved.projectDir, "nax");
+  const naxDir = join41(resolved.projectDir, ".nax");
   const featureDir = join41(naxDir, "features", featureName);
   const prdPath = join41(featureDir, "prd.json");
   if (!existsSync31(featureDir)) {
@@ -70628,7 +70830,14 @@ function precomputeBatchPlan(stories, maxBatchSize = DEFAULT_MAX_BATCH_SIZE) {
   let currentBatch = [];
   for (const story of stories) {
     const isSimple = story.routing?.complexity === "simple" && story.routing?.testStrategy === "test-after";
-    if (isSimple && currentBatch.length < maxBatchSize) {
+    const isNoTest = story.routing?.testStrategy === "no-test";
+    const isBatchable = isSimple || isNoTest;
+    if (isBatchable && currentBatch.length < maxBatchSize) {
+      const batchIsNoTest = currentBatch.length > 0 && currentBatch[0]?.routing?.testStrategy === "no-test";
+      if (currentBatch.length > 0 && batchIsNoTest !== isNoTest) {
+        batches.push({ stories: [...currentBatch], isBatch: currentBatch.length > 1 });
+        currentBatch = [];
+      }
       currentBatch.push(story);
     } else {
       if (currentBatch.length > 0) {
@@ -70638,11 +70847,8 @@ function precomputeBatchPlan(stories, maxBatchSize = DEFAULT_MAX_BATCH_SIZE) {
         });
         currentBatch = [];
       }
-      if (!isSimple) {
-        batches.push({
-          stories: [story],
-          isBatch: false
-        });
+      if (!isBatchable) {
+        batches.push({ stories: [story], isBatch: false });
       } else {
         currentBatch.push(story);
       }
@@ -78321,15 +78527,15 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join52(workdir, "nax");
+  const naxDir = join53(workdir, "nax");
   if (existsSync34(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
-  mkdirSync6(join52(naxDir, "features"), { recursive: true });
-  mkdirSync6(join52(naxDir, "hooks"), { recursive: true });
-  await Bun.write(join52(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
-  await Bun.write(join52(naxDir, "hooks.json"), JSON.stringify({
+  mkdirSync6(join53(naxDir, "features"), { recursive: true });
+  mkdirSync6(join53(naxDir, "hooks"), { recursive: true });
+  await Bun.write(join53(naxDir, "config.json"), JSON.stringify(DEFAULT_CONFIG, null, 2));
+  await Bun.write(join53(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
       "on-start": { command: 'echo "nax started: $NAX_FEATURE"', enabled: false },
       "on-complete": { command: 'echo "nax complete: $NAX_FEATURE"', enabled: false },
@@ -78337,12 +78543,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join52(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join53(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join52(naxDir, "context.md"), `# Project Context
+  await Bun.write(join53(naxDir, "context.md"), `# Project Context
 
 This document defines coding standards, architectural decisions, and forbidden patterns for this project.
 Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) from this file.
@@ -78468,8 +78674,8 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join52(naxDir, "features", options.feature);
-  const prdPath = join52(featureDir, "prd.json");
+  const featureDir = join53(naxDir, "features", options.feature);
+  const prdPath = join53(featureDir, "prd.json");
   if (options.plan && options.from) {
     if (existsSync34(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
@@ -78491,10 +78697,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join52(featureDir, "plan");
+      const planLogDir = join53(featureDir, "plan");
       mkdirSync6(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join52(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join53(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
       console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
       console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
@@ -78532,10 +78738,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
     process.exit(1);
   }
   resetLogger();
-  const runsDir = join52(featureDir, "runs");
+  const runsDir = join53(featureDir, "runs");
   mkdirSync6(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join52(runsDir, `${runId}.jsonl`);
+  const logFilePath = join53(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -78551,7 +78757,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.autoMode.defaultAgent = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join52(homedir10(), ".nax");
+  const globalNaxDir = join53(homedir10(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   let tuiInstance;
@@ -78574,7 +78780,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join52(workdir, "nax", "status.json");
+  const statusFilePath = join53(workdir, "nax", "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -78600,7 +78806,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     headless: useHeadless,
     skipPrecheck: options.skipPrecheck ?? false
   });
-  const latestSymlink = join52(runsDir, "latest.jsonl");
+  const latestSymlink = join53(runsDir, "latest.jsonl");
   try {
     if (existsSync34(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
@@ -78638,9 +78844,9 @@ features.command("create <name>").description("Create a new feature").option("-d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join52(naxDir, "features", name);
+  const featureDir = join53(naxDir, "features", name);
   mkdirSync6(featureDir, { recursive: true });
-  await Bun.write(join52(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join53(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -78648,7 +78854,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 ## Acceptance Criteria
 `);
-  await Bun.write(join52(featureDir, "plan.md"), `# Plan: ${name}
+  await Bun.write(join53(featureDir, "plan.md"), `# Plan: ${name}
 
 ## Architecture
 
@@ -78656,7 +78862,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 ## Dependencies
 `);
-  await Bun.write(join52(featureDir, "tasks.md"), `# Tasks: ${name}
+  await Bun.write(join53(featureDir, "tasks.md"), `# Tasks: ${name}
 
 ## US-001: [Title]
 
@@ -78665,7 +78871,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 ### Acceptance Criteria
 - [ ] Criterion 1
 `);
-  await Bun.write(join52(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join53(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -78693,7 +78899,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join52(naxDir, "features");
+  const featuresDir = join53(naxDir, "features");
   if (!existsSync34(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
@@ -78708,7 +78914,7 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join52(featuresDir, name, "prd.json");
+    const prdPath = join53(featuresDir, name, "prd.json");
     if (existsSync34(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
@@ -78739,10 +78945,10 @@ Use: nax plan -f <feature> --from <spec>`));
     process.exit(1);
   }
   const config2 = await loadConfig(workdir);
-  const featureLogDir = join52(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join53(naxDir, "features", options.feature, "plan");
   mkdirSync6(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join52(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join53(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {
@@ -78779,7 +78985,7 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join52(naxDir, "features", options.feature);
+  const featureDir = join53(naxDir, "features", options.feature);
   if (!existsSync34(featureDir)) {
     console.error(source_default.red(`Feature "${options.feature}" not found.`));
     process.exit(1);
@@ -78795,7 +79001,7 @@ program2.command("analyze").description("(deprecated) Parse spec.md into prd.jso
       specPath: options.from,
       reclassify: options.reclassify
     });
-    const prdPath = join52(featureDir, "prd.json");
+    const prdPath = join53(featureDir, "prd.json");
     await Bun.write(prdPath, JSON.stringify(prd, null, 2));
     const c = countStories(prd);
     console.log(source_default.green(`