@nathapp/nax 0.67.0-canary.6 → 0.67.0

package/dist/nax.js

@@ -17156,7 +17156,8 @@ var init_schemas_infra = __esm(() => {
   PromptsConfigSchema = exports_external.object({
     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()
+    }), exports_external.string().min(1, "Override path must be non-empty")).optional(),
+    behavioralGuardrails: exports_external.enum(["off", "lite", "strict"]).default("lite")
   });
   ProjectProfileSchema = exports_external.object({
     language: exports_external.enum(["typescript", "javascript", "go", "rust", "python", "ruby", "java", "kotlin", "php"]).optional(),
@@ -17550,7 +17551,7 @@ var init_schemas3 = __esm(() => {
         maxReplanAttempts: 3
       }
     }),
-    prompts: PromptsConfigSchema.optional(),
+    prompts: PromptsConfigSchema.default({ behavioralGuardrails: "lite" }),
     generate: GenerateConfigSchema.optional(),
     project: ProjectProfileSchema.optional(),
     debate: DebateConfigSchema.optional().default(() => ({
@@ -20717,6 +20718,12 @@ var init_adapter = __esm(() => {
       displayName: "Gemini CLI (ACP)",
       supportedTiers: ["fast", "balanced", "powerful"],
       maxContextTokens: 1e6
+    },
+    opencode: {
+      binary: "opencode",
+      displayName: "opencode (ACP)",
+      supportedTiers: ["fast", "balanced", "powerful"],
+      maxContextTokens: 128000
     }
   };
   DEFAULT_ENTRY = {
@@ -22594,6 +22601,15 @@ var init_conventions = __esm(() => {
   ]);
   DEFAULT_SEPARATED_TEST_DIRS = Object.freeze(["test/unit", "test/integration"]);
 });
+
+// src/test-runners/classifier.ts
+function createTestFileClassifier(resolved) {
+  const { regex } = resolved;
+  if (regex.length === 0)
+    return () => false;
+  return (path) => regex.some((re) => re.test(path));
+}
+
 // src/test-runners/detect/cache.ts
 function cachePath(workdir) {
   return `${workdir}/.nax/cache/test-patterns.json`;
@@ -24150,6 +24166,32 @@ var init_ac_parser = __esm(() => {
 });
 
 // src/test-runners/index.ts
+var exports_test_runners = {};
+__export(exports_test_runners, {
+  resolveTestFilePatterns: () => resolveTestFilePatterns,
+  resolveReviewExcludePatterns: () => resolveReviewExcludePatterns,
+  parseTestOutput: () => parseTestOutput,
+  parseTestFailures: () => parseTestFailures,
+  parseBunTestOutput: () => parseBunTestOutput,
+  isTestFileByPatterns: () => isTestFileByPatterns,
+  isTestFile: () => isTestFile,
+  globsToTestRegex: () => globsToTestRegex,
+  globsToPathspec: () => globsToPathspec,
+  formatFailureSummary: () => formatFailureSummary,
+  findPackageDir: () => findPackageDir,
+  extractTestDirs: () => extractTestDirs,
+  detectTestFilePatterns: () => detectTestFilePatterns,
+  detectManifestFrameworksFromPackageJson: () => detectManifestFrameworksFromPackageJson,
+  detectFramework: () => detectFramework,
+  createTestFileClassifier: () => createTestFileClassifier,
+  buildTestFrameworkHint: () => buildTestFrameworkHint,
+  analyzeTestExitCode: () => analyzeTestExitCode,
+  _resolverDeps: () => _resolverDeps,
+  DEFAULT_TS_DERIVE_SUFFIXES: () => DEFAULT_TS_DERIVE_SUFFIXES,
+  DEFAULT_TEST_FILE_PATTERNS: () => DEFAULT_TEST_FILE_PATTERNS,
+  DEFAULT_SEPARATED_TEST_DIRS: () => DEFAULT_SEPARATED_TEST_DIRS,
+  DEFAULT_SCAN_TEST_DIRS: () => DEFAULT_SCAN_TEST_DIRS
+});
 var init_test_runners = __esm(() => {
   init_conventions();
   init_detect2();
@@ -29046,9 +29088,7 @@ function buildIsolationSection(roleOrMode, mode, testCommand) {
 
 ${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}`;
+    return "";
   }
   if (role === "test-writer") {
     const m = mode ?? "strict";
@@ -29082,13 +29122,14 @@ isolation scope: You may modify both src/ and test/ files. Write failing tests F
 }
 
 // src/prompts/sections/role-task.ts
-function buildRoleTaskSection(roleOrVariant, variant, testCommand, isolation, noTestJustification) {
+function buildRoleTaskSection(roleOrVariant, variant, testCommand, isolation, noTestJustification, storyId) {
   if ((roleOrVariant === "standard" || roleOrVariant === "lite") && variant === undefined) {
-    return buildRoleTaskSection("implementer", roleOrVariant, testCommand, isolation);
+    return buildRoleTaskSection("implementer", roleOrVariant, testCommand, isolation, noTestJustification, storyId);
   }
   const role = roleOrVariant;
   const testCmd = testCommand ?? "";
   const frameworkHint = buildTestFrameworkHint(testCmd);
+  const commitMsg = storyId ? `feat(${storyId}): <description>` : "feat: <description>";
   if (role === "no-test") {
     const justification = noTestJustification ?? "No behavioral changes \u2014 tests not required";
     return `# Role: Implementer (No Tests)
@@ -29099,7 +29140,7 @@ 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>'
+- When done, stage and commit ALL changed files with: git commit -m '${commitMsg}'
 - Goal: change implemented, no test files created or modified, all changes committed`;
   }
   if (role === "implementer") {
@@ -29107,62 +29148,78 @@ Instructions:
     if (v === "standard") {
       return `# Role: Implementer
 
-Your task: make failing tests pass.
+Your task: make the failing tests pass by writing real source code.
 
-Instructions:
-- Implement source code in src/ to make tests pass
-- Do NOT modify test files \u2014 three narrow lint/contract/sibling exceptions exist; see the escape valve section in the rectification prompt if you encounter one
-- Run tests frequently to track progress
-- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-- Goal: all tests green, all changes committed`;
+Workflow:
+1. Read every failing test in scope. The tests are the contract \u2014 understand what each one asserts before editing source.
+2. Run the scoped test files once to establish the baseline (which fail, which pass, and why).
+3. Implement source code in the package's source location (the project context names it).
+4. After each meaningful change, re-run only the scoped test files \u2014 never the full suite.
+5. When all scoped tests pass, stage and commit ALL changed files: \`git commit -m '${commitMsg}'\`.
+
+Rules:
+- Do NOT modify test files. Three narrow exceptions: (a) a lint-only fix to a test, (b) a contract drift where the test imports a removed/renamed symbol, (c) a sibling test file rename forced by your source change. Name which exception applies in the commit body before editing any test file.
+- Goal: every acceptance criterion covered by at least one passing test; all changes committed.`;
     }
     return `# Role: Implementer (Lite)
 
-Your task: Make the failing tests pass AND add any missing test coverage.
+Your task: make the failing tests pass AND fill any test coverage gaps an earlier session left.
 
-Context: A test-writer session has already created test files with failing tests and possibly minimal stubs in src/. Your job is to make those tests pass by implementing the real logic.
+Context: A test-writer session has already created tests and may have added minimal stubs in the package's source location. Your job is to (a) replace stubs with real implementations and (b) confirm every AC has test coverage before committing.
 
-Instructions:
-- Start by running the existing tests to see what's failing
-- Implement source code in src/ to make all failing tests pass
-- You MAY add additional tests if you find gaps in coverage
-- Replace any stubs with real implementations
+Workflow:
+1. Run the existing scoped tests to see which fail and why (assertion failure vs import error).
+2. Read each failing test. Note which ACs they cover and which they DON'T.
+3. Replace stubs with real implementations. A stub is one of: a type-only declaration, a function returning a placeholder/throwing "not implemented", or a const placeholder.
+4. If any AC has no test, add one before implementing \u2014 do not implement uncovered behavior.
+5. Re-run only the scoped test files after each meaningful change.
+6. When all scoped tests pass, stage and commit ALL changed files: \`git commit -m '${commitMsg}'\`.
+
+Rules:
+- Three test-modification exceptions apply (lint-only fix, contract drift, sibling rename). Name the exception in the commit body before editing any test the test-writer wrote.
 - ${frameworkHint}
-- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-- Goal: all tests green, all criteria met, all changes committed`;
+- Goal: every AC has at least one passing test; all stubs replaced with real logic; all changes committed.`;
   }
   if (role === "test-writer") {
     if (isolation === "lite") {
       return `# Role: Test-Writer (Lite)
 
-Your task: Write failing tests for the feature. You may create minimal stubs to support imports.
+Your task: write failing tests AND minimal stubs that let the tests compile.
 
 Context: You are session 1 of a multi-session workflow. An implementer will follow to make your tests pass.
 
-Instructions:
-- Create test files in test/ directory that cover all acceptance criteria
-- Tests must fail initially (RED phase) \u2014 do NOT implement real logic
+Workflow:
+1. Re-read the acceptance criteria above.
+2. Create test files in the location the project uses for tests.
+3. Create stubs in the package's source location so the tests can import and compile. A stub is one of: a type/interface declaration, a function returning a placeholder/throwing "not implemented" (no more than 3 lines of body), or a const placeholder. If a stub body needs real logic, you have crossed into implementer territory \u2014 stop.
+4. For each AC: at least one success-path test and one boundary/failure-path test.
+5. Run the new test files. Confirm tests compile (stubs work) AND fail with ASSERTION failures \u2014 NOT import errors or compile errors. A test that errors before reaching its assertion does not prove the behavior is missing.
+
+Rules:
+- Stubs are NOT implementations. The implementer in the next session writes real logic.
+- Each test name describes ONE behavior. Use AC IDs in test names when available (e.g. \`it('AC4: throws Division by zero when b === 0')\`).
+- Assert on observable outputs.
 - ${frameworkHint}
-- You MAY read src/ files and import types/interfaces from them
-- You MAY create minimal stubs in src/ (type definitions, empty functions) so tests can import and compile
-- Write clear test names that document expected behavior
-- Focus on behavior, not implementation details
-- Goal: comprehensive failing test suite with compilable imports, ready for implementation`;
+- Goal: comprehensive failing test suite that compiles, with stubs \u22643 lines each, ready for implementation.`;
     }
     return `# Role: Test-Writer
 
-Your task: Write comprehensive failing tests for the feature.
+Your task: write failing tests that pin down every acceptance criterion. An implementer will follow.
 
-Context: You are session 1 of a multi-session workflow. An implementer will follow to make your tests pass.
+Context: You are session 1 of a multi-session workflow.
 
-Instructions:
-- Create test files in test/ directory that cover all acceptance criteria
-- Tests must fail initially (RED phase) \u2014 the feature is not yet implemented
-- Do NOT create or modify any files in src/
+Workflow:
+1. Re-read the acceptance criteria above.
+2. Create test files in the location the project uses for tests (project context names it).
+3. For each AC: write at least one test for the success path AND at least one for a boundary/failure path (zero, empty, negative, missing, throws). ACs worded as "throws X" require a test asserting the throw.
+4. Run the new test files. Confirm every test fails with an ASSERTION failure \u2014 NOT an import error, compile error, or runtime crash before assertion. A test that errors before reaching its assertion does not prove the behavior is missing.
+
+Rules:
+- Do NOT create or modify any source files. Read source for types/interfaces only.
+- Each test name describes ONE behavior; each test asserts ONE behavior. When the AC has a number or ID, prefix the test name (e.g. \`it('AC4: throws Division by zero when b === 0')\`).
+- Assert on observable outputs (return values, thrown errors, file contents, log output, boundary state). Do not assert on private helpers, internal call counts, or implementation-level mocks unless the AC requires it.
 - ${frameworkHint}
-- Write clear test names that document expected behavior
-- Focus on behavior, not implementation details
-- Goal: comprehensive failing test suite ready for implementation`;
+- Goal: every AC has at least one failing test that fails at assertion time and clearly documents what the implementer must build.`;
   }
   if (role === "verifier") {
     return `# Role: Verifier
@@ -29183,45 +29240,59 @@ Instructions:
   if (role === "single-session") {
     return `# Role: Single-Session
 
-Your task: Write tests AND implement the feature in a single focused session.
+Your task: write tests AND implement the feature in one session.
 
-Instructions:
-- Phase 1: Write comprehensive tests (test/ directory)
-- Phase 2: Implement to make all tests pass (src/ directory)
+Workflow:
+1. Read the acceptance criteria. For each AC, plan one success-path test and one boundary/failure test.
+2. Create test files in the location the project uses for tests. Cover every AC.
+3. Run the tests to confirm they fail with ASSERTION failures \u2014 NOT import errors or compile errors. A test that errors before reaching its assertion does not prove the behavior is missing.
+4. Implement source code in the package's source location to make the tests pass.
+5. After each meaningful change, re-run only the scoped test files \u2014 never the full suite.
+6. When all scoped tests pass, stage and commit ALL changed files: \`git commit -m '${commitMsg}'\`.
+
+Rules:
+- Each test name describes ONE behavior; use AC IDs when available.
+- Assert on observable outputs.
 - ${frameworkHint}
-- Run tests frequently throughout implementation
-- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-- Goal: all tests passing, all changes committed, full story complete`;
+- Goal: every AC has at least one passing test; all changes committed.`;
   }
   if (role === "batch") {
-    const verifyCmdLine = testCmd ? `  - Verify all tests pass: ${testCmd}` : "  - Verify all tests pass using your project's test command";
+    const verifyCmdLine = testCmd ? `  - Re-run only the scoped test files after each meaningful change: ${testCmd}` : "  - Re-run only the scoped test files after each meaningful change";
     return `# Role: Batch Implementer
 
-Your task: Implement each story in order using TDD \u2014 write tests first, then implement, then verify.
+Your task: implement each story in order using TDD \u2014 write tests first, then implement, then commit per story.
 
-Instructions:
-- Process each story in order (Story 1, Story 2, \u2026)
-- For each story:
-  - Write failing tests FIRST covering the acceptance criteria
-  - Run tests to confirm they fail (RED phase)
-  - Implement the minimum code to make tests pass (GREEN phase)
-${verifyCmdLine}
-  - Commit the story with its story ID in the commit message: git commit -m 'feat(<story-id>): <description>'
+Per-story workflow (RED \u2192 GREEN):
+1. RED \u2014 write failing tests in the location the project uses for tests covering the story's ACs (success + boundary).
+2. RED \u2014 run the new test files. Confirm assertion failures \u2014 NOT import errors or compile errors. A test that errors before reaching its assertion does not prove the behavior is missing.
+3. GREEN \u2014 implement source code in the package's source location.
+4. GREEN \u2014 re-run only the scoped test files after each meaningful change.
+5. Commit the story with its ID: \`git commit -m 'feat(<story-id>): <description>'\`.
+
+Rules:
+- One commit per story \u2014 never bundle stories.
+- Process stories in order (Story 1, Story 2, \u2026).
+- Each test name describes ONE behavior; use AC IDs when available.
 - ${frameworkHint}
-- Do NOT commit multiple stories together \u2014 each story gets its own commit
-- Goal: all stories implemented, all tests passing, each story committed with its story ID`;
+${verifyCmdLine}
+- Goal: every story implemented with passing tests; one commit per story tagged with the story ID.`;
   }
   return `# Role: TDD-Simple
 
-Your task: Write failing tests FIRST, then implement to make them pass.
+Your task: write failing tests FIRST, then implement in one session.
 
-Instructions:
-- RED phase: Write failing tests FIRST for the acceptance criteria
-- RED phase: Run the tests to confirm they fail
-- GREEN phase: Implement the minimum code to make tests pass
-- REFACTOR phase: Refactor while keeping tests green
-- When all tests are green, stage and commit ALL changed files with: git commit -m 'feat: <description>'
-- Goal: all tests passing, feature complete, all changes committed`;
+Workflow (RED \u2192 GREEN \u2192 REFACTOR):
+1. RED \u2014 write failing tests in the location the project uses for tests covering every AC (success + boundary).
+2. RED \u2014 run the tests. Confirm they fail with ASSERTION failures \u2014 NOT import errors or compile errors. A test that errors before reaching its assertion does not prove the behavior is missing.
+3. GREEN \u2014 implement minimum source code in the package's source location to make the tests pass.
+4. GREEN \u2014 re-run only the scoped test files after each meaningful change.
+5. REFACTOR \u2014 clean up while keeping tests green. No new behavior; no expanded scope.
+6. Stage and commit ALL changed files: \`git commit -m '${commitMsg}'\`.
+
+Rules:
+- Each test name describes ONE behavior; use AC IDs when available.
+- ${frameworkHint}
+- Goal: every AC covered by passing tests; refactor complete; all changes committed.`;
 }
 var init_role_task = __esm(() => {
   init_test_runners();
@@ -29433,11 +29504,12 @@ function buildSelfVerificationSection(role, input) {
     `- packageDir: \`${input.packageDir}\``,
     input.language ? `- language: \`${input.language}\`` : "- language: unknown",
     roleSpecificLine(role),
-    "- Scope: changed files from this turn (`CHANGED`) inside this package.",
+    "- Scope: focus first on changed files from this turn (`CHANGED`) inside this package.",
     commandLine("lint", input.lintCommand),
     commandLine("typecheck", input.typecheckCommand),
     "- If a configured check fails on files in CHANGED: fix and rerun.",
-    "- If a configured check fails only on files outside CHANGED: do not edit those files; report them under PRE_EXISTING_FAILURES.",
+    "- If a configured check fails outside CHANGED but the smallest package-local fix is required to satisfy this story's acceptance criteria, you MAY make that fix and rerun.",
+    "- Otherwise, do not edit unrelated sibling files; report them under PRE_EXISTING_FAILURES.",
     "",
     "End your response with exactly this block:",
     "```text",
@@ -29452,6 +29524,97 @@ function buildSelfVerificationSection(role, input) {
 }
 var CHECK_HEADER = "# Self-Verification Gate";
 
+// src/prompts/sections/behavioral-guardrails.ts
+function buildBehavioralGuardrailsSection(role, level, _variant, _isolation) {
+  if (level === "off" || role === "verifier" || role === "no-test") {
+    return null;
+  }
+  if (role === "test-writer") {
+    return buildTestWriterGuardrails(level);
+  }
+  if (role === "single-session" || role === "tdd-simple" || role === "batch") {
+    return buildCombinedGuardrails(level);
+  }
+  return buildImplementerGuardrails(level);
+}
+function buildTestWriterGuardrails(level) {
+  const lines = [
+    "# Behavioral Guardrails",
+    "",
+    "- Simplicity: write tests that cover the acceptance criteria. No tests for behaviors the story does not require.",
+    "- Surgical: do not modify source files beyond the stub allowance in the Isolation Rules above. Do not add tests for unrelated existing code."
+  ];
+  if (level === "strict") {
+    lines.push("- State Assumptions: when the story is ambiguous, pick an interpretation, proceed, and document the choice in the commit body under `Assumptions:`. Do not invent requirements; do not silently choose when the story is genuinely under-specified \u2014 note it.");
+  }
+  return lines.join(`
+`);
+}
+function buildCombinedGuardrails(level) {
+  if (level === "lite") {
+    return `# Behavioral Guardrails
+
+- Simplicity (tests): write tests that cover the acceptance criteria only. No tests for behaviors the story does not require.
+- Simplicity (source): write the minimum source code that makes the tests pass. No speculative abstractions, configurability, or error handling for scenarios that cannot occur.
+- Surgical: every changed line must trace to the story. Do not refactor adjacent code, reformat unrelated files, or rename symbols beyond what the story requires.
+- Anti-cheat: do not weaken assertions, catch-and-swallow exceptions in tests, or add tautological assertions to coerce a green run.
+- Orphans: remove imports/variables/helpers that YOUR changes made unused. Do not delete pre-existing dead code.
+- Commit: include the story ID when known \u2014 \`feat(<story-id>): <description>\`.`;
+  }
+  return `# Behavioral Guardrails
+
+## Simplicity (Tests)
+Write tests that cover the acceptance criteria only. No tests for behaviors the story does not require. Every test you add is a constraint the implementer must satisfy \u2014 do not over-constrain with speculative behavior.
+
+## Simplicity (Source)
+Write the minimum source code that makes the tests pass. Every line you add is a line someone else must read, understand, and maintain. Do not add speculative abstractions, configurability, or error handling for scenarios that cannot occur given the story's constraints.
+
+## Surgical
+Every changed line must trace directly to a story requirement or a failing test. Do not refactor adjacent code, reformat unrelated files, or rename symbols beyond what the story requires. Reviewers will flag any change that cannot be linked to a specific requirement.
+
+## Anti-cheat
+Do not weaken assertions, catch-and-swallow exceptions in tests, or add tautological assertions to coerce a green run. A green test suite achieved by weakening tests is not a passing implementation \u2014 it is a failing one with hidden evidence.
+
+## Orphans
+Remove imports, variables, and helpers that YOUR changes made unused. Do not delete pre-existing dead code that was already there before your changes.
+
+## Commit
+Include the story ID when known \u2014 \`feat(<story-id>): <description>\`.
+
+## State Assumptions
+When the story is ambiguous, pick an interpretation, proceed, and document the choice in the commit body under \`Assumptions:\`. Do not invent requirements; do not silently choose when the story is genuinely under-specified \u2014 note it.`;
+}
+function buildImplementerGuardrails(level) {
+  if (level === "lite") {
+    return `# Behavioral Guardrails
+
+- Simplicity: write the minimum code that makes the tests pass. No speculative abstractions, configurability, or error handling for scenarios that cannot occur.
+- Surgical: every changed line must trace to the story. Do not refactor adjacent code, reformat unrelated files, or rename symbols beyond what the story requires.
+- Anti-cheat: do not weaken assertions, catch-and-swallow exceptions in tests, or add tautological assertions to coerce a green run.
+- Orphans: remove imports/variables/helpers that YOUR changes made unused. Do not delete pre-existing dead code.
+- Commit: include the story ID when known \u2014 \`feat(<story-id>): <description>\`.`;
+  }
+  return `# Behavioral Guardrails
+
+## Simplicity
+Write the minimum code that makes the tests pass. Every line you add is a line someone else must read, understand, and maintain. Do not add speculative abstractions, configurability, or error handling for scenarios that cannot occur given the story's constraints. If it isn't required by a test or acceptance criterion, don't write it.
+
+## Surgical
+Every changed line must trace directly to a story requirement or a failing test. Do not refactor adjacent code, reformat unrelated files, or rename symbols beyond what the story requires. Reviewers will flag any change that cannot be linked to a specific requirement.
+
+## Anti-cheat
+Do not weaken assertions, catch-and-swallow exceptions in tests, or add tautological assertions to coerce a green run. A green test suite achieved by weakening tests is not a passing implementation \u2014 it is a failing one with hidden evidence.
+
+## Orphans
+Remove imports, variables, and helpers that YOUR changes made unused. Do not delete pre-existing dead code that was already there before your changes.
+
+## Commit
+Include the story ID when known \u2014 \`feat(<story-id>): <description>\`.
+
+## State Assumptions
+When the story is ambiguous, pick an interpretation, proceed, and document the choice in the commit body under \`Assumptions:\`. Do not invent requirements; do not silently choose when the story is genuinely under-specified \u2014 note it.`;
+}
+
 // src/prompts/sections/index.ts
 var init_sections2 = __esm(() => {
   init_hermetic();
@@ -29609,6 +29772,12 @@ class TddPromptBuilder {
       if (hermeticSection)
         acc.add(this.s("hermetic", hermeticSection));
     }
+    const guardrailLevel = this.loaderConfig_?.prompts?.behavioralGuardrails ?? "lite";
+    const guardrailVariant = this.options.variant;
+    const guardrailIsolation = this.options.isolation;
+    const guardrails = buildBehavioralGuardrailsSection(this.role, guardrailLevel, guardrailVariant, guardrailIsolation);
+    if (guardrails)
+      acc.add(this.s("guardrails", guardrails));
     if (this.role !== "verifier") {
       const selfVerify = buildSelfVerificationSection(this.role, this.selfVerification_);
       if (selfVerify)
@@ -29645,7 +29814,7 @@ class TddPromptBuilder {
     }
     const variant = this.options.variant;
     const isolation = this.options.isolation;
-    return buildRoleTaskSection(this.role, variant, this.testCommand_, isolation, this.noTestJustification_);
+    return buildRoleTaskSection(this.role, variant, this.testCommand_, isolation, this.noTestJustification_, this.story_?.id);
   }
 }
 var init_tdd_builder = __esm(() => {
@@ -34924,31 +35093,101 @@ var init_debate_plan = __esm(() => {
   };
 });
 
+// src/tdd/isolation.ts
+function isSourceFile(filePath) {
+  return SRC_PATTERNS.some((pattern) => pattern.test(filePath));
+}
+async function getChangedFiles(workdir, fromRef = "HEAD") {
+  const proc = _isolationDeps.spawn(["git", "diff", "--name-only", fromRef], {
+    cwd: workdir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const output = await Bun.readableStreamToText(proc.stdout);
+  await proc.exited;
+  return output.trim().split(`
+`).filter(Boolean);
+}
+function matchesAllowedPath(filePath, allowedPaths) {
+  return allowedPaths.some((pattern) => {
+    const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(filePath);
+  });
+}
+async function verifyTestWriterIsolation(workdir, beforeRef, allowedPaths = ["src/index.ts", "src/**/index.ts"], testFilePatterns = DEFAULT_TEST_FILE_PATTERNS) {
+  const changed = await getChangedFiles(workdir, beforeRef);
+  const sourceFiles = changed.filter((f) => isSourceFile(f) && !isTestFileByPatterns(f, testFilePatterns));
+  const softViolations = [];
+  const violations = [];
+  for (const file3 of sourceFiles) {
+    if (matchesAllowedPath(file3, allowedPaths)) {
+      softViolations.push(file3);
+    } else {
+      violations.push(file3);
+    }
+  }
+  return {
+    passed: violations.length === 0,
+    violations,
+    softViolations,
+    description: "Test writer should only modify test files, not source files"
+  };
+}
+async function verifyImplementerIsolation(workdir, beforeRef, testFilePatterns = DEFAULT_TEST_FILE_PATTERNS) {
+  const changed = await getChangedFiles(workdir, beforeRef);
+  const testFiles = changed.filter((f) => isTestFileByPatterns(f, testFilePatterns));
+  if (testFiles.length > 0) {
+    return {
+      passed: true,
+      violations: [],
+      warnings: testFiles,
+      description: "Implementer modified test files (warning: should be minimal fixes only)"
+    };
+  }
+  return {
+    passed: true,
+    violations: [],
+    description: "Implementer should not modify test files"
+  };
+}
+var _isolationDeps, SRC_PATTERNS;
+var init_isolation = __esm(() => {
+  init_test_runners();
+  init_bun_deps();
+  _isolationDeps = { spawn };
+  SRC_PATTERNS = [/^src\//, /^lib\//, /^packages\//];
+});
+
 // src/operations/_session-output.ts
 function parseSessionJsonOutput(output) {
   if (!output)
     return EMPTY;
   try {
     const v = JSON.parse(output);
-    if (v === null || typeof v !== "object" || typeof v.success !== "boolean")
-      return EMPTY;
+    if (v === null || typeof v !== "object" || typeof v.success !== "boolean") {
+      return { ...EMPTY, output };
+    }
     return {
       success: v.success,
-      filesChanged: Array.isArray(v.filesChanged) ? v.filesChanged : []
+      filesChanged: Array.isArray(v.filesChanged) ? v.filesChanged : [],
+      output,
+      parsed: true
     };
   } catch {
-    return EMPTY;
+    return { ...EMPTY, output };
   }
 }
 var EMPTY;
 var init__session_output = __esm(() => {
-  EMPTY = { success: false, filesChanged: [] };
+  EMPTY = { success: false, filesChanged: [], output: "", parsed: false };
 });
 
 // src/operations/write-test.ts
 var testWriterOp;
 var init_write_test = __esm(() => {
   init_config();
+  init_isolation();
   init__session_output();
   testWriterOp = {
     kind: "run",
@@ -34957,6 +35196,12 @@ var init_write_test = __esm(() => {
     session: { role: "test-writer", lifetime: "fresh" },
     config: tddConfigSelector,
     build(input, _ctx) {
+      if (input.promptMarkdown?.trim()) {
+        return {
+          role: { id: "role", content: "", overridable: false },
+          task: { id: "task", content: input.promptMarkdown, overridable: false }
+        };
+      }
       const context = [input.contextMarkdown, input.featureContextMarkdown].filter(Boolean).join(`
 
 `);
@@ -34971,24 +35216,66 @@ var init_write_test = __esm(() => {
       };
     },
     parse(output, _input, _ctx) {
+      if (!output)
+        return { success: false, filesChanged: [], estimatedCostUsd: 0, durationMs: 0, output: "" };
+      if (output.startsWith('Agent "')) {
+        return { success: false, filesChanged: [], estimatedCostUsd: 0, durationMs: 0, output };
+      }
       const envelope = parseSessionJsonOutput(output);
-      return { ...envelope, estimatedCostUsd: 0, durationMs: 0 };
+      return {
+        success: envelope.parsed ? envelope.success : true,
+        filesChanged: envelope.filesChanged,
+        estimatedCostUsd: 0,
+        durationMs: 0,
+        output: envelope.output
+      };
+    },
+    async verify(parsed, input, ctx) {
+      if (!input.beforeRef)
+        return parsed;
+      const allowedPaths = ctx.config.tdd?.testWriterAllowedPaths ?? ["src/index.ts", "src/**/index.ts"];
+      const testFilePatterns = typeof ctx.packageView.config.execution?.smartTestRunner === "object" && ctx.packageView.config.execution.smartTestRunner !== null ? ctx.packageView.config.execution.smartTestRunner.testFilePatterns : undefined;
+      const isolation = await verifyTestWriterIsolation(ctx.packageView.packageDir, input.beforeRef, allowedPaths, testFilePatterns);
+      return { ...parsed, isolation };
     }
   };
 });
 
+// src/operations/execution-gates.ts
+function shouldRunReview(config2) {
+  return config2.review?.enabled === true;
+}
+function shouldRunRectification(config2) {
+  return config2.execution?.rectification?.enabled === true;
+}
+function shouldKeepSessionOpen(config2, role) {
+  return role === "implementer" && (shouldRunReview(config2) || shouldRunRectification(config2));
+}
+var init_execution_gates = __esm(() => {
+  init_config();
+});
+
 // src/operations/implement.ts
 var implementerOp;
 var init_implement = __esm(() => {
   init_config();
+  init_isolation();
   init__session_output();
+  init_execution_gates();
   implementerOp = {
     kind: "run",
     name: "implementer",
     stage: "run",
     session: { role: "implementer", lifetime: "warm" },
     config: tddConfigSelector,
+    keepOpen: (_input, ctx) => shouldKeepSessionOpen(ctx.config, "implementer"),
     build(input, _ctx) {
+      if (input.promptMarkdown?.trim()) {
+        return {
+          role: { id: "role", content: "", overridable: false },
+          task: { id: "task", content: input.promptMarkdown, overridable: false }
+        };
+      }
       const context = [input.contextMarkdown, input.featureContextMarkdown].filter(Boolean).join(`
 
 `);
@@ -35003,8 +35290,26 @@ var init_implement = __esm(() => {
       };
     },
     parse(output, _input, _ctx) {
+      if (!output)
+        return { success: false, filesChanged: [], estimatedCostUsd: 0, durationMs: 0, output: "" };
+      if (output.startsWith('Agent "')) {
+        return { success: false, filesChanged: [], estimatedCostUsd: 0, durationMs: 0, output };
+      }
       const envelope = parseSessionJsonOutput(output);
-      return { ...envelope, estimatedCostUsd: 0, durationMs: 0 };
+      return {
+        success: envelope.parsed ? envelope.success : true,
+        filesChanged: envelope.filesChanged,
+        estimatedCostUsd: 0,
+        durationMs: 0,
+        output: envelope.output
+      };
+    },
+    async verify(parsed, input, ctx) {
+      if (!input.beforeRef)
+        return parsed;
+      const testFilePatterns = typeof ctx.packageView.config.execution?.smartTestRunner === "object" && ctx.packageView.config.execution.smartTestRunner !== null ? ctx.packageView.config.execution.smartTestRunner.testFilePatterns : undefined;
+      const isolation = await verifyImplementerIsolation(ctx.packageView.packageDir, input.beforeRef, testFilePatterns);
+      return { ...parsed, isolation };
     }
   };
 });
@@ -35264,9 +35569,16 @@ var init_verdict = __esm(() => {
 });
 
 // src/operations/verify.ts
+async function runVerifierIsolation(beforeRef, ctx) {
+  if (!beforeRef)
+    return;
+  const testFilePatterns = typeof ctx.packageView.config.execution?.smartTestRunner === "object" && ctx.packageView.config.execution.smartTestRunner !== null ? ctx.packageView.config.execution.smartTestRunner.testFilePatterns : undefined;
+  return verifyImplementerIsolation(ctx.packageView.packageDir, beforeRef, testFilePatterns);
+}
 var verifierOp;
 var init_verify = __esm(() => {
   init_config();
+  init_isolation();
   init_verdict();
   init__session_output();
   verifierOp = {
@@ -35276,6 +35588,12 @@ var init_verify = __esm(() => {
     session: { role: "verifier", lifetime: "fresh" },
     config: tddConfigSelector,
     build(input, _ctx) {
+      if (input.promptMarkdown?.trim()) {
+        return {
+          role: { id: "role", content: "", overridable: false },
+          task: { id: "task", content: input.promptMarkdown, overridable: false }
+        };
+      }
       return {
         role: { id: "role", content: "", overridable: false },
         task: {
@@ -35289,10 +35607,13 @@ var init_verify = __esm(() => {
       const envelope = parseSessionJsonOutput(output);
       return { ...envelope, estimatedCostUsd: 0, durationMs: 0 };
     },
-    async verify(parsed, _input, _ctx) {
-      return parsed.success ? parsed : null;
+    async verify(parsed, input, ctx) {
+      if (!parsed.success)
+        return null;
+      const isolation = await runVerifierIsolation(input.beforeRef, ctx);
+      return isolation ? { ...parsed, isolation } : parsed;
     },
-    async recover(_input, verifyCtx) {
+    async recover(input, verifyCtx) {
       const packageDir = verifyCtx.packageView.packageDir;
       try {
         const verdict = await readVerdict(packageDir);
@@ -35300,13 +35621,16 @@ var init_verify = __esm(() => {
           return null;
         const testsAllPassing = verdict.tests.allPassing === true;
         const categorization = categorizeVerdict(verdict, testsAllPassing);
+        const isolation = await runVerifierIsolation(input.beforeRef, verifyCtx);
         return {
           success: categorization.success,
           filesChanged: [],
           estimatedCostUsd: 0,
           durationMs: 0,
+          output: "",
           ...categorization.failureCategory && { failureCategory: categorization.failureCategory },
-          ...categorization.reviewReason && { reviewReason: categorization.reviewReason }
+          ...categorization.reviewReason && { reviewReason: categorization.reviewReason },
+          ...isolation && { isolation }
         };
       } finally {
         await cleanupVerdict(packageDir);
@@ -35793,14 +36117,6 @@ var init_plan_critic_llm = __esm(() => {
   };
 });
 
-// src/operations/execution-gates.ts
-function shouldRunRectification(config2) {
-  return config2.execution?.rectification?.enabled === true;
-}
-var init_execution_gates = __esm(() => {
-  init_config();
-});
-
 // src/context/greenfield.ts
 import { readdir as readdir2 } from "fs/promises";
 import { join as join19 } from "path";
@@ -35930,11 +36246,6 @@ function makePassResult(storyId, strategy, opts = {}) {
   };
 }
 
-// src/verification/parser.ts
-var init_parser2 = __esm(() => {
-  init_test_runners();
-});
-
 // src/utils/process-kill.ts
 function killProcessGroup(pid, signal) {
   try {
@@ -36183,9 +36494,9 @@ async function regression(options) {
 }
 var _regressionRunnerDeps;
 var init_runners = __esm(() => {
+  init_test_runners();
   init_bun_deps();
   init_executor();
-  init_parser2();
   _regressionRunnerDeps = {
     sleep
   };
@@ -36481,8 +36792,8 @@ class ScopedStrategy {
 var DEFAULT_SMART_RUNNER_CONFIG, _scopedDeps;
 var init_scoped = __esm(() => {
   init_logger2();
-  init_conventions();
-  init_parser2();
+  init_test_runners();
+  init_test_runners();
   init_runners();
   init_smart_runner();
   DEFAULT_SMART_RUNNER_CONFIG = {
@@ -36928,7 +37239,8 @@ ${debateResult.output}`;
         story,
         failures: failureRecords,
         testCommand,
-        conventions: true
+        conventions: true,
+        guardrailLevel: config2.prompts.behavioralGuardrails
       });
       const rectPromise = Promise.resolve(rectPrompt);
       return (async () => {
@@ -37140,8 +37452,7 @@ var init_rectification_loop = __esm(() => {
   init_prompts();
   init_session_name();
   init_session_keeper();
-  init_parser2();
-  init_parser2();
+  init_test_runners();
   init_runners();
   _rectificationDeps = {
     agentManager: undefined,
@@ -37158,19 +37469,15 @@ __export(exports_verification, {
   shouldRetryRectification: () => shouldRetryRectification,
   scoped: () => scoped,
   runRetryLoop: () => runRetryLoop,
+  runRectificationLoop: () => runRectificationLoop,
   regression: () => regression,
-  parseTestOutput: () => parseTestOutput,
-  parseBunTestOutput: () => parseBunTestOutput,
   normalizeEnvironment: () => normalizeEnvironment,
   fullSuite: () => fullSuite,
-  formatFailureSummary: () => formatFailureSummary,
   executeWithTimeout: () => executeWithTimeout,
-  detectFramework: () => detectFramework,
   buildTestCommand: () => buildTestCommand,
   buildProgressivePromptPreamble: () => buildProgressivePromptPreamble,
   appendOpenHandlesFlag: () => appendOpenHandlesFlag,
   appendForceExitFlag: () => appendForceExitFlag,
-  analyzeTestExitCode: () => analyzeTestExitCode,
   _regressionRunnerDeps: () => _regressionRunnerDeps,
   _rectificationDeps: () => _rectificationDeps,
   _executorDeps: () => _executorDeps
@@ -37178,7 +37485,6 @@ __export(exports_verification, {
 var init_verification = __esm(() => {
   init_rectification_loop();
   init_executor();
-  init_parser2();
   init_runners();
 });
 
@@ -37207,7 +37513,8 @@ var init_full_suite_gate = __esm(() => {
       return { config: config2, testCmd: resolvedTestCmd, fullSuiteTimeout };
     },
     runTests: async (input, gateCtx) => {
-      const { executeWithTimeout: executeWithTimeout2, parseTestOutput: parseTestOutput2 } = await Promise.resolve().then(() => (init_verification(), exports_verification));
+      const { executeWithTimeout: executeWithTimeout2 } = await Promise.resolve().then(() => (init_verification(), exports_verification));
+      const { parseTestOutput: parseTestOutput2 } = await Promise.resolve().then(() => (init_test_runners(), exports_test_runners));
       const result = await executeWithTimeout2(gateCtx.testCmd, gateCtx.fullSuiteTimeout, undefined, {
         cwd: input.workdir
       });
@@ -39550,7 +39857,7 @@ var init_verdict_writer = __esm(() => {
 // src/review/orchestrator.ts
 import { join as join25 } from "path";
 var {spawn: spawn4 } = globalThis.Bun;
-async function getChangedFiles(workdir, baseRef) {
+async function getChangedFiles2(workdir, baseRef) {
   try {
     const diffArgs = ["diff", "--name-only"];
     const [stagedProc, unstagedProc, baseProc] = [
@@ -39879,7 +40186,7 @@ class ReviewOrchestrator {
       const reviewers = plugins.getReviewers();
       if (reviewers.length > 0) {
         const baseRef = storyGitRef ?? executionConfig?.storyGitRef;
-        const changedFiles = await getChangedFiles(workdir, baseRef);
+        const changedFiles = await getChangedFiles2(workdir, baseRef);
         const repoRoot = projectDir ?? workdir;
         const packageDir = scopePrefix ? join25(repoRoot, scopePrefix) : undefined;
         const ignoreMatchers = naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(repoRoot, packageDir);
@@ -40071,6 +40378,17 @@ var init_review = __esm(() => {
 });
 
 // src/prompts/builders/rectifier-builder-helpers.ts
+function escapeHatchFor(story) {
+  const isTdd = THREE_SESSION_STRATEGIES.has(story.routing?.testStrategy ?? "");
+  return isTdd ? CONTRADICTION_ESCAPE_HATCH : CONTRADICTION_ESCAPE_HATCH.replace(EXCEPTION_4_MOCK_HANDOFF, "");
+}
+function noTestIsolationBlock(story) {
+  if (story.routing?.testStrategy !== "no-test")
+    return "";
+  return `
+
+${buildIsolationSection("no-test")}`;
+}
 function formatCheckErrors(checks3) {
   return checks3.map((c) => `## ${c.check} errors (exit code ${c.exitCode})
 \`\`\`
@@ -40100,7 +40418,7 @@ ${errors3}
 
 Do NOT change test files or test behavior \u2014 see the three narrow exceptions appended below.
 Do NOT add new features \u2014 only fix valid issues.
-Commit your fixes when done.${scopeConstraint}${CONTRADICTION_ESCAPE_HATCH}`;
+Commit your fixes when done.${scopeConstraint}${noTestIsolationBlock(story)}${escapeHatchFor(story)}`;
 }
 function adversarialRectification(checks3, story, scopeConstraint) {
   const errors3 = formatCheckErrors(checks3);
@@ -40122,7 +40440,7 @@ ${errors3}
 3. Do NOT add keys, functions, or imports that already exist \u2014 check first
 
 Do NOT add new features \u2014 only fix valid issues.
-Commit your fixes when done.${scopeConstraint}${CONTRADICTION_ESCAPE_HATCH}`;
+Commit your fixes when done.${scopeConstraint}${noTestIsolationBlock(story)}${escapeHatchFor(story)}`;
 }
 function combinedLlmRectification(semanticChecks, adversarialChecks, story, scopeConstraint) {
   const semanticErrors = formatCheckErrors(semanticChecks);
@@ -40148,7 +40466,7 @@ ${adversarialErrors}
 3. Do NOT add keys, functions, or imports that already exist \u2014 check first
 
 Do NOT add new features \u2014 only fix valid issues.
-Commit your fixes when done.${scopeConstraint}${CONTRADICTION_ESCAPE_HATCH}`;
+Commit your fixes when done.${scopeConstraint}${noTestIsolationBlock(story)}${escapeHatchFor(story)}`;
 }
 function mechanicalRectification(checks3, story, scopeConstraint) {
   const errors3 = formatCheckErrors(checks3);
@@ -40162,7 +40480,7 @@ ${errors3}
 
 Fix all errors listed above that are within this story's scope \u2014 see the three narrow exceptions appended below for sibling-story spillover. Do NOT change test files or test behavior except via those exceptions.
 Do NOT add new features \u2014 only fix the quality check errors.
-After fixing, re-run the failing check(s) to verify they pass, then commit your changes.${scopeConstraint}${CONTRADICTION_ESCAPE_HATCH}`;
+After fixing, re-run the failing check(s) to verify they pass, then commit your changes.${scopeConstraint}${noTestIsolationBlock(story)}${escapeHatchFor(story)}`;
 }
 var CONTRADICTION_ESCAPE_HATCH = `
 If two findings in this list contradict each other and you cannot satisfy both, do not guess.
@@ -40210,10 +40528,11 @@ TEST_AFTER: <corrected call line>
 Do NOT use this exception to change test logic, assertions, or mock setup \u2014 only call
 signatures that directly contradict a quoted PRD interface.
 
-### Exception 3 \u2014 Sibling-story lint spillover
+### Exception 3 \u2014 Unrelated sibling spillover
 
-When a lint or typecheck error is in a file you did NOT create or modify in this turn,
-do NOT edit that file. Instead declare:
+When a lint or typecheck error is outside this story's intended scope, do NOT edit that
+file. If the smallest package-local fix is required to satisfy this story's acceptance
+criteria, you MAY make that fix instead. Otherwise declare:
 \`\`\`
 TEST_EDIT_REASON: sibling_scope
 SIBLING_FILE: <file path>
@@ -40237,7 +40556,28 @@ REASON: <one paragraph: which mock is wrong vs which dispatch the new code uses>
 Rules:
 - Do NOT make any edits yourself; the test-writer will fulfill.
 - Do NOT also emit \`UNRESOLVED:\` in the same turn \u2014 this declaration IS the handoff.
-- FILES must list real test files. Each path must exist and be a test file.`;
+- FILES must list real test files. Each path must exist and be a test file.`, EXCEPTION_4_MOCK_HANDOFF = `
+### Exception 4 \u2014 Mock-structure handoff
+
+Use ONLY when the only path to satisfy the ACs requires a structural test rewrite
+that does NOT fit Exception 2. Examples: mocks reference primitives the new code
+bypasses; assertion topology must change to match a new dispatch shape.
+
+Declare with:
+\`\`\`
+TEST_EDIT_REASON: mock_structure
+FILES: <comma-separated test file paths>
+REASON: <one paragraph: which mock is wrong vs which dispatch the new code uses>
+\`\`\`
+
+Rules:
+- Do NOT make any edits yourself; the test-writer will fulfill.
+- Do NOT also emit \`UNRESOLVED:\` in the same turn \u2014 this declaration IS the handoff.
+- FILES must list real test files. Each path must exist and be a test file.`, THREE_SESSION_STRATEGIES;
+var init_rectifier_builder_helpers = __esm(() => {
+  init_sections2();
+  THREE_SESSION_STRATEGIES = new Set(["three-session-tdd", "three-session-tdd-lite"]);
+});
 
 // src/prompts/builders/rectifier-builder.ts
 function priorityForCheck(checkName) {
@@ -40317,7 +40657,7 @@ function renderPrioritizedFailures(failedChecks, opts) {
 }
 
 class RectifierPromptBuilder {
-  static firstAttemptDelta(failedChecks, maxAttempts) {
+  static firstAttemptDelta(failedChecks, maxAttempts, guardrailLevel) {
     const parts = [];
     const attemptWord = maxAttempts === 1 ? "1 attempt" : `${maxAttempts} attempts`;
     parts.push(`Review failed after your implementation. Fix the following issues (${attemptWord} available before escalation):
@@ -40326,10 +40666,16 @@ class RectifierPromptBuilder {
     parts.push(`
 Fix in priority order. After fixing each priority, re-run the failing check(s) at that level to verify they pass before moving on. Do NOT change test files or test behavior \u2014 see the three narrow exceptions appended below. Commit your changes when all checks pass.`);
     parts.push(CONTRADICTION_ESCAPE_HATCH);
+    const guardrails = buildBehavioralGuardrailsSection("implementer", guardrailLevel ?? "lite");
+    if (guardrails) {
+      parts.push(`
+
+${guardrails}`);
+    }
     return parts.join(`
 `);
   }
-  static continuation(failedChecks, attempt, rethinkAtAttempt, urgencyAtAttempt) {
+  static continuation(failedChecks, attempt, rethinkAtAttempt, urgencyAtAttempt, guardrailLevel) {
     const parts = [];
     parts.push(`Your previous fix attempt did not resolve all issues. Here are the remaining failures:
 `);
@@ -40343,6 +40689,12 @@ Fix in priority order. After fixing each priority, re-run the failing check(s) a
       parts.push("\n**URGENT: This is your final attempt.** If you cannot fix all issues, emit `UNRESOLVED: <reason>` to escalate.\n");
     }
     parts.push(CONTRADICTION_ESCAPE_HATCH);
+    const guardrails = buildBehavioralGuardrailsSection("implementer", guardrailLevel ?? "lite");
+    if (guardrails) {
+      parts.push(`
+
+${guardrails}`);
+    }
     return parts.join(`
 `);
   }
@@ -40734,6 +41086,13 @@ ${basePrompt}`;
       parts.push(buildIsolationSection("implementer", opts.isolation, undefined));
       parts.push(`
 
+`);
+    }
+    const guardrails = buildBehavioralGuardrailsSection("implementer", opts.guardrailLevel ?? "lite");
+    if (guardrails) {
+      parts.push(guardrails);
+      parts.push(`
+
 `);
     }
     if (opts.conventions !== false) {
@@ -40790,9 +41149,11 @@ Fix the implementation (not the tests) to make all failing tests pass. Run the t
 var PRIORITY_BUCKETS, PRIORITY_ORDER;
 var init_rectifier_builder = __esm(() => {
   init_review();
-  init_verification();
+  init_test_runners();
   init_core3();
   init_sections2();
+  init_rectifier_builder_helpers();
+  init_rectifier_builder_helpers();
   PRIORITY_BUCKETS = {
     "compile-build": {
       priority: 1,
@@ -41827,6 +42188,7 @@ async function callOp(ctx, op, input) {
   const sessionRole = ctx.sessionOverride?.role ?? runOp.session.role;
   const retryStrategy = resolveOpRetry(runOp, input, buildCtx);
   const fileOutputPath = runOp.fileOutput?.(input);
+  const keepOpen = runOp.keepOpen?.(input, buildCtx) ?? runOp.session.lifetime === "warm";
   const runOptions = {
     prompt,
     workdir: ctx.packageDir,
@@ -41839,7 +42201,7 @@ async function callOp(ctx, op, input) {
     featureName: ctx.featureName,
     storyId: ctx.storyId,
     callId,
-    ...runOp.session.lifetime === "warm" ? { keepOpen: true } : {},
+    ...keepOpen ? { keepOpen: true } : {},
     ...ctx.scopeId !== undefined ? { scopeId: ctx.scopeId } : {},
     ...ctx.interactionBridge ? { interactionBridge: ctx.interactionBridge } : {},
     ...ctx.maxInteractionTurns !== undefined ? { maxInteractionTurns: ctx.maxInteractionTurns } : {}
@@ -46723,11 +47085,6 @@ var init_types8 = __esm(() => {
       safety: "yellow",
       defaultSummary: "Story {{storyId}} is oversized ({{criteriaCount}} acceptance criteria) \u2014 decompose into smaller stories?"
     },
-    "story-ambiguity": {
-      defaultFallback: "continue",
-      safety: "green",
-      defaultSummary: "Story {{storyId}} requirements unclear \u2014 continue with best effort?"
-    },
     "review-gate": {
       defaultFallback: "continue",
       safety: "green",
@@ -48127,12 +48484,6 @@ async function checkPreMerge(context, config2, chain) {
   const response = await executeTrigger("pre-merge", context, config2, chain);
   return response.action === "approve";
 }
-async function checkStoryAmbiguity(context, config2, chain) {
-  if (!isTriggerEnabled("story-ambiguity", config2))
-    return true;
-  const response = await executeTrigger("story-ambiguity", context, config2, chain);
-  return response.action === "approve";
-}
 async function checkReviewGate(context, config2, chain) {
   if (!isTriggerEnabled("review-gate", config2))
     return true;
@@ -51309,113 +51660,7 @@ var init_event_bus = __esm(() => {
   pipelineEventBus = new PipelineEventBus;
 });
 
-// src/tdd/isolation.ts
-function isSourceFile(filePath) {
-  return SRC_PATTERNS.some((pattern) => pattern.test(filePath));
-}
-async function getChangedFiles2(workdir, fromRef = "HEAD") {
-  const proc = _isolationDeps.spawn(["git", "diff", "--name-only", fromRef], {
-    cwd: workdir,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const output = await Bun.readableStreamToText(proc.stdout);
-  await proc.exited;
-  return output.trim().split(`
-`).filter(Boolean);
-}
-function matchesAllowedPath(filePath, allowedPaths) {
-  return allowedPaths.some((pattern) => {
-    const regexPattern = pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(filePath);
-  });
-}
-async function verifyTestWriterIsolation(workdir, beforeRef, allowedPaths = ["src/index.ts", "src/**/index.ts"], testFilePatterns = DEFAULT_TEST_FILE_PATTERNS) {
-  const changed = await getChangedFiles2(workdir, beforeRef);
-  const sourceFiles = changed.filter((f) => isSourceFile(f) && !isTestFileByPatterns(f, testFilePatterns));
-  const softViolations = [];
-  const violations = [];
-  for (const file3 of sourceFiles) {
-    if (matchesAllowedPath(file3, allowedPaths)) {
-      softViolations.push(file3);
-    } else {
-      violations.push(file3);
-    }
-  }
-  return {
-    passed: violations.length === 0,
-    violations,
-    softViolations,
-    description: "Test writer should only modify test files, not source files"
-  };
-}
-async function verifyImplementerIsolation(workdir, beforeRef, testFilePatterns = DEFAULT_TEST_FILE_PATTERNS) {
-  const changed = await getChangedFiles2(workdir, beforeRef);
-  const testFiles = changed.filter((f) => isTestFileByPatterns(f, testFilePatterns));
-  if (testFiles.length > 0) {
-    return {
-      passed: true,
-      violations: [],
-      warnings: testFiles,
-      description: "Implementer modified test files (warning: should be minimal fixes only)"
-    };
-  }
-  return {
-    passed: true,
-    violations: [],
-    description: "Implementer should not modify test files"
-  };
-}
-var _isolationDeps, SRC_PATTERNS;
-var init_isolation = __esm(() => {
-  init_test_runners();
-  init_bun_deps();
-  _isolationDeps = { spawn };
-  SRC_PATTERNS = [/^src\//, /^lib\//, /^packages\//];
-});
-
 // src/tdd/cleanup.ts
-async function getPgid(pid) {
-  try {
-    const proc = _cleanupDeps.spawn(["ps", "-o", "pgid=", "-p", String(pid)], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const output = await Bun.readableStreamToText(proc.stdout);
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      return null;
-    }
-    const pgid = Number.parseInt(output.trim(), 10);
-    return Number.isNaN(pgid) ? null : pgid;
-  } catch {
-    return null;
-  }
-}
-async function cleanupProcessTree(pid, gracePeriodMs = 3000) {
-  try {
-    const pgid = await getPgid(pid);
-    if (!pgid) {
-      return;
-    }
-    const sentSigterm = _cleanupDeps.killProcessGroupFn(pgid, "SIGTERM");
-    if (!sentSigterm) {
-      return;
-    }
-    await _cleanupDeps.sleep(gracePeriodMs);
-    const pgidAfterWait = await getPgid(pid);
-    if (pgidAfterWait && pgidAfterWait === pgid) {
-      _cleanupDeps.killProcessGroupFn(pgid, "SIGKILL");
-    }
-  } catch (error48) {
-    const logger = getLogger();
-    logger.warn("tdd", "Failed to cleanup process tree", {
-      pid,
-      error: error48.message
-    });
-  }
-}
 var _cleanupDeps;
 var init_cleanup = __esm(() => {
   init_logger2();
@@ -51428,11 +51673,11 @@ var init_cleanup = __esm(() => {
   };
 });
 
-// src/tdd/session-runner.ts
+// src/tdd/rollback.ts
 async function rollbackToRef(workdir, ref) {
   const logger = getLogger();
   logger.warn("tdd", "Rolling back git changes", { ref });
-  const resetProc = _sessionRunnerDeps.spawn(["git", "reset", "--hard", ref], {
+  const resetProc = _rollbackDeps.spawn(["git", "reset", "--hard", ref], {
     cwd: workdir,
     stdout: "pipe",
     stderr: "pipe"
@@ -51443,7 +51688,7 @@ async function rollbackToRef(workdir, ref) {
     logger.error("tdd", "Failed to rollback git changes", { ref, stderr });
     throw new Error(`Git rollback failed: ${stderr}`);
   }
-  const cleanProc = _sessionRunnerDeps.spawn(["git", "clean", "-fd"], {
+  const cleanProc = _rollbackDeps.spawn(["git", "clean", "-fd"], {
     cwd: workdir,
     stdout: "pipe",
     stderr: "pipe"
@@ -51455,48 +51700,22 @@ async function rollbackToRef(workdir, ref) {
   }
   logger.info("tdd", "Successfully rolled back git changes", { ref });
 }
-var _sessionRunnerDeps;
-var init_session_runner = __esm(() => {
-  init_agents();
-  init_config();
-  init_engine();
+var _rollbackDeps;
+var init_rollback = __esm(() => {
   init_logger2();
-  init_execution_gates();
-  init_prompts();
-  init_quality();
-  init_git();
-  init_git();
-  init_cleanup();
-  init_isolation();
-  _sessionRunnerDeps = {
-    autoCommitIfDirty,
-    spawn: Bun.spawn,
-    getChangedFiles: getChangedFiles2,
-    verifyTestWriterIsolation,
-    verifyImplementerIsolation,
-    captureGitRef,
-    cleanupProcessTree,
-    buildPrompt: null
+  _rollbackDeps = {
+    spawn: Bun.spawn
   };
 });
 
-// src/tdd/session-op.ts
-var init_session_op = __esm(() => {
-  init_agents();
-  init_bridge_builder();
-  init_logger2();
-  init_operations();
-  init_quality();
-  init_session_runner();
-});
-
 // src/tdd/index.ts
 var init_tdd = __esm(() => {
   init_test_runners();
   init_isolation();
   init_cleanup();
   init_verdict();
-  init_session_op();
+  init_rollback();
+  init_operations();
 });
 
 // src/pipeline/stages/autofix-guards.ts
@@ -53988,14 +54207,53 @@ function gatherRectificationFindings(phaseOutputs, verifierPhase, fullSuiteGateP
   }
   return findings;
 }
-async function runPhase(ctx, slot, phaseCosts, phaseOutputs) {
+async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = false) {
+  const logger = getSafeLogger();
+  const opName = slot.op.name;
+  const isTddPhase = isThreeSession && TDD_OP_NAMES.has(opName);
+  const beforeRef = isTddPhase ? await _storyOrchestratorDeps.captureGitRef(ctx.packageDir) : undefined;
+  const dispatchInput = isTddPhase && beforeRef ? { ...slot.input, beforeRef } : slot.input;
+  if (isTddPhase) {
+    logger?.info("tdd", `-> Session: ${opName}`, { storyId: ctx.storyId, role: opName });
+  } else if (isThreeSession && opName === "full-suite-gate") {
+    logger?.info("tdd", "-> Running full test suite gate (before Verifier)", { storyId: ctx.storyId });
+  }
+  const phaseStartedAt = Date.now();
   const scope = ctx.runtime.costAggregator.openScope();
   try {
-    const output = await _storyOrchestratorDeps.callOp({ ...ctx, scopeId: scope.scopeId }, slot.op, slot.input);
-    phaseOutputs[slot.op.name] = output;
+    const output = await _storyOrchestratorDeps.callOp({ ...ctx, scopeId: scope.scopeId }, slot.op, dispatchInput);
+    phaseOutputs[opName] = output;
+    if (isTddPhase) {
+      const durationMs = Date.now() - phaseStartedAt;
+      logger?.info("tdd", `Session complete: ${opName}`, {
+        storyId: ctx.storyId,
+        role: opName,
+        durationMs
+      });
+      const filesChanged = output?.filesChanged ?? [];
+      if (opName === "test-writer" && filesChanged.length > 0) {
+        logger?.info("tdd", "Created test files", {
+          storyId: ctx.storyId,
+          testFilesCount: filesChanged.length,
+          testFiles: [...filesChanged]
+        });
+      }
+      const isolation = output?.isolation;
+      if (isolation) {
+        if (isolation.passed) {
+          logger?.info("tdd", "Isolation maintained", { storyId: ctx.storyId, role: opName });
+        } else {
+          logger?.error("tdd", "Isolation violated", {
+            storyId: ctx.storyId,
+            role: opName,
+            violations: isolation.violations
+          });
+        }
+      }
+    }
     return output;
   } finally {
-    phaseCosts[slot.op.name] = (phaseCosts[slot.op.name] ?? 0) + scope.snapshot().totalCostUsd;
+    phaseCosts[opName] = (phaseCosts[opName] ?? 0) + scope.snapshot().totalCostUsd;
     scope.close();
   }
 }
@@ -54070,9 +54328,11 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs) {
 class ExecutionPlan {
   ctx;
   state;
-  constructor(ctx, state) {
+  isThreeSession;
+  constructor(ctx, state, isThreeSession = false) {
     this.ctx = ctx;
     this.state = state;
+    this.isThreeSession = isThreeSession;
   }
   phaseNames() {
     const names = collectOrderedPhases(this.state).map((p) => p.slot.op.name);
@@ -54092,7 +54352,7 @@ class ExecutionPlan {
     ]) : new Set;
     for (const phase of collectOrderedPhases(this.state)) {
       try {
-        await runPhase(this.ctx, phase.slot, phaseCosts, phaseOutputs);
+        await runPhase(this.ctx, phase.slot, phaseCosts, phaseOutputs, this.isThreeSession);
       } catch (error48) {
         logger?.error("story-orchestrator", "Phase threw unexpected error", {
           storyId: this.ctx.storyId,
@@ -54154,24 +54414,27 @@ class StoryOrchestratorBuilder {
     this.state.rectification = opts;
     return this;
   }
-  build(ctx) {
+  build(ctx, opts = {}) {
     if (!this.state.implementer) {
       throw new NaxError("StoryOrchestratorBuilder.build(): addImplementer() must be called before build()", "ORCHESTRATOR_NO_IMPLEMENTER", { stage: "execution" });
     }
-    return new ExecutionPlan(ctx, { ...this.state });
+    return new ExecutionPlan(ctx, { ...this.state }, opts.isThreeSession ?? false);
   }
 }
-var _storyOrchestratorDeps, CANONICAL_ORDER, PHASE_KIND_TO_STATE_KEY;
+var _storyOrchestratorDeps, TDD_OP_NAMES, CANONICAL_ORDER, PHASE_KIND_TO_STATE_KEY;
 var init_story_orchestrator = __esm(() => {
   init_errors();
   init_findings();
   init_logger2();
   init_operations();
   init_call();
+  init_git();
   _storyOrchestratorDeps = {
     callOp,
-    runFixCycle
+    runFixCycle,
+    captureGitRef
   };
+  TDD_OP_NAMES = new Set(["test-writer", "implementer", "verifier"]);
   CANONICAL_ORDER = [
     "test-writer",
     "greenfield-gate",
@@ -54194,7 +54457,7 @@ var init_story_orchestrator = __esm(() => {
 
 // src/execution/build-plan-for-strategy.ts
 function isThreeSessionStrategy(strategy) {
-  return THREE_SESSION_STRATEGIES.has(strategy);
+  return THREE_SESSION_STRATEGIES2.has(strategy);
 }
 function requiresInitialRefCapture(strategy) {
   return isThreeSessionStrategy(strategy);
@@ -54211,22 +54474,22 @@ function isFreshRun(story) {
   return !hasAttempts && !hasReviewEscalation;
 }
 function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
-  const isTdd = isThreeSessionStrategy(testStrategy);
+  const isThreeSession = isThreeSessionStrategy(testStrategy);
   const freshRun = isFreshRun(story);
   const builder = new StoryOrchestratorBuilder;
-  if (isTdd && freshRun && inputs.testWriter) {
+  if (isThreeSession && freshRun && inputs.testWriter) {
     builder.addTestWriter(inputs.testWriter);
   }
-  if (isTdd && freshRun && inputs.greenfieldGate) {
+  if (isThreeSession && freshRun && inputs.greenfieldGate) {
     builder.addGreenfieldGate(inputs.greenfieldGate);
   }
   if (inputs.implementer) {
     builder.addImplementer(inputs.implementer);
   }
-  if (isTdd && inputs.fullSuiteGate) {
+  if (isThreeSession && inputs.fullSuiteGate) {
     builder.addFullSuiteGate(inputs.fullSuiteGate);
   }
-  if (isTdd && inputs.verifier) {
+  if (isThreeSession && inputs.verifier) {
     builder.addVerifier(inputs.verifier);
   }
   if (hasReviewCheck(config2, "semantic") && inputs.semanticReview) {
@@ -54236,21 +54499,21 @@ function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
     builder.addAdversarialReview(inputs.adversarialReview);
   }
   if (shouldRunRectification(config2) && inputs.rectification) {
-    const gateStrategies = isTdd && inputs.fullSuiteGate ? [makeFullSuiteRectifyStrategy(story)] : [];
+    const gateStrategies = isThreeSession && inputs.fullSuiteGate ? [makeFullSuiteRectifyStrategy(story)] : [];
     const rectOpts = {
       ...inputs.rectification,
       strategies: [...gateStrategies, ...inputs.rectification.strategies]
     };
     builder.addRectification(rectOpts);
   }
-  return builder.build(ctx);
+  return builder.build(ctx, { isThreeSession });
 }
-var THREE_SESSION_STRATEGIES;
+var THREE_SESSION_STRATEGIES2;
 var init_build_plan_for_strategy = __esm(() => {
   init_execution_gates();
   init_full_suite_rectify();
   init_story_orchestrator();
-  THREE_SESSION_STRATEGIES = new Set(["three-session-tdd", "three-session-tdd-lite"]);
+  THREE_SESSION_STRATEGIES2 = new Set(["three-session-tdd", "three-session-tdd-lite"]);
 });
 
 // src/execution/plan-inputs.ts
@@ -54286,22 +54549,40 @@ function validatePlanInputs(story, config2) {
 function hasReviewEscalation(story) {
   return (story.priorFailures ?? []).some((f) => f.stage === "review");
 }
+async function buildThreeSessionPrompt(role, ctx, lite) {
+  return TddPromptBuilder.buildForRole(role, ctx.workdir, ctx.config, ctx.story, {
+    lite,
+    contextMarkdown: ctx.contextMarkdown,
+    featureContextMarkdown: ctx.featureContextMarkdown,
+    contextBundle: ctx.contextBundle,
+    constitution: ctx.constitution?.content
+  });
+}
 async function assemblePlanInputsFromCtx(ctx) {
   const { story, config: config2 } = ctx;
   validatePlanInputs(story, config2);
   const _isTdd = isThreeSessionStrategy(ctx.routing.testStrategy);
   const _isFreshRun = (story.attempts ?? 0) === 0 && !hasReviewEscalation(story);
+  const isLite = ctx.routing.testStrategy === "three-session-tdd-lite";
+  if (!_isTdd && !ctx.prompt?.trim()) {
+    throw new NaxError(`Prompt missing for strategy "${ctx.routing.testStrategy}" \u2014 non-TDD strategies require ctx.prompt`, "PROMPT_NOT_BUILT", { stage: "plan-inputs", storyId: story.id, testStrategy: ctx.routing.testStrategy });
+  }
   const resolvedTestPatterns = _isTdd ? await resolveTestFilePatterns(config2, ctx.workdir) : undefined;
+  const [testWriterPrompt, implementerPrompt, verifierPrompt] = _isTdd ? await Promise.all([
+    _isFreshRun ? buildThreeSessionPrompt("test-writer", ctx, isLite) : Promise.resolve(""),
+    buildThreeSessionPrompt("implementer", ctx, isLite),
+    buildThreeSessionPrompt("verifier", ctx, isLite)
+  ]) : ["", ctx.prompt, ""];
   const testWriterInput = _isTdd && _isFreshRun ? {
     story,
-    contextMarkdown: ctx.prompt,
+    promptMarkdown: testWriterPrompt,
     featureContextMarkdown: ctx.featureContextMarkdown,
     constitution: ctx.constitution?.content
   } : undefined;
   const greenfieldGateInput = _isTdd && _isFreshRun && resolvedTestPatterns ? { story, workdir: ctx.workdir, resolvedTestPatterns } : undefined;
   const implementerInput = {
     story,
-    contextMarkdown: ctx.prompt,
+    promptMarkdown: implementerPrompt,
     featureContextMarkdown: ctx.featureContextMarkdown,
     constitution: ctx.constitution?.content
   };
@@ -54312,7 +54593,7 @@ async function assemblePlanInputsFromCtx(ctx) {
     projectDir: ctx.projectDir,
     resolvedTestPatterns
   } : undefined;
-  const verifierInput = _isTdd ? { story } : undefined;
+  const verifierInput = _isTdd ? { story, promptMarkdown: verifierPrompt } : undefined;
   const inlineReviewEnabled = ctx.config.execution?.inlineReview === true;
   const semanticStory = {
     id: story.id,
@@ -54357,25 +54638,12 @@ async function assemblePlanInputsFromCtx(ctx) {
 }
 var init_plan_inputs = __esm(() => {
   init_errors();
+  init_prompts();
   init_resolver();
   init_build_plan_for_strategy();
 });
 
 // src/pipeline/stages/execution-helpers.ts
-function isAmbiguousOutput(output) {
-  if (!output)
-    return false;
-  const ambiguityKeywords = [
-    "unclear",
-    "ambiguous",
-    "need clarification",
-    "please clarify",
-    "which one",
-    "not sure which"
-  ];
-  const lowerOutput = output.toLowerCase();
-  return ambiguityKeywords.some((keyword) => lowerOutput.includes(keyword));
-}
 function routeTddFailure(failureCategory, isLiteMode, ctx, reviewReason) {
   if (failureCategory === "isolation-violation") {
     if (!isLiteMode) {
@@ -54608,6 +54876,16 @@ async function applyPostRunInspection(ctx, planResult, opts) {
   }
   const pauseReason = extractPauseReason(planResult.phaseOutputs);
   const failureCategory = isTdd && !planResult.success ? deriveTddFailureCategory(planResult.phaseOutputs) : undefined;
+  const tddIsolations = {};
+  for (const opName of ["test-writer", "implementer", "verifier"]) {
+    const phaseOut = planResult.phaseOutputs[opName];
+    if (phaseOut?.isolation) {
+      tddIsolations[opName] = phaseOut.isolation;
+    }
+  }
+  if (Object.keys(tddIsolations).length > 0) {
+    ctx.tddIsolations = tddIsolations;
+  }
   const needsHumanReview = failureCategory === "session-failure";
   const combinedOutput = (agentResult.output ?? "") + (agentResult.stderr ?? "");
   if (isTdd) {
@@ -54721,13 +54999,6 @@ Category: ${failureCategory ?? "unknown"}`,
     await cleanupSessionOnFailure(ctx);
     return { action: "escalate" };
   }
-  if (agentResult.success && _postRunDeps.isAmbiguousOutput(combinedOutput) && ctx.interaction && isTriggerEnabled("story-ambiguity", ctx.config)) {
-    const shouldContinue = await _postRunDeps.checkStoryAmbiguity({ featureName: ctx.prd.feature, storyId: ctx.story.id, reason: "Agent output suggests ambiguity" }, ctx.config, ctx.interaction);
-    if (!shouldContinue) {
-      logger.warn("execution", "Story ambiguity detected \u2014 escalating story", { storyId: ctx.story.id });
-      return { action: "escalate", reason: "Story ambiguity detected \u2014 needs clarification" };
-    }
-  }
   if (!isTdd) {
     await _postRunDeps.autoCommitIfDirty(ctx.workdir, "execution", "single-session", ctx.story.id);
   }
@@ -54745,13 +55016,11 @@ var init_post_run = __esm(() => {
   init_execution_helpers();
   init_quality();
   init_scratch_writer();
-  init_session_runner();
+  init_rollback();
   init_git();
   _postRunDeps = {
     detectMergeConflict,
     checkMergeConflict,
-    isAmbiguousOutput,
-    checkStoryAmbiguity,
     failAndClose,
     rollbackToRef,
     autoCommitIfDirty
@@ -54778,8 +55047,6 @@ var init_execution = __esm(() => {
       const agent = (ctx.agentGetFn ?? _executionDeps.getAgent)(defaultAgent);
       if (!agent)
         return { action: "fail", reason: `Agent "${defaultAgent}" not found` };
-      if (!ctx.prompt)
-        return { action: "fail", reason: "Prompt not built (prompt stage skipped?)" };
       let effectiveTier = ctx.routing.modelTier;
       if (!_executionDeps.validateAgentForTier(agent, ctx.routing.modelTier)) {
         effectiveTier = agent.capabilities.supportedTiers[0] ?? ctx.routing.modelTier;
@@ -54791,7 +55058,8 @@ var init_execution = __esm(() => {
           supportedTiers: agent.capabilities.supportedTiers
         });
       }
-      if (!ctx.packageView)
+      const packageView = ctx.packageView ?? ctx.runtime?.packages?.resolve(ctx.workdir);
+      if (!packageView)
         return { action: "fail", reason: "Package view unavailable for execution dispatch" };
       const interactionBridge = buildInteractionBridge(ctx.interaction, {
         featureName: ctx.prd.feature,
@@ -54800,7 +55068,7 @@ var init_execution = __esm(() => {
       });
       const callCtx = {
         runtime: ctx.runtime,
-        packageView: ctx.packageView,
+        packageView,
         packageDir: ctx.workdir,
         agentName: ctx.routing.agent ?? defaultAgent,
         storyId: ctx.story.id,
@@ -55593,7 +55861,7 @@ class RegressionStrategy {
 var _regressionStrategyDeps, DeferredRegressionStrategy;
 var init_regression = __esm(() => {
   init_logger2();
-  init_parser2();
+  init_test_runners();
   init_runners();
   _regressionStrategyDeps = { runVerification: fullSuite };
   DeferredRegressionStrategy = class DeferredRegressionStrategy extends RegressionStrategy {
@@ -58892,7 +59160,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.67.0-canary.6",
+    version: "0.67.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -58987,8 +59255,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("e83c9ffd"))
-        return "e83c9ffd";
+      if (/^[0-9a-f]{6,10}$/.test("ffa2f392"))
+        return "ffa2f392";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -60195,10 +60463,9 @@ var _regressionDeps;
 var init_run_regression = __esm(() => {
   init_logger2();
   init_prd();
+  init_test_runners();
   init_git();
   init_verification();
-  init_rectification_loop();
-  init_runners();
   _regressionDeps = {
     runVerification: fullSuite,
     runRectificationLoop,
@@ -60456,6 +60723,7 @@ async function handleRunCompletion(options) {
   return {
     durationMs,
     runCompletedAt,
+    reportedTotal,
     finalCounts: {
       total: finalCounts.total,
       passed: finalCounts.passed,
@@ -62320,6 +62588,27 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
       });
     }
   }
+  if (pipelineResult.finalAction === "escalate" && ctx.sessionManager) {
+    const sessionManager = ctx.sessionManager;
+    const liveStorySessions = sessionManager.getForStory(story.id).filter((desc) => desc.handle && (desc.state === "RUNNING" || desc.state === "CREATED"));
+    for (const desc of liveStorySessions) {
+      if (!desc.handle)
+        continue;
+      const live = sessionManager.getLiveHandle(desc.handle);
+      if (!live)
+        continue;
+      try {
+        await sessionManager.closeSession(live);
+      } catch (err) {
+        getLogger().warn("iteration-runner", "Failed to close warm session on escalation \u2014 continuing", {
+          storyId: story.id,
+          sessionName: desc.handle ?? "(no handle)",
+          role: desc.role,
+          error: errorMessage(err)
+        });
+      }
+    }
+  }
   const reviewSummaryFromPipeline = pipelineResult.context.reviewResult?.reviewSummary;
   if (reviewSummaryFromPipeline) {
     ctx.statusWriter.setReviewSummary(reviewSummaryFromPipeline);
@@ -99013,11 +99302,11 @@ async function runCompletionPhase(options) {
     runtime: options.runtime,
     abortSignal: options.abortSignal
   });
-  const { durationMs, runCompletedAt, finalCounts } = completionResult;
+  const { durationMs, runCompletedAt, finalCounts, reportedTotal } = completionResult;
   if (options.featureDir) {
     const finalStatus = isComplete(options.prd) ? "completed" : "failed";
     options.statusWriter.setRunStatus(finalStatus);
-    await options.statusWriter.writeFeatureStatus(options.featureDir, options.totalCost, options.iterations);
+    await options.statusWriter.writeFeatureStatus(options.featureDir, reportedTotal, options.iterations);
   }
   if (options.headless && options.formatterMode !== "json") {
     const { outputRunFooter: outputRunFooter2 } = await Promise.resolve().then(() => (init_headless_formatter(), exports_headless_formatter));
@@ -99029,7 +99318,7 @@ async function runCompletionPhase(options) {
         skipped: finalCounts.skipped
       },
       durationMs,
-      totalCost: options.totalCost,
+      totalCost: reportedTotal,
       startedAt: options.startedAt,
       completedAt: runCompletedAt,
       formatterMode: options.formatterMode
@@ -99037,7 +99326,7 @@ async function runCompletionPhase(options) {
   }
   logger?.debug("execution", "Completion phase \u2014 stopping heartbeat and writing exit summary");
   stopHeartbeat();
-  await writeExitSummary(options.logFilePath, options.totalCost, options.iterations, options.storiesCompleted, durationMs);
+  await writeExitSummary(options.logFilePath, reportedTotal, options.iterations, options.storiesCompleted, durationMs);
   logger?.debug("execution", "Completion phase \u2014 auto-committing dirty files");
   await autoCommitIfDirty(options.workdir, "run.complete", "run-summary", options.feature);
   reviewOrchestrator.reset();