@nathapp/nax 0.68.0 → 0.68.2

package/dist/nax.js

@@ -17735,19 +17735,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 +17820,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 +17844,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 +17934,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 +18002,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 +18133,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 +18196,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,
@@ -21971,6 +22079,10 @@ function tryParseLLMJson(text) {
 }
 
 // src/agents/retry/parse-retry.ts
+function previewOutput(output, maxBytes) {
+  const collapsed = output.replace(/\s+/g, " ").trim();
+  return collapsed.length > maxBytes ? `${collapsed.slice(0, maxBytes)}\u2026` : collapsed;
+}
 function makeParseRetryStrategy(opts) {
   const parse5 = opts.parse ?? tryParseLLMJson;
   const checkTruncated = opts.looksTruncated ?? looksLikeTruncatedJson;
@@ -22003,16 +22115,19 @@ function makeParseRetryStrategy(opts) {
       const isTruncated = checkTruncated(ctx.lastOutput);
       const nextPrompt = isTruncated ? opts.prompts.truncated() : opts.prompts.invalid();
       const logger = opts._logger ?? getSafeLogger();
+      const preview = opts.outputPreviewBytes && opts.outputPreviewBytes > 0 ? { outputPreview: previewOutput(ctx.lastOutput, opts.outputPreviewBytes) } : {};
       if (isTruncated) {
         logger?.warn(opts.reviewerKind, "JSON parse retry \u2014 likely truncated", {
           storyId: ctx.storyId,
           originalByteSize: ctx.lastOutput.length,
+          ...preview,
           ...opts.logContext
         });
       } else {
         logger?.warn(opts.reviewerKind, "JSON parse retry \u2014 invalid shape", {
           storyId: ctx.storyId,
           originalByteSize: ctx.lastOutput.length,
+          ...preview,
           ...opts.logContext
         });
       }
@@ -22544,9 +22659,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")
@@ -22574,7 +22696,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) {
@@ -22595,6 +22717,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
@@ -23723,7 +23846,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),
@@ -23742,7 +23868,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 = {
@@ -23755,6 +23888,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
@@ -24618,6 +24752,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)
@@ -24637,28 +24784,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))];
@@ -24683,11 +24830,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;
 }
@@ -24726,7 +24873,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;
     }
@@ -24753,7 +24900,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;
@@ -24764,8 +24911,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();
@@ -24776,6 +24924,7 @@ var init_smart_runner = __esm(() => {
   _gitUtilDeps = {
     getGitRoot
   };
+  _gitRootCache = new Map;
   _smartRunnerDeps = {
     glob: _bunDeps.glob,
     file: _bunDeps.file,
@@ -25133,31 +25282,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) {
@@ -25166,17 +25334,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;
@@ -25239,10 +25398,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) {
@@ -26160,13 +26326,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);
   }
@@ -26805,12 +26983,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: [] };
     }
@@ -33270,20 +33443,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;
@@ -36863,7 +37039,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");
   }
@@ -36876,6 +37052,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: [],
@@ -36897,6 +37085,7 @@ var verifierOp;
 var init_verify = __esm(() => {
   init_retry();
   init_config();
+  init_logger2();
   init_tdd_builder();
   init_isolation();
   init_verdict();
@@ -36915,6 +37104,7 @@ var init_verify = __esm(() => {
       },
       reviewerKind: "verifier",
       maxAttempts: 2,
+      outputPreviewBytes: 600,
       prompts: {
         invalid: () => TddPromptBuilder.verdictRetry(),
         truncated: () => TddPromptBuilder.verdictRetryCondensed()
@@ -36943,24 +37133,38 @@ var init_verify = __esm(() => {
     },
     async recover(input, verifyCtx) {
       const packageDir = verifyCtx.packageView.packageDir;
+      const logger = getSafeLogger();
+      const storyId = input.story.id;
       try {
         const verdict = await readVerdict(packageDir);
         if (verdict) {
           const testsAllPassing = verdict.tests.allPassing === true;
           const categorization = categorizeVerdict(verdict, testsAllPassing);
           const isolation = await runVerifierIsolation(input.beforeRef, verifyCtx);
+          const normalizedFindings = buildVerifierFindings(verdict, categorization);
+          logger?.warn("verifier", "Recovered verdict from disk after unparseable stdout", {
+            storyId,
+            packageDir,
+            success: categorization.success,
+            findingsCount: normalizedFindings.length,
+            ...categorization.failureCategory && { failureCategory: categorization.failureCategory }
+          });
           return {
             success: categorization.success,
             filesChanged: [],
             estimatedCostUsd: 0,
             durationMs: 0,
             output: "",
-            normalizedFindings: buildVerifierFindings(verdict, categorization),
+            normalizedFindings,
             ...categorization.failureCategory && { failureCategory: categorization.failureCategory },
             ...categorization.reviewReason && { reviewReason: categorization.reviewReason },
             ...isolation && { isolation }
           };
         }
+        logger?.error("verifier", "No usable verdict \u2014 unparseable stdout and no verdict file on disk (fail-closed)", {
+          storyId,
+          packageDir
+        });
         return {
           success: false,
           filesChanged: [],
@@ -38212,7 +38416,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 };
     }
@@ -38270,7 +38475,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 };
     }
@@ -38303,7 +38509,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 };
@@ -38552,7 +38759,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 };
@@ -39527,13 +39735,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) {
@@ -39574,7 +39783,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 });
@@ -39599,19 +39808,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", {
@@ -40337,8 +40546,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,
@@ -40544,8 +40753,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`, {
@@ -43893,13 +44103,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}`;
@@ -43920,15 +44130,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`, {
@@ -43940,7 +44143,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}`, {
@@ -43959,8 +44162,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", {
@@ -44179,6 +44382,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(() => {
@@ -52025,7 +52259,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 });
@@ -52033,7 +52267,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 = () => {};
 
@@ -52140,6 +52374,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) {
@@ -52164,7 +52399,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,
@@ -52196,7 +52433,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,
@@ -52981,23 +53220,35 @@ function logUnifiedReviewPhaseStart(storyId, opName) {
     logger?.info("review", "Running adversarial check", { storyId });
   }
 }
