@nathapp/nax 0.68.1 → 0.68.3

package/dist/nax.js

@@ -17203,7 +17203,8 @@ var init_schemas_review = __esm(() => {
       requote: true,
       maxRequotes: 5
     }),
-    excludePatterns: exports_external.array(exports_external.string()).optional()
+    excludePatterns: exports_external.array(exports_external.string()).optional(),
+    demandInspectionTrail: exports_external.boolean().default(true)
   });
   AdversarialReviewConfigSchema = exports_external.object({
     model: ConfiguredModelSchema.default("balanced"),
@@ -17214,6 +17215,7 @@ var init_schemas_review = __esm(() => {
     parallel: exports_external.boolean().default(false),
     maxConcurrentSessions: exports_external.number().int().min(1).max(4).default(2),
     acRegroundOnDrop: exports_external.boolean().default(true),
+    demandInspectionTrail: exports_external.boolean().default(true),
     substantiation: exports_external.object({
       requote: exports_external.boolean().default(true),
       maxRequotes: exports_external.number().int().min(0).default(5)
@@ -17428,6 +17430,7 @@ var init_schemas3 = __esm(() => {
         resetRefOnRerun: false,
         rules: [],
         timeoutMs: 600000,
+        demandInspectionTrail: true,
         substantiation: {
           requote: true,
           maxRequotes: 5
@@ -17451,6 +17454,7 @@ var init_schemas3 = __esm(() => {
         parallel: false,
         maxConcurrentSessions: 2,
         acRegroundOnDrop: true,
+        demandInspectionTrail: true,
         substantiation: {
           requote: true,
           maxRequotes: 5
@@ -17735,19 +17739,30 @@ function formatStoryStart(entry, c, _timestamp, mode) {
   const complexity = typeof data.complexity === "string" ? data.complexity : "unknown";
   const tier = typeof data.modelTier === "string" ? data.modelTier : "unknown";
   const attempt = typeof data.attempt === "number" ? data.attempt : 1;
+  const agent = typeof data.agent === "string" ? data.agent : undefined;
+  const progress = typeof data.storyNumber === "number" && typeof data.storyTotal === "number" ? `${data.storyNumber}/${data.storyTotal}` : undefined;
   const lines = [];
   lines.push("");
   lines.push(c.bold(`${EMOJI.storyStart} ${c.cyan(storyId)}: ${title}`));
   if (mode === "verbose") {
+    if (progress)
+      lines.push(`  ${c.gray("\u251C\u2500")} Story: ${c.cyan(progress)}`);
     lines.push(`  ${c.gray("\u251C\u2500")} Complexity: ${c.yellow(complexity)}`);
     lines.push(`  ${c.gray("\u251C\u2500")} Tier: ${c.magenta(tier)}`);
+    if (agent)
+      lines.push(`  ${c.gray("\u251C\u2500")} Agent: ${c.cyan(agent)}`);
     if (attempt > 1) {
       lines.push(`  ${c.gray("\u2514\u2500")} Attempt: ${c.yellow(`#${attempt}`)} ${EMOJI.retry}`);
     } else {
       lines.push(`  ${c.gray("\u2514\u2500")} Status: ${c.green("starting")}`);
     }
   } else {
-    const metadata = [complexity, tier];
+    const metadata = [];
+    if (progress)
+      metadata.push(progress);
+    metadata.push(complexity, tier);
+    if (agent)
+      metadata.push(agent);
     if (attempt > 1)
       metadata.push(`attempt #${attempt} ${EMOJI.retry}`);
     lines.push(`  ${c.gray(metadata.join(" \u2022 "))}`);
@@ -17809,24 +17824,19 @@ function formatDefault(entry, c, timestamp, mode) {
   if (entry.storyId) {
     parts.push(c.dim(`[${entry.storyId}]`));
   }
+  if (entry.sessionRole) {
+    parts.push(c.dim(`(${entry.sessionRole})`));
+  }
   parts.push(entry.message);
   let output = parts.join(" ");
   const data = entry.data;
   if (data && typeof data === "object") {
-    const meta3 = [];
-    if (typeof data.cost === "number" && data.cost > 0)
-      meta3.push(`${EMOJI.cost} ${formatCost(data.cost)}`);
-    if (typeof data.durationMs === "number" && data.durationMs > 0)
-      meta3.push(`${EMOJI.duration} ${formatDuration(data.durationMs)}`);
-    if (typeof data.action === "string")
-      meta3.push(`action: ${data.action}`);
-    if (typeof data.reason === "string" && mode !== "quiet")
-      meta3.push(data.reason);
+    const meta3 = buildDefaultMeta(data, mode);
     if (meta3.length > 0) {
       output += `  ${c.gray(meta3.join("  "))}`;
     }
     if (mode === "verbose") {
-      const { cost: _c, durationMs: _d, action: _a2, reason: _r, ...filtered } = data;
+      const filtered = stripConsumedMetaFields(data);
       if (Object.keys(filtered).length > 0) {
         output += `
 ${c.gray(JSON.stringify(filtered, null, 2))}`;
@@ -17838,6 +17848,52 @@ ${c.gray(JSON.stringify(filtered, null, 2))}`;
     shouldDisplay: true
   };
 }
+function buildDefaultMeta(data, mode) {
+  const meta3 = [];
+  const identity = [data.agentName, data.model].filter((v) => typeof v === "string" && v.length > 0);
+  if (identity.length > 0)
+    meta3.push(`${EMOJI.agent} ${identity.join("\xB7")}`);
+  if (typeof data.phaseIndex === "number" && typeof data.totalPhases === "number") {
+    meta3.push(`${data.phaseIndex}/${data.totalPhases}`);
+  }
+  if (typeof data.status === "string")
+    meta3.push(`status: ${data.status}`);
+  if (typeof data.findingsCount === "number")
+    meta3.push(`${data.findingsCount} finding${data.findingsCount === 1 ? "" : "s"}`);
+  const activity = buildActivityMeta(data);
+  if (activity)
+    meta3.push(activity);
+  if (typeof data.cost === "number" && data.cost > 0)
+    meta3.push(`${EMOJI.cost} ${formatCost(data.cost)}`);
+  if (typeof data.durationMs === "number" && data.durationMs > 0)
+    meta3.push(`${EMOJI.duration} ${formatDuration(data.durationMs)}`);
+  if (typeof data.action === "string")
+    meta3.push(`action: ${data.action}`);
+  if (typeof data.reason === "string" && mode !== "quiet")
+    meta3.push(data.reason);
+  return meta3;
+}
+function buildActivityMeta(data) {
+  const segments = [];
+  if (typeof data.messageUpdates === "number" && data.messageUpdates > 0)
+    segments.push(`msg ${data.messageUpdates}`);
+  if (typeof data.toolCallUpdates === "number" && data.toolCallUpdates > 0)
+    segments.push(`tools ${data.toolCallUpdates}`);
+  if (typeof data.thinkingUpdates === "number" && data.thinkingUpdates > 0)
+    segments.push(`think ${data.thinkingUpdates}`);
+  if (typeof data.idleMs === "number" && data.idleMs > 0)
+    segments.push(`idle ${formatDuration(data.idleMs)}`);
+  return segments.length > 0 ? segments.join(" ") : null;
+}
+function stripConsumedMetaFields(data) {
+  const filtered = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!CONSUMED_META_KEYS.includes(key)) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
 function formatRunSummary(summary, options) {
   const { mode, useColor = true } = options;
   if (mode === "json") {
@@ -17882,9 +17938,26 @@ function createNoopChalk() {
     cyan: noop
   };
 }
+var CONSUMED_META_KEYS;
 var init_formatter = __esm(() => {
   init_source();
   init_types2();
+  CONSUMED_META_KEYS = [
+    "agentName",
+    "model",
+    "phaseIndex",
+    "totalPhases",
+    "status",
+    "findingsCount",
+    "messageUpdates",
+    "toolCallUpdates",
+    "thinkingUpdates",
+    "idleMs",
+    "cost",
+    "durationMs",
+    "action",
+    "reason"
+  ];
 });
 
 // src/logging/index.ts
@@ -17933,6 +18006,43 @@ var init_formatters = __esm(() => {
   init_source();
 });
 
+// src/logger/redact.ts
+function redactString(value) {
+  let out = value;
+  for (const re of SECRET_VALUE_PATTERNS) {
+    re.lastIndex = 0;
+    out = out.replace(re, REDACTED);
+  }
+  return out;
+}
+function redactSecrets(input) {
+  if (typeof input === "string")
+    return redactString(input);
+  if (Array.isArray(input))
+    return input.map(redactSecrets);
+  if (input !== null && typeof input === "object") {
+    const out = {};
+    for (const [key, value] of Object.entries(input)) {
+      out[key] = SECRET_KEY_PATTERN.test(key) ? REDACTED : redactSecrets(value);
+    }
+    return out;
+  }
+  return input;
+}
+var SECRET_KEY_PATTERN, SECRET_VALUE_PATTERNS, REDACTED = "[REDACTED]";
+var init_redact = __esm(() => {
+  SECRET_KEY_PATTERN = /(SECRET|TOKEN|API_?KEY|PASSWORD|PRIVATE_?KEY|ACCESS_?KEY|WEBHOOK)/i;
+  SECRET_VALUE_PATTERNS = [
+    /sk-[A-Za-z0-9_-]{16,}/g,
+    /ghp_[A-Za-z0-9]{16,}/g,
+    /gh[opsu]_[A-Za-z0-9]{16,}/g,
+    /npm_[A-Za-z0-9]{8,}/g,
+    /AKIA[0-9A-Z]{16}/g,
+    /xox[baprs]-[A-Za-z0-9-]{10,}/g,
+    /(?:SECRET|TOKEN|API_?KEY|PASSWORD|PRIVATE_?KEY|ACCESS_?KEY|WEBHOOK)=[^\s"',]+/gi
+  ];
+});
+
 // src/logger/logger.ts
 import { mkdirSync } from "fs";
 import { appendFile } from "fs/promises";
@@ -18027,7 +18137,8 @@ ${JSON.stringify(entry.data, null, 2)}`;
   writeToFile(entry) {
     if (!this.filePath)
       return;
-    const line = `${formatJsonl(entry)}
+    const safeEntry = entry.data ? { ...entry, data: redactSecrets(entry.data) } : entry;
+    const line = `${formatJsonl(safeEntry)}
 `;
     const filePath = this.filePath;
     this.writeQueueTail = this.writeQueueTail.then(() => appendFile(filePath, line).catch((error48) => {
@@ -18089,6 +18200,7 @@ var LOG_LEVEL_PRIORITY, instance = null, noopLogger;
 var init_logger = __esm(() => {
   init_logging();
   init_formatters();
+  init_redact();
   LOG_LEVEL_PRIORITY = {
     silent: -1,
     error: 0,
@@ -19070,7 +19182,7 @@ GOOD (write ACs like these):
 
 When a spec is provided, these rules govern acceptance criteria generation:
 
-1. **Preserve spec ACs.** Every acceptance criterion stated in the spec must appear in \`acceptanceCriteria\`, verbatim or lightly rephrased for testability. Never silently drop a spec AC.
+1. **Preserve spec ACs.** Every acceptance criterion stated in the spec must appear in \`acceptanceCriteria\`. Never silently drop a spec AC. ACs the spec tags \`[verbatim]\` (typically executable greps, file-existence checks, regex/count assertions, or architectural invariants) MUST be copied **character-for-character** into an \`acceptanceCriteria\` entry \u2014 preserve every backtick-quoted command, file path, regex, and count exactly; do not paraphrase, retag, split, or move them into a description. Untagged ACs may be lightly rephrased for testability, but must retain the same assertion and concrete identifiers.
 2. **Do not invent spec ACs.** If you identify useful behavioral edge cases or negative paths that the spec did not explicitly list, place them in \`suggestedCriteria\` (a string array on the same story object) \u2014 never in \`acceptanceCriteria\`. These go through a separate hardening pass.
 3. **Respect story scope.** Each story's criteria must only cover what the spec says for that story. Do not assign criteria that belong to a different story's scope (wrong feature area, wrong file, wrong dependency chain).
 4. **\`suggestedCriteria\` format.** Each element must be a plain behavioral assertion \u2014 an observable output, return value, state change, or error condition that a test can assert. Never include implementation details (imports, internal structure), design suggestions, or vague descriptions.
@@ -22551,9 +22663,16 @@ async function detectTestFramework(_workdir, language, pkg) {
   }
   return;
 }
+function clearLanguageCache() {
+  _languageCache.clear();
+}
 async function detectLanguage(packageDir) {
+  if (_languageCache.has(packageDir))
+    return _languageCache.get(packageDir);
   const pkg = await _detectorDeps.readJson(join5(packageDir, "package.json"));
-  return _detectLanguageImpl(packageDir, pkg);
+  const result = await _detectLanguageImpl(packageDir, pkg);
+  _languageCache.set(packageDir, result);
+  return result;
 }
 async function detectLintTool(workdir, language) {
   if (language === "go")
@@ -22581,7 +22700,7 @@ async function detectProjectProfile(workdir, existing) {
   const lintTool = existing.lintTool !== undefined ? existing.lintTool : await detectLintTool(workdir, language);
   return { language, type, testFramework, lintTool };
 }
-var _detectorDeps, WEB_DEPS, API_DEPS;
+var _detectorDeps, WEB_DEPS, API_DEPS, _languageCache;
 var init_detector = __esm(() => {
   _detectorDeps = {
     async fileExists(path) {
@@ -22602,6 +22721,7 @@ var init_detector = __esm(() => {
   };
   WEB_DEPS = new Set(["react", "next", "vue", "nuxt"]);
   API_DEPS = new Set(["express", "fastify", "hono"]);
+  _languageCache = new Map;
 });
 
 // src/test-runners/conventions.ts
@@ -23730,7 +23850,10 @@ async function detectNaxMonoLayout(workdir) {
   } catch {}
   return dirs;
 }
-async function discoverWorkspacePackages(workdir) {
+function clearWorkspaceCache() {
+  _workspaceCache.clear();
+}
+async function discoverWorkspacePackagesUncached(workdir) {
   const [fromPnpm, fromNpm, fromLerna, fromTurboNx, fromNaxMono] = await Promise.all([
     detectPnpmWorkspace(workdir),
     detectNpmWorkspaces(workdir),
@@ -23749,7 +23872,14 @@ async function discoverWorkspacePackages(workdir) {
   }
   return unique;
 }
-var _workspaceDeps;
+async function discoverWorkspacePackages(workdir) {
+  if (_workspaceCache.has(workdir))
+    return _workspaceCache.get(workdir) ?? [];
+  const result = await discoverWorkspacePackagesUncached(workdir);
+  _workspaceCache.set(workdir, result);
+  return result;
+}
+var _workspaceDeps, _workspaceCache;
 var init_workspace = __esm(() => {
   init_logger2();
   _workspaceDeps = {
@@ -23762,6 +23892,7 @@ var init_workspace = __esm(() => {
     spawn: Bun.spawn,
     glob: (pattern, cwd) => new Bun.Glob(pattern).scan({ cwd, onlyFiles: false })
   };
+  _workspaceCache = new Map;
 });
 
 // src/test-runners/detect.ts
@@ -24625,6 +24756,19 @@ var init_path_filters = __esm(() => {
 
 // src/verification/smart-runner.ts
 import { join as join8, relative as relative3 } from "path";
+function clearGitRootCache() {
+  _gitRootCache.clear();
+}
+async function getGitRootMemo(workdir) {
+  const cached2 = _gitRootCache.get(workdir);
+  if (cached2 !== undefined)
+    return cached2;
+  const result = await _gitUtilDeps.getGitRoot(workdir);
+  if (result !== null && result !== undefined) {
+    _gitRootCache.set(workdir, result);
+  }
+  return result ?? null;
+}
 function extractPatternSuffix(pattern) {
   const lastStar = pattern.lastIndexOf("*");
   if (lastStar === -1)
@@ -24644,28 +24788,28 @@ async function importGrepFallback(sourceFiles, workdir, testFilePatterns) {
     return [];
   const searchTerms = sourceFiles.flatMap(extractSearchTerms);
   const testFilePaths = [];
-  for (const pattern of testFilePatterns) {
-    const glob = _bunDeps.glob(pattern);
-    for await (const file3 of glob.scan(workdir)) {
-      testFilePaths.push(`${workdir}/${file3}`);
+  outer:
+    for (const pattern of testFilePatterns) {
+      const g = _bunDeps.glob(pattern);
+      for await (const file3 of g.scan(workdir)) {
+        testFilePaths.push(`${workdir}/${file3}`);
+        if (testFilePaths.length >= MAX_GREP_TEST_FILES) {
+          getSafeLogger()?.debug("smart-runner", "import-grep glob cap reached \u2014 results truncated", {
+            cap: MAX_GREP_TEST_FILES
+          });
+          break outer;
+        }
+      }
     }
-  }
-  const matched = [];
-  for (const testFile of testFilePaths) {
-    let content;
+  const results = await Promise.all(testFilePaths.map(async (testFile) => {
     try {
-      content = await _bunDeps.file(testFile).text();
+      const content = await _bunDeps.file(testFile).text();
+      return searchTerms.some((t) => content.includes(t)) ? testFile : null;
     } catch {
-      continue;
-    }
-    for (const term of searchTerms) {
-      if (content.includes(term)) {
-        matched.push(testFile);
-        break;
-      }
+      return null;
     }
-  }
-  return matched;
+  }));
+  return results.filter((p) => p !== null);
 }
 async function mapSourceToTests(sourceFiles, workdir, packagePrefix, testFilePatterns = [...DEFAULT_TEST_FILE_PATTERNS]) {
   const testSuffixes = [...new Set(testFilePatterns.map(extractPatternSuffix).filter((s) => s !== null))];
@@ -24690,11 +24834,11 @@ async function mapSourceToTests(sourceFiles, workdir, packagePrefix, testFilePat
       }
       candidates.push(`${workdir}/${sourceWithoutExt}${suffix}`);
     }
-    for (const candidate of candidates) {
-      if (await _bunDeps.file(candidate).exists()) {
-        result.push(candidate);
-      }
-    }
+    const existsFlags = await Promise.all(candidates.map((c) => _bunDeps.file(c).exists()));
+    candidates.forEach((c, i) => {
+      if (existsFlags[i])
+        result.push(c);
+    });
   }
   return result;
 }
@@ -24733,7 +24877,7 @@ async function getChangedNonTestFiles(workdir, baseRef, packagePrefix, testFileR
     const ignoreMatchers = naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(effectiveRepoRoot, packageDir);
     let effectivePrefix = packagePrefix;
     if (packagePrefix && repoRoot) {
-      const gitRoot = await _gitUtilDeps.getGitRoot(workdir);
+      const gitRoot = await getGitRootMemo(workdir);
       const extraPrefix2 = gitRoot && gitRoot !== repoRoot ? relative3(gitRoot, repoRoot) : "";
       effectivePrefix = extraPrefix2 ? `${extraPrefix2}/${packagePrefix}` : packagePrefix;
     }
@@ -24760,7 +24904,7 @@ async function getChangedTestFiles(workdir, repoRoot, baseRef, packagePrefix, te
 `).filter(Boolean);
     const packageDir = packagePrefix ? join8(repoRoot, packagePrefix) : undefined;
     const ignoreMatchers = naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(repoRoot, packageDir);
-    const gitRoot = await _gitUtilDeps.getGitRoot(workdir);
+    const gitRoot = await getGitRootMemo(workdir);
     const extraPrefix = gitRoot && gitRoot !== repoRoot ? relative3(gitRoot, repoRoot) : "";
     const effectivePrefix = packagePrefix ? extraPrefix ? `${extraPrefix}/${packagePrefix}` : packagePrefix : undefined;
     const scopedRaw = effectivePrefix ? lines.filter((f) => f.startsWith(`${effectivePrefix}/`)) : lines;
@@ -24771,8 +24915,9 @@ async function getChangedTestFiles(workdir, repoRoot, baseRef, packagePrefix, te
     return [];
   }
 }
-var _bunDeps, _gitUtilDeps, _smartRunnerDeps;
+var _bunDeps, MAX_GREP_TEST_FILES = 200, _gitUtilDeps, _gitRootCache, _smartRunnerDeps;
 var init_smart_runner = __esm(() => {
+  init_logger2();
   init_conventions();
   init_git();
   init_path_filters();
@@ -24783,6 +24928,7 @@ var init_smart_runner = __esm(() => {
   _gitUtilDeps = {
     getGitRoot
   };
+  _gitRootCache = new Map;
   _smartRunnerDeps = {
     glob: _bunDeps.glob,
     file: _bunDeps.file,
@@ -25140,31 +25286,50 @@ async function resolveSourceGlob(override, packageDir) {
   const language = await _codeNeighborDeps.detectLanguage(packageDir);
   return (language && SOURCE_GLOB_BY_LANGUAGE[language]) ?? FALLBACK_SOURCE_GLOB;
 }
-async function collectNeighbors(filePath, workdir, sourceGlob, maxGlobFiles, extraGlobWorkdirs, siblingTestContext, ignoreMatchers, globCtx) {
+function scanDirectory(sourceGlob, workdir, ignoreMatchers, maxGlobFiles, globCtx) {
+  const { files, truncated } = _codeNeighborDeps.glob(sourceGlob, workdir, ignoreMatchers, maxGlobFiles, globCtx);
+  return { workdir, files, truncated };
+}
+async function readCached(absolutePath, cache) {
+  const cached2 = cache.get(absolutePath);
+  if (cached2 !== undefined)
+    return cached2;
+  try {
+    const content = await _codeNeighborDeps.readFile(absolutePath);
+    cache.set(absolutePath, content);
+    return content;
+  } catch {
+    cache.set(absolutePath, "");
+    return null;
+  }
+}
+async function collectNeighbors(filePath, workdir, scannedDirs, contentCache, siblingTestContext) {
   const neighbors = new Set;
   let anyTruncated = false;
-  if (await _codeNeighborDeps.fileExists(join10(workdir, filePath))) {
-    const content = await _codeNeighborDeps.readFile(join10(workdir, filePath));
-    for (const spec of parseImportSpecifiers(content)) {
-      const resolved = resolveImport(spec, filePath, workdir);
-      if (resolved && resolved !== filePath)
-        neighbors.add(resolved);
+  const ownAbsPath = join10(workdir, filePath);
+  if (await _codeNeighborDeps.fileExists(ownAbsPath)) {
+    const ownContent = await readCached(ownAbsPath, contentCache);
+    if (ownContent !== null && ownContent.length > 0) {
+      for (const spec of parseImportSpecifiers(ownContent)) {
+        const resolved = resolveImport(spec, filePath, workdir);
+        if (resolved && resolved !== filePath)
+          neighbors.add(resolved);
+      }
     }
   }
   const fileBaseName = (filePath.split("/").pop() ?? filePath).replace(/\.[^.]+$/, "");
   const fileNoExt = filePath.replace(/\.[^.]+$/, "");
-  const scanForReverseDeps = async (scanWorkdir) => {
-    const { files: srcFiles, truncated } = _codeNeighborDeps.glob(sourceGlob, scanWorkdir, ignoreMatchers, maxGlobFiles, globCtx);
-    if (truncated)
-      anyTruncated = true;
-    for (const srcFile of srcFiles) {
-      if (neighbors.size >= MAX_NEIGHBORS_PER_FILE)
-        break;
-      if (srcFile === filePath)
-        continue;
-      try {
-        const content = await _codeNeighborDeps.readFile(join10(scanWorkdir, srcFile));
-        if (content.includes(fileBaseName)) {
+  outer:
+    for (const { workdir: scanWorkdir, files: srcFiles, truncated } of scannedDirs) {
+      if (truncated)
+        anyTruncated = true;
+      for (const srcFile of srcFiles) {
+        if (neighbors.size >= MAX_NEIGHBORS_PER_FILE)
+          break outer;
+        if (srcFile === filePath)
+          continue;
+        const content = await readCached(join10(scanWorkdir, srcFile), contentCache);
+        if (content?.includes(fileBaseName)) {
           for (const spec of parseImportSpecifiers(content)) {
             const resolved = resolveImport(spec, srcFile, scanWorkdir);
             if (resolved === filePath || resolved === fileNoExt) {
@@ -25173,17 +25338,8 @@ async function collectNeighbors(filePath, workdir, sourceGlob, maxGlobFiles, ext
             }
           }
         }
-      } catch {}
-    }
-  };
-  await scanForReverseDeps(workdir);
-  if (extraGlobWorkdirs) {
-    for (const extraDir of extraGlobWorkdirs) {
-      if (neighbors.size >= MAX_NEIGHBORS_PER_FILE)
-        break;
-      await scanForReverseDeps(extraDir);
+      }
     }
-  }
   if (siblingTestContext && !isTestFile2(filePath, siblingTestContext.regex)) {
     const candidates = deriveSiblingTestCandidates(filePath, siblingTestContext.globs);
     let chosen = null;
@@ -25246,10 +25402,17 @@ class CodeNeighborProvider {
     const ignoreMatchers = request.naxIgnoreIndex?.getMatchers(workdir);
     const sourceGlob = await resolveSourceGlob(this.sourceGlobOverride, request.packageDir);
     const globCtx = { storyId: request.storyId, packageDir: request.packageDir };
+    const scannedDirs = [scanDirectory(sourceGlob, workdir, ignoreMatchers, this.maxGlobFiles, globCtx)];
+    if (extraGlobWorkdirs) {
+      for (const extraDir of extraGlobWorkdirs) {
+        scannedDirs.push(scanDirectory(sourceGlob, extraDir, ignoreMatchers, this.maxGlobFiles, globCtx));
+      }
+    }
+    const contentCache = new Map;
     const sections = [];
     let anyTruncated = false;
     for (const file3 of filesToProcess) {
-      const { neighbors, truncated } = await collectNeighbors(file3, workdir, sourceGlob, this.maxGlobFiles, extraGlobWorkdirs, siblingTestContext, ignoreMatchers, globCtx);
+      const { neighbors, truncated } = await collectNeighbors(file3, workdir, scannedDirs, contentCache, siblingTestContext);
       if (truncated)
         anyTruncated = true;
       if (neighbors.length > 0) {
@@ -26167,13 +26330,25 @@ function buildPullToolDescriptors(stageToolNames, pullConfig) {
   const allowed = pullConfig.allowedTools;
   return stageToolNames.filter((name) => allowed.length === 0 || allowed.includes(name)).map((name) => PULL_TOOL_REGISTRY[name]).filter((d) => d !== undefined).map((d) => ({ ...d, maxCallsPerSession: pullConfig.maxCallsPerSession ?? d.maxCallsPerSession }));
 }
-async function fetchWithTimeout(provider, request) {
+async function fetchWithTimeout(provider, request, timeoutMs = PROVIDER_FETCH_TIMEOUT_MS) {
+  const controller = new AbortController;
   let handle;
+  let timedOut = false;
   const timeout = new Promise((_, reject) => {
-    handle = setTimeout(() => reject(new Error(`Provider "${provider.id}" timed out`)), PROVIDER_FETCH_TIMEOUT_MS);
+    handle = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+      reject(new Error(`Provider "${provider.id}" timed out`));
+    }, timeoutMs);
+  });
+  const fetchPromise = provider.fetch(request, controller.signal).then((result) => result, (err) => {
+    if (timedOut) {
+      return new Promise(() => {});
+    }
+    throw err;
   });
   try {
-    return await Promise.race([provider.fetch(request), timeout]);
+    return await Promise.race([fetchPromise, timeout]);
   } finally {
     clearTimeout(handle);
   }
@@ -26812,12 +26987,7 @@ class GitHistoryProvider {
       return { chunks: [], pullTools: [] };
     }
     const filesToProcess = touchedFiles.filter(isRelativeAndSafe).slice(0, MAX_FILES2);
-    const sections = [];
-    for (const file3 of filesToProcess) {
-      const section = await fetchFileHistory(file3, workdir);
-      if (section)
-        sections.push(section);
-    }
+    const sections = (await Promise.all(filesToProcess.map((file3) => fetchFileHistory(file3, workdir)))).filter((section) => section !== null);
     if (sections.length === 0) {
       return { chunks: [], pullTools: [] };
     }
@@ -27323,6 +27493,75 @@ function isStalled(prd) {
   return remaining.every((s) => s.status === "blocked" || s.status === "failed" || s.status === "paused" || s.status === "regression-failed" || s.dependencies.some((dep) => blockedIds.has(dep)));
 }
 
+// src/prd/verbatim-fidelity.ts
+function normalizeWs(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function stripBackticks(text) {
+  return text.replace(/`/g, "");
+}
+function canonical(text) {
+  return normalizeWs(stripBackticks(text));
+}
+function leadingTagGroup(line) {
+  return line.match(LEADING_TAG_GROUP)?.[1] ?? null;
+}
+function isVerbatimBullet(line) {
+  const tags = leadingTagGroup(line);
+  return tags !== null && /\[verbatim\]/i.test(tags);
+}
+function isContinuation(line) {
+  if (line.trim().length === 0)
+    return false;
+  if (HEADING.test(line))
+    return false;
+  if (LIST_ITEM_START.test(line))
+    return false;
+  return true;
+}
+function stripTagPrefix(block) {
+  return block.replace(LEADING_TAG_GROUP, "");
+}
+function extractVerbatimAcs(specContent) {
+  const lines = specContent.split(`
+`);
+  const blocks = [];
+  for (let i = 0;i < lines.length; i++) {
+    if (!isVerbatimBullet(lines[i]))
+      continue;
+    const parts = [lines[i].trim()];
+    let j = i + 1;
+    while (j < lines.length && isContinuation(lines[j])) {
+      parts.push(lines[j].trim());
+      j += 1;
+    }
+    blocks.push(parts.join(" "));
+    i = j - 1;
+  }
+  return blocks;
+}
+function prdAcPayloads(prd) {
+  return (prd.userStories ?? []).flatMap((story) => (story.acceptanceCriteria ?? []).map(canonical));
+}
+function findMissingVerbatimAcs(specContent, prd) {
+  const prdAcs = prdAcPayloads(prd);
+  const missing = [];
+  for (const block of extractVerbatimAcs(specContent)) {
+    const payload = canonical(stripTagPrefix(block));
+    if (payload.length === 0)
+      continue;
+    if (!prdAcs.some((ac) => ac.includes(payload)))
+      missing.push(block);
+  }
+  return missing;
+}
+var LEADING_TAG_GROUP, LIST_ITEM_START, HEADING;
+var init_verbatim_fidelity = __esm(() => {
+  LEADING_TAG_GROUP = /^\s*(?:[-*]|\d+\.)?\s*((?:\[[a-z][a-z-]*\]\s*)+)/i;
+  LIST_ITEM_START = /^\s*(?:[-*]|\d+\.)\s/;
+  HEADING = /^\s*#/;
+});
+
 // src/prd/validate.ts
 function validateStoryId(id) {
   if (!id || id.length === 0) {
@@ -27727,6 +27966,7 @@ function markStoryPaused(prd, storyId) {
 var PRD_MAX_FILE_SIZE;
 var init_prd = __esm(() => {
   init_json_file();
+  init_verbatim_fidelity();
   init_schema2();
   PRD_MAX_FILE_SIZE = 5 * 1024 * 1024;
 });
@@ -30731,6 +30971,7 @@ Flag issues only when you have confirmed:
 Do NOT flag: style issues, naming conventions, import ordering, file length, or anything lint handles.`, SEMANTIC_OUTPUT_SCHEMA = `Respond with JSON only \u2014 no explanation text before or after:
 {
   "passed": boolean,
+  "inspectedFiles": ["relative/path/you/actually/opened.ts"],
   "findings": [
     {
       "severity": "error" | "warning" | "info" | "unverifiable",
@@ -30754,7 +30995,8 @@ Notes:
 - \`acIndex\` is required when severity is "error" (1-based, into the Acceptance Criteria list above).
 - \`acQuote\` is optional advisory metadata for human auditors \u2014 not validated.
 - Omit both for "warning", "info", "unverifiable".
-If all ACs are correctly implemented, respond with { "passed": true, "findings": [] }.`, ReviewPromptBuilder;
+- \`inspectedFiles\` must list the relative paths you actually opened while reviewing. A \`passed:true\` verdict with an empty or absent \`inspectedFiles\` is invalid \u2014 walk each AC against the real files before passing.
+If all ACs are correctly implemented after inspecting the code, respond with { "passed": true, "inspectedFiles": ["..."], "findings": [] }.`, ReviewPromptBuilder;
 var init_review_builder = __esm(() => {
   SEMANTIC_ROLE = "You are a semantic code reviewer with access to the repository files. " + "Your job is to walk each acceptance criterion (AC) and judge whether the production code fulfills it \u2014 fully, partially, or not at all. " + "Test coverage gaps and convention/lint issues are out of scope \u2014 adversarial review and lint/typecheck handle those.";
   ReviewPromptBuilder = class ReviewPromptBuilder {
@@ -30807,6 +31049,16 @@ Respond with a condensed summary:
 - Keep \`verifiedBy\` for every finding. If \`verifiedBy.observed\` is long, abbreviate it to one line \u2014 never drop the field.
 Output ONLY a complete, valid JSON object. It must start with { and end with }.
 Schema: {"passed": boolean, "findings": [{"severity": string, "category": string, "file": string, "line": number, "issue": string, "suggestion": string, "verifiedBy": {"command": string, "file": string, "line": number, "observed": string}}]}`;
+    }
+    static demandInspection() {
+      return `Your previous review returned \`passed:true\` with no findings and an empty (or absent) \`inspectedFiles\` list. That means you did not open any of the changed files \u2014 a verdict reached without reading the code is not valid.
+
+Use your file-reading tools NOW to open the changed files and walk each acceptance criterion against the real implementation. Then re-issue your verdict as the same JSON object.
+
+Rules:
+- Populate \`inspectedFiles\` with the relative paths you actually opened.
+- If, after genuinely inspecting the code, every AC is satisfied, you may still return \`passed:true\` \u2014 but \`inspectedFiles\` must list the files you read.
+- Return ONLY the JSON object \u2014 no markdown fences, no explanation.`;
     }
     static requoteVerbatim(opts) {
       const file3 = opts.finding.verifiedBy?.file ?? opts.finding.file;
@@ -30981,6 +31233,13 @@ What new exported units lack corresponding test files?
 - New public functions that only appear in implementation, not in tests
 - Acceptance criteria that touch a code path with no test coverage
 
+**Placeholder / tautological tests (blocking).** A test that exists but verifies nothing is worse than a missing test \u2014 it manufactures a false green. Treat the following as a **\`severity:"error"\`, \`category:"test-gap"\`** finding whenever the fake test is the only coverage for an acceptance criterion:
+- Bodies that always pass: \`expect(true).toBe(true)\`, \`expect(x).toBe(x)\`, \`expect(1).toBe(1)\`, an empty test body, or \`assert(true)\`.
+- Tests skipped/disabled (\`it.skip\`, \`test.todo\`, \`xit\`, commented-out assertions) that an AC depends on.
+- Assertions that never exercise the implementation (e.g. asserting on a literal, not on a value the production code produced).
+
+For each such finding: set \`acIndex\` to the AC the fake test purports to cover, \`acQuote\` to a verbatim substring of that AC, and \`verifiedBy.observed\` to the placeholder line itself (e.g. \`expect(true).toBe(true)\`). Do **not** downgrade these to \`warning\` \u2014 a green suite built on placeholder assertions is a failing implementation with hidden evidence.
+
 ### 5. Convention Breaks
 What pattern exists elsewhere that this code does not follow?
 - Logger calls missing \`storyId\` as first key in data object
@@ -31000,6 +31259,7 @@ Respond with ONLY a JSON object \u2014 no preamble, no explanation outside the J
 \`\`\`json
 {
   "passed": true | false,
+  "inspectedFiles": ["relative/path/you/actually/opened.ts"],
   "findings": [
     {
       "severity": "error" | "warning" | "info" | "unverifiable",
@@ -31021,6 +31281,8 @@ Respond with ONLY a JSON object \u2014 no preamble, no explanation outside the J
 }
 \`\`\`
 
+**No rubber-stamping:** \`inspectedFiles\` must list the relative paths you actually opened with your tools while reviewing. A \`passed:true\` verdict with an empty or absent \`inspectedFiles\` is invalid \u2014 it means you never looked at the code. Fetch the diff and open the changed files before forming any verdict.
+
 Severity guide:
 - \`"error"\`: confident this will cause real failure or regression
 - \`"warning"\`: fragile or incomplete but may ship without immediate breakage
@@ -31050,6 +31312,8 @@ Worked example:
 
 **Convention / coding-standard violations almost always belong as \`"info"\`** unless an AC specifically names the convention or the symbol it concerns.
 
+**Exception \u2014 the trap does NOT apply to \`category:"test-gap"\` findings.** A fake/placeholder/missing test is the *absence* of verification for an AC's behaviour; it cannot name a symbol that is present in the (worthless) test file, because the defect is precisely that the symbol-under-test is never exercised. A \`test-gap\` finding is grounded by the AC whose behaviour goes unverified \u2014 cite that AC's \`acIndex\` and a verbatim \`acQuote\` substring from it, and keep severity \`"error"\`. The symbol-naming requirement is waived for this category.
+
 **Scope constraints are not Acceptance Criteria:**
 The story description may contain a "Scope" section with "In:" and "Out:" bullets. These are implementation guidelines, not ACs. A finding about code changed outside the stated scope (e.g., a file listed under "Out:") cannot cite a scope constraint as its \`acQuote\`/\`acIndex\` because scope text is not in the numbered AC list. Emit scope-violation findings as \`"warning"\` \u2014 never \`"error"\`. Never use \`acIndex: 0\`; \`acIndex\` is 1-based (first AC bullet = 1).
 
@@ -31138,6 +31402,16 @@ Rules:
 - observed must be a 1-3 line excerpt that proves the claim, taken from at or near line ${line}.
 - If after reading the file you cannot find anything that proves the claim, set observed to "".
 - Do not return a full review. Do not include markdown fences or explanation.`;
+    }
+    static demandInspection() {
+      return `Your previous review returned \`passed:true\` with no findings and an empty (or absent) \`inspectedFiles\` list. That means you did not open any of the changed files \u2014 a verdict reached without inspecting the code is not valid.
+
+Use your git and file-reading tools NOW to fetch the diff and open the changed files for this story. Then re-issue your verdict as the same JSON object.
+
+Rules:
+- Populate \`inspectedFiles\` with the relative paths you actually opened.
+- If, after genuinely inspecting the code, there is truly nothing to flag, you may still return \`passed:true\` \u2014 but \`inspectedFiles\` must list the files you read.
+- Return ONLY the JSON object \u2014 no markdown fences, no explanation.`;
     }
     static DROP_CODE_MESSAGES_QUOTE = {
       missing_ac_quote: "no `acQuote` field was provided \u2014 every blocking finding must cite an AC",
@@ -31517,7 +31791,7 @@ var init_acceptance_builder = __esm(() => {
 });
 
 // src/review/ac-quote-validator.ts
-function normalizeWs(s) {
+function normalizeWs2(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 function stripMarkdownInline(s) {
@@ -31552,11 +31826,14 @@ function validateAcQuote(finding, acceptanceCriteria) {
   if (typeof acIndex !== "number" || acIndex < 1 || acIndex > acceptanceCriteria.length) {
     return { valid: false, code: "ac_index_out_of_range" };
   }
-  const acText = normalizeWs(stripMarkdownInline(acceptanceCriteria[acIndex - 1]));
-  const normalizedQuote = normalizeWs(stripMarkdownInline(acQuote));
+  const acText = normalizeWs2(stripMarkdownInline(acceptanceCriteria[acIndex - 1]));
+  const normalizedQuote = normalizeWs2(stripMarkdownInline(acQuote));
   if (!acText.toLowerCase().includes(normalizedQuote.toLowerCase())) {
     return { valid: false, code: "ac_quote_not_substring" };
   }
+  if (finding.category === "test-gap") {
+    return { valid: true };
+  }
   const keywords = extractLocusKeywords(finding);
   if (keywords.length === 0) {
     return { valid: false, code: "ac_quote_does_not_constrain_locus" };
@@ -31875,6 +32152,10 @@ var init_semantic_evidence = __esm(() => {
 });
 
 // src/review/finding-filters.ts
+function hasInspectionTrail(raw) {
+  const files = raw?.inspectedFiles;
+  return Array.isArray(files) && files.some((f) => typeof f === "string" && f.trim().length > 0);
+}
 async function substantiateAdversarialFindings(opts) {
   const { findings, workdir, storyId, blockingThreshold } = opts;
   return Promise.all(findings.map(async (finding) => {
@@ -31906,9 +32187,9 @@ function parseRequoteResponse(output) {
   const parsed = tryParseLLMJson(output);
   if (!isRecord(parsed))
     return null;
-  const canonical = extractCanonical(parsed);
-  if (canonical)
-    return canonical;
+  const canonical2 = extractCanonical(parsed);
+  if (canonical2)
+    return canonical2;
   const findings = parsed.findings;
   if (!Array.isArray(findings) || findings.length !== 1)
     return null;
@@ -32102,6 +32383,23 @@ async function performAdversarialReground(turn, firstParsed, drops, ctx) {
     output: withRepromptMarker(turn.output, { dropCount, outcome: "still-dropped", costUsd })
   };
 }
+async function maybeRepromptForInspection(turn, parsed, rawObject, ctx) {
+  if (ctx.input.adversarialConfig.demandInspectionTrail === false)
+    return null;
+  if (!parsed.passed || parsed.findings.length !== 0)
+    return null;
+  if (hasInspectionTrail(rawObject))
+    return null;
+  const secondTurn = await ctx.send(AdversarialReviewPromptBuilder.demandInspection());
+  const costUsd = (turn.estimatedCostUsd ?? 0) + (secondTurn.estimatedCostUsd ?? 0);
+  const secondParsed = validateAdversarialShape(tryParseLLMJson(secondTurn.output));
+  getSafeLogger()?.warn("review", "Adversarial reviewer returned empty pass with no inspection trail \u2014 re-prompted", {
+    storyId: ctx.input.story.id,
+    event: "review.adversarial.inspection_trail.reprompted",
+    recovered: secondParsed !== null
+  });
+  return secondParsed ? { ...turn, output: secondTurn.output, estimatedCostUsd: costUsd } : { ...turn, estimatedCostUsd: costUsd };
+}
 var FAIL_OPEN, ADVERSARIAL_REQUOTE_RECOVERED_EVENT = "review.adversarial.finding.requote_recovered", ADVERSARIAL_REQUOTE_FAILED_EVENT = "review.adversarial.finding.requote_failed", DEFAULT_MAX_REQUOTES = 5, adversarialParseRetry = (input) => makeParseRetryStrategy({
   validate: (parsed) => validateAdversarialShape(parsed) !== null,
   reviewerKind: "adversarial",
@@ -32139,11 +32437,15 @@ var init_adversarial_review = __esm(() => {
     retry: (input) => adversarialParseRetry(input),
     async hopBody(initialPrompt, ctx) {
       const turn = await ctx.sendWithParseRetry(initialPrompt);
-      const parsed = validateAdversarialShape(tryParseLLMJson(turn.output));
+      const rawObject = tryParseLLMJson(turn.output);
+      const parsed = validateAdversarialShape(rawObject);
       if (!parsed)
         return turn;
       if (ctx.input.mode !== "ref")
         return turn;
+      const inspectionGuard = await maybeRepromptForInspection(turn, parsed, rawObject, ctx);
+      if (inspectionGuard)
+        return inspectionGuard;
       const regroundEnabled = ctx.input.adversarialConfig.acRegroundOnDrop !== false;
       if (regroundEnabled) {
         const firstShape = { passed: parsed.passed, findings: parsed.findings };
@@ -33277,20 +33579,23 @@ function createDrainDeadline(deadlineMs) {
   };
 }
 async function runQualityCommand(opts) {
-  const { commandName, command, workdir, storyId, timeoutMs = DEFAULT_TIMEOUT_MS, env: env2 } = opts;
+  const { commandName, command, workdir, storyId, timeoutMs = DEFAULT_TIMEOUT_MS, env: env2, stripEnvVars } = opts;
   const startTime = Date.now();
   const logger = getSafeLogger();
   logger?.info("quality", `Running ${commandName}`, { storyId, commandName, command, workdir });
   try {
+    const baseEnv = {
+      ...process.env
+    };
+    for (const key of stripEnvVars ?? []) {
+      delete baseEnv[key];
+    }
     const proc = _qualityRunnerDeps.spawn({
       cmd: ["/bin/sh", "-c", command],
       cwd: workdir,
       stdout: "pipe",
       stderr: "pipe",
-      env: {
-        ...process.env,
-        ...env2 ?? {}
-      }
+      env: { ...baseEnv, ...env2 ?? {} }
     });
     let timedOut = false;
     let exitedBeforeSigkill = false;
@@ -33776,6 +34081,18 @@ var init_adapters = __esm(() => {
   init_typecheck();
 });
 
+// src/operations/verbatim-warn.ts
+function warnOnDroppedVerbatimAcs(prd, specContent, featureName) {
+  const missing = findMissingVerbatimAcs(specContent, prd);
+  if (missing.length > 0) {
+    getSafeLogger()?.warn("plan", "[verbatim] spec acceptance criteria dropped from PRD \u2014 run spec-review --prd before executing", { featureName, missingCount: missing.length, missing });
+  }
+}
+var init_verbatim_warn = __esm(() => {
+  init_logger2();
+  init_prd();
+});
+
 // src/operations/plan.ts
 var planInteractiveOp;
 var init_plan = __esm(() => {
@@ -33783,6 +34100,7 @@ var init_plan = __esm(() => {
   init_config();
   init_schema2();
   init_prompts();
+  init_verbatim_warn();
   planInteractiveOp = {
     kind: "run",
     name: "plan-interactive",
@@ -33822,9 +34140,10 @@ ${outputFormat}`, overridable: false }
     parse(output, input, _ctx) {
       return validatePlanOutput(output, input.featureName, input.branchName);
     },
-    verify: async (parsed, _input, _ctx) => {
+    verify: async (parsed, input, _ctx) => {
       if (!parsed.userStories || parsed.userStories.length === 0)
         return null;
+      warnOnDroppedVerbatimAcs(parsed, input.specContent, input.featureName);
       return parsed;
     },
     recover: async (input, ctx) => {
@@ -33875,13 +34194,39 @@ function validateRefinedPrd(prd) {
     validateRefinedStory(story);
   return prd;
 }
-var NEGATIVE_PATH_TOKENS, planRefineOp;
+async function readMissingVerbatimAcs(input) {
+  const content = await _planRefineDeps.readFile(input.outputPath);
+  if (!content)
+    return [];
+  try {
+    const prd = validatePlanOutput(content, input.featureName, input.branchName);
+    return findMissingVerbatimAcs(input.specContent, prd);
+  } catch {
+    getSafeLogger()?.debug("plan", "Skipped [verbatim] self-heal \u2014 draft PRD not yet parseable", {
+      featureName: input.featureName
+    });
+    return [];
+  }
+}
+var _planRefineDeps, NEGATIVE_PATH_TOKENS, planRefineOp;
 var init_plan_refine = __esm(() => {
   init_retry();
   init_config();
   init_errors();
+  init_logger2();
+  init_prd();
   init_schema2();
   init_prompts();
+  init_verbatim_warn();
+  _planRefineDeps = {
+    readFile: async (path3) => {
+      try {
+        return await Bun.file(path3).text();
+      } catch {
+        return null;
+      }
+    }
+  };
   NEGATIVE_PATH_TOKENS = [
     "error",
     "fail",
@@ -33945,19 +34290,30 @@ ${outputFormat}`,
       };
     },
     async hopBody(initialPrompt, ctx) {
+      const builder = new PlanPromptBuilder;
       const turn1 = await ctx.sendWithParseRetry(initialPrompt);
-      const refinePrompt = new PlanPromptBuilder().buildRefineContinuation(ctx.input.outputPath);
-      const turn2 = await ctx.send(refinePrompt);
-      return {
-        ...turn2,
-        estimatedCostUsd: (turn1.estimatedCostUsd ?? 0) + (turn2.estimatedCostUsd ?? 0)
-      };
+      const turn2 = await ctx.send(builder.buildRefineContinuation(ctx.input.outputPath));
+      let totalCost = (turn1.estimatedCostUsd ?? 0) + (turn2.estimatedCostUsd ?? 0);
+      let last = turn2;
+      const missing = await readMissingVerbatimAcs(ctx.input);
+      if (missing.length > 0) {
+        getSafeLogger()?.info("plan", "Refine dropped [verbatim] spec ACs \u2014 issuing one repair turn", {
+          featureName: ctx.input.featureName,
+          missingCount: missing.length
+        });
+        const turn3 = await ctx.send(builder.buildVerbatimRepair(missing, ctx.input.outputPath));
+        totalCost += turn3.estimatedCostUsd ?? 0;
+        last = turn3;
+      }
+      return { ...last, estimatedCostUsd: totalCost };
     },
     parse(output, input) {
       return validatePlanOutput(output, input.featureName, input.branchName);
     },
-    verify: async (parsed, _input, _ctx) => {
-      return validateRefinedPrd(parsed);
+    verify: async (parsed, input, _ctx) => {
+      const validated = validateRefinedPrd(parsed);
+      warnOnDroppedVerbatimAcs(validated, input.specContent, input.featureName);
+      return validated;
     },
     recover: async (input, ctx) => {
       const content = await ctx.readFile(input.outputPath);
@@ -35091,6 +35447,17 @@ function parseRefinementResponse(response, criteria) {
     return fallbackCriteria(criteria);
   }
 }
+function refinementWouldFallback(response) {
+  if (!response || !response.trim())
+    return true;
+  try {
+    const fromFence = extractJsonFromMarkdown(response);
+    const cleaned = stripTrailingCommas(fromFence !== response ? fromFence : response);
+    return !Array.isArray(JSON.parse(cleaned));
+  } catch {
+    return true;
+  }
+}
 function fallbackCriteria(criteria, storyId = "") {
   return criteria.map((c) => ({
     original: c,
@@ -35106,6 +35473,7 @@ var acceptanceRefineOp;
 var init_acceptance_refine = __esm(() => {
   init_refinement();
   init_config();
+  init_logger2();
   init_prompts();
   acceptanceRefineOp = {
     kind: "complete",
@@ -35128,6 +35496,9 @@ var init_acceptance_refine = __esm(() => {
       };
     },
     parse(output, input, _ctx) {
+      if (refinementWouldFallback(output)) {
+        getSafeLogger()?.warn("acceptance", "AC refinement returned no usable JSON \u2014 falling back to unrefined criteria", { storyId: input.storyId, criteriaCount: input.criteria.length, responseBytes: output?.length ?? 0 });
+      }
       const items = parseRefinementResponse(output, input.criteria);
       return items.map((item) => ({ ...item, storyId: item.storyId || input.storyId }));
     }
@@ -35279,6 +35650,25 @@ function evaluateRepromptTrigger2(shape, input) {
     return { shouldReprompt: false };
   return { shouldReprompt: true, acDropped: dropped };
 }
+async function maybeRepromptForInspection2(turn, parsed, rawObject, ctx) {
+  if (ctx.input.mode !== "ref")
+    return null;
+  if (ctx.input.semanticConfig.demandInspectionTrail === false)
+    return null;
+  if (!parsed.passed || parsed.findings.length !== 0)
+    return null;
+  if (hasInspectionTrail(rawObject))
+    return null;
+  const secondTurn = await ctx.send(ReviewPromptBuilder.demandInspection());
+  const costUsd = (turn.estimatedCostUsd ?? 0) + (secondTurn.estimatedCostUsd ?? 0);
+  const secondParsed = validateLLMShape(tryParseLLMJson(secondTurn.output));
+  getSafeLogger()?.warn("review", "Semantic reviewer returned empty pass with no inspection trail \u2014 re-prompted", {
+    storyId: ctx.input.story.id,
+    event: "review.semantic.inspection_trail.reprompted",
+    recovered: secondParsed !== null
+  });
+  return secondParsed ? { ...turn, output: secondTurn.output, estimatedCostUsd: costUsd } : { ...turn, estimatedCostUsd: costUsd };
+}
 async function performSemanticReground(turn, firstParsed, drops, ctx) {
   const threshold = ctx.input.blockingThreshold ?? "error";
   const acceptanceCriteria = ctx.input.story.acceptanceCriteria;
@@ -35399,9 +35789,13 @@ async function requoteBlockingFindings(findings, ctx) {
 }
 var FAIL_OPEN2, SEMANTIC_REQUOTE_RECOVERED_EVENT = "review.semantic.finding.requote_recovered", SEMANTIC_REQUOTE_FAILED_EVENT = "review.semantic.finding.requote_failed", DEFAULT_MAX_REQUOTES2 = 5, semanticReviewHopBody = async (initialPrompt, ctx) => {
   const turn = await ctx.sendWithParseRetry(initialPrompt);
-  const parsed = validateLLMShape(tryParseLLMJson(turn.output));
+  const rawObject = tryParseLLMJson(turn.output);
+  const parsed = validateLLMShape(rawObject);
   if (!parsed)
     return turn;
+  const inspectionGuard = await maybeRepromptForInspection2(turn, parsed, rawObject, ctx);
+  if (inspectionGuard)
+    return inspectionGuard;
   const requoted = await requoteBlockingFindings(parsed.findings, ctx);
   if (requoted.changed) {
     const passed = !requoted.findings.some((finding) => isBlockingSeverity(finding.severity, ctx.input.blockingThreshold ?? "error"));
@@ -36870,7 +37264,7 @@ function buildVerifierFindings(verdict, categorization) {
       return [];
   }
 }
-function parseVerdictFromStdout(output, _input, _ctx) {
+function parseVerdictFromStdout(output, input, _ctx) {
   if (!output || !output.trim()) {
     throw new ParseValidationError("verifier produced no stdout");
   }
@@ -36883,6 +37277,18 @@ function parseVerdictFromStdout(output, _input, _ctx) {
     throw new ParseValidationError("verifier stdout JSON missing required VerifierVerdict fields");
   }
   const categorization = categorizeVerdict(verdict, verdict.tests.allPassing === true);
+  getSafeLogger()?.info("verifier", "Verdict categorized", {
+    storyId: input.story.id,
+    approved: verdict.approved,
+    success: categorization.success,
+    advisoryOverride: verdict.approved === false && categorization.success,
+    testsPassing: verdict.tests.allPassing,
+    passCount: verdict.tests.passCount,
+    failCount: verdict.tests.failCount,
+    testModsDetected: verdict.testModifications.detected,
+    testModsLegitimate: verdict.testModifications.legitimate,
+    ...categorization.failureCategory && { failureCategory: categorization.failureCategory }
+  });
   return {
     success: categorization.success,
     filesChanged: [],
@@ -38235,7 +38641,8 @@ var init_mechanical_lintfix_strategy = __esm(() => {
         commandName: "lintFix",
         command,
         workdir: input.workdir,
-        storyId: input.storyId
+        storyId: input.storyId,
+        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
       });
       return { applied: true, exitCode: result.exitCode };
     }
@@ -38293,7 +38700,8 @@ var init_mechanical_formatfix_strategy = __esm(() => {
         commandName: "formatFix",
         command,
         workdir: input.workdir,
-        storyId: input.storyId
+        storyId: input.storyId,
+        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
       });
       return { applied: true, exitCode: result.exitCode };
     }
@@ -38326,7 +38734,8 @@ var init_lint_check = __esm(() => {
         commandName: "lint",
         command: command ?? "",
         workdir: input.workdir,
-        storyId: input.storyId
+        storyId: input.storyId,
+        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
       });
       if (result.exitCode === 0) {
         return { success: true, findings: [], durationMs: Date.now() - start };
@@ -38575,7 +38984,8 @@ var init_typecheck_check = __esm(() => {
         commandName: "typecheck",
         command: command ?? "",
         workdir: input.workdir,
-        storyId: input.storyId
+        storyId: input.storyId,
+        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
       });
       if (result.exitCode === 0) {
         return { success: true, findings: [], durationMs: Date.now() - start };
@@ -38740,6 +39150,7 @@ var init_operations = __esm(() => {
   init_call();
   init_plan();
   init_plan_refine();
+  init_verbatim_warn();
   init_decompose2();
   init_build_hop_callback();
   init_classify_route();
@@ -39550,13 +39961,14 @@ async function resolveLintScope(args) {
 function resolveScopedTemplate(reviewCommands, qualityCommands) {
   return reviewCommands.lintScoped ?? qualityCommands?.lintScoped;
 }
-async function runLintCommand(workdir, storyId, env2, command) {
+async function runLintCommand(workdir, storyId, env2, command, stripEnvVars) {
   return runQualityCommand({
     commandName: SCOPED_LINT_CHECK,
     command,
     workdir,
     storyId,
-    env: env2
+    env: env2,
+    stripEnvVars
   });
 }
 function toReviewCheck(result) {
@@ -39597,7 +40009,7 @@ async function runScopedLintCheck(args) {
         storyId: args.storyId,
         reason: scope.degradedReason
       });
-      const fullResult2 = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, fullLintCommand);
+      const fullResult2 = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, fullLintCommand, args.stripEnvVars);
       return withLintScope(attachLintFindings(toReviewCheck(fullResult2), args.lintOutputFormat, args.workdir), scope, "degraded");
     }
     logger?.info("review", "lint_scope_empty", { storyId: args.storyId });
@@ -39622,19 +40034,19 @@ async function runScopedLintCheck(args) {
   }
   if (scopedTemplate) {
     const scopedCommand = scopedTemplate.replaceAll("{{files}}", scope.files.map(shellQuotePath4).join(" "));
-    const scopedResult = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, scopedCommand);
+    const scopedResult = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, scopedCommand, args.stripEnvVars);
     return withLintScope(attachLintFindings(toReviewCheck(scopedResult), args.lintOutputFormat, args.workdir), scope);
   }
   if (!scope.degradedReason && isSupportedDerivedScopedCommand(fullLintCommand)) {
     const scopedCommand = appendFilesToCommand(fullLintCommand, scope.files);
-    const scopedResult = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, scopedCommand);
+    const scopedResult = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, scopedCommand, args.stripEnvVars);
     return withLintScope(attachLintFindings(toReviewCheck(scopedResult), args.lintOutputFormat, args.workdir), scope);
   }
   logger?.warn("review", "lint_scope_degraded", {
     storyId: args.storyId,
     reason: scope.degradedReason ?? "unsupported_scoped_command_shape"
   });
-  const fullResult = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, fullLintCommand);
+  const fullResult = await _scopedLintDeps.runLintCommand(args.workdir, args.storyId, args.env, fullLintCommand, args.stripEnvVars);
   if (fullResult.exitCode === 0)
     return withLintScope(toReviewCheck(fullResult), scope, "degraded");
   const parsed = parseLintOutput(fullResult.output, args.lintOutputFormat ?? "auto", {
@@ -40360,8 +40772,8 @@ async function resolveCommand(check2, config2, executionConfig, workdir, quality
   }
   return null;
 }
-async function runCheck(check2, command, workdir, storyId, env2) {
-  const result = await runQualityCommand({ commandName: check2, command, workdir, storyId, env: env2 });
+async function runCheck(check2, command, workdir, storyId, env2, stripEnvVars) {
+  const result = await runQualityCommand({ commandName: check2, command, workdir, storyId, env: env2, stripEnvVars });
   return {
     check: check2,
     command: result.command,
@@ -40567,8 +40979,9 @@ async function runReview(opts) {
       story,
       storyGitRef,
       env: env2,
+      stripEnvVars: naxConfig?.quality?.stripEnvVars ?? [],
       naxIgnoreIndex
-    }) : normalizeMechanicalFindings(checkName, await runCheck(checkName, command, workdir, storyId, env2), workdir);
+    }) : normalizeMechanicalFindings(checkName, await runCheck(checkName, command, workdir, storyId, env2, naxConfig?.quality?.stripEnvVars ?? []), workdir);
     checks3.push(result);
     if (result.success) {
       logger?.info("review", `${checkName} passed`, {
@@ -41611,6 +42024,9 @@ Output ONLY the JSON object. Do not include markdown fences or explanation.`;
 
 Review the draft with a strict self-audit mindset. Re-read the codebase context and compare the PRD against it. Focus only on the issues below, then rewrite the PRD if needed.
 
+#### spec-ac-preservation
+Enumerate every acceptance criterion the spec states. Confirm each one appears in some story's acceptanceCriteria \u2014 never drop a spec AC during this audit. If an AC looks unsupported by the current codebase, keep it: the story may be adding that capability. Any AC the spec tags \`[verbatim]\` MUST appear character-for-character in an acceptanceCriteria entry \u2014 preserve every backtick-quoted command, file path, regex, and count exactly. If a \`[verbatim]\` AC is missing or altered, restore it verbatim.
+
 #### ac-testable
 For each acceptance criterion, ask whether the assertion is observable through a return value, exception, log output, file content, or state change. If any AC is not directly testable, rewrite it so it is observable.
 
@@ -41623,7 +42039,7 @@ Check whether any sentence in any description contradicts an acceptance criterio
 #### codebase-fit
 For each story, verify:
 1. Proposed files, helpers, tests, dependencies, and implementation notes match the codebase context. Remove invented helpers, files, call sites, or dependencies unless the change clearly requires creating them.
-2. Each acceptance criterion's semantic meaning matches the spec's actual interface and data flow. Criteria that assert incorrect parameter semantics, wrong data flow, or behavior that contradicts the spec must be corrected or removed. Cross-check each AC against the spec's interface definitions, pseudocode, and design notes.
+2. Each acceptance criterion's semantic meaning matches the spec's actual interface and data flow. Criteria that assert incorrect parameter semantics, wrong data flow, or behavior that contradicts the spec must be corrected. Never delete an AC that restates a spec AC \u2014 correct its wording to match the spec instead. Cross-check each AC against the spec's interface definitions, pseudocode, and design notes.
 
 #### contextfiles-spec-alignment
 For each story, compare contextFiles against files the spec explicitly lists as context (e.g., in "Context Files" sections). Ensure the most critical spec-recommended files are included, up to the 5-file limit. If a spec-recommended file is absent, add it (removing the least critical one if already at 5). Files the story will CREATE must not appear here.
@@ -41641,6 +42057,23 @@ If a story changes existing behavior, extracts a shared helper, extends an exist
 Check each story's title, description, scope, contextFiles, and acceptance criteria for internal consistency. If the story says a file or command is in scope anywhere else, do not list it as out of scope. If the title or acceptance criteria clearly include CLI, output, tests, or helper extraction work, the Scope section must reflect that accurately.
 
 Write the revised PRD to this file path: ${outputFilePath}
+Do not output the PRD in chat. After writing the file, reply with a brief text confirmation only.`;
+  }
+  buildVerbatimRepair(missingAcs, outputFilePath) {
+    const list = missingAcs.map((ac) => `- ${ac}`).join(`
+`);
+    return `Your revised PRD dropped or altered acceptance criteria the spec marked \`[verbatim]\`. These are load-bearing executable checks (greps, file-existence checks, regex/count assertions, or architectural invariants) and MUST survive character-for-character \u2014 paraphrasing destroys the verification mechanism.
+
+The following \`[verbatim]\` spec acceptance criteria are missing or altered in the PRD:
+
+${list}
+
+For each one:
+- Add it to the \`acceptanceCriteria\` array of the single most relevant user story.
+- Preserve every backtick-quoted command, file path, regex, and count exactly as written in the spec. Do not paraphrase, retag, split, or move them into a description.
+- Do not remove or weaken any acceptance criteria that are already correct.
+
+Write the corrected PRD to this file path: ${outputFilePath}
 Do not output the PRD in chat. After writing the file, reply with a brief text confirmation only.`;
   }
   build(specContent, codebaseContext, outputFilePath, packages, packageDetails, projectProfile, proposers) {
@@ -43916,13 +44349,13 @@ var init_factory = __esm(() => {
 
 // src/execution/pid-registry.ts
 import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile2 } from "fs/promises";
 
 class PidRegistry {
   workdir;
   pidsFilePath;
   pids = new Set;
   frozen = false;
+  writeQueueTail = Promise.resolve();
   constructor(workdir, _platform) {
     this.workdir = workdir;
     this.pidsFilePath = `${workdir}/${PID_REGISTRY_FILE}`;
@@ -43943,15 +44376,8 @@ class PidRegistry {
       return;
     }
     this.pids.add(pid);
-    const entry = {
-      pid,
-      spawnedAt: new Date().toISOString(),
-      workdir: this.workdir
-    };
     try {
-      const line = `${JSON.stringify(entry)}
-`;
-      await appendFile2(this.pidsFilePath, line);
+      await this.enqueueWrite();
       logger?.debug("pid-registry", `Registered PID ${pid}`, { pid });
     } catch (err) {
       logger?.warn("pid-registry", `Failed to write PID ${pid} to registry`, {
@@ -43963,7 +44389,7 @@ class PidRegistry {
     const logger = getSafeLogger();
     this.pids.delete(pid);
     try {
-      await this.writePidsFile();
+      await this.enqueueWrite();
       logger?.debug("pid-registry", `Unregistered PID ${pid}`, { pid });
     } catch (err) {
       logger?.warn("pid-registry", `Failed to unregister PID ${pid}`, {
@@ -43982,8 +44408,8 @@ class PidRegistry {
     const killPromises = pids.map((pid) => this.killPidTree(pid));
     await Promise.allSettled(killPromises);
     try {
-      await Bun.write(this.pidsFilePath, "");
       this.pids.clear();
+      await this.enqueueWrite();
       logger?.info("pid-registry", "All registered PIDs killed and registry cleared");
     } catch (err) {
       logger?.warn("pid-registry", "Failed to clear registry file", {
@@ -44202,6 +44628,37 @@ class PidRegistry {
   getPids() {
     return Array.from(this.pids);
   }
+  snapshot() {
+    return Array.from(this.pids);
+  }
+  async flush() {
+    await this.writeQueueTail;
+  }
+  async readPidsFromDisk() {
+    try {
+      if (!existsSync7(this.pidsFilePath))
+        return [];
+      const content = await Bun.file(this.pidsFilePath).text();
+      return content.split(`
+`).filter((line) => line.trim()).map((line) => {
+        try {
+          return JSON.parse(line).pid;
+        } catch {
+          return null;
+        }
+      }).filter((pid) => pid !== null);
+    } catch {
+      return [];
+    }
+  }
+  enqueueWrite() {
+    this.writeQueueTail = this.writeQueueTail.then(() => this.writePidsFile().catch((err) => {
+      getSafeLogger()?.warn("pid-registry", "Failed to flush PID file \u2014 on-disk registry may be stale", {
+        error: errorMessage(err)
+      });
+    }));
+    return this.writeQueueTail;
+  }
 }
 var PID_REGISTRY_FILE = ".nax-pids", PID_TREE_KILL_GRACE_MS = 250, _pidRegistryDeps;
 var init_pid_registry = __esm(() => {
@@ -52048,7 +52505,7 @@ var init_effectiveness = __esm(() => {
 });
 
 // src/execution/progress.ts
-import { appendFile as appendFile3, mkdir as mkdir7 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir7 } from "fs/promises";
 import { join as join44 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   await mkdir7(featureDir, { recursive: true });
@@ -52056,7 +52513,7 @@ async function appendProgress(featureDir, storyId, status, message) {
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
-  await appendFile3(progressPath, entry);
+  await appendFile2(progressPath, entry);
 }
 var init_progress = () => {};
 
@@ -52163,6 +52620,7 @@ var init_completion = __esm(() => {
       const logger = getLogger();
       const isBatch = ctx.stories.length > 1;
       const sessionCost = ctx.agentResult?.estimatedCostUsd || 0;
+      const persistPrd = ctx.skipPrdPersistence !== true;
       const prdPath = ctx.prdPath ?? (ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`);
       const storyStartTime = ctx.storyStartTime || new Date().toISOString();
       if (isBatch) {
@@ -52187,7 +52645,9 @@ var init_completion = __esm(() => {
         }
       }
       for (const completedStory of ctx.stories) {
-        markStoryPassed(ctx.prd, completedStory.id);
+        if (persistPrd) {
+          markStoryPassed(ctx.prd, completedStory.id);
+        }
         const costPerStory = sessionCost / ctx.stories.length;
         logger.info("completion", "Story passed", {
           storyId: completedStory.id,
@@ -52219,7 +52679,9 @@ var init_completion = __esm(() => {
           }
         }
       }
-      await _completionDeps.savePRD(ctx.prd, prdPath);
+      if (persistPrd) {
+        await _completionDeps.savePRD(ctx.prd, prdPath);
+      }
       const updatedCounts = countStories(ctx.prd);
       logger.info("completion", "Progress update", {
         storyId: ctx.story.id,
@@ -53022,7 +53484,7 @@ function buildPhaseOutcomeLogData(storyId, opName, output, durationMs) {
     data.reviewReason = r.reviewReason;
   return { success: success2, data };
 }
-function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase, stage) {
+function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase, stage, progressData = {}) {
   if (isTddPhase)
     return;
   if (opName === "semantic-review" || opName === "adversarial-review")
@@ -53030,7 +53492,8 @@ function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTdd
   const built = buildPhaseOutcomeLogData(storyId, opName, output, durationMs);
   if (!built)
     return;
-  const { success: success2, data } = built;
+  const { success: success2 } = built;
+  const data = { ...built.data, ...progressData };
   const logger = getSafeLogger();
   const message = formatPhaseResultMessage(opName, success2, stage);
   if (stage === "rectification") {
@@ -53093,17 +53556,21 @@ function logUnifiedReviewPhaseResult(storyId, opName, output) {
     truncated: findingsCount > findingsSummary.length
   });
 }
-async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = false) {
+async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = false, progress) {
   const logger = getSafeLogger();
   const opName = slot.op.name;
+  const progressData = progress ? { phaseIndex: progress.index, totalPhases: progress.total } : {};
   const isTddPhase = isThreeSession && TDD_OP_NAMES.has(opName);
   const beforeRef = isTddPhase ? await _storyOrchestratorDeps.captureGitRef(ctx.packageDir) : undefined;
   let dispatchInput = isTddPhase && beforeRef ? { ...slot.input, beforeRef } : slot.input;
   dispatchInput = await refreshReviewInputForDispatch(opName, dispatchInput);
   if (isTddPhase) {
-    logger?.info("tdd", `-> Session: ${opName}`, { storyId: ctx.storyId, role: opName });
+    logger?.info("tdd", `-> Session: ${opName}`, { storyId: ctx.storyId, role: opName, ...progressData });
   } else if (isThreeSession && opName === "full-suite-gate") {
-    logger?.info("tdd", "-> Running full test suite gate (before Verifier)", { storyId: ctx.storyId });
+    logger?.info("tdd", "-> Running full test suite gate (before Verifier)", {
+      storyId: ctx.storyId,
+      ...progressData
+    });
   }
   logUnifiedReviewPhaseStart(ctx.storyId, opName);
   const phaseStartedAt = Date.now();
@@ -53113,7 +53580,7 @@ async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = fa
     phaseOutputs[opName] = output;
     emitReviewDecision(ctx, opName, output);
     logUnifiedReviewPhaseResult(ctx.storyId, opName, output);
-    logDeterministicPhaseOutcome(ctx.storyId, opName, output, Date.now() - phaseStartedAt, isTddPhase, slot.op.stage);
+    logDeterministicPhaseOutcome(ctx.storyId, opName, output, Date.now() - phaseStartedAt, isTddPhase, slot.op.stage, progressData);
     if (isTddPhase) {
       const durationMs = Date.now() - phaseStartedAt;
       logger?.info("tdd", `Session complete: ${opName}`, {
@@ -53282,9 +53749,13 @@ class ExecutionPlan {
     const phaseOutputs = {};
     const startedAt = Date.now();
     const logger = getSafeLogger();
-    for (const phase of collectOrderedPhases(this.state)) {
+    const orderedPhases = collectOrderedPhases(this.state);
+    for (const [phaseIndex, phase] of orderedPhases.entries()) {
       try {
-        await runPhase(this.ctx, phase.slot, phaseCosts, phaseOutputs, this.isThreeSession);
+        await runPhase(this.ctx, phase.slot, phaseCosts, phaseOutputs, this.isThreeSession, {
+          index: phaseIndex + 1,
+          total: orderedPhases.length
+        });
       } catch (error48) {
         logger?.error("story-orchestrator", "Phase threw unexpected error", {
           storyId: this.ctx.storyId,
@@ -56949,7 +57420,7 @@ function renderProposals(proposals, runId, observationCount) {
 }
 
 // src/plugins/builtin/curator/rollup.ts
-import { appendFile as appendFile4, mkdir as mkdir10, writeFile } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir10, writeFile } from "fs/promises";
 import * as path14 from "path";
 async function appendToRollup(observations, rollupPath) {
   try {
@@ -56965,7 +57436,7 @@ async function appendToRollup(observations, rollupPath) {
     const newLines = `${observations.map((o) => JSON.stringify(o)).join(`
 `)}
 `;
-    await appendFile4(rollupPath, newLines);
+    await appendFile3(rollupPath, newLines);
   } catch {}
 }
 var init_rollup = () => {};
@@ -57883,7 +58354,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.68.1",
+    version: "0.68.3",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -57978,8 +58449,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("5d69e4e4"))
-        return "5d69e4e4";
+      if (/^[0-9a-f]{6,10}$/.test("a1007103"))
+        return "a1007103";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -59395,6 +59866,9 @@ async function handleRunCompletion(options) {
   if (options.pluginProviderCache) {
     await options.pluginProviderCache.disposeAll();
   }
+  clearLanguageCache();
+  clearWorkspaceCache();
+  clearGitRootCache();
   const finalCounts = countStories(prd);
   const fallbackAggregate = deriveRunFallbackAggregates(allStoryMetrics);
   pipelineEventBus.emit({
@@ -59500,7 +59974,10 @@ var init_run_completion = __esm(() => {
   init_metrics();
   init_event_bus();
   init_prd();
+  init_detector();
   init_scratch_purge();
+  init_workspace();
+  init_smart_runner();
   init_run_regression();
   _runCompletionDeps = {
     runDeferredRegression,
@@ -59598,7 +60075,7 @@ function precomputeBatchPlan(stories, maxBatchSize = DEFAULT_MAX_BATCH_SIZE) {
 var DEFAULT_MAX_BATCH_SIZE = 4;
 
 // src/pipeline/subscribers/events-writer.ts
-import { appendFile as appendFile5, mkdir as mkdir14 } from "fs/promises";
+import { appendFile as appendFile4, mkdir as mkdir14 } from "fs/promises";
 import { basename as basename14, join as join73 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
@@ -59613,7 +60090,7 @@ function wireEventsWriter(bus, feature, runId, workdir) {
           await mkdir14(eventsDir, { recursive: true });
           dirReady = true;
         }
-        await appendFile5(eventsFile, `${JSON.stringify(line)}
+        await appendFile4(eventsFile, `${JSON.stringify(line)}
 `);
       } catch (err) {
         logger?.warn("events-writer", "Failed to write event line (non-fatal)", {
@@ -60623,7 +61100,7 @@ function extractQuoteTriples(reason) {
   }
   return triples;
 }
-function normalizeWs2(s) {
+function normalizeWs3(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function verifyQuoteTriple(triple, workdir, deps = _quoteIntegrityDeps) {
@@ -60637,7 +61114,7 @@ async function verifyQuoteTriple(triple, workdir, deps = _quoteIntegrityDeps) {
   const end = Math.min(lines.length, triple.line + CONTEXT_LINES);
   const window2 = lines.slice(start, end).join(`
 `);
-  return normalizeWs2(window2).toLowerCase().includes(normalizeWs2(triple.quote).toLowerCase());
+  return normalizeWs3(window2).toLowerCase().includes(normalizeWs3(triple.quote).toLowerCase());
 }
 async function verifyEscalationQuotes(reason, workdir, storyId, deps = _quoteIntegrityDeps) {
   const triples = extractQuoteTriples(reason);
@@ -61510,9 +61987,13 @@ var exports_parallel_worker = {};
 __export(exports_parallel_worker, {
   executeStoryInWorktree: () => executeStoryInWorktree,
   executeParallelBatch: () => executeParallelBatch,
+  buildWorktreePipelineContext: () => buildWorktreePipelineContext,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
 import { join as join79 } from "path";
+function buildWorktreePipelineContext(base, _story) {
+  return { ...base, prd: structuredClone(base.prd) };
+}
 async function executeStoryInWorktree(story, worktreePath, dependencyContext, context, routing, eventEmitter) {
   const logger = getSafeLogger();
   try {
@@ -61526,7 +62007,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       }
     }
     const pipelineContext = {
-      ...context,
+      ...buildWorktreePipelineContext(context, story),
       config: context.config,
       rootConfig: context.rootConfig,
       story,
@@ -61826,6 +62307,7 @@ var init_parallel_batch = __esm(() => {
 // src/execution/unified-executor.ts
 var exports_unified_executor = {};
 __export(exports_unified_executor, {
+  reconcileBatchOutcome: () => reconcileBatchOutcome,
   executeUnified: () => executeUnified,
   _unifiedExecutorDeps: () => _unifiedExecutorDeps
 });
@@ -61949,7 +62431,10 @@ async function executeUnified(ctx, initialPrd) {
         const readyStories = getAllReadyStories(prd);
         const batch = _unifiedExecutorDeps.selectIndependentBatch(readyStories, ctx.parallelCount);
         if (batch.length > 1) {
-          for (const story of batch) {
+          const batchAgent = ctx.agentManager?.getDefault() ?? resolveDefaultAgent(ctx.config);
+          const batchCounts = countStories(prd);
+          const batchBaseDone = batchCounts.total - batchCounts.pending;
+          for (const [batchIndex, story] of batch.entries()) {
             const modelTier2 = story.routing?.modelTier ?? ctx.config.autoMode.complexityRouting?.[story.routing?.complexity ?? "medium"] ?? "balanced";
             pipelineEventBus.emit({
               type: "story:started",
@@ -61957,7 +62442,7 @@ async function executeUnified(ctx, initialPrd) {
               story: { id: story.id, title: story.title, status: story.status, attempts: story.attempts },
               workdir: ctx.workdir,
               modelTier: modelTier2,
-              agent: ctx.agentManager?.getDefault() ?? resolveDefaultAgent(ctx.config),
+              agent: batchAgent,
               iteration: iterations
             });
             logger?.info("story.start", `${story.title}`, {
@@ -61965,6 +62450,9 @@ async function executeUnified(ctx, initialPrd) {
               storyTitle: story.title,
               complexity: story.routing?.complexity ?? "unknown",
               modelTier: modelTier2,
+              agent: batchAgent,
+              storyNumber: batchBaseDone + batchIndex + 1,
+              storyTotal: batchCounts.total,
               attempt: story.attempts + 1
             });
           }
@@ -61984,6 +62472,7 @@ async function executeUnified(ctx, initialPrd) {
                 config: ctx.config,
                 rootConfig: ctx.config,
                 prd,
+                skipPrdPersistence: true,
                 projectDir: ctx.workdir,
                 naxIgnoreIndex,
                 hooks: ctx.hooks,
@@ -62031,6 +62520,8 @@ async function executeUnified(ctx, initialPrd) {
               abortSignal: ctx.abortSignal
             }, pipelineResult);
           }
+          reconcileBatchOutcome(prd, batchResult);
+          await savePRD(prd, ctx.prdPath);
           await pipelineEventBus.drain();
           totalCost += batchResult.totalCost;
           storiesCompleted += batchResult.completed.length;
@@ -62121,6 +62612,8 @@ async function executeUnified(ctx, initialPrd) {
             }
           }
           const modelTier2 = singleSelection.routing.modelTier;
+          const singleAgent = ctx.agentManager?.getDefault() ?? resolveDefaultAgent(ctx.config);
+          const singleCounts = countStories(prd);
           pipelineEventBus.emit({
             type: "story:started",
             storyId: singleStory.id,
@@ -62132,7 +62625,7 @@ async function executeUnified(ctx, initialPrd) {
             },
             workdir: ctx.workdir,
             modelTier: modelTier2,
-            agent: ctx.agentManager?.getDefault() ?? resolveDefaultAgent(ctx.config),
+            agent: singleAgent,
             iteration: iterations
           });
           logger?.info("story.start", `${singleStory.title}`, {
@@ -62140,6 +62633,9 @@ async function executeUnified(ctx, initialPrd) {
             storyTitle: singleStory.title,
             complexity: singleSelection.routing.complexity ?? "unknown",
             modelTier: modelTier2,
+            agent: singleAgent,
+            storyNumber: singleCounts.total - singleCounts.pending + 1,
+            storyTotal: singleCounts.total,
             attempt: singleStory.attempts + 1
           });
           const singleIter = await _unifiedExecutorDeps.runIteration(ctx, prd, singleSelection, iterations, totalCost, allStoryMetrics);
@@ -62191,6 +62687,8 @@ async function executeUnified(ctx, initialPrd) {
         }
       }
       const modelTier = selection.routing.modelTier;
+      const seqAgent = ctx.agentManager?.getDefault() ?? resolveDefaultAgent(ctx.config);
+      const seqCounts = countStories(prd);
       pipelineEventBus.emit({
         type: "story:started",
         storyId: selection.story.id,
@@ -62202,7 +62700,7 @@ async function executeUnified(ctx, initialPrd) {
         },
         workdir: ctx.workdir,
         modelTier,
-        agent: ctx.agentManager?.getDefault() ?? resolveDefaultAgent(ctx.config),
+        agent: seqAgent,
         iteration: iterations
       });
       logger?.info("story.start", `${selection.story.title}`, {
@@ -62210,6 +62708,9 @@ async function executeUnified(ctx, initialPrd) {
         storyTitle: selection.story.title,
         complexity: selection.routing.complexity ?? "unknown",
         modelTier,
+        agent: seqAgent,
+        storyNumber: seqCounts.total - seqCounts.pending + 1,
+        storyTotal: seqCounts.total,
         attempt: selection.story.attempts + 1
       });
       const iter = await _unifiedExecutorDeps.runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics);
@@ -62268,6 +62769,18 @@ async function executeUnified(ctx, initialPrd) {
     return buildResult2("max-iterations");
   } finally {}
 }
+function reconcileBatchOutcome(prd, batchResult) {
+  for (const story of batchResult.completed) {
+    markStoryPassed(prd, story.id);
+  }
+  for (const conflict of batchResult.mergeConflicts) {
+    if (conflict.rectified) {
+      markStoryPassed(prd, conflict.story.id);
+    } else {
+      markStoryFailed(prd, conflict.story.id, undefined, "merge-conflict");
+    }
+  }
+}
 var TERMINAL_ACTIONS, _unifiedExecutorDeps;
 var init_unified_executor = __esm(() => {
   init_agents();
@@ -94922,6 +95435,7 @@ class DebatePlanStrategy {
       });
       if (debateResult.outcome !== "failed" && debateResult.output) {
         const prd2 = validatePlanOutput(debateResult.output, ctx.options.feature, ctx.branchName);
+        warnOnDroppedVerbatimAcs(prd2, ctx.specContent, ctx.options.feature);
         const withProject2 = { ...prd2, project: ctx.projectName };
         return _debatePlanDeps.writeOrRecoverPrd(ctx, withProject2);
       }