-function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase, stage) {
-  if (isTddPhase)
-    return;
-  if (opName === "semantic-review" || opName === "adversarial-review")
-    return;
+function buildPhaseOutcomeLogData(storyId, opName, output, durationMs) {
   if (output === null || output === undefined || typeof output !== "object")
-    return;
-  const logger = getSafeLogger();
+    return null;
   const r = output;
   const success2 = r.success === true || r.passed === true;
-  const findingsCount = Array.isArray(r.findings) ? r.findings.length : undefined;
+  const findingsCount = Array.isArray(r.normalizedFindings) ? r.normalizedFindings.length : Array.isArray(r.findings) ? r.findings.length : undefined;
   const status = typeof r.status === "string" ? r.status : undefined;
   const data = { storyId, phase: opName, durationMs };
   if (findingsCount !== undefined)
     data.findingsCount = findingsCount;
   if (status !== undefined)
     data.status = status;
+  if (typeof r.failureCategory === "string")
+    data.failureCategory = r.failureCategory;
+  if (typeof r.reviewReason === "string")
+    data.reviewReason = r.reviewReason;
+  return { success: success2, data };
+}
+function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTddPhase, stage, progressData = {}) {
+  if (isTddPhase)
+    return;
+  if (opName === "semantic-review" || opName === "adversarial-review")
+    return;
+  const built = buildPhaseOutcomeLogData(storyId, opName, output, durationMs);
+  if (!built)
+    return;
+  const { success: success2 } = built;
+  const data = { ...built.data, ...progressData };
+  const logger = getSafeLogger();
   const message = formatPhaseResultMessage(opName, success2, stage);
   if (stage === "rectification") {
     logger?.info("story-orchestrator", message, data);
@@ -53059,17 +53310,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();
@@ -53079,7 +53334,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}`, {
@@ -53248,9 +53503,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,
@@ -56915,7 +57174,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 {
@@ -56931,7 +57190,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 = () => {};
@@ -57849,7 +58108,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.68.0",
+    version: "0.68.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -57944,8 +58203,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("d56db412"))
-        return "d56db412";
+      if (/^[0-9a-f]{6,10}$/.test("27a81a5e"))
+        return "27a81a5e";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -59361,6 +59620,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({
@@ -59466,7 +59728,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,
@@ -59564,7 +59829,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();
@@ -59579,7 +59844,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)", {
@@ -61476,9 +61741,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 {
@@ -61492,7 +61761,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       }
     }
     const pipelineContext = {
-      ...context,
+      ...buildWorktreePipelineContext(context, story),
       config: context.config,
       rootConfig: context.rootConfig,
       story,
@@ -61792,6 +62061,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
 });
@@ -61915,7 +62185,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",
@@ -61923,7 +62196,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}`, {
@@ -61931,6 +62204,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
             });
           }
@@ -61950,6 +62226,7 @@ async function executeUnified(ctx, initialPrd) {
                 config: ctx.config,
                 rootConfig: ctx.config,
                 prd,
+                skipPrdPersistence: true,
                 projectDir: ctx.workdir,
                 naxIgnoreIndex,
                 hooks: ctx.hooks,
@@ -61997,6 +62274,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;
@@ -62087,6 +62366,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,
@@ -62098,7 +62379,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}`, {
@@ -62106,6 +62387,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);
@@ -62157,6 +62441,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,
@@ -62168,7 +62454,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}`, {
@@ -62176,6 +62462,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);
@@ -62234,6 +62523,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();

package/package.json

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