@nathapp/nax 0.69.0 → 0.69.2

package/dist/nax.js

@@ -16983,10 +16983,10 @@ var init_schemas_execution = __esm(() => {
     autoApproveVerifier: exports_external.boolean(),
     strategy: exports_external.enum(["auto", "strict", "lite", "off"]).default("auto"),
     sessionTiers: exports_external.object({
-      testWriter: exports_external.string().optional(),
-      implementer: exports_external.string().optional(),
-      verifier: exports_external.string().optional()
-    }).optional(),
+      testWriter: ConfiguredModelSchema.default("fast"),
+      verifier: ConfiguredModelSchema.default("fast"),
+      implementer: ConfiguredModelSchema.optional()
+    }).default({ testWriter: "fast", verifier: "fast" }),
     testWriterAllowedPaths: exports_external.array(exports_external.string()).optional(),
     rollbackOnFailure: exports_external.boolean().optional(),
     greenfieldDetection: exports_external.boolean().optional()
@@ -17221,6 +17221,12 @@ var init_schemas_review = __esm(() => {
     substantiation: exports_external.object({
       requote: exports_external.boolean().default(true),
       maxRequotes: exports_external.number().int().min(0).default(5)
+    }).optional(),
+    nonBlockingFix: exports_external.object({
+      enabled: exports_external.boolean().default(false),
+      scope: exports_external.enum(["source", "both"]).default("both"),
+      regressionAttempts: exports_external.number().int().min(0).default(1),
+      verifierGuard: exports_external.boolean().default(true)
     }).optional()
   });
   ReviewConfigSchema = exports_external.object({
@@ -17407,7 +17413,7 @@ var init_schemas3 = __esm(() => {
       autoApproveVerifier: true,
       strategy: "auto",
       sessionTiers: {
-        testWriter: "balanced",
+        testWriter: "fast",
         verifier: "fast"
       },
       testWriterAllowedPaths: ["src/index.ts", "src/**/index.ts"],
@@ -18940,6 +18946,14 @@ ${errors3.join(`
   }
   return result.data;
 }
+async function loadPackageOverride(repoRoot, packageDir) {
+  const packageConfigPath = join3(repoRoot, PROJECT_NAX_DIR, "mono", packageDir, "config.json");
+  const override = await loadJsonFile(packageConfigPath, "config");
+  if (!override)
+    return null;
+  const { profile: _profile, ...fields } = override;
+  return fields;
+}
 async function loadConfigForWorkdir(rootConfigPath, packageDir, cliOverrides) {
   const logger = getLogger();
   const resolvedRootConfigPath = resolve3(rootConfigPath);
@@ -19004,6 +19018,106 @@ var init_loader = __esm(() => {
   init_schema();
   _rootConfigCache = new Map;
 });
+
+// src/config/validate.ts
+function validateConfig(config2) {
+  const errors3 = [];
+  if (config2.version !== 1) {
+    errors3.push(`Invalid version: expected 1, got ${config2.version}`);
+  }
+  const requiredTiers = ["fast", "balanced", "powerful"];
+  if (!config2.models) {
+    errors3.push("models mapping is required");
+  } else {
+    const defaultAgent = config2.agent?.default ?? "claude";
+    const agentModels = config2.models[defaultAgent];
+    if (!agentModels) {
+      errors3.push(`models.${defaultAgent} is required (default agent has no model map)`);
+    } else {
+      for (const tier of requiredTiers) {
+        const entry = agentModels[tier];
+        if (!entry) {
+          errors3.push(`models.${defaultAgent}.${tier} is required`);
+        } else if (typeof entry === "string") {
+          if (entry.trim() === "") {
+            errors3.push(`models.${defaultAgent}.${tier} must be a non-empty model identifier`);
+          }
+        } else {
+          if (!entry.provider || entry.provider.trim() === "") {
+            errors3.push(`models.${defaultAgent}.${tier}.provider must be non-empty`);
+          }
+          if (!entry.model || entry.model.trim() === "") {
+            errors3.push(`models.${defaultAgent}.${tier}.model must be non-empty`);
+          }
+        }
+      }
+    }
+  }
+  if (config2.execution.maxIterations <= 0) {
+    errors3.push(`maxIterations must be > 0, got ${config2.execution.maxIterations}`);
+  }
+  if (config2.execution.costLimit <= 0) {
+    errors3.push(`costLimit must be > 0, got ${config2.execution.costLimit}`);
+  }
+  if (config2.execution.sessionTimeoutSeconds <= 0) {
+    errors3.push(`sessionTimeoutSeconds must be > 0, got ${config2.execution.sessionTimeoutSeconds}`);
+  }
+  const agentDefault = config2.agent?.default;
+  if (!agentDefault || agentDefault.trim() === "") {
+    errors3.push("agent.default must be non-empty");
+  }
+  if (!config2.autoMode.escalation.tierOrder || config2.autoMode.escalation.tierOrder.length === 0) {
+    errors3.push("escalation.tierOrder must have at least one tier");
+  } else {
+    for (const tc of config2.autoMode.escalation.tierOrder) {
+      if (tc.attempts < 1 || tc.attempts > 20) {
+        errors3.push(`escalation.tierOrder: tier "${tc.tier}" attempts must be 1-20, got ${tc.attempts}`);
+      }
+    }
+  }
+  if (config2.models && config2.agent?.fallback?.map) {
+    const modelKeys = Object.keys(config2.models);
+    const fallbackAgents = new Set;
+    for (const [primary, candidates] of Object.entries(config2.agent.fallback.map)) {
+      fallbackAgents.add(primary);
+      for (const c of candidates)
+        fallbackAgents.add(c);
+    }
+    for (const agent of fallbackAgents) {
+      if (!modelKeys.includes(agent)) {
+        errors3.push(`agent.fallback.map: agent "${agent}" is not a key in models (available: ${modelKeys.join(", ")})`);
+      } else {
+        for (const tier of requiredTiers) {
+          if (!config2.models[agent]?.[tier]) {
+            errors3.push(`models.${agent}.${tier} is required (fallback agent "${agent}" in agent.fallback.map)`);
+          }
+        }
+      }
+    }
+  }
+  if (config2.models && config2.autoMode?.escalation?.tierOrder) {
+    const modelKeys = Object.keys(config2.models);
+    for (const tc of config2.autoMode.escalation.tierOrder) {
+      if (tc.agent !== undefined && !modelKeys.includes(tc.agent)) {
+        errors3.push(`autoMode.escalation.tierOrder: tier "${tc.tier}" agent "${tc.agent}" is not a key in models (available: ${modelKeys.join(", ")})`);
+      }
+    }
+  }
+  const defaultAgentKey = config2.agent?.default ?? "claude";
+  const configuredTiers = Object.keys(config2.models[defaultAgentKey] ?? {});
+  const complexities = ["simple", "medium", "complex", "expert"];
+  for (const complexity of complexities) {
+    const tier = config2.autoMode.complexityRouting[complexity];
+    if (!configuredTiers.includes(tier)) {
+      errors3.push(`complexityRouting.${complexity} must be one of: ${configuredTiers.join(", ")} (got '${tier}')`);
+    }
+  }
+  return {
+    valid: errors3.length === 0,
+    errors: errors3
+  };
+}
+
 // src/config/selector.ts
 function pickSelector(name, ...keys) {
   return {
@@ -19286,10 +19400,81 @@ var init_test_strategy = __esm(() => {
 });
 
 // src/config/index.ts
+var exports_config = {};
+__export(exports_config, {
+  verifyConfigSelector: () => verifyConfigSelector,
+  validateFilePath: () => validateFilePath,
+  validateDirectory: () => validateDirectory,
+  validateConfig: () => validateConfig,
+  testPatternConfigSelector: () => testPatternConfigSelector,
+  tddConfigSelector: () => tddConfigSelector,
+  routingConfigSelector: () => routingConfigSelector,
+  reviewConfigSelector: () => reviewConfigSelector,
+  resolveTestStrategy: () => resolveTestStrategy,
+  resolveProfileName: () => resolveProfileName,
+  resolveModelForAgent: () => resolveModelForAgent,
+  resolveModel: () => resolveModel,
+  resolveConfiguredModel: () => resolveConfiguredModel,
+  reshapeSelector: () => reshapeSelector,
+  rectifyConfigSelector: () => rectifyConfigSelector,
+  rectificationGateConfigSelector: () => rectificationGateConfigSelector,
+  qualityConfigSelector: () => qualityConfigSelector,
+  promptLoaderConfigSelector: () => promptLoaderConfigSelector,
+  projectConfigDir: () => projectConfigDir,
+  precheckConfigSelector: () => precheckConfigSelector,
+  planConfigSelector: () => planConfigSelector,
+  pickSelector: () => pickSelector,
+  mergePackageConfig: () => mergePackageConfig,
+  loadProfileEnv: () => loadProfileEnv,
+  loadProfile: () => loadProfile,
+  loadPackageOverride: () => loadPackageOverride,
+  loadConfigForWorkdir: () => loadConfigForWorkdir,
+  loadConfig: () => loadConfig,
+  llmRoutingConfigSelector: () => llmRoutingConfigSelector,
+  listProfiles: () => listProfiles,
+  isWithinDirectory: () => isWithinDirectory,
+  isThreeSessionStrategy: () => isThreeSessionStrategy,
+  isSingleSessionTestOwningStrategy: () => isSingleSessionTestOwningStrategy,
+  interactionConfigSelector: () => interactionConfigSelector,
+  globalConfigPath: () => globalConfigPath,
+  globalConfigDir: () => globalConfigDir,
+  getAcQualityRules: () => getAcQualityRules,
+  findProjectDir: () => findProjectDir,
+  executionGatesConfigSelector: () => executionGatesConfigSelector,
+  deepMergeConfig: () => deepMergeConfig,
+  decomposeConfigSelector: () => decomposeConfigSelector,
+  debateConfigSelector: () => debateConfigSelector,
+  createConfigLoader: () => createConfigLoader,
+  contextToolRuntimeConfigSelector: () => contextToolRuntimeConfigSelector,
+  autofixConfigSelector: () => autofixConfigSelector,
+  agentManagerConfigSelector: () => agentManagerConfigSelector,
+  acceptanceGenConfigSelector: () => acceptanceGenConfigSelector,
+  acceptanceFixConfigSelector: () => acceptanceFixConfigSelector,
+  acceptanceConfigSelector: () => acceptanceConfigSelector,
+  VALID_TEST_STRATEGIES: () => VALID_TEST_STRATEGIES,
+  TddConfigSchema: () => TddConfigSchema,
+  THREE_SESSION_STRATEGIES: () => THREE_SESSION_STRATEGIES,
+  TEST_STRATEGY_GUIDE: () => TEST_STRATEGY_GUIDE,
+  SPEC_ANCHOR_RULES: () => SPEC_ANCHOR_RULES,
+  SINGLE_SESSION_TEST_OWNING_STRATEGIES: () => SINGLE_SESSION_TEST_OWNING_STRATEGIES,
+  PlanConfigSchema: () => PlanConfigSchema,
+  NaxConfigSchema: () => NaxConfigSchema,
+  ModelTierSchema: () => ModelTierSchema,
+  MAX_DIRECTORY_DEPTH: () => MAX_DIRECTORY_DEPTH,
+  GROUPING_RULES: () => GROUPING_RULES,
+  DebateConfigSchema: () => DebateConfigSchema,
+  DESCRIPTION_QUALITY_RULES: () => DESCRIPTION_QUALITY_RULES,
+  DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  ConfiguredModelSchema: () => ConfiguredModelSchema,
+  COMPLEXITY_GUIDE: () => COMPLEXITY_GUIDE,
+  AcceptanceConfigSchema: () => AcceptanceConfigSchema,
+  AC_QUALITY_RULES: () => AC_QUALITY_RULES
+});
 var init_config = __esm(() => {
   init_schema();
   init_schemas_model();
   init_schemas_debate();
+  init_schemas_execution();
   init_loader();
   init_path_security();
   init_paths();
@@ -23786,6 +23971,7 @@ var init_detect = __esm(() => {
 });
 
 // src/test-runners/detect/workspace.ts
+import { join as join6 } from "path";
 async function expandWorkspaceGlob(workdir, pattern) {
   const dirs = [];
   try {
@@ -23859,15 +24045,31 @@ async function detectTurboOrNx(workdir) {
 }
 async function detectNaxMonoLayout(workdir) {
   const dirs = [];
-  try {
-    const glob = new Bun.Glob(".nax/mono/*/config.json");
-    for await (const entry of glob.scan({ cwd: workdir })) {
-      const parts = entry.split("/");
-      if (parts.length >= 4) {
-        const pkgDir = parts.slice(2, -1).join("/");
-        dirs.push(pkgDir);
+  const monoRoot = join6(workdir, ".nax", "mono");
+  async function walk(currentDir, relativeParts) {
+    const entries = [];
+    for await (const entry of _workspaceDeps.glob("*", currentDir)) {
+      entries.push(entry);
+    }
+    let hasConfig = false;
+    for (const entry of entries) {
+      const entryPath = join6(currentDir, entry);
+      const stat = await _workspaceDeps.stat(entryPath);
+      const isDirectory = (stat.mode & 61440) === 16384;
+      if (!isDirectory && entry === "config.json") {
+        hasConfig = true;
+        continue;
       }
+      if (isDirectory) {
+        await walk(entryPath, [...relativeParts, entry]);
+      }
+    }
+    if (hasConfig && relativeParts.length > 0) {
+      dirs.push(relativeParts.join("/"));
     }
+  }
+  try {
+    await walk(monoRoot, []);
   } catch {}
   return dirs;
 }
@@ -23911,7 +24113,8 @@ var init_workspace = __esm(() => {
       return f.text();
     },
     spawn: Bun.spawn,
-    glob: (pattern, cwd) => new Bun.Glob(pattern).scan({ cwd, onlyFiles: false })
+    glob: (pattern, cwd) => new Bun.Glob(pattern).scan({ cwd, onlyFiles: false }),
+    stat: (path) => Bun.file(path).stat()
   };
   _workspaceCache = new Map;
 });
@@ -23985,7 +24188,7 @@ var init_detector2 = __esm(() => {
 });
 
 // src/test-runners/resolver.ts
-import { dirname as dirname2, isAbsolute as isAbsolute3, join as join6, relative, resolve as resolve4 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join7, relative, resolve as resolve4 } from "path";
 function buildResolved(globs, resolution) {
   return {
     globs,
@@ -24037,7 +24240,7 @@ async function resolveTestFilePatterns(config2, workdir, packageDir, options) {
     validateGlobs(rootPatterns, "resolver");
     return buildResolved(rootPatterns, "root-config");
   }
-  const detectionWorkdir = packageDir ? join6(workdir, packageDir) : workdir;
+  const detectionWorkdir = packageDir ? join7(workdir, packageDir) : workdir;
   const detected = await _resolverDeps.detectTestFilePatterns(detectionWorkdir);
   if (detected.confidence !== "empty" && detected.patterns.length > 0) {
     getSafeLogger()?.info("resolver", "Test patterns auto-detected", {
@@ -24616,7 +24819,7 @@ var init_git = __esm(() => {
 });
 
 // src/utils/path-filters.ts
-import { join as join7, relative as relative2 } from "path";
+import { join as join8, relative as relative2 } from "path";
 function basename3(path) {
   const stripped = path.startsWith("./") ? path.slice(2) : path;
   const idx = stripped.lastIndexOf("/");
@@ -24706,8 +24909,8 @@ async function resolveNaxIgnorePatterns(repoRoot, packageDir) {
   const normalizedRepoRoot = normalizePath(repoRoot);
   const normalizedPackageDir = packageDir ? normalizePath(packageDir) : normalizedRepoRoot;
   const packagePrefix = normalizedPackageDir !== normalizedRepoRoot ? normalizePath(relative2(repoRoot, packageDir ?? repoRoot)) : null;
-  const rootFile = join7(repoRoot, NAX_IGNORE_FILENAME);
-  const packageFile = join7(packageDir ?? repoRoot, NAX_IGNORE_FILENAME);
+  const rootFile = join8(repoRoot, NAX_IGNORE_FILENAME);
+  const packageFile = join8(packageDir ?? repoRoot, NAX_IGNORE_FILENAME);
   const rootPatterns = await readIgnorePatterns(rootFile);
   const packagePatterns = packageDir && packageDir !== repoRoot ? await readIgnorePatterns(packageFile) : [];
   return [
@@ -24776,7 +24979,7 @@ var init_path_filters = __esm(() => {
 });
 
 // src/verification/smart-runner.ts
-import { join as join8, relative as relative3 } from "path";
+import { join as join9, relative as relative3 } from "path";
 function clearGitRootCache() {
   _gitRootCache.clear();
 }
@@ -24894,7 +25097,7 @@ async function getChangedNonTestFiles(workdir, baseRef, packagePrefix, testFileR
     const lines = stdout.trim().split(`
 `).filter(Boolean);
     const effectiveRepoRoot = repoRoot ?? workdir;
-    const packageDir = packagePrefix ? join8(effectiveRepoRoot, packagePrefix) : undefined;
+    const packageDir = packagePrefix ? join9(effectiveRepoRoot, packagePrefix) : undefined;
     const ignoreMatchers = naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(effectiveRepoRoot, packageDir);
     let effectivePrefix = packagePrefix;
     if (packagePrefix && repoRoot) {
@@ -24923,7 +25126,7 @@ async function getChangedTestFiles(workdir, repoRoot, baseRef, packagePrefix, te
       return [];
     const lines = stdout.trim().split(`
 `).filter(Boolean);
-    const packageDir = packagePrefix ? join8(repoRoot, packagePrefix) : undefined;
+    const packageDir = packagePrefix ? join9(repoRoot, packagePrefix) : undefined;
     const ignoreMatchers = naxIgnoreIndex?.getMatchers(packageDir) ?? await resolveNaxIgnorePatterns(repoRoot, packageDir);
     const gitRoot = await getGitRootMemo(workdir);
     const extraPrefix = gitRoot && gitRoot !== repoRoot ? relative3(gitRoot, repoRoot) : "";
@@ -24931,7 +25134,7 @@ async function getChangedTestFiles(workdir, repoRoot, baseRef, packagePrefix, te
     const scopedRaw = effectivePrefix ? lines.filter((f) => f.startsWith(`${effectivePrefix}/`)) : lines;
     const scoped = filterNaxInternalPaths(scopedRaw, ignoreMatchers);
     const stripped = extraPrefix ? scoped.map((f) => f.slice(`${extraPrefix}/`.length)) : scoped;
-    return stripped.filter((f) => testFileRegex.some((re) => re.test(f))).map((f) => join8(repoRoot, f));
+    return stripped.filter((f) => testFileRegex.some((re) => re.test(f))).map((f) => join9(repoRoot, f));
   } catch {
     return [];
   }
@@ -25063,6 +25266,7 @@ __export(exports_test_runners, {
   formatFailureSummary: () => formatFailureSummary,
   findPackageDir: () => findPackageDir,
   extractTestDirs: () => extractTestDirs,
+  discoverWorkspacePackages: () => discoverWorkspacePackages,
   detectTestFilePatterns: () => detectTestFilePatterns,
   detectManifestFrameworksFromPackageJson: () => detectManifestFrameworksFromPackageJson,
   detectFramework: () => detectFramework,
@@ -25084,6 +25288,7 @@ var init_test_runners = __esm(() => {
   init_detector2();
   init_resolver();
   init_parser();
+  init_workspace();
   init_ac_parser();
   init_scoped_selection();
 });
@@ -25135,7 +25340,7 @@ var init_project = __esm(() => {
 
 // src/utils/path-security.ts
 import { realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname3, isAbsolute as isAbsolute4, join as join9, normalize as normalize3, resolve as resolve5 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute4, join as join10, normalize as normalize3, resolve as resolve5 } from "path";
 function safeRealpathForComparison(p) {
   try {
     return realpathSync2(p);
@@ -25144,7 +25349,7 @@ function safeRealpathForComparison(p) {
     if (parent === p)
       return normalize3(p);
     const resolvedParent = safeRealpathForComparison(parent);
-    return join9(resolvedParent, p.split("/").pop() ?? "");
+    return join10(resolvedParent, p.split("/").pop() ?? "");
   }
 }
 function isRelativeAndSafe(filePath) {
@@ -25172,7 +25377,7 @@ function validateModulePath(modulePath, allowedRoots) {
   } else {
     for (let i = 0;i < allowedRoots.length; i++) {
       const originalRoot = resolve5(allowedRoots[i]);
-      const absoluteInput = resolve5(join9(originalRoot, modulePath));
+      const absoluteInput = resolve5(join10(originalRoot, modulePath));
       const resolved = safeRealpathForComparison(absoluteInput);
       const resolvedRoot = resolvedRoots[i];
       if (resolved.startsWith(`${resolvedRoot}/`) || resolved === resolvedRoot) {
@@ -25189,7 +25394,7 @@ var init_path_security2 = () => {};
 
 // src/context/engine/providers/code-neighbor.ts
 import { createHash as createHash3 } from "crypto";
-import { join as join10, relative as relative4, resolve as resolve6 } from "path";
+import { join as join11, relative as relative4, resolve as resolve6 } from "path";
 function isExcludedPath(file3, ignoreMatchers) {
   for (const prefix of EXCLUDED_DIR_PREFIXES2) {
     if (file3.startsWith(prefix) || file3.includes(`/${prefix}`))
@@ -25327,7 +25532,7 @@ async function readCached(absolutePath, cache) {
 async function collectNeighbors(filePath, workdir, scannedDirs, contentCache, siblingTestContext) {
   const neighbors = new Set;
   let anyTruncated = false;
-  const ownAbsPath = join10(workdir, filePath);
+  const ownAbsPath = join11(workdir, filePath);
   if (await _codeNeighborDeps.fileExists(ownAbsPath)) {
     const ownContent = await readCached(ownAbsPath, contentCache);
     if (ownContent !== null && ownContent.length > 0) {
@@ -25349,7 +25554,7 @@ async function collectNeighbors(filePath, workdir, scannedDirs, contentCache, si
           break outer;
         if (srcFile === filePath)
           continue;
-        const content = await readCached(join10(scanWorkdir, srcFile), contentCache);
+        const content = await readCached(join11(scanWorkdir, srcFile), contentCache);
         if (content?.includes(fileBaseName)) {
           for (const spec of parseImportSpecifiers(content)) {
             const resolved = resolveImport(spec, srcFile, scanWorkdir);
@@ -25365,7 +25570,7 @@ async function collectNeighbors(filePath, workdir, scannedDirs, contentCache, si
     const candidates = deriveSiblingTestCandidates(filePath, siblingTestContext.globs);
     let chosen = null;
     for (const candidate of candidates) {
-      if (await _codeNeighborDeps.fileExists(join10(workdir, candidate))) {
+      if (await _codeNeighborDeps.fileExists(join11(workdir, candidate))) {
         chosen = candidate;
         break;
       }
@@ -25389,7 +25594,7 @@ async function resolveExtraGlobWorkdirs(neighborScope, crossPackageDepth, repoRo
     const relPkgDirs = await _codeNeighborDeps.discoverWorkspacePackages(repoRoot);
     if (relPkgDirs.length === 0)
       return [repoRoot];
-    return relPkgDirs.map((rel) => join10(repoRoot, rel)).filter((abs) => abs !== packageDir);
+    return relPkgDirs.map((rel) => join11(repoRoot, rel)).filter((abs) => abs !== packageDir);
   } catch {
     return [repoRoot];
   }
@@ -26686,7 +26891,7 @@ var init_orchestrator = __esm(() => {
 });
 
 // src/context/rules/canonical-loader.ts
-import { basename as basename4, join as join11 } from "path";
+import { basename as basename4, join as join12 } from "path";
 function parseRuleAllowMarker(line) {
   const allowed = new Set;
   RULE_ALLOW_MARKER.lastIndex = 0;
@@ -26821,7 +27026,7 @@ function applyCanonicalRulesBudget(rules, budgetTokens) {
 }
 async function loadCanonicalRules(workdir, options = {}) {
   const logger = _canonicalLoaderDeps.getLogger();
-  const rulesDir = join11(workdir, CANONICAL_RULES_DIR);
+  const rulesDir = join12(workdir, CANONICAL_RULES_DIR);
   const allFilePaths = _canonicalLoaderDeps.globInDir(rulesDir);
   const filePaths = allFilePaths.filter((filePath) => {
     const normalized = filePath.replaceAll("\\", "/");
@@ -26922,7 +27127,7 @@ var init_canonical_loader = __esm(() => {
         for (const rel of files) {
           const depth = rel.split("/").length - 1;
           if (depth <= 1) {
-            kept.push(join11(dir, rel));
+            kept.push(join12(dir, rel));
           } else {
             ignored.push(rel);
           }
@@ -27204,7 +27409,7 @@ var init_session_scratch = __esm(() => {
 
 // src/context/engine/providers/static-rules.ts
 import { createHash as createHash8 } from "crypto";
-import { join as join12, relative as relative5 } from "path";
+import { join as join13, relative as relative5 } from "path";
 function contentHash85(content) {
   return createHash8("sha256").update(content).digest("hex").slice(0, 8);
 }
@@ -27412,7 +27617,7 @@ ${rule.content}`,
     const existingCandidates = [];
     for (const fileName of LEGACY_CANDIDATE_FILES) {
       try {
-        if (await _staticRulesDeps.fileExists(join12(rootDir, fileName))) {
+        if (await _staticRulesDeps.fileExists(join13(rootDir, fileName))) {
           existingCandidates.push(fileName);
         }
       } catch {}
@@ -27428,11 +27633,11 @@ ${rule.content}`,
     for (const fileName of LEGACY_CANDIDATE_FILES) {
       legacySources.push({
         sourceId: fileName,
-        filePath: join12(rootDir, fileName),
+        filePath: join13(rootDir, fileName),
         heading: fileName
       });
     }
-    const rulesDir = join12(rootDir, LEGACY_RULES_DIR);
+    const rulesDir = join13(rootDir, LEGACY_RULES_DIR);
     const nestedRulePaths = _staticRulesDeps.globInDir(rulesDir);
     for (const filePath of nestedRulePaths) {
       const normalized = normalizePath2(filePath);
@@ -27491,7 +27696,7 @@ var init_static_rules = __esm(() => {
     fileExists: async (path) => Bun.file(path).exists(),
     globInDir: (dir) => {
       try {
-        return [...new Bun.Glob("**/*.md").scanSync({ cwd: dir, absolute: false })].sort().map((f) => join12(dir, f));
+        return [...new Bun.Glob("**/*.md").scanSync({ cwd: dir, absolute: false })].sort().map((f) => join13(dir, f));
       } catch {
         return [];
       }
@@ -27830,7 +28035,7 @@ function validateStory(raw, index, allIds) {
     routing: {
       complexity,
       testStrategy,
-      reasoning: "validated from LLM output",
+      reasoning: typeof routing.reasoning === "string" && routing.reasoning.trim().length > 0 ? routing.reasoning.trim() : "validated from LLM output",
       ...noTestJustification !== undefined ? { noTestJustification } : {}
     },
     ...workdir !== undefined ? { workdir } : {},
@@ -28381,7 +28586,7 @@ var init_orchestrator_factory = __esm(() => {
 });
 
 // src/context/engine/providers/plugin-loader.ts
-import { isAbsolute as isAbsolute5, join as join13, resolve as resolve7 } from "path";
+import { isAbsolute as isAbsolute5, join as join14, resolve as resolve7 } from "path";
 function isInitialisable(p) {
   return typeof p.init === "function";
 }
@@ -28409,7 +28614,7 @@ function resolveModuleSpecifier(specifier, workdir) {
   }
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
     const resolvedWorkdir = resolve7(workdir);
-    const resolved = resolve7(join13(workdir, specifier));
+    const resolved = resolve7(join14(workdir, specifier));
     if (resolved !== resolvedWorkdir && !resolved.startsWith(`${resolvedWorkdir}/`)) {
       throw new Error(`Plugin module path escapes project workdir: "${specifier}" resolves to "${resolved}" (workdir: "${resolvedWorkdir}")`);
     }
@@ -28555,15 +28760,15 @@ var init_available_budget = __esm(() => {
 
 // src/context/engine/manifest-store.ts
 import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute6, join as join14, relative as relative7, resolve as resolve8 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute6, join as join15, relative as relative7, resolve as resolve8 } from "path";
 function contextStoryDir(projectDir, featureId, storyId) {
-  return join14(projectDir, ".nax", "features", featureId, "stories", storyId);
+  return join15(projectDir, ".nax", "features", featureId, "stories", storyId);
 }
 function contextManifestPath(projectDir, featureId, storyId, stage) {
-  return join14(contextStoryDir(projectDir, featureId, storyId), `context-manifest-${stage}.json`);
+  return join15(contextStoryDir(projectDir, featureId, storyId), `context-manifest-${stage}.json`);
 }
 function rebuildManifestPath(projectDir, featureId, storyId) {
-  return join14(contextStoryDir(projectDir, featureId, storyId), "rebuild-manifest.json");
+  return join15(contextStoryDir(projectDir, featureId, storyId), "rebuild-manifest.json");
 }
 function toStoredPath(projectDir, pathValue) {
   const relativePath = isAbsolute6(pathValue) ? relative7(projectDir, pathValue) : pathValue;
@@ -28619,7 +28824,7 @@ async function loadContextManifests(projectDir, storyId, featureId) {
     const storyDir = contextStoryDir(projectDir, feature, storyId);
     const manifestFiles = await _manifestStoreDeps.listManifestFiles(storyDir);
     for (const fileName of manifestFiles) {
-      const fullPath = join14(storyDir, fileName);
+      const fullPath = join15(storyDir, fileName);
       if (!await _manifestStoreDeps.fileExists(fullPath))
         continue;
       try {
@@ -28644,7 +28849,7 @@ var init_manifest_store = __esm(() => {
     fileExists: (path2) => Bun.file(path2).exists(),
     readFile: (path2) => Bun.file(path2).text(),
     listFeatureDirs: async (projectDir) => {
-      const baseDir = join14(projectDir, ".nax", "features");
+      const baseDir = join15(projectDir, ".nax", "features");
       try {
         const dirs = [];
         for await (const entry of new Bun.Glob("*").scan({ cwd: baseDir, absolute: false })) {
@@ -28671,7 +28876,7 @@ var init_manifest_store = __esm(() => {
 
 // src/context/engine/stage-assembler.ts
 import { readdir } from "fs/promises";
-import { isAbsolute as isAbsolute7, join as join15, resolve as resolve9 } from "path";
+import { isAbsolute as isAbsolute7, join as join16, resolve as resolve9 } from "path";
 function dedupeScratchDirs(dirs) {
   return [...new Set(dirs.filter((dir) => Boolean(dir)))];
 }
@@ -28680,7 +28885,7 @@ function toAbsolutePath2(projectDir, pathValue) {
 }
 async function discoverSessionScratchDirsOnDisk(projectDir, featureName, storyId, ttlMs) {
   const logger = getLogger();
-  const sessionsRoot = join15(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsRoot = join16(projectDir, ".nax", "features", featureName, "sessions");
   let entries;
   try {
     entries = await _stageAssemblerDeps.readdir(sessionsRoot);
@@ -28690,7 +28895,7 @@ async function discoverSessionScratchDirsOnDisk(projectDir, featureName, storyId
   const cutoff = _stageAssemblerDeps.now() - ttlMs;
   const found = [];
   for (const entry of entries) {
-    const descriptorPath = join15(sessionsRoot, entry, "descriptor.json");
+    const descriptorPath = join16(sessionsRoot, entry, "descriptor.json");
     try {
       const parsed = await _stageAssemblerDeps.readDescriptor(descriptorPath);
       if (!parsed || parsed.storyId !== storyId || !parsed.scratchDir)
@@ -30355,13 +30560,13 @@ var exports_loader = {};
 __export(exports_loader, {
   loadOverride: () => loadOverride
 });
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function loadOverride(role, workdir, config2) {
   const overridePath = config2.prompts?.overrides?.[role];
   if (!overridePath) {
     return null;
   }
-  const absolutePath = join16(workdir, overridePath);
+  const absolutePath = join17(workdir, overridePath);
   const file3 = Bun.file(absolutePath);
   if (!await file3.exists()) {
     return null;
@@ -32641,12 +32846,14 @@ var init_adversarial_review = __esm(() => {
       });
       const { accepted, dropped } = filterByAcQuote(substantiated, input.story.acceptanceCriteria);
       const blocking = accepted.filter((f) => isBlockingSeverity(f.severity, threshold));
+      const advisory = accepted.filter((f) => !isBlockingSeverity(f.severity, threshold));
       const passed = parsed.passed && blocking.length === 0;
       return {
         ...parsed,
         passed,
         findings: accepted,
         normalizedFindings: toAdversarialReviewFindings(blocking),
+        advisoryFindings: toAdversarialReviewFindings(advisory),
         acDropped: dropped
       };
     }
@@ -33026,11 +33233,11 @@ var init_prepare_inputs = __esm(() => {
 });
 
 // src/utils/nax-project-root.ts
-import { dirname as dirname6, join as join17, resolve as resolve10 } from "path";
+import { dirname as dirname6, join as join18, resolve as resolve10 } from "path";
 async function findNaxProjectRoot(startDir) {
   let dir = resolve10(startDir);
   for (let depth = 0;depth < MAX_NAX_WALK_DEPTH; depth++) {
-    if (await _naxProjectRootDeps.exists(join17(dir, ".nax", "config.json"))) {
+    if (await _naxProjectRootDeps.exists(join18(dir, ".nax", "config.json"))) {
       return dir;
     }
     const parent = dirname6(dir);
@@ -33051,7 +33258,7 @@ var init_nax_project_root = __esm(() => {
 
 // src/review/review-audit.ts
 import { mkdir as mkdir3 } from "fs/promises";
-import { join as join18 } from "path";
+import { join as join19 } from "path";
 function auditKey(reviewer, storyId) {
   return `${reviewer}:${storyId ?? "_feature"}`;
 }
@@ -33084,15 +33291,15 @@ function toPersistedEntry(entry, epochMs) {
 async function persistReviewAudit(entry) {
   let resolvedDir;
   if (entry.outputDir) {
-    resolvedDir = join18(entry.outputDir, "review-audit", entry.featureName ?? "_unknown");
+    resolvedDir = join19(entry.outputDir, "review-audit", entry.featureName ?? "_unknown");
   } else {
     const projectRoot = entry.projectDir ?? await _reviewAuditDeps.findNaxProjectRoot(entry.workdir);
-    resolvedDir = join18(projectRoot, ".nax", "review-audit", entry.featureName ?? "_unknown");
+    resolvedDir = join19(projectRoot, ".nax", "review-audit", entry.featureName ?? "_unknown");
   }
   await _reviewAuditDeps.mkdir(resolvedDir);
   const epochMs = _reviewAuditDeps.now();
   const filename = `${epochMs}-${entry.sessionName}.json`;
-  await _reviewAuditDeps.writeFile(join18(resolvedDir, filename), toPersistedEntry(entry, epochMs));
+  await _reviewAuditDeps.writeFile(join19(resolvedDir, filename), toPersistedEntry(entry, epochMs));
 }
 function createNoOpReviewAuditor() {
   return {
@@ -33693,6 +33900,17 @@ function createDrainDeadline(deadlineMs) {
 }
 async function runQualityCommand(opts) {
   const { commandName, command, workdir, storyId, timeoutMs = DEFAULT_TIMEOUT_MS, env: env2, stripEnvVars } = opts;
+  if (!command || command.trim() === "") {
+    return {
+      commandName,
+      command,
+      success: false,
+      exitCode: -1,
+      output: `[nax] ${commandName} skipped: empty command`,
+      durationMs: 0,
+      timedOut: false
+    };
+  }
   const startTime = Date.now();
   const logger = getSafeLogger();
   logger?.info("quality", `Running ${commandName}`, { storyId, commandName, command, workdir });
@@ -33807,7 +34025,7 @@ __export(exports_command_resolver, {
   resolveQualityTestCommands: () => resolveQualityTestCommands,
   _commandResolverDeps: () => _commandResolverDeps
 });
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 async function resolveQualityTestCommands(config2, workdir, storyWorkdir) {
   const rawTestCommand = config2.review?.commands?.test ?? config2.quality?.commands?.test;
   const rawScopedTemplate = config2.quality?.commands?.testScoped;
@@ -33834,7 +34052,7 @@ var init_command_resolver = __esm(() => {
   _commandResolverDeps = {
     readPackageName: async (dir) => {
       try {
-        const content = await Bun.file(join19(dir, "package.json")).json();
+        const content = await Bun.file(join20(dir, "package.json")).json();
         return typeof content.name === "string" ? content.name : null;
       } catch {
         return null;
@@ -34283,7 +34501,7 @@ ${outputFormat}`, overridable: false }
 });
 
 // src/operations/plan-refine.ts
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function hasToken(text, tokens) {
   const lower = text.toLowerCase();
   return tokens.some((token) => lower.includes(token));
@@ -34375,7 +34593,7 @@ async function normalizeStoryFiles(story, workdir, fileExists, upstreamProduced)
   for (const entry of contextFiles) {
     const filePath = typeof entry === "string" ? entry : entry.path;
     const factId = typeof entry === "string" ? undefined : entry.factId;
-    if (expected.has(filePath) || await fileExists(join20(workdir, filePath))) {
+    if (expected.has(filePath) || await fileExists(join21(workdir, filePath))) {
       kept.push(entry);
       continue;
     }
@@ -35527,11 +35745,11 @@ function extractTestCode(output) {
 
 // src/acceptance/generator.ts
 import { existsSync as existsSync5 } from "fs";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function resolvePytestBin(packageDir) {
   if (packageDir) {
     for (const venvDir of [".venv", "venv", "env"]) {
-      const candidate = join21(packageDir, venvDir, "bin", "pytest");
+      const candidate = join22(packageDir, venvDir, "bin", "pytest");
       if (existsSync5(candidate))
         return candidate;
     }
@@ -37117,6 +37335,7 @@ var init_write_test = __esm(() => {
     stage: "run",
     session: { role: "test-writer", lifetime: "warm" },
     config: tddConfigSelector,
+    model: (_input, ctx) => ctx.config.tdd?.sessionTiers?.testWriter,
     keepOpen: (_input, ctx) => shouldKeepSessionOpen(ctx.config, "test-writer"),
     build(input, _ctx) {
       if (input.promptMarkdown?.trim()) {
@@ -37177,6 +37396,7 @@ var init_implement = __esm(() => {
     stage: "run",
     session: { role: "implementer", lifetime: "warm" },
     config: tddConfigSelector,
+    model: (input) => input.story.routing?.modelTier,
     keepOpen: (_input, ctx) => shouldKeepSessionOpen(ctx.config, "implementer"),
     build(input, _ctx) {
       if (input.promptMarkdown?.trim()) {
@@ -37574,6 +37794,7 @@ var init_verify = __esm(() => {
     stage: "verify",
     session: { role: "verifier", lifetime: "fresh" },
     config: tddConfigSelector,
+    model: (_input, ctx) => ctx.config.tdd?.sessionTiers?.verifier,
     retry: makeParseRetryStrategy({
       validate: (parsed) => {
         if (!parsed || typeof parsed !== "object")
@@ -38140,14 +38361,14 @@ var init_plan_critic_llm = __esm(() => {
 
 // src/context/greenfield.ts
 import { readdir as readdir2 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 async function scanForTestFiles(dir, testPatterns, isRootCall = true) {
   const results = [];
   const ignoreDirs = new Set(["node_modules", "dist", "build", ".next", ".git"]);
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join22(dir, entry.name);
+      const fullPath = join23(dir, entry.name);
       if (entry.isDirectory()) {
         if (ignoreDirs.has(entry.name))
           continue;
@@ -38352,13 +38573,13 @@ __export(exports_runners, {
   _regressionRunnerDeps: () => _regressionRunnerDeps
 });
 import { existsSync as existsSync6 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 async function verifyAssets(workingDirectory, expectedFiles) {
   if (!expectedFiles || expectedFiles.length === 0)
     return { success: true, missingFiles: [] };
   const missingFiles = [];
   for (const file3 of expectedFiles) {
-    if (!existsSync6(join23(workingDirectory, file3)))
+    if (!existsSync6(join24(workingDirectory, file3)))
       missingFiles.push(file3);
   }
   if (missingFiles.length > 0) {
@@ -38484,7 +38705,7 @@ var init_full_suite_gate = __esm(() => {
   _fullSuiteGateDeps = {
     resolveGateContext: async (input, ctx) => {
       const { resolveQualityTestCommands: resolveQualityTestCommands2 } = await Promise.resolve().then(() => (init_command_resolver(), exports_command_resolver));
-      const config2 = ctx.runtime.configLoader.current();
+      const config2 = ctx.packageView.config;
       const fullSuiteTimeout = config2.execution?.regressionGate?.timeoutSeconds ?? config2.execution?.rectification?.fullSuiteTimeoutSeconds ?? 300;
       const { testCommand: resolvedTestCmd } = await resolveQualityTestCommands2(config2, input.workdir, input.story.workdir);
       if (!resolvedTestCmd) {
@@ -38533,7 +38754,7 @@ var init_full_suite_gate = __esm(() => {
     config: fullSuiteGateConfigSelector,
     async execute(input, ctx, deps = _fullSuiteGateDeps) {
       const logger = getLogger();
-      const ctxConfig = ctx.config;
+      const ctxConfig = ctx.packageView.config;
       const enabled = ctxConfig?.execution?.regressionGate?.enabled ?? true;
       if (!enabled) {
         logger.info("verify[regression]", "Regression gate disabled \u2014 skipping full-suite run", {
@@ -38804,7 +39025,7 @@ var init_apply_test_edit_declarations = __esm(() => {
 });
 
 // src/operations/validate-mock-structure-files.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 async function validateMockStructureFiles(declarations, resolvedTestPatterns, packageDir, deps) {
   const fileExists = deps?.fileExists ?? defaultFileExists;
   const valid = [];
@@ -38817,7 +39038,7 @@ async function validateMockStructureFiles(declarations, resolvedTestPatterns, pa
     const files = d.files ?? [d.file];
     let allValid = true;
     for (const file3 of files) {
-      const absolutePath = join24(packageDir, file3);
+      const absolutePath = join25(packageDir, file3);
       const exists = await fileExists(absolutePath);
       if (!exists) {
         allValid = false;
@@ -38840,6 +39061,159 @@ async function validateMockStructureFiles(declarations, resolvedTestPatterns, pa
 var defaultFileExists = (p) => Bun.file(p).exists();
 var init_validate_mock_structure_files = () => {};
 
+// src/prompts/builders/setup-builder.ts
+function formatPackageFacts(pkg) {
+  const lines = [`  Package: ${pkg.relativeDir || "(root)"}`];
+  if (pkg.testFramework)
+    lines.push(`    Test framework: ${pkg.testFramework}`);
+  if (pkg.testFilePatterns.length > 0) {
+    lines.push(`    Test patterns: ${pkg.testFilePatterns.slice(0, 4).join(", ")}`);
+  }
+  if (pkg.missingScripts.length > 0) {
+    lines.push(`    Missing scripts: ${pkg.missingScripts.join(", ")}`);
+  } else {
+    lines.push("    Missing scripts: (none \u2014 all canonical scripts present)");
+  }
+  return lines.join(`
+`);
+}
+
+class SetupPromptBuilder {
+  build(analysis) {
+    const isMonoRepo = analysis.shape === "mono";
+    const packageFacts = analysis.packages.map(formatPackageFacts).join(`
+
+`);
+    return {
+      role: {
+        id: "setup-role",
+        content: "You are an expert nax configuration generator. Generate a valid nax config JSON based on the repository analysis provided. Only reference scripts that actually exist \u2014 any script listed under 'Missing scripts' must NOT appear in quality.commands.",
+        overridable: false
+      },
+      task: {
+        id: "setup-task",
+        content: [
+          `Generate a nax configuration for this ${isMonoRepo ? "monorepo" : "single-package"} repository.`,
+          "",
+          "Repository facts:",
+          `- Shape: ${analysis.shape}`,
+          `- Package manager: ${analysis.pmRunPrefix}`,
+          `- DLX runner: ${analysis.pmDlx}`,
+          `- Orchestrator: ${analysis.orchestrator}`,
+          "",
+          "Per-package facts:",
+          packageFacts,
+          "",
+          "IMPORTANT: A script listed under 'Missing scripts' does NOT exist in that package's package.json.",
+          "Do NOT include commands for missing scripts in quality.commands.",
+          "",
+          isMonoRepo ? 'Respond with a JSON code block: { "config": <root NaxConfig>, "monoConfigs": [{ "relativeDir": "<pkg>", "config": <partial NaxConfig> }] }' : 'Respond with a JSON code block: { "config": <NaxConfig> }'
+        ].join(`
+`),
+        overridable: false
+      }
+    };
+  }
+}
+
+// src/operations/setup-generate.ts
+function throwSetupPlanError(message) {
+  throw new NaxError(`[setup-generate] ${message}`, "SETUP_PLAN_INVALID");
+}
+function validateSetupOutput(parsed) {
+  const config2 = parsed?.config ?? parsed;
+  return NaxConfigSchema.safeParse(config2).success;
+}
+function crossCheckCommands(config2, analysis) {
+  const rootPkg = analysis.packages.find((p) => p.relativeDir === "") ?? analysis.packages[0];
+  const missing = new Set(rootPkg?.missingScripts ?? []);
+  if (missing.size === 0)
+    return { config: config2, gaps: [] };
+  const quality = config2.quality;
+  if (!quality?.commands)
+    return { config: config2, gaps: [] };
+  const gaps = [];
+  const commands = {};
+  for (const [key, value] of Object.entries(quality.commands)) {
+    if (missing.has(key)) {
+      gaps.push(`Script "${key}" in quality.commands.${key} is missing from package.json`);
+    } else {
+      commands[key] = value;
+    }
+  }
+  if (gaps.length === 0)
+    return { config: config2, gaps: [] };
+  return { config: { ...config2, quality: { ...quality, commands } }, gaps };
+}
+function buildMonoConfigs(parsed, analysis) {
+  if (analysis.shape !== "mono")
+    return [];
+  const rawMonoConfigs = parsed.monoConfigs ?? [];
+  return analysis.packages.map((pkg) => {
+    const rawMono = rawMonoConfigs.find((m) => m.relativeDir === pkg.relativeDir);
+    const validated = rawMono ? NaxConfigSchema.safeParse(rawMono.config) : undefined;
+    if (rawMono && !validated?.success) {
+      getLogger().warn("setup-generate", "Per-package config failed schema validation \u2014 using empty config", {
+        storyId: "setup",
+        relativeDir: pkg.relativeDir
+      });
+    }
+    const config2 = (validated?.success ? validated.data : undefined) ?? {};
+    return { relativeDir: pkg.relativeDir, config: config2 };
+  });
+}
+var MAX_SETUP_LLM_ATTEMPTS = 2, SetupPlanError, setupRetryStrategy, setupGenerateOp;
+var init_setup_generate = __esm(() => {
+  init_retry();
+  init_schemas3();
+  init_errors();
+  init_logger2();
+  SetupPlanError = class SetupPlanError extends ParseValidationError {
+    code = "SETUP_PLAN_INVALID";
+  };
+  setupRetryStrategy = makeParseRetryStrategy({
+    reviewerKind: "setup-generate",
+    maxAttempts: MAX_SETUP_LLM_ATTEMPTS,
+    validate: validateSetupOutput,
+    prompts: {
+      invalid: () => "The response was not valid JSON or failed schema validation. Please respond with a valid JSON object.",
+      truncated: () => "The response was truncated. Please provide the complete JSON config."
+    },
+    exhaustedFallback: () => {
+      throwSetupPlanError("LLM failed to generate a valid setup plan after exhausting retries");
+    }
+  });
+  setupGenerateOp = {
+    kind: "run",
+    name: "setup-generate",
+    stage: "setup",
+    session: { role: "setup", lifetime: "fresh" },
+    noFallback: true,
+    config: ["quality"],
+    retry: setupRetryStrategy,
+    build(analysis, _ctx) {
+      return new SetupPromptBuilder().build(analysis);
+    },
+    parse(output, analysis, _ctx) {
+      let parsedRaw;
+      try {
+        parsedRaw = parseLLMJson(output);
+      } catch {
+        throw new SetupPlanError("Failed to parse LLM output as JSON");
+      }
+      const parsedObj = parsedRaw;
+      const rawConfig = parsedObj?.config ?? parsedRaw;
+      const result = NaxConfigSchema.safeParse(rawConfig);
+      if (!result.success) {
+        throw new SetupPlanError(`Config failed NaxConfigSchema: ${result.error.message}`);
+      }
+      const { config: config2, gaps } = crossCheckCommands(result.data, analysis);
+      const monoConfigs = buildMonoConfigs(parsedObj ?? { config: rawConfig }, analysis);
+      return { config: config2, monoConfigs, gaps };
+    }
+  };
+});
+
 // src/operations/declaration-sink.ts
 function makeDeclarationSink() {
   return { testEdits: [], mockHandoffs: [] };
@@ -38886,9 +39260,9 @@ var init_mechanical_lintfix_strategy = __esm(() => {
     stage: "rectification",
     config: qualityConfigSelector,
     async execute(input, ctx, deps = _mechanicalLintFixDeps) {
-      const ctxConfig = ctx.config;
-      const broad = ctxConfig?.quality?.commands?.lintFix;
-      const scoped2 = ctxConfig?.quality?.commands?.lintFixScoped;
+      const quality = ctx.packageView.select(qualityConfigSelector).quality;
+      const broad = quality?.commands?.lintFix;
+      const scoped2 = quality?.commands?.lintFixScoped;
       const command = buildCommand(broad, scoped2, input.scopeFiles);
       if (!command)
         return { applied: true, exitCode: 0 };
@@ -38897,7 +39271,7 @@ var init_mechanical_lintfix_strategy = __esm(() => {
         command,
         workdir: input.workdir,
         storyId: input.storyId,
-        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
+        stripEnvVars: quality?.stripEnvVars ?? []
       });
       return { applied: true, exitCode: result.exitCode };
     }
@@ -38945,9 +39319,9 @@ var init_mechanical_formatfix_strategy = __esm(() => {
     stage: "rectification",
     config: qualityConfigSelector,
     async execute(input, ctx, deps = _mechanicalFormatFixDeps) {
-      const ctxConfig = ctx.config;
-      const broad = ctxConfig?.quality?.commands?.formatFix;
-      const scoped2 = ctxConfig?.quality?.commands?.formatFixScoped;
+      const quality = ctx.packageView.select(qualityConfigSelector).quality;
+      const broad = quality?.commands?.formatFix;
+      const scoped2 = quality?.commands?.formatFixScoped;
       const command = buildCommand2(broad, scoped2, input.scopeFiles);
       if (!command)
         return { applied: true, exitCode: 0 };
@@ -38956,7 +39330,7 @@ var init_mechanical_formatfix_strategy = __esm(() => {
         command,
         workdir: input.workdir,
         storyId: input.storyId,
-        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
+        stripEnvVars: quality?.stripEnvVars ?? []
       });
       return { applied: true, exitCode: result.exitCode };
     }
@@ -38967,6 +39341,7 @@ var init_mechanical_formatfix_strategy = __esm(() => {
 var _lintCheckDeps, lintCheckOp;
 var init_lint_check = __esm(() => {
   init_config();
+  init_logger2();
   init_runner();
   init_lint_parsing();
   _lintCheckDeps = {
@@ -38979,21 +39354,25 @@ var init_lint_check = __esm(() => {
     stage: "review",
     config: qualityConfigSelector,
     async execute(input, ctx, deps = _lintCheckDeps) {
-      const ctxConfig = ctx.config;
-      const command = ctxConfig?.quality?.commands?.lint;
-      if (ctxConfig !== undefined && !command) {
-        return { success: true, findings: [], durationMs: 0 };
+      const quality = ctx.packageView.select(qualityConfigSelector).quality;
+      const command = quality?.commands?.lint;
+      if (!command) {
+        getSafeLogger()?.warn("quality", "No lint command configured \u2014 skipping lint gate", {
+          storyId: input.storyId,
+          packageDir: ctx.packageView.packageDir
+        });
+        return { success: true, status: "skipped", findings: [], durationMs: 0 };
       }
       const start = Date.now();
       const result = await deps.runQualityCommand({
         commandName: "lint",
-        command: command ?? "",
+        command,
         workdir: input.workdir,
         storyId: input.storyId,
-        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
+        stripEnvVars: quality?.stripEnvVars ?? []
       });
       if (result.exitCode === 0) {
-        return { success: true, findings: [], durationMs: Date.now() - start };
+        return { success: true, status: "passed", findings: [], durationMs: Date.now() - start };
       }
       const parsed = deps.parseLintOutput(result.output, "auto", { workdir: input.workdir });
       return { success: false, findings: parsed?.findings ?? [], durationMs: Date.now() - start };
@@ -39217,6 +39596,7 @@ var init_typecheck_parsing = __esm(() => {
 var _typecheckCheckDeps, typecheckCheckOp;
 var init_typecheck_check = __esm(() => {
   init_config();
+  init_logger2();
   init_runner();
   init_typecheck_parsing();
   _typecheckCheckDeps = {
@@ -39229,21 +39609,25 @@ var init_typecheck_check = __esm(() => {
     stage: "review",
     config: qualityConfigSelector,
     async execute(input, ctx, deps = _typecheckCheckDeps) {
-      const ctxConfig = ctx.config;
-      const command = ctxConfig?.quality?.commands?.typecheck;
-      if (ctxConfig !== undefined && !command) {
-        return { success: true, findings: [], durationMs: 0 };
+      const quality = ctx.packageView.select(qualityConfigSelector).quality;
+      const command = quality?.commands?.typecheck;
+      if (!command) {
+        getSafeLogger()?.warn("quality", "No typecheck command configured \u2014 skipping typecheck gate", {
+          storyId: input.storyId,
+          packageDir: ctx.packageView.packageDir
+        });
+        return { success: true, status: "skipped", findings: [], durationMs: 0 };
       }
       const start = Date.now();
       const result = await deps.runQualityCommand({
         commandName: "typecheck",
-        command: command ?? "",
+        command,
         workdir: input.workdir,
         storyId: input.storyId,
-        stripEnvVars: ctxConfig?.quality?.stripEnvVars ?? []
+        stripEnvVars: quality?.stripEnvVars ?? []
       });
       if (result.exitCode === 0) {
-        return { success: true, findings: [], durationMs: Date.now() - start };
+        return { success: true, status: "passed", findings: [], durationMs: Date.now() - start };
       }
       const parsed = deps.parseTypecheckOutput(result.output, "auto", { workdir: input.workdir });
       return { success: false, findings: parsed?.findings ?? [], durationMs: Date.now() - start };
@@ -39272,12 +39656,16 @@ var init_verify_scoped = __esm(() => {
     config: qualityConfigSelector,
     async execute(input, ctx, deps = _verifyScopedDeps) {
       const logger = getLogger();
-      const ctxConfig = ctx.config;
-      const baseCommand = ctxConfig?.quality?.commands?.test;
-      if (!ctxConfig || !baseCommand) {
+      const quality = ctx.packageView.select(qualityConfigSelector);
+      const baseCommand = quality.quality?.commands?.test;
+      if (!baseCommand) {
+        logger.warn("quality", "No test command configured \u2014 skipping scoped verify", {
+          storyId: input.storyId,
+          packageDir: ctx.packageView.packageDir
+        });
         return {
           success: true,
-          status: "passed",
+          status: "skipped",
           findings: [],
           durationMs: 0,
           passCount: 0,
@@ -39289,11 +39677,11 @@ var init_verify_scoped = __esm(() => {
         workdir: input.workdir,
         storyId: input.storyId,
         storyGitRef: input.storyGitRef,
-        testCommand: baseCommand ?? "",
-        testScopedTemplate: ctxConfig.quality?.commands?.testScoped,
-        smartRunnerConfig: ctxConfig.execution?.smartTestRunner,
-        scopeTestThreshold: ctxConfig.quality?.scopeTestThreshold,
-        fallbackFullSuiteCommand: ctxConfig.quality?.commands?.test,
+        testCommand: baseCommand,
+        testScopedTemplate: quality.quality?.commands?.testScoped,
+        smartRunnerConfig: quality.execution?.smartTestRunner,
+        scopeTestThreshold: quality.quality?.scopeTestThreshold,
+        fallbackFullSuiteCommand: quality.quality?.commands?.test,
         naxIgnoreIndex: input.naxIgnoreIndex
       });
       if (selection.isFullSuite && regressionMode === "deferred" && !selection.isMonorepoOrchestrator && !selection.thresholdFallback) {
@@ -39320,7 +39708,7 @@ var init_verify_scoped = __esm(() => {
           command: selection.effectiveCommand
         });
       }
-      const scopedTimeout = ctxConfig.execution?.regressionGate?.timeoutSeconds ?? 600;
+      const scopedTimeout = quality.execution?.regressionGate?.timeoutSeconds ?? 600;
       logger.info("verify[scoped]", "Running scoped tests", {
         storyId: input.storyId,
         packageDir: input.packageDir,
@@ -39333,14 +39721,14 @@ var init_verify_scoped = __esm(() => {
       const result = await deps.regression({
         workdir: input.workdir,
         command: selection.effectiveCommand,
-        timeoutSeconds: ctxConfig.execution?.regressionGate?.timeoutSeconds ?? 600,
-        forceExit: ctxConfig.quality?.forceExit,
-        detectOpenHandles: ctxConfig.quality?.detectOpenHandles,
-        detectOpenHandlesRetries: ctxConfig.quality?.detectOpenHandlesRetries,
-        gracePeriodMs: ctxConfig.quality?.gracePeriodMs,
-        drainTimeoutMs: ctxConfig.quality?.drainTimeoutMs,
-        shell: ctxConfig.quality?.shell,
-        stripEnvVars: ctxConfig.quality?.stripEnvVars
+        timeoutSeconds: quality.execution?.regressionGate?.timeoutSeconds ?? 600,
+        forceExit: quality.quality?.forceExit,
+        detectOpenHandles: quality.quality?.detectOpenHandles,
+        detectOpenHandlesRetries: quality.quality?.detectOpenHandlesRetries,
+        gracePeriodMs: quality.quality?.gracePeriodMs,
+        drainTimeoutMs: quality.quality?.drainTimeoutMs,
+        shell: quality.quality?.shell,
+        stripEnvVars: quality.quality?.stripEnvVars
       });
       const durationMs = Date.now() - start;
       const parsed = result.output ? deps.parseTestOutput(result.output) : { passed: 0, failed: 0, failures: [] };
@@ -39441,6 +39829,7 @@ var init_operations = __esm(() => {
   init_autofix_test_writer_strategy();
   init_apply_test_edit_declarations();
   init_validate_mock_structure_files();
+  init_setup_generate();
   init__finding_to_check();
   init_mechanical_lintfix_strategy();
   init_mechanical_formatfix_strategy();
@@ -40111,7 +40500,7 @@ var init_lint_parsing = __esm(() => {
 });
 
 // src/review/scoped-lint.ts
-import { join as join25, relative as relative10 } from "path";
+import { join as join26, relative as relative10 } from "path";
 function shellQuotePath4(path5) {
   return `'${path5.replaceAll("'", "'\\''")}'`;
 }
@@ -40159,7 +40548,7 @@ function uniqueFiles(files) {
 async function filterFilesToScope(files, workdir, projectDir, activePackageDir) {
   const inScope = [];
   for (const relPath of files) {
-    const absPath = join25(workdir, relPath);
+    const absPath = join26(workdir, relPath);
     const exists = await _scopedLintDeps.fileExists(absPath);
     if (!exists)
       continue;
@@ -43533,7 +43922,7 @@ var init_call = __esm(() => {
 
 // src/runtime/cost-aggregator.ts
 import { mkdirSync as mkdirSync2 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 function makeCorrelationId() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -43724,7 +44113,7 @@ class CostAggregator {
       if (events.length === 0 && errors3.length === 0)
         return;
       mkdirSync2(this._drainDir, { recursive: true });
-      const path5 = join26(this._drainDir, `${this._runId}.jsonl`);
+      const path5 = join27(this._drainDir, `${this._runId}.jsonl`);
       const sorted = [...events, ...errors3].sort((a, b) => a.ts - b.ts);
       await _costAggDeps.write(path5, `${sorted.map((e) => JSON.stringify(e)).join(`
 `)}
@@ -43764,7 +44153,7 @@ var init_cost_aggregator = __esm(() => {
 // src/runtime/prompt-auditor.ts
 import { appendFileSync } from "fs";
 import { mkdir as mkdir4 } from "fs/promises";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function createNoOpPromptAuditor() {
   return {
     record() {},
@@ -43830,8 +44219,8 @@ class PromptAuditor {
   _jsonlPath;
   _featureDir;
   constructor(runId, flushDir, featureName) {
-    this._featureDir = join27(flushDir, featureName);
-    this._jsonlPath = join27(this._featureDir, `${runId}.jsonl`);
+    this._featureDir = join28(flushDir, featureName);
+    this._jsonlPath = join28(this._featureDir, `${runId}.jsonl`);
   }
   record(entry) {
     this._enqueue(entry);
@@ -43880,7 +44269,7 @@ class PromptAuditor {
     const auditEntry = entry;
     const filename = deriveTxtFilename(auditEntry);
     try {
-      await _promptAuditorDeps.write(join27(this._featureDir, filename), buildTxtContent(auditEntry));
+      await _promptAuditorDeps.write(join28(this._featureDir, filename), buildTxtContent(auditEntry));
     } catch (err) {
       throw tagAuditError(err, "txt");
     }
@@ -44015,17 +44404,44 @@ function createPackageView(config2, packageDir, repoRoot) {
 }
 function createPackageRegistry(loader, repoRoot) {
   const cache = new Map;
+  const mergedConfigs = new Map;
+  function toRelativeKey(packageDir) {
+    if (!packageDir)
+      return "";
+    const prefix = repoRoot.endsWith("/") ? repoRoot : `${repoRoot}/`;
+    if (packageDir.startsWith(prefix))
+      return packageDir.slice(prefix.length);
+    if (packageDir === repoRoot)
+      return "";
+    return packageDir;
+  }
   function resolve12(packageDir) {
-    const key = packageDir ?? "";
+    const key = toRelativeKey(packageDir);
     const cached2 = cache.get(key);
     if (cached2 !== undefined) {
       return cached2;
     }
-    const config2 = loader.current();
+    const config2 = mergedConfigs.get(key) ?? loader.current();
     const view = createPackageView(config2, key, repoRoot);
     cache.set(key, view);
     return view;
   }
+  async function hydrate(packageDirs, loadOverride2) {
+    const load = loadOverride2 ?? (await Promise.resolve().then(() => (init_config(), exports_config))).loadPackageOverride;
+    for (const dir of packageDirs) {
+      if (!dir) {
+        continue;
+      }
+      if (mergedConfigs.has(dir)) {
+        continue;
+      }
+      const override = await load(repoRoot, dir);
+      if (override !== null) {
+        mergedConfigs.set(dir, mergePackageConfig(loader.current(), override));
+        cache.delete(dir);
+      }
+    }
+  }
   return {
     all() {
       return [...cache.values()];
@@ -44033,9 +44449,13 @@ function createPackageRegistry(loader, repoRoot) {
     resolve: resolve12,
     repo() {
       return resolve12(undefined);
-    }
+    },
+    hydrate
   };
 }
+var init_packages = __esm(() => {
+  init_config();
+});
 
 // src/runtime/agent-stream-events.ts
 class AgentStreamEventBus {
@@ -44655,7 +45075,8 @@ var init_session_role = __esm(() => {
     "fix-gen",
     "auto",
     "synthesis",
-    "judge"
+    "judge",
+    "setup"
   ];
 });
 
@@ -44992,7 +45413,7 @@ var init_pid_registry = __esm(() => {
 // src/session/manager-deps.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir5 } from "fs/promises";
-import { isAbsolute as isAbsolute9, join as join28, relative as relative11, sep as sep2 } from "path";
+import { isAbsolute as isAbsolute9, join as join29, relative as relative11, sep as sep2 } from "path";
 function resolveProjectDirFromScratchDir(scratchDir) {
   const marker = `${sep2}.nax${sep2}features${sep2}`;
   const markerIdx = scratchDir.lastIndexOf(marker);
@@ -45013,7 +45434,7 @@ var init_manager_deps = __esm(() => {
     now: () => new Date().toISOString(),
     nowMs: () => Date.now(),
     uuid: () => randomUUID3(),
-    sessionScratchDir: (projectDir, featureName, sessionId) => join28(projectDir, ".nax", "features", featureName, "sessions", sessionId),
+    sessionScratchDir: (projectDir, featureName, sessionId) => join29(projectDir, ".nax", "features", featureName, "sessions", sessionId),
     writeDescriptor: async (scratchDir, descriptor, projectDir) => {
       await mkdir5(scratchDir, { recursive: true });
       const { handle: _handle, ...persistable } = descriptor;
@@ -45024,7 +45445,7 @@ var init_manager_deps = __esm(() => {
           persistable.scratchDir = toProjectRelativePath(derivedProjectDir, persistable.scratchDir);
         }
       }
-      await Bun.write(join28(scratchDir, "descriptor.json"), JSON.stringify(persistable, null, 2));
+      await Bun.write(join29(scratchDir, "descriptor.json"), JSON.stringify(persistable, null, 2));
     }
   };
 });
@@ -45775,7 +46196,7 @@ __export(exports_runtime, {
   CostAggregator: () => CostAggregator,
   AgentStreamEventBus: () => AgentStreamEventBus
 });
-import { basename as basename5, join as join29 } from "path";
+import { basename as basename5, join as join30 } from "path";
 function createRuntime(config2, workdir, opts) {
   const runId = crypto.randomUUID();
   const controller = new AbortController;
@@ -45791,10 +46212,10 @@ function createRuntime(config2, workdir, opts) {
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
   const globalDir = globalOutputDir();
   const curatorRollupPathValue = curatorRollupPath(globalDir, config2.curator?.rollupPath);
-  const costDir = join29(outputDir, "cost");
+  const costDir = join30(outputDir, "cost");
   const costAggregator = opts?.costAggregator ?? new CostAggregator(runId, costDir);
   const auditEnabled = config2.agent?.promptAudit?.enabled ?? false;
-  const auditDir = config2.agent?.promptAudit?.dir ?? join29(outputDir, "prompt-audit");
+  const auditDir = config2.agent?.promptAudit?.dir ?? join30(outputDir, "prompt-audit");
   let promptAuditor;
   if (opts?.promptAuditor) {
     promptAuditor = opts.promptAuditor;
@@ -45900,6 +46321,7 @@ var init_runtime = __esm(() => {
   init_prompt_auditor();
   init_review_audit();
   init_paths2();
+  init_packages();
   init_dispatch_events();
   init_agent_stream_events();
   init_middleware();
@@ -45917,6 +46339,7 @@ var init_runtime = __esm(() => {
   init_cost_aggregator();
   init_dispatch_events();
   init_middleware();
+  init_packages();
   init_paths2();
   init_prompt_auditor();
   init_session_run_hop();
@@ -45945,9 +46368,9 @@ async function allSettledBounded(tasks, limit) {
 
 // src/context/injector.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 async function detectNode(workdir) {
-  const pkgPath = join30(workdir, "package.json");
+  const pkgPath = join31(workdir, "package.json");
   if (!existsSync8(pkgPath))
     return null;
   try {
@@ -45964,7 +46387,7 @@ async function detectNode(workdir) {
   }
 }
 async function detectGo(workdir) {
-  const goMod = join30(workdir, "go.mod");
+  const goMod = join31(workdir, "go.mod");
   if (!existsSync8(goMod))
     return null;
   try {
@@ -45988,7 +46411,7 @@ async function detectGo(workdir) {
   }
 }
 async function detectRust(workdir) {
-  const cargoPath = join30(workdir, "Cargo.toml");
+  const cargoPath = join31(workdir, "Cargo.toml");
   if (!existsSync8(cargoPath))
     return null;
   try {
@@ -46004,8 +46427,8 @@ async function detectRust(workdir) {
   }
 }
 async function detectPython(workdir) {
-  const pyproject = join30(workdir, "pyproject.toml");
-  const requirements = join30(workdir, "requirements.txt");
+  const pyproject = join31(workdir, "pyproject.toml");
+  const requirements = join31(workdir, "requirements.txt");
   if (!existsSync8(pyproject) && !existsSync8(requirements))
     return null;
   try {
@@ -46024,7 +46447,7 @@ async function detectPython(workdir) {
   }
 }
 async function detectPhp(workdir) {
-  const composerPath = join30(workdir, "composer.json");
+  const composerPath = join31(workdir, "composer.json");
   if (!existsSync8(composerPath))
     return null;
   try {
@@ -46037,7 +46460,7 @@ async function detectPhp(workdir) {
   }
 }
 async function detectRuby(workdir) {
-  const gemfile = join30(workdir, "Gemfile");
+  const gemfile = join31(workdir, "Gemfile");
   if (!existsSync8(gemfile))
     return null;
   try {
@@ -46049,9 +46472,9 @@ async function detectRuby(workdir) {
   }
 }
 async function detectJvm(workdir) {
-  const pom = join30(workdir, "pom.xml");
-  const gradle = join30(workdir, "build.gradle");
-  const gradleKts = join30(workdir, "build.gradle.kts");
+  const pom = join31(workdir, "pom.xml");
+  const gradle = join31(workdir, "build.gradle");
+  const gradleKts = join31(workdir, "build.gradle.kts");
   if (!existsSync8(pom) && !existsSync8(gradle) && !existsSync8(gradleKts))
     return null;
   try {
@@ -46059,7 +46482,7 @@ async function detectJvm(workdir) {
       const content2 = await Bun.file(pom).text();
       const nameMatch = content2.match(/<artifactId>([^<]+)<\/artifactId>/);
       const deps2 = [...content2.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1]).filter((d) => d !== nameMatch?.[1]).slice(0, 10);
-      const lang2 = existsSync8(join30(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
+      const lang2 = existsSync8(join31(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
       return { name: nameMatch?.[1], lang: lang2, dependencies: deps2 };
     }
     const gradleFile = existsSync8(gradleKts) ? gradleKts : gradle;
@@ -46313,7 +46736,7 @@ var init_windsurf = __esm(() => {
 
 // src/context/generator.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join31, relative as relative12 } from "path";
+import { join as join32, relative as relative12 } from "path";
 async function loadContextContent(options, config2) {
   if (!_generatorDeps.existsSync(options.contextPath)) {
     throw new Error(`Context file not found: ${options.contextPath}`);
@@ -46331,7 +46754,7 @@ async function generateFor(agent, options, config2) {
   try {
     const context = await loadContextContent(options, config2);
     const content = generator.generate(context);
-    const outputPath = join31(options.outputDir, generator.outputFile);
+    const outputPath = join32(options.outputDir, generator.outputFile);
     validateFilePath(outputPath, options.outputDir);
     if (!options.dryRun) {
       await _generatorDeps.writeFile(outputPath, content);
@@ -46349,7 +46772,7 @@ async function generateAll(options, config2, agentFilter) {
   for (const [agentKey, generator] of entries) {
     try {
       const content = generator.generate(context);
-      const outputPath = join31(options.outputDir, generator.outputFile);
+      const outputPath = join32(options.outputDir, generator.outputFile);
       validateFilePath(outputPath, options.outputDir);
       if (!options.dryRun) {
         await _generatorDeps.writeFile(outputPath, content);
@@ -46369,7 +46792,7 @@ async function discoverPackages(repoRoot) {
     const glob = new Bun.Glob(pattern);
     for await (const match of glob.scan({ cwd: repoRoot, dot: true })) {
       const pkgRelative = match.replace(/^\.nax\/mono\//, "").replace(/\/context\.md$/, "");
-      const pkgAbsolute = join31(repoRoot, pkgRelative);
+      const pkgAbsolute = join32(repoRoot, pkgRelative);
       if (!seen.has(pkgAbsolute)) {
         seen.add(pkgAbsolute);
         packages.push(pkgAbsolute);
@@ -46401,14 +46824,14 @@ async function discoverWorkspacePackages2(repoRoot) {
       }
     }
   }
-  const turboPath = join31(repoRoot, "turbo.json");
+  const turboPath = join32(repoRoot, "turbo.json");
   try {
     const turbo = JSON.parse(await _generatorDeps.readTextFile(turboPath));
     if (Array.isArray(turbo.packages)) {
       await resolveGlobs(turbo.packages);
     }
   } catch {}
-  const pkgPath = join31(repoRoot, "package.json");
+  const pkgPath = join32(repoRoot, "package.json");
   try {
     const pkg = JSON.parse(await _generatorDeps.readTextFile(pkgPath));
     const ws = pkg.workspaces;
@@ -46416,7 +46839,7 @@ async function discoverWorkspacePackages2(repoRoot) {
     if (patterns.length > 0)
       await resolveGlobs(patterns);
   } catch {}
-  const pnpmPath = join31(repoRoot, "pnpm-workspace.yaml");
+  const pnpmPath = join32(repoRoot, "pnpm-workspace.yaml");
   try {
     const raw = await _generatorDeps.readTextFile(pnpmPath);
     const lines = raw.split(`
@@ -46442,7 +46865,7 @@ async function discoverWorkspacePackages2(repoRoot) {
 async function generateForPackage(packageDir, config2, dryRun = false, repoRoot) {
   const resolvedRepoRoot = repoRoot ?? packageDir;
   const relativePkgPath = relative12(resolvedRepoRoot, packageDir);
-  const contextPath = join31(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
+  const contextPath = join32(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
   if (!_generatorDeps.existsSync(contextPath)) {
     return [
       {
@@ -46510,7 +46933,7 @@ var init_generator2 = __esm(() => {
 });
 
 // src/analyze/scanner.ts
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 function resolveFrameworkAndRunner(language, pkg) {
   if (language === "go")
     return { framework: "", testRunner: "go-test" };
@@ -46532,7 +46955,7 @@ async function scanSourceRoots(workdir) {
     });
     try {
       const language = await deps.detectLanguage(workdir);
-      const pkg = await deps.readPackageJson(join32(workdir, "package.json"));
+      const pkg = await deps.readPackageJson(join33(workdir, "package.json"));
       const { framework, testRunner } = resolveFrameworkAndRunner(language, pkg);
       return [{ path: ".", language, framework, testRunner }];
     } catch {
@@ -46550,9 +46973,9 @@ async function scanSourceRoots(workdir) {
     packages = packages.slice(0, MAX_SOURCE_ROOTS);
   }
   return Promise.all(packages.map(async (pkgPath) => {
-    const pkgDir = pkgPath === "." ? workdir : join32(workdir, pkgPath);
+    const pkgDir = pkgPath === "." ? workdir : join33(workdir, pkgPath);
     const language = await deps.detectLanguage(pkgDir);
-    const pkg = await deps.readPackageJson(join32(pkgDir, "package.json"));
+    const pkg = await deps.readPackageJson(join33(pkgDir, "package.json"));
     const { framework, testRunner } = resolveFrameworkAndRunner(language, pkg);
     return { path: pkgPath, language, framework, testRunner };
   }));
@@ -46585,7 +47008,7 @@ var init_analyze = __esm(() => {
 });
 
 // src/debate/pre-phase/grounder.ts
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 async function buildCodebaseContext(workdir) {
   const roots = await _grounderDeps.scanSourceRoots(workdir);
   return buildSourceRootsSection(normalizeRoots(workdir, roots));
@@ -46597,7 +47020,7 @@ function normalizeRoots(workdir, roots) {
   }));
 }
 async function writeManifestArtifact(ctx, manifest) {
-  const manifestPath = join33(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
+  const manifestPath = join34(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
   await _grounderDeps.write(manifestPath, JSON.stringify(manifest, null, 2));
 }
 var _grounderDeps, grounderStrategy = async (ctx) => {
@@ -46940,7 +47363,7 @@ function formatSpecDeltas(blockers, manifest) {
 
 // src/debate/verifiers/checks.ts
 import { existsSync as defaultExistsSync } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function checkFilesExist(prd, workdir, deps) {
   const existsSync10 = deps?.existsSync ?? defaultExistsSync;
   const findings = [];
@@ -46950,7 +47373,7 @@ function checkFilesExist(prd, workdir, deps) {
     for (const entry of story.contextFiles) {
       const filePath = typeof entry === "string" ? entry : entry.path;
       const factId = typeof entry === "string" ? undefined : entry.factId;
-      const absPath = join34(workdir, filePath);
+      const absPath = join35(workdir, filePath);
       if (existsSync10(absPath))
         continue;
       if (factId) {
@@ -47061,7 +47484,7 @@ var init_checks3 = () => {};
 
 // src/debate/verifiers/plan-checklist.ts
 import { existsSync as existsSync10 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 function parsePrd(output) {
   if (!output)
     return null;
@@ -47072,7 +47495,7 @@ function parsePrd(output) {
   }
 }
 async function loadManifest(ctx) {
-  const manifestPath = join35(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
+  const manifestPath = join36(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "facts-manifest.json");
   const raw = await _planChecklistDeps.readFile(manifestPath);
   if (!raw)
     return null;
@@ -47085,7 +47508,7 @@ async function loadManifest(ctx) {
   }
 }
 async function emitSpecDeltas(ctx, blockers, manifest) {
-  const artifactPath = join35(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "spec-deltas.md");
+  const artifactPath = join36(ctx.workdir, ".nax", "runs", ctx.ctx.runtime.runId, "plan", ctx.storyId, "spec-deltas.md");
   const content = formatSpecDeltas(blockers, manifest ?? { repoFacts: [], specClaims: [], gaps: [] });
   await _planChecklistDeps.write(artifactPath, content);
   return artifactPath;
@@ -47431,7 +47854,7 @@ var init_runner_plan_helpers = __esm(() => {
 });
 
 // src/debate/runner-plan.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 async function runPlan(ctx, taskContext, outputFormat, opts) {
   const logger = _debateSessionDeps.getSafeLogger();
   const config2 = ctx.stageConfig;
@@ -47490,7 +47913,7 @@ async function runPlan(ctx, taskContext, outputFormat, opts) {
     sessionMode: ctx.stageConfig.sessionMode ?? "one-shot",
     proposers: ctx.stageConfig.proposers
   });
-  const outputPaths = resolved.map((_, i) => join36(opts.outputDir, `prd-debate-${i}.json`));
+  const outputPaths = resolved.map((_, i) => join37(opts.outputDir, `prd-debate-${i}.json`));
   const successful = [];
   let rebuttalList;
   if (selectorKind === "verifier-pick") {
@@ -49733,9 +50156,9 @@ function validateFeatureName(feature) {
 
 // src/plan/critic.ts
 import { mkdir as mkdir6 } from "fs/promises";
-import { dirname as dirname7, join as join39 } from "path";
+import { dirname as dirname7, join as join40 } from "path";
 async function writeSpecDeltas(findings, workdir, runId, storyId, manifest) {
-  const path7 = join39(workdir, ".nax", "runs", runId, "plan", storyId, "spec-deltas.md");
+  const path7 = join40(workdir, ".nax", "runs", runId, "plan", storyId, "spec-deltas.md");
   await mkdir6(dirname7(path7), { recursive: true });
   await Bun.write(path7, formatSpecDeltas(findings, manifest));
   return path7;
@@ -50948,9 +51371,9 @@ __export(exports_plan_decompose, {
   runReplanLoop: () => runReplanLoop,
   planDecomposeCommand: () => planDecomposeCommand
 });
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 async function planDecomposeCommand(workdir, config2, options) {
-  const prdPath = join40(workdir, ".nax", "features", options.feature, "prd.json");
+  const prdPath = join41(workdir, ".nax", "features", options.feature, "prd.json");
   if (!_planDeps.existsSync(prdPath)) {
     throw new NaxError(`PRD not found: ${prdPath}`, "PRD_NOT_FOUND", {
       stage: "decompose",
@@ -51124,7 +51547,7 @@ var init_plan_decompose = __esm(() => {
 
 // src/cli/plan-runtime.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join41 } from "path";
+import { join as join42 } from "path";
 function isRuntimeWithAgentManager(value) {
   return typeof value === "object" && value !== null && "agentManager" in value;
 }
@@ -51176,7 +51599,7 @@ var init_plan_runtime = __esm(() => {
     writeFile: (path7, content) => Bun.write(path7, content).then(() => {}),
     scanSourceRoots: (workdir) => scanSourceRoots(workdir),
     createRuntime: (cfg, wd, featureName) => createRuntime(cfg, wd, { featureName }),
-    readPackageJson: (workdir) => Bun.file(join41(workdir, "package.json")).json().catch(() => null),
+    readPackageJson: (workdir) => Bun.file(join42(workdir, "package.json")).json().catch(() => null),
     spawnSync: (cmd, opts) => {
       const result = Bun.spawnSync(cmd, opts ? { cwd: opts.cwd } : {});
       return { stdout: result.stdout, exitCode: result.exitCode };
@@ -51561,7 +51984,7 @@ var init_metrics = __esm(() => {
 
 // src/commands/common.ts
 import { existsSync as existsSync16, readdirSync as readdirSync2, realpathSync as realpathSync3 } from "fs";
-import { join as join42, resolve as resolve13 } from "path";
+import { join as join43, resolve as resolve13 } from "path";
 function resolveProject(options = {}) {
   const { dir, feature } = options;
   let projectRoot;
@@ -51569,12 +51992,12 @@ function resolveProject(options = {}) {
   let configPath;
   if (dir) {
     projectRoot = realpathSync3(resolve13(dir));
-    naxDir = join42(projectRoot, ".nax");
+    naxDir = join43(projectRoot, ".nax");
     if (!existsSync16(naxDir)) {
       throw new NaxError(`Directory does not contain a nax project: ${projectRoot}
 Expected to find: ${naxDir}`, "NAX_DIR_NOT_FOUND", { projectRoot, naxDir });
     }
-    configPath = join42(naxDir, "config.json");
+    configPath = join43(naxDir, "config.json");
     if (!existsSync16(configPath)) {
       throw new NaxError(`.nax directory found but config.json is missing: ${naxDir}
 Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
@@ -51582,17 +52005,17 @@ Expected to find: ${configPath}`, "CONFIG_NOT_FOUND", { naxDir, configPath });
   } else {
     const found = findProjectRoot(process.cwd());
     if (!found) {
-      const cwdNaxDir = join42(process.cwd(), ".nax");
+      const cwdNaxDir = join43(process.cwd(), ".nax");
       if (existsSync16(cwdNaxDir)) {
-        const cwdConfigPath = join42(cwdNaxDir, "config.json");
+        const cwdConfigPath = join43(cwdNaxDir, "config.json");
         throw new NaxError(`.nax directory found but config.json is missing: ${cwdNaxDir}
 Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, configPath: cwdConfigPath });
       }
       throw new NaxError("No nax project found. Run this command from within a nax project directory, or use -d flag to specify the project path.", "PROJECT_NOT_FOUND", { cwd: process.cwd() });
     }
     projectRoot = found;
-    naxDir = join42(projectRoot, ".nax");
-    configPath = join42(naxDir, "config.json");
+    naxDir = join43(projectRoot, ".nax");
+    configPath = join43(naxDir, "config.json");
   }
   let featureDir;
   if (feature) {
@@ -51601,8 +52024,8 @@ Expected to find: ${cwdConfigPath}`, "CONFIG_NOT_FOUND", { naxDir: cwdNaxDir, co
     } catch (error48) {
       throw new NaxError(error48.message, "FEATURE_INVALID", { feature });
     }
-    const featuresDir = join42(naxDir, "features");
-    featureDir = join42(featuresDir, feature);
+    const featuresDir = join43(naxDir, "features");
+    featureDir = join43(featuresDir, feature);
     if (!existsSync16(featureDir)) {
       const availableFeatures = existsSync16(featuresDir) ? readdirSync2(featuresDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name) : [];
       const availableMsg = availableFeatures.length > 0 ? `
@@ -51635,7 +52058,7 @@ async function resolveProjectAsync(options = {}) {
   }
   const isPlainName = !dir.includes("/") && !dir.includes("\\");
   if (isPlainName) {
-    const registryIdentityPath = join42(globalConfigDir(), dir, ".identity");
+    const registryIdentityPath = join43(globalConfigDir(), dir, ".identity");
     const identityFile = Bun.file(registryIdentityPath);
     if (await identityFile.exists()) {
       try {
@@ -51667,12 +52090,12 @@ function findProjectRoot(startDir) {
   let current = resolve13(startDir);
   let depth = 0;
   while (depth < MAX_DIRECTORY_DEPTH) {
-    const naxDir = join42(current, ".nax");
-    const configPath = join42(naxDir, "config.json");
+    const naxDir = join43(current, ".nax");
+    const configPath = join43(naxDir, "config.json");
     if (existsSync16(configPath)) {
       return realpathSync3(current);
     }
-    const parent = join42(current, "..");
+    const parent = join43(current, "..");
     if (parent === current) {
       break;
     }
@@ -52831,10 +53254,10 @@ var init_effectiveness = __esm(() => {
 
 // src/execution/progress.ts
 import { appendFile as appendFile2, mkdir as mkdir7 } from "fs/promises";
-import { join as join45 } from "path";
+import { join as join46 } from "path";
 async function appendProgress(featureDir, storyId, status, message) {
   await mkdir7(featureDir, { recursive: true });
-  const progressPath = join45(featureDir, "progress.txt");
+  const progressPath = join46(featureDir, "progress.txt");
   const timestamp = new Date().toISOString();
   const entry = `[${timestamp}] ${storyId} \u2014 ${status.toUpperCase()} \u2014 ${message}
 `;
@@ -53028,7 +53451,7 @@ var init_completion = __esm(() => {
 
 // src/constitution/loader.ts
 import { existsSync as existsSync19 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 function truncateToTokens(text, maxTokens) {
   const maxChars = maxTokens * 3;
   if (text.length <= maxChars) {
@@ -53050,7 +53473,7 @@ async function loadConstitution(projectDir, config2) {
   }
   let combinedContent = "";
   if (!config2.skipGlobal) {
-    const globalPath = join46(globalConfigDir(), config2.path);
+    const globalPath = join47(globalConfigDir(), config2.path);
     if (existsSync19(globalPath)) {
       const validatedPath = validateFilePath(globalPath, globalConfigDir());
       const globalFile = Bun.file(validatedPath);
@@ -53060,7 +53483,7 @@ async function loadConstitution(projectDir, config2) {
       }
     }
   }
-  const projectPath = join46(projectDir, config2.path);
+  const projectPath = join47(projectDir, config2.path);
   if (existsSync19(projectPath)) {
     const validatedPath = validateFilePath(projectPath, projectDir);
     const projectFile = Bun.file(validatedPath);
@@ -53532,6 +53955,166 @@ var init_context2 = __esm(() => {
   };
 });
 
+// src/tdd/rollback.ts
+async function rollbackToRef(workdir, ref) {
+  const logger = getLogger();
+  logger.warn("tdd", "Rolling back git changes", { ref });
+  const resetProc = _rollbackDeps.spawn(["git", "reset", "--hard", ref], {
+    cwd: workdir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const exitCode = await resetProc.exited;
+  if (exitCode !== 0) {
+    const stderr = await new Response(resetProc.stderr).text();
+    logger.error("tdd", "Failed to rollback git changes", { ref, stderr });
+    throw new Error(`Git rollback failed: ${stderr}`);
+  }
+  const cleanProc = _rollbackDeps.spawn(["git", "clean", "-fd"], {
+    cwd: workdir,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const cleanExitCode = await cleanProc.exited;
+  if (cleanExitCode !== 0) {
+    const stderr = await new Response(cleanProc.stderr).text();
+    logger.warn("tdd", "Failed to clean untracked files", { stderr });
+  }
+  logger.info("tdd", "Successfully rolled back git changes", { ref });
+}
+async function captureSnapshotRef(workdir, storyId) {
+  await _rollbackDeps.autoCommitIfDirty(workdir, "non-blocking-fix-snapshot", "snapshot", storyId);
+  const proc = _rollbackDeps.spawn(["git", "rev-parse", "HEAD"], { cwd: workdir, stdout: "pipe", stderr: "pipe" });
+  const sha = (await new Response(proc.stdout).text()).trim();
+  const exitCode = await proc.exited;
+  if (exitCode !== 0) {
+    throw new NaxError("git rev-parse HEAD failed in non-blocking-fix snapshot", "SNAPSHOT_REF_FAILED", {
+      storyId,
+      workdir,
+      stage: "non-blocking-fix-snapshot"
+    });
+  }
+  return sha;
+}
+var _rollbackDeps;
+var init_rollback = __esm(() => {
+  init_errors();
+  init_logger2();
+  init_git();
+  _rollbackDeps = {
+    spawn: Bun.spawn,
+    autoCommitIfDirty
+  };
+});
+
+// src/execution/non-blocking-fix.ts
+function shouldRunNonBlockingFix(cfg, advisoryCount) {
+  return cfg?.enabled === true && advisoryCount > 0;
+}
+function nonBlockingExcludePhases() {
+  return REVIEW_PHASE_KINDS;
+}
+function nonBlockingExtraPhases(cfg) {
+  return cfg.scope === "both" && cfg.verifierGuard ? ["verifier"] : [];
+}
+async function runNonBlockingFix(args, _deps = DEFAULT_DEPS) {
+  const logger = getSafeLogger();
+  if (!shouldRunNonBlockingFix(args.cfg, args.advisoryFindings.length)) {
+    return { ran: false, kept: false, restored: false };
+  }
+  const phaseOutputsSnapshot = { ...args.phaseOutputs };
+  const restoreRef = await _deps.captureSnapshotRef(args.workdir, args.storyId);
+  const maxAttempts = 1 + args.cfg.regressionAttempts;
+  let exhausted = false;
+  try {
+    const result = await args.runRectify(maxAttempts);
+    exhausted = result.rectificationExhausted === true;
+  } catch (err) {
+    logger?.warn("non-blocking-fix", "best-effort pass threw \u2014 restoring", {
+      storyId: args.storyId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    exhausted = true;
+  }
+  if (!exhausted) {
+    logger?.info("non-blocking-fix", "best-effort fix kept", { storyId: args.storyId });
+    return { ran: true, kept: true, restored: false };
+  }
+  await _deps.rollbackToRef(args.workdir, restoreRef);
+  for (const key of Object.keys(args.phaseOutputs))
+    delete args.phaseOutputs[key];
+  Object.assign(args.phaseOutputs, phaseOutputsSnapshot);
+  logger?.info("non-blocking-fix", "best-effort fix exhausted \u2014 restored to adversarial-passed", {
+    storyId: args.storyId
+  });
+  return { ran: true, kept: false, restored: true };
+}
+var REVIEW_PHASE_KINDS, DEFAULT_DEPS;
+var init_non_blocking_fix = __esm(() => {
+  init_logger2();
+  init_rollback();
+  REVIEW_PHASE_KINDS = ["semantic-review", "adversarial-review"];
+  DEFAULT_DEPS = { captureSnapshotRef, rollbackToRef };
+});
+
+// src/execution/story-orchestrator-logging.ts
+function formatPhaseResultMessage(opName, success2, stage, status) {
+  if (opName === "greenfield-gate") {
+    return success2 ? "Greenfield-gate: pre-existing tests detected (not greenfield) \u2014 proceeding with normal TDD" : "Greenfield-gate: no pre-existing tests \u2014 greenfield run, pausing TDD test-writer";
+  }
+  if (status === "skipped") {
+    return `Phase skipped: ${opName}`;
+  }
+  if (stage === "rectification") {
+    return `Rectification strategy completed: ${opName}`;
+  }
+  return success2 ? `Phase passed: ${opName}` : `Phase failed: ${opName}`;
+}
+function buildPhaseOutcomeLogData(storyId, opName, output, durationMs) {
+  if (output === null || output === undefined || typeof output !== "object")
+    return null;
+  const r = output;
+  const success2 = r.success === true || r.passed === true;
+  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 status = typeof built.data.status === "string" ? built.data.status : undefined;
+  const logger = getSafeLogger();
+  const message = formatPhaseResultMessage(opName, success2, stage, status);
+  if (stage === "rectification") {
+    logger?.info("story-orchestrator", message, data);
+    return;
+  }
+  if (success2) {
+    logger?.info("story-orchestrator", message, data);
+  } else {
+    logger?.warn("story-orchestrator", message, data);
+  }
+}
+var init_story_orchestrator_logging = __esm(() => {
+  init_logger2();
+});
+
 // src/execution/story-orchestrator.ts
 async function refreshReviewInputForDispatch(opName, input) {
   if (opName !== "semantic-review" && opName !== "adversarial-review")
@@ -53592,15 +54175,6 @@ async function refreshReviewInputForDispatch(opName, input) {
     return fallback;
   }
 }
-function formatPhaseResultMessage(opName, success2, stage) {
-  if (opName === "greenfield-gate") {
-    return success2 ? "Greenfield-gate: pre-existing tests detected (not greenfield) \u2014 proceeding with normal TDD" : "Greenfield-gate: no pre-existing tests \u2014 greenfield run, pausing TDD test-writer";
-  }
-  if (stage === "rectification") {
-    return `Rectification strategy completed: ${opName}`;
-  }
-  return success2 ? `Phase passed: ${opName}` : `Phase failed: ${opName}`;
-}
 function isSlot(value) {
   return value !== null && typeof value === "object" && "op" in value && "input" in value && typeof value.op?.kind === "string";
 }
@@ -53796,46 +54370,6 @@ function logUnifiedReviewPhaseStart(storyId, opName) {
     logger?.info("review", "Running adversarial check", { storyId });
   }
 }
-function buildPhaseOutcomeLogData(storyId, opName, output, durationMs) {
-  if (output === null || output === undefined || typeof output !== "object")
-    return null;
-  const r = output;
-  const success2 = r.success === true || r.passed === true;
-  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);
-    return;
-  }
-  if (success2) {
-    logger?.info("story-orchestrator", message, data);
-  } else {
-    logger?.warn("story-orchestrator", message, data);
-  }
-}
 function logUnifiedReviewPhaseResult(storyId, opName, output) {
   const logger = getSafeLogger();
   const payload = toReviewDecisionPayload(opName, output);
@@ -53971,16 +54505,17 @@ function withIncreasingFailuresBail(strategies, enabled, consecutiveIncreases) {
     }
   }));
 }
-async function runRectification(ctx, state, phaseCosts, phaseOutputs) {
+async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides) {
   const rectification = state.rectification;
-  const validationPhases = collectRectificationPhases(state);
+  const baseValidationPhases = collectRectificationPhases(state);
+  const validationPhases = overrides?.excludePhaseKinds ? baseValidationPhases.filter((p) => !overrides.excludePhaseKinds?.includes(p.kind)) : baseValidationPhases;
   if (!rectification || validationPhases.length === 0) {
     return {};
   }
   if (ctx.runtime.signal?.aborted) {
     return {};
   }
-  const initialFindings = gatherRectificationFindings(phaseOutputs, validationPhases, state);
+  const initialFindings = overrides?.initialFindings ? [...overrides.initialFindings] : gatherRectificationFindings(phaseOutputs, validationPhases, state);
   if (initialFindings.length === 0) {
     return {};
   }
@@ -53995,14 +54530,16 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs) {
   const cycle = {
     findings: [...initialFindings],
     iterations: [],
-    strategies: withIncreasingFailuresBail(rectification.strategies, rectification.abortOnIncreasingFailures, rectification.consecutiveIncreasesToBail ?? 1),
-    config: { maxAttemptsTotal: rectification.maxAttempts, validatorRetries: 1 },
+    strategies: withIncreasingFailuresBail(overrides?.strategies ?? rectification.strategies, rectification.abortOnIncreasingFailures, rectification.consecutiveIncreasesToBail ?? 1),
+    config: { maxAttemptsTotal: overrides?.maxAttempts ?? rectification.maxAttempts, validatorRetries: 1 },
     validate: async (_validateCtx, opts) => {
       if (ctx.runtime.signal?.aborted)
         return { findings: [], shortCircuited: false };
       const lite = (opts?.mode ?? "full") === "lite";
       const selected = phasesToRevalidate(opts?.strategiesRun, validationPhases);
-      const phases = lite ? orderGateLast(selected) : selected;
+      const extra = overrides?.extraRevalidationKinds ? validationPhases.filter((p) => overrides.extraRevalidationKinds?.includes(p.kind) && !selected.some((s) => s.kind === p.kind)) : [];
+      const selectedWithExtra = [...selected, ...extra];
+      const phases = lite ? orderGateLast(selectedWithExtra) : selectedWithExtra;
       getSafeLogger()?.debug("story-orchestrator", "rectification validate scope", {
         storyId: ctx.storyId,
         mode: opts?.mode ?? "full",
@@ -54154,6 +54691,25 @@ class ExecutionPlan {
         }
       }
     }
+    const advCfg = this.state.adversarialReview ? this.state.nonBlockingFix : undefined;
+    const advisoryOut = phaseOutputs["adversarial-review"];
+    const advisoryFindings = advisoryOut?.advisoryFindings ?? [];
+    if (advCfg && this.state.rectification && this.ctx.storyId && shouldRunNonBlockingFix(advCfg, advisoryFindings.length)) {
+      await runNonBlockingFix({
+        workdir: this.ctx.packageDir,
+        storyId: this.ctx.storyId,
+        advisoryFindings,
+        cfg: advCfg,
+        phaseOutputs,
+        runRectify: (maxAttempts) => runRectification(this.ctx, this.state, phaseCosts, phaseOutputs, {
+          initialFindings: advisoryFindings,
+          strategies: this.state.nonBlockingFixStrategies ?? [],
+          excludePhaseKinds: nonBlockingExcludePhases(),
+          extraRevalidationKinds: nonBlockingExtraPhases(advCfg),
+          maxAttempts
+        })
+      });
+    }
     const verifierName = this.state.verifier?.slot.op.name;
     const gateName = this.state.fullSuiteGate?.slot.op.name;
     const verifierPassedSsot = verifierName !== undefined && phaseExplicitlyPassed(phaseOutputs[verifierName]);
@@ -54246,6 +54802,11 @@ class StoryOrchestratorBuilder {
     this.state.rectification = opts;
     return this;
   }
+  addNonBlockingFix(cfg, strategies) {
+    this.state.nonBlockingFix = cfg;
+    this.state.nonBlockingFixStrategies = strategies;
+    return this;
+  }
   build(ctx, opts = {}) {
     if (!this.state.implementer) {
       throw new NaxError("StoryOrchestratorBuilder.build(): addImplementer() must be called before build()", "ORCHESTRATOR_NO_IMPLEMENTER", { stage: "execution" });
@@ -54263,6 +54824,8 @@ var init_story_orchestrator = __esm(() => {
   init_event_bus();
   init_prepare_inputs();
   init_git();
+  init_non_blocking_fix();
+  init_story_orchestrator_logging();
   _storyOrchestratorDeps = {
     callOp,
     runFixCycle,
@@ -54327,7 +54890,7 @@ var init_story_orchestrator = __esm(() => {
 });
 
 // src/execution/build-plan-for-strategy.ts
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 function requiresInitialRefCapture(strategy) {
   return isThreeSessionStrategy(strategy);
 }
@@ -54373,13 +54936,14 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
   }
   if (shouldRunRectification(config2) && inputs.rectification) {
     const sink = makeDeclarationSink();
-    const packageDir = join47(ctx.packageDir, story.workdir ?? "");
+    const packageDir = join48(ctx.packageDir, story.workdir ?? "");
     const resolvedTestPatterns = await resolveTestFilePatterns(config2, ctx.packageDir, story.workdir);
     const strategies = [];
-    if (config2.quality.commands.lintFix || config2.quality.commands.lintFixScoped) {
+    const pkgQuality = ctx.packageView.select(qualityConfigSelector).quality;
+    if (pkgQuality?.commands?.lintFix || pkgQuality?.commands?.lintFixScoped) {
       strategies.push(makeMechanicalLintFixStrategy());
     }
-    if (config2.quality.commands.formatFix || config2.quality.commands.formatFixScoped) {
+    if (pkgQuality?.commands?.formatFix || pkgQuality?.commands?.formatFixScoped) {
       strategies.push(makeMechanicalFormatFixStrategy());
     }
     if (inputs.fullSuiteGate && (isThreeSession || regressionMode === "per-story")) {
@@ -54415,6 +54979,22 @@ async function buildPlanForStrategy(ctx, story, config2, testStrategy, inputs) {
     };
     builder.addRectification(rectOpts);
   }
+  const nbf = config2.review?.adversarial?.nonBlockingFix;
+  const nbStrategies = [];
+  if (nbf?.enabled && inputs.adversarialReview) {
+    const nbSink = makeDeclarationSink();
+    if (nbf.scope === "source") {
+      nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
+        includeAdversarialReview: true
+      }));
+    } else {
+      nbStrategies.push(makeAutofixImplementerStrategy(story, config2, nbSink, {
+        includeAdversarialReview: false
+      }), makeAutofixTestWriterStrategy(story, config2, nbSink));
+    }
+    nbStrategies.push(makeFullSuiteRectifyStrategy(story, config2));
+    builder.addNonBlockingFix(nbf, nbStrategies);
+  }
   return builder.build(ctx, { isThreeSession });
 }
 var init_build_plan_for_strategy = __esm(() => {
@@ -54678,41 +55258,6 @@ var init_execution_helpers = __esm(() => {
   init_errors();
 });
 
-// src/tdd/rollback.ts
-async function rollbackToRef(workdir, ref) {
-  const logger = getLogger();
-  logger.warn("tdd", "Rolling back git changes", { ref });
-  const resetProc = _rollbackDeps.spawn(["git", "reset", "--hard", ref], {
-    cwd: workdir,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const exitCode = await resetProc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(resetProc.stderr).text();
-    logger.error("tdd", "Failed to rollback git changes", { ref, stderr });
-    throw new Error(`Git rollback failed: ${stderr}`);
-  }
-  const cleanProc = _rollbackDeps.spawn(["git", "clean", "-fd"], {
-    cwd: workdir,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const cleanExitCode = await cleanProc.exited;
-  if (cleanExitCode !== 0) {
-    const stderr = await new Response(cleanProc.stderr).text();
-    logger.warn("tdd", "Failed to clean untracked files", { stderr });
-  }
-  logger.info("tdd", "Successfully rolled back git changes", { ref });
-}
-var _rollbackDeps;
-var init_rollback = __esm(() => {
-  init_logger2();
-  _rollbackDeps = {
-    spawn: Bun.spawn
-  };
-});
-
 // src/execution/session-manager-runtime.ts
 async function closePhysicalSession(descriptor, agentGetFn, force) {
   if (!descriptor.handle)
@@ -55925,7 +56470,7 @@ function buildFrontmatter(story, ctx, role) {
 }
 
 // src/cli/prompts-tdd.ts
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 async function handleThreeSessionTddPrompts(story, ctx, outputDir, logger) {
   const [testWriterPrompt, implementerPrompt, verifierPrompt] = await Promise.all([
     TddPromptBuilder.for("test-writer", { isolation: "strict" }).withLoader(ctx.workdir, ctx.config).story(story).context(ctx.contextMarkdown).constitution(ctx.constitution?.content).testCommand(ctx.config.quality?.commands?.test).build(),
@@ -55944,7 +56489,7 @@ ${frontmatter}---
 
 ${session.prompt}`;
     if (outputDir) {
-      const promptFile = join48(outputDir, `${story.id}.${session.role}.md`);
+      const promptFile = join49(outputDir, `${story.id}.${session.role}.md`);
       await Bun.write(promptFile, fullOutput);
       logger.info("cli", "Written TDD prompt file", {
         storyId: story.id,
@@ -55960,7 +56505,7 @@ ${"=".repeat(80)}`);
     }
   }
   if (outputDir && ctx.contextMarkdown) {
-    const contextFile = join48(outputDir, `${story.id}.context.md`);
+    const contextFile = join49(outputDir, `${story.id}.context.md`);
     const frontmatter = buildFrontmatter(story, ctx);
     const contextOutput = `---
 ${frontmatter}---
@@ -55975,16 +56520,16 @@ var init_prompts_tdd = __esm(() => {
 
 // src/cli/prompts-main.ts
 import { existsSync as existsSync20, mkdirSync as mkdirSync3 } from "fs";
-import { join as join49 } from "path";
+import { join as join50 } from "path";
 async function promptsCommand(options) {
   const logger = getLogger();
   const { feature, workdir, config: config2, storyId, outputDir } = options;
-  const naxDir = join49(workdir, ".nax");
+  const naxDir = join50(workdir, ".nax");
   if (!existsSync20(naxDir)) {
     throw new Error(`.nax directory not found. Run 'nax init' first in ${workdir}`);
   }
-  const featureDir = join49(naxDir, "features", feature);
-  const prdPath = join49(featureDir, "prd.json");
+  const featureDir = join50(naxDir, "features", feature);
+  const prdPath = join50(featureDir, "prd.json");
   if (!existsSync20(prdPath)) {
     throw new Error(`Feature "${feature}" not found or missing prd.json`);
   }
@@ -56051,10 +56596,10 @@ ${frontmatter}---
 
 ${ctx.prompt}`;
     if (outputDir) {
-      const promptFile = join49(outputDir, `${story.id}.prompt.md`);
+      const promptFile = join50(outputDir, `${story.id}.prompt.md`);
       await Bun.write(promptFile, fullOutput);
       if (ctx.contextMarkdown) {
-        const contextFile = join49(outputDir, `${story.id}.context.md`);
+        const contextFile = join50(outputDir, `${story.id}.context.md`);
         const contextOutput = `---
 ${frontmatter}---
 
@@ -56090,12 +56635,12 @@ var init_prompts_main = __esm(() => {
 
 // src/cli/prompts-init.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync4 } from "fs";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 async function promptsInitCommand(options) {
   const { workdir, force = false, autoWireConfig = true } = options;
-  const templatesDir = join50(workdir, ".nax", "templates");
+  const templatesDir = join51(workdir, ".nax", "templates");
   mkdirSync4(templatesDir, { recursive: true });
-  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join50(templatesDir, f)));
+  const existingFiles = TEMPLATE_ROLES.map((t) => t.file).filter((f) => existsSync21(join51(templatesDir, f)));
   if (existingFiles.length > 0 && !force) {
     _promptsInitDeps.warn(`[WARN] nax/templates/ already contains files: ${existingFiles.join(", ")}. No files overwritten.
        Pass --force to overwrite existing templates.`);
@@ -56103,7 +56648,7 @@ async function promptsInitCommand(options) {
   }
   const written = [];
   for (const template of TEMPLATE_ROLES) {
-    const filePath = join50(templatesDir, template.file);
+    const filePath = join51(templatesDir, template.file);
     const roleBody = template.role === "implementer" ? buildRoleTaskSection(template.role, template.variant) : buildRoleTaskSection(template.role);
     const content = TEMPLATE_HEADER + roleBody;
     await Bun.write(filePath, content);
@@ -56119,7 +56664,7 @@ async function promptsInitCommand(options) {
   return written;
 }
 async function autoWirePromptsConfig(workdir) {
-  const configPath = join50(workdir, "nax.config.json");
+  const configPath = join51(workdir, "nax.config.json");
   if (!existsSync21(configPath)) {
     const exampleConfig = JSON.stringify({
       prompts: {
@@ -56287,9 +56832,14 @@ __export(exports_init_context, {
   generateContextTemplate: () => generateContextTemplate,
   _initContextDeps: () => _initContextDeps
 });
-import { existsSync as existsSync22 } from "fs";
-import { mkdir as mkdir8 } from "fs/promises";
-import { basename as basename9, join as join51 } from "path";
+import { basename as basename9, join as join52 } from "path";
+async function bunFileExists(path13) {
+  return Bun.file(path13).exists();
+}
+async function bunMkdirp(path13) {
+  const proc = Bun.spawn(["mkdir", "-p", path13]);
+  await proc.exited;
+}
 async function findFiles(dir, maxFiles = 200) {
   try {
     const proc = Bun.spawnSync([
@@ -56317,8 +56867,8 @@ async function findFiles(dir, maxFiles = 200) {
   return [];
 }
 async function readPackageManifest(projectRoot) {
-  const packageJsonPath = join51(projectRoot, "package.json");
-  if (!existsSync22(packageJsonPath)) {
+  const packageJsonPath = join52(projectRoot, "package.json");
+  if (!await bunFileExists(packageJsonPath)) {
     return null;
   }
   try {
@@ -56335,8 +56885,8 @@ async function readPackageManifest(projectRoot) {
   }
 }
 async function readReadmeSnippet(projectRoot) {
-  const readmePath = join51(projectRoot, "README.md");
-  if (!existsSync22(readmePath)) {
+  const readmePath = join52(projectRoot, "README.md");
+  if (!await bunFileExists(readmePath)) {
     return null;
   }
   try {
@@ -56353,8 +56903,8 @@ async function detectEntryPoints(projectRoot) {
   const candidates = ["src/index.ts", "src/main.ts", "main.go", "src/lib.rs"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join51(projectRoot, candidate);
-    if (existsSync22(path13)) {
+    const path13 = join52(projectRoot, candidate);
+    if (await bunFileExists(path13)) {
       found.push(candidate);
     }
   }
@@ -56364,8 +56914,8 @@ async function detectConfigFiles(projectRoot) {
   const candidates = ["tsconfig.json", "biome.json", "turbo.json", ".env.example"];
   const found = [];
   for (const candidate of candidates) {
-    const path13 = join51(projectRoot, candidate);
-    if (existsSync22(path13)) {
+    const path13 = join52(projectRoot, candidate);
+    if (await bunFileExists(path13)) {
       found.push(candidate);
     }
   }
@@ -56495,10 +57045,10 @@ Keep it under 2000 tokens. Use markdown formatting. Be specific to the detected
 `;
   try {
     const result = await _initContextDeps.callLLM(prompt);
-    logger.info("init", "Generated context.md with LLM");
+    logger.info("init", "Generated context.md with LLM", { storyId: "init-context" });
     return result;
   } catch (err) {
-    logger.warn("init", `LLM context generation failed, falling back to template: ${err instanceof Error ? err.message : String(err)}`);
+    logger.warn("init", `LLM context generation failed, falling back to template: ${err instanceof Error ? err.message : String(err)}`, { storyId: "init-context" });
     return generateContextTemplate(scan);
   }
 }
@@ -56525,29 +57075,35 @@ function generatePackageContextTemplate(packagePath) {
 }
 async function initPackage(repoRoot, packagePath, force = false) {
   const logger = getLogger();
-  const naxDir = join51(repoRoot, ".nax", "mono", packagePath);
-  const contextPath = join51(naxDir, "context.md");
-  if (existsSync22(contextPath) && !force) {
-    logger.info("init", "Package context.md already exists (use --force to overwrite)", { path: contextPath });
+  const naxDir = join52(repoRoot, ".nax", "mono", packagePath);
+  const contextPath = join52(naxDir, "context.md");
+  if (await bunFileExists(contextPath) && !force) {
+    logger.info("init", "Package context.md already exists (use --force to overwrite)", {
+      storyId: "init-context",
+      path: contextPath
+    });
     return;
   }
-  if (!existsSync22(naxDir)) {
-    await mkdir8(naxDir, { recursive: true });
+  if (!await bunFileExists(naxDir)) {
+    await bunMkdirp(naxDir);
   }
   const content = generatePackageContextTemplate(packagePath);
   await Bun.write(contextPath, content);
-  logger.info("init", "Created package context.md", { path: contextPath });
+  logger.info("init", "Created package context.md", { storyId: "init-context", path: contextPath });
 }
 async function initContext(projectRoot, options = {}) {
   const logger = getLogger();
-  const naxDir = join51(projectRoot, ".nax");
-  const contextPath = join51(naxDir, "context.md");
-  if (existsSync22(contextPath) && !options.force) {
-    logger.info("init", "context.md already exists, skipping (use --force to overwrite)", { path: contextPath });
+  const naxDir = join52(projectRoot, ".nax");
+  const contextPath = join52(naxDir, "context.md");
+  if (await bunFileExists(contextPath) && !options.force) {
+    logger.info("init", "context.md already exists, skipping (use --force to overwrite)", {
+      storyId: "init-context",
+      path: contextPath
+    });
     return;
   }
-  if (!existsSync22(naxDir)) {
-    await mkdir8(naxDir, { recursive: true });
+  if (!await bunFileExists(naxDir)) {
+    await bunMkdirp(naxDir);
   }
   const scan = await scanProject(projectRoot);
   let content;
@@ -56557,7 +57113,10 @@ async function initContext(projectRoot, options = {}) {
     content = generateContextTemplate(scan);
   }
   await Bun.write(contextPath, content);
-  logger.info("init", "Generated .nax/context.md template from project scan", { path: contextPath });
+  logger.info("init", "Generated .nax/context.md template from project scan", {
+    storyId: "init-context",
+    path: contextPath
+  });
 }
 var _initContextDeps;
 var init_init_context = __esm(() => {
@@ -56570,11 +57129,11 @@ var init_init_context = __esm(() => {
 });
 
 // src/cli/init-detect.ts
-import { existsSync as existsSync23, readFileSync } from "fs";
-import { join as join52 } from "path";
+import { existsSync as existsSync22, readFileSync } from "fs";
+import { join as join53 } from "path";
 function readPackageJson(projectRoot) {
-  const pkgPath = join52(projectRoot, "package.json");
-  if (!existsSync23(pkgPath))
+  const pkgPath = join53(projectRoot, "package.json");
+  if (!existsSync22(pkgPath))
     return;
   try {
     return JSON.parse(readFileSync(pkgPath, "utf-8"));
@@ -56616,41 +57175,41 @@ function detectStack(projectRoot) {
   };
 }
 function detectRuntime(projectRoot) {
-  if (existsSync23(join52(projectRoot, "bun.lockb")) || existsSync23(join52(projectRoot, "bunfig.toml"))) {
+  if (existsSync22(join53(projectRoot, "bun.lockb")) || existsSync22(join53(projectRoot, "bunfig.toml"))) {
     return "bun";
   }
-  if (existsSync23(join52(projectRoot, "package-lock.json")) || existsSync23(join52(projectRoot, "yarn.lock")) || existsSync23(join52(projectRoot, "pnpm-lock.yaml"))) {
+  if (existsSync22(join53(projectRoot, "package-lock.json")) || existsSync22(join53(projectRoot, "yarn.lock")) || existsSync22(join53(projectRoot, "pnpm-lock.yaml"))) {
     return "node";
   }
   return "unknown";
 }
 function detectLanguage2(projectRoot) {
-  if (existsSync23(join52(projectRoot, "tsconfig.json")))
+  if (existsSync22(join53(projectRoot, "tsconfig.json")))
     return "typescript";
-  if (existsSync23(join52(projectRoot, "pyproject.toml")) || existsSync23(join52(projectRoot, "setup.py"))) {
+  if (existsSync22(join53(projectRoot, "pyproject.toml")) || existsSync22(join53(projectRoot, "setup.py"))) {
     return "python";
   }
-  if (existsSync23(join52(projectRoot, "Cargo.toml")))
+  if (existsSync22(join53(projectRoot, "Cargo.toml")))
     return "rust";
-  if (existsSync23(join52(projectRoot, "go.mod")))
+  if (existsSync22(join53(projectRoot, "go.mod")))
     return "go";
   return "unknown";
 }
 function detectLinter(projectRoot) {
-  if (existsSync23(join52(projectRoot, "biome.json")) || existsSync23(join52(projectRoot, "biome.jsonc"))) {
+  if (existsSync22(join53(projectRoot, "biome.json")) || existsSync22(join53(projectRoot, "biome.jsonc"))) {
     return "biome";
   }
-  if (existsSync23(join52(projectRoot, ".eslintrc.json")) || existsSync23(join52(projectRoot, ".eslintrc.js")) || existsSync23(join52(projectRoot, "eslint.config.js"))) {
+  if (existsSync22(join53(projectRoot, ".eslintrc.json")) || existsSync22(join53(projectRoot, ".eslintrc.js")) || existsSync22(join53(projectRoot, "eslint.config.js"))) {
     return "eslint";
   }
   return "unknown";
 }
 function detectMonorepo(projectRoot) {
-  if (existsSync23(join52(projectRoot, "turbo.json")))
+  if (existsSync22(join53(projectRoot, "turbo.json")))
     return "turborepo";
-  if (existsSync23(join52(projectRoot, "nx.json")))
+  if (existsSync22(join53(projectRoot, "nx.json")))
     return "nx";
-  if (existsSync23(join52(projectRoot, "pnpm-workspace.yaml")))
+  if (existsSync22(join53(projectRoot, "pnpm-workspace.yaml")))
     return "pnpm-workspaces";
   const pkg = readPackageJson(projectRoot);
   if (pkg?.workspaces)
@@ -56792,9 +57351,9 @@ __export(exports_init, {
   checkInitCollision: () => checkInitCollision,
   _initDeps: () => _initDeps
 });
-import { existsSync as existsSync24 } from "fs";
-import { mkdir as mkdir9 } from "fs/promises";
-import { join as join53 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { mkdir as mkdir8 } from "fs/promises";
+import { join as join54 } from "path";
 function validateProjectName(name) {
   if (!name)
     return { valid: false, error: "name must be non-empty" };
@@ -56830,9 +57389,9 @@ async function checkInitCollision(name, currentWorkdir, currentRemote) {
 }
 async function updateGitignore(projectRoot) {
   const logger = getLogger();
-  const gitignorePath = join53(projectRoot, ".gitignore");
+  const gitignorePath = join54(projectRoot, ".gitignore");
   let existing = "";
-  if (existsSync24(gitignorePath)) {
+  if (existsSync23(gitignorePath)) {
     existing = await Bun.file(gitignorePath).text();
   }
   const missingEntries = NAX_GITIGNORE_ENTRIES.filter((entry) => !existing.includes(entry));
@@ -56912,28 +57471,28 @@ function buildConstitution(stack) {
 async function initGlobal() {
   const logger = getLogger();
   const globalDir = globalConfigDir();
-  if (!existsSync24(globalDir)) {
-    await mkdir9(globalDir, { recursive: true });
+  if (!existsSync23(globalDir)) {
+    await mkdir8(globalDir, { recursive: true });
     logger.info("init", "Created global config directory", { path: globalDir });
   }
-  const configPath = join53(globalDir, "config.json");
-  if (!existsSync24(configPath)) {
+  const configPath = join54(globalDir, "config.json");
+  if (!existsSync23(configPath)) {
     await Bun.write(configPath, `${JSON.stringify(MINIMAL_GLOBAL_CONFIG, null, 2)}
 `);
     logger.info("init", "Created global config", { path: configPath });
   } else {
     logger.info("init", "Global config already exists", { path: configPath });
   }
-  const constitutionPath = join53(globalDir, "constitution.md");
-  if (!existsSync24(constitutionPath)) {
+  const constitutionPath = join54(globalDir, "constitution.md");
+  if (!existsSync23(constitutionPath)) {
     await Bun.write(constitutionPath, buildConstitution({ runtime: "unknown", language: "unknown", linter: "unknown", monorepo: "none" }));
     logger.info("init", "Created global constitution", { path: constitutionPath });
   } else {
     logger.info("init", "Global constitution already exists", { path: constitutionPath });
   }
-  const hooksDir = join53(globalDir, "hooks");
-  if (!existsSync24(hooksDir)) {
-    await mkdir9(hooksDir, { recursive: true });
+  const hooksDir = join54(globalDir, "hooks");
+  if (!existsSync23(hooksDir)) {
+    await mkdir8(hooksDir, { recursive: true });
     logger.info("init", "Created global hooks directory", { path: hooksDir });
   } else {
     logger.info("init", "Global hooks directory already exists", { path: hooksDir });
@@ -56964,7 +57523,7 @@ async function initProject(projectRoot, options) {
   if (detectedName && !options?.force) {
     const collision = await checkInitCollision(detectedName, projectRoot, currentRemote);
     if (collision.collision && collision.existing) {
-      const configPath2 = join53(projectDir, "config.json");
+      const configPath2 = join54(projectDir, "config.json");
       throw new NaxError([
         `Project name collision: "${detectedName}"`,
         `  This project:    ${projectRoot}`,
@@ -56977,8 +57536,8 @@ async function initProject(projectRoot, options) {
 `), "INIT_NAME_COLLISION", { stage: "init", name: detectedName });
     }
   }
-  if (!existsSync24(projectDir)) {
-    await mkdir9(projectDir, { recursive: true });
+  if (!existsSync23(projectDir)) {
+    await mkdir8(projectDir, { recursive: true });
     logger.info("init", "Created project config directory", { path: projectDir });
   }
   const stack = detectStack(projectRoot);
@@ -56992,8 +57551,8 @@ async function initProject(projectRoot, options) {
     linter: stack.linter,
     monorepo: stack.monorepo
   });
-  const configPath = join53(projectDir, "config.json");
-  if (!existsSync24(configPath)) {
+  const configPath = join54(projectDir, "config.json");
+  if (!existsSync23(configPath)) {
     await Bun.write(configPath, `${JSON.stringify(projectConfig, null, 2)}
 `);
     logger.info("init", "Created project config", { path: configPath });
@@ -57001,16 +57560,16 @@ async function initProject(projectRoot, options) {
     logger.info("init", "Project config already exists", { path: configPath });
   }
   await initContext(projectRoot, { ai: options?.ai, force: options?.force });
-  const constitutionPath = join53(projectDir, "constitution.md");
-  if (!existsSync24(constitutionPath) || options?.force) {
+  const constitutionPath = join54(projectDir, "constitution.md");
+  if (!existsSync23(constitutionPath) || options?.force) {
     await Bun.write(constitutionPath, buildConstitution(stack));
     logger.info("init", "Created project constitution", { path: constitutionPath });
   } else {
     logger.info("init", "Project constitution already exists", { path: constitutionPath });
   }
-  const hooksDir = join53(projectDir, "hooks");
-  if (!existsSync24(hooksDir)) {
-    await mkdir9(hooksDir, { recursive: true });
+  const hooksDir = join54(projectDir, "hooks");
+  if (!existsSync23(hooksDir)) {
+    await mkdir8(hooksDir, { recursive: true });
     logger.info("init", "Created project hooks directory", { path: hooksDir });
   } else {
     logger.info("init", "Project hooks directory already exists", { path: hooksDir });
@@ -57069,6 +57628,286 @@ var init_init2 = __esm(() => {
   };
 });
 
+// src/cli/setup-analyze.ts
+import { join as join55 } from "path";
+async function detectPackageManager(workdir) {
+  const { fileExists } = _analyzeRepoDeps;
+  if (await fileExists(join55(workdir, "bun.lock")))
+    return { pmRunPrefix: "bun run", pmDlx: "bunx" };
+  if (await fileExists(join55(workdir, "bun.lockb")))
+    return { pmRunPrefix: "bun run", pmDlx: "bunx" };
+  if (await fileExists(join55(workdir, "package-lock.json")))
+    return { pmRunPrefix: "npm run", pmDlx: "npx" };
+  if (await fileExists(join55(workdir, "yarn.lock")))
+    return { pmRunPrefix: "yarn", pmDlx: "yarn dlx" };
+  if (await fileExists(join55(workdir, "pnpm-lock.yaml")))
+    return { pmRunPrefix: "pnpm run", pmDlx: "pnpx" };
+  return { pmRunPrefix: "npm run", pmDlx: "npx" };
+}
+async function detectOrchestrator(workdir) {
+  const { fileExists } = _analyzeRepoDeps;
+  if (await fileExists(join55(workdir, "turbo.json")))
+    return "turbo";
+  if (await fileExists(join55(workdir, "nx.json")))
+    return "nx";
+  return "none";
+}
+async function getMissingScripts(packageDir) {
+  const pkg = await _analyzeRepoDeps.readJson(join55(packageDir, "package.json"));
+  const scripts = pkg?.scripts ?? {};
+  return CANONICAL_SCRIPTS.filter((s) => !(s in scripts));
+}
+async function buildPackageFacts(workdir, relativeDir, testPatternMap) {
+  const packageDir = relativeDir === "" ? workdir : join55(workdir, relativeDir);
+  const [profile, missingScripts] = await Promise.all([
+    _analyzeRepoDeps.detectProjectProfile(packageDir, {}),
+    getMissingScripts(packageDir)
+  ]);
+  const detection = testPatternMap[relativeDir] ?? {
+    patterns: [],
+    confidence: "empty",
+    sources: []
+  };
+  return {
+    relativeDir,
+    testFramework: profile.testFramework,
+    testFilePatterns: detection.patterns,
+    missingScripts
+  };
+}
+async function analyzeRepo(workdir) {
+  const { discoverWorkspacePackages: discover, detectTestFilePatternsForWorkspace: detectPatterns } = _analyzeRepoDeps;
+  const [pmInfo, orchestrator, packageDirs] = await Promise.all([
+    detectPackageManager(workdir),
+    detectOrchestrator(workdir),
+    discover(workdir)
+  ]);
+  const shape = packageDirs.length > 0 ? "mono" : "single";
+  const dirsToAnalyze = shape === "single" ? [""] : packageDirs;
+  const testPatternMap = await detectPatterns(workdir, packageDirs);
+  const packages = await Promise.all(dirsToAnalyze.map((dir) => buildPackageFacts(workdir, dir, testPatternMap)));
+  return {
+    shape,
+    packages,
+    pmRunPrefix: pmInfo.pmRunPrefix,
+    pmDlx: pmInfo.pmDlx,
+    orchestrator
+  };
+}
+var CANONICAL_SCRIPTS, _analyzeRepoDeps;
+var init_setup_analyze = __esm(() => {
+  init_project();
+  init_detect2();
+  init_workspace();
+  CANONICAL_SCRIPTS = ["build", "test", "lint", "type-check", "lint:fix"];
+  _analyzeRepoDeps = {
+    fileExists: async (path13) => Bun.file(path13).exists(),
+    readJson: async (path13) => {
+      try {
+        const f = Bun.file(path13);
+        if (!await f.exists())
+          return null;
+        return JSON.parse(await f.text());
+      } catch {
+        return null;
+      }
+    },
+    discoverWorkspacePackages,
+    detectProjectProfile,
+    detectTestFilePatternsForWorkspace
+  };
+});
+
+// src/cli/setup-fill.ts
+import { join as join56 } from "path";
+async function addScriptToPackageJson(pkgJsonPath, key, value) {
+  const pkg = await _fillScriptsDeps.readJson(pkgJsonPath) ?? {};
+  const scripts = pkg.scripts ?? {};
+  if (key in scripts)
+    return;
+  const updated = { ...pkg, scripts: { ...scripts, [key]: value } };
+  await _fillScriptsDeps.writeFile(pkgJsonPath, JSON.stringify(updated, null, 2));
+}
+async function addTurboTask(turboJsonPath, taskKey) {
+  const turbo = await _fillScriptsDeps.readJson(turboJsonPath) ?? {};
+  const field = "pipeline" in turbo ? "pipeline" : "tasks";
+  const existing = turbo[field] ?? {};
+  if (taskKey in existing)
+    return;
+  const updated = { ...turbo, [field]: { ...existing, [taskKey]: {} } };
+  await _fillScriptsDeps.writeFile(turboJsonPath, JSON.stringify(updated, null, 2));
+}
+async function fillScripts(workdir, analysis) {
+  const { shape, packages, orchestrator } = analysis;
+  if (shape === "single") {
+    const rootPkg = packages[0];
+    if (rootPkg?.missingScripts.includes(TYPE_CHECK_KEY)) {
+      await addScriptToPackageJson(join56(workdir, "package.json"), TYPE_CHECK_KEY, TYPE_CHECK_SCRIPT);
+    }
+    return;
+  }
+  for (const pkg of packages) {
+    if (!pkg.missingScripts.includes(TYPE_CHECK_KEY))
+      continue;
+    await addScriptToPackageJson(join56(workdir, pkg.relativeDir, "package.json"), TYPE_CHECK_KEY, TYPE_CHECK_SCRIPT);
+  }
+  if (orchestrator === "turbo" && packages.some((p) => p.missingScripts.includes(TYPE_CHECK_KEY))) {
+    await addTurboTask(join56(workdir, "turbo.json"), TYPE_CHECK_KEY);
+    await addScriptToPackageJson(join56(workdir, "package.json"), TYPE_CHECK_KEY, TYPE_CHECK_TURBO_PASSTHROUGH);
+  }
+}
+var TYPE_CHECK_KEY = "type-check", TYPE_CHECK_SCRIPT = "tsc --noEmit -p tsconfig.json", TYPE_CHECK_TURBO_PASSTHROUGH = "turbo run type-check", _fillScriptsDeps;
+var init_setup_fill = __esm(() => {
+  _fillScriptsDeps = {
+    readJson: async (path13) => {
+      try {
+        const f = Bun.file(path13);
+        if (!await f.exists())
+          return null;
+        return JSON.parse(await f.text());
+      } catch {
+        return null;
+      }
+    },
+    writeFile: async (path13, content) => {
+      await Bun.write(path13, content);
+    }
+  };
+});
+
+// src/cli/setup-llm.ts
+var generateSetupPlan = (ctx, analysis) => callOp(ctx, setupGenerateOp, analysis);
+var init_setup_llm = __esm(() => {
+  init_operations();
+  init_setup_generate();
+});
+
+// src/cli/setup-verify.ts
+async function runSetupGate(workdir, config2) {
+  const logger = getLogger();
+  const quality = config2.quality;
+  const testCmd = quality?.commands?.test;
+  if (!testCmd) {
+    logger.info("setup-verify", "No test command configured \u2014 skipping verification gate", {
+      storyId: "setup"
+    });
+    return 0;
+  }
+  logger.info("setup-verify", "Running verification gate", { storyId: "setup", cmd: testCmd });
+  const parts = testCmd.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0)
+    return 0;
+  const proc = _setupVerifyDeps.spawn(parts, { cwd: workdir });
+  return await proc.exited;
+}
+var _setupVerifyDeps;
+var init_setup_verify = __esm(() => {
+  init_logger2();
+  _setupVerifyDeps = {
+    spawn: Bun.spawn.bind(Bun)
+  };
+});
+
+// src/cli/setup.ts
+var exports_setup = {};
+__export(exports_setup, {
+  setupCommand: () => setupCommand,
+  _setupDeps: () => _setupDeps
+});
+import { join as join57 } from "path";
+async function setupCommand(options = {}) {
+  const workdir = options.dir ?? process.cwd();
+  const naxDir = join57(workdir, ".nax");
+  const naxConfigPath = join57(naxDir, "config.json");
+  const exists = await _setupDeps.fileExists(naxConfigPath);
+  if (exists && !options.force) {
+    _setupDeps.stderr("[setup] .nax/config.json already exists. Use --force to overwrite.");
+    return 1;
+  }
+  const analysis = await _setupDeps.analyzeRepo(workdir);
+  const { ctx, close } = await _setupDeps.buildCallContext(workdir, options.agent);
+  let plan;
+  try {
+    try {
+      plan = await _setupDeps.generateSetupPlan(ctx, analysis);
+    } catch (err) {
+      if (err instanceof NaxError && err.code === "SETUP_PLAN_INVALID") {
+        _setupDeps.stderr(`[setup] ${err.message}`);
+        return 1;
+      }
+      throw err;
+    }
+    if (options.dryRun) {
+      _setupDeps.stdout(`[setup] Dry run \u2014 planned root config:
+${JSON.stringify(plan.config, null, 2)}`);
+      return 0;
+    }
+    for (const gap of plan.gaps) {
+      _setupDeps.stderr(`[setup] gap: ${gap}`);
+    }
+    if (options.fillScripts) {
+      await _setupDeps.fillScripts(workdir, analysis);
+    }
+    await _setupDeps.mkdir(naxDir);
+    await _setupDeps.writeFile(naxConfigPath, JSON.stringify(plan.config, null, 2));
+    for (const mc of plan.monoConfigs) {
+      const monoDir = join57(naxDir, "mono", mc.relativeDir);
+      await _setupDeps.mkdir(monoDir);
+      await _setupDeps.writeFile(join57(monoDir, "config.json"), JSON.stringify(mc.config, null, 2));
+    }
+    const gateResult = await _setupDeps.runGate(workdir, plan.config);
+    if (gateResult !== 0) {
+      return gateResult;
+    }
+    return 0;
+  } finally {
+    await close();
+  }
+}
+var _setupDeps;
+var init_setup = __esm(() => {
+  init_errors();
+  init_setup_analyze();
+  init_setup_fill();
+  init_setup_llm();
+  init_setup_verify();
+  _setupDeps = {
+    analyzeRepo,
+    fillScripts,
+    buildCallContext: async (workdir, agentName) => {
+      const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
+      const { createRuntime: createRuntime2 } = await Promise.resolve().then(() => (init_runtime(), exports_runtime));
+      const config2 = await loadConfig2(workdir);
+      const rt = createRuntime2(config2, workdir);
+      return {
+        ctx: {
+          runtime: rt,
+          packageView: rt.packages.resolve(),
+          packageDir: workdir,
+          agentName: agentName ?? rt.agentManager.getDefault()
+        },
+        close: () => rt.close()
+      };
+    },
+    generateSetupPlan: (ctx, analysis) => generateSetupPlan(ctx, analysis),
+    runGate: (workdir, config2) => runSetupGate(workdir, config2),
+    fileExists: (path13) => Bun.file(path13).exists(),
+    writeFile: (path13, content) => Bun.write(path13, content).then(() => {}),
+    mkdir: async (path13) => {
+      const proc = Bun.spawn(["mkdir", "-p", path13]);
+      await proc.exited;
+    },
+    stdout: (msg) => {
+      process.stdout.write(`${msg}
+`);
+    },
+    stderr: (msg) => {
+      process.stderr.write(`${msg}
+`);
+    }
+  };
+});
+
 // src/plugins/builtin/curator/collect.ts
 import * as path13 from "path";
 function now() {
@@ -57770,12 +58609,12 @@ function renderProposals(proposals, runId, observationCount) {
 }
 
 // src/plugins/builtin/curator/rollup.ts
-import { appendFile as appendFile3, mkdir as mkdir10, writeFile } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir9, writeFile } from "fs/promises";
 import * as path14 from "path";
 async function appendToRollup(observations, rollupPath) {
   try {
     const dir = path14.dirname(rollupPath);
-    await mkdir10(dir, { recursive: true });
+    await mkdir9(dir, { recursive: true });
     if (observations.length === 0) {
       const f = Bun.file(rollupPath);
       if (!await f.exists()) {
@@ -57792,7 +58631,7 @@ async function appendToRollup(observations, rollupPath) {
 var init_rollup = () => {};
 
 // src/plugins/builtin/curator/index.ts
-import { mkdir as mkdir11 } from "fs/promises";
+import { mkdir as mkdir10 } from "fs/promises";
 import * as path15 from "path";
 function getCuratorEnabled(context) {
   const cfg = context.config;
@@ -57867,7 +58706,7 @@ var init_curator = __esm(() => {
         if (context.outputDir) {
           const { observationsPath, rollupPath } = resolveCuratorOutputs(curatorContext);
           const runDir = path15.dirname(observationsPath);
-          await mkdir11(runDir, { recursive: true });
+          await mkdir10(runDir, { recursive: true });
           await Bun.write(observationsPath, observations.map((o) => JSON.stringify(o)).join(`
 `) + (observations.length > 0 ? `
 ` : ""));
@@ -58443,12 +59282,12 @@ var init_loader4 = __esm(() => {
 });
 
 // src/utils/paths.ts
-import { join as join64 } from "path";
+import { join as join68 } from "path";
 function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join64(globalConfigDir(), "runs");
+  return process.env.NAX_RUNS_DIR ?? join68(globalConfigDir(), "runs");
 }
 function getEventsRootDir() {
-  return join64(globalConfigDir(), "events");
+  return join68(globalConfigDir(), "events");
 }
 var init_paths3 = __esm(() => {
   init_paths();
@@ -58508,7 +59347,7 @@ var init_command_argv = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join71 } from "path";
+import { join as join75 } from "path";
 function createDrainDeadline2(deadlineMs) {
   let timeoutId;
   const promise2 = new Promise((resolve16) => {
@@ -58527,14 +59366,14 @@ async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join71(projectDir, "hooks.json");
+  const projectPath = join75(projectDir, "hooks.json");
   const projectData = await loadJsonFile(projectPath, "hooks");
   if (projectData) {
     projectHooks = projectData;
     skipGlobal = projectData.skipGlobal ?? false;
   }
   if (!skipGlobal && globalDir) {
-    const globalPath = join71(globalDir, "hooks.json");
+    const globalPath = join75(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -58704,7 +59543,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.69.0",
+    version: "0.69.2",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -58799,8 +59638,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("ce4d8f0e"))
-        return "ce4d8f0e";
+      if (/^[0-9a-f]{6,10}$/.test("99db370f"))
+        return "99db370f";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -59676,16 +60515,16 @@ var init_acceptance_loop = __esm(() => {
 });
 
 // src/session/scratch-purge.ts
-import { mkdir as mkdir13, rename, rm } from "fs/promises";
-import { dirname as dirname12, join as join72 } from "path";
+import { mkdir as mkdir12, rename, rm } from "fs/promises";
+import { dirname as dirname12, join as join76 } from "path";
 async function purgeStaleScratch(projectDir, featureName, retentionDays, archiveInsteadOfDelete = false) {
-  const sessionsDir = join72(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsDir = join76(projectDir, ".nax", "features", featureName, "sessions");
   const sessionIds = await _scratchPurgeDeps.listSessionDirs(sessionsDir);
   const cutoffMs = _scratchPurgeDeps.now() - retentionDays * 86400000;
   let purged = 0;
   for (const sessionId of sessionIds) {
-    const sessionDir = join72(sessionsDir, sessionId);
-    const descriptorPath = join72(sessionDir, "descriptor.json");
+    const sessionDir = join76(sessionsDir, sessionId);
+    const descriptorPath = join76(sessionDir, "descriptor.json");
     if (!await _scratchPurgeDeps.fileExists(descriptorPath))
       continue;
     let lastActivityAt;
@@ -59701,7 +60540,7 @@ async function purgeStaleScratch(projectDir, featureName, retentionDays, archive
     if (new Date(lastActivityAt).getTime() >= cutoffMs)
       continue;
     if (archiveInsteadOfDelete) {
-      const archiveDest = join72(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
+      const archiveDest = join76(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
       await _scratchPurgeDeps.move(sessionDir, archiveDest);
     } else {
       await _scratchPurgeDeps.remove(sessionDir);
@@ -59728,7 +60567,7 @@ var init_scratch_purge = __esm(() => {
     readFile: (path19) => Bun.file(path19).text(),
     remove: (path19) => rm(path19, { recursive: true, force: true }),
     move: async (src, dest) => {
-      await mkdir13(dirname12(dest), { recursive: true });
+      await mkdir12(dirname12(dest), { recursive: true });
       await rename(src, dest);
     },
     now: () => Date.now()
@@ -60438,19 +61277,19 @@ function precomputeBatchPlan(stories, maxBatchSize = DEFAULT_MAX_BATCH_SIZE) {
 var DEFAULT_MAX_BATCH_SIZE = 4;
 
 // src/pipeline/subscribers/events-writer.ts
-import { appendFile as appendFile4, mkdir as mkdir14 } from "fs/promises";
-import { basename as basename13, join as join73 } from "path";
+import { appendFile as appendFile4, mkdir as mkdir13 } from "fs/promises";
+import { basename as basename13, join as join77 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
   const project = basename13(workdir);
-  const eventsDir = join73(getEventsRootDir(), project);
-  const eventsFile = join73(eventsDir, "events.jsonl");
+  const eventsDir = join77(getEventsRootDir(), project);
+  const eventsFile = join77(eventsDir, "events.jsonl");
   let dirReady = false;
   const write = (line) => {
     return (async () => {
       try {
         if (!dirReady) {
-          await mkdir14(eventsDir, { recursive: true });
+          await mkdir13(eventsDir, { recursive: true });
           dirReady = true;
         }
         await appendFile4(eventsFile, `${JSON.stringify(line)}
@@ -60624,24 +61463,24 @@ var init_interaction2 = __esm(() => {
 });
 
 // src/pipeline/subscribers/registry.ts
-import { mkdir as mkdir15, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename14, join as join74 } from "path";
+import { mkdir as mkdir14, writeFile as writeFile2 } from "fs/promises";
+import { basename as basename14, join as join78 } from "path";
 function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const logger = getSafeLogger();
   const project = basename14(workdir);
-  const runDir = join74(getRunsDir(), `${project}-${feature}-${runId}`);
-  const metaFile = join74(runDir, "meta.json");
+  const runDir = join78(getRunsDir(), `${project}-${feature}-${runId}`);
+  const metaFile = join78(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
     return (async () => {
       try {
-        await mkdir15(runDir, { recursive: true });
+        await mkdir14(runDir, { recursive: true });
         const meta3 = {
           runId,
           project,
           feature,
           workdir,
-          statusPath: join74(outputDir, "features", feature, "status.json"),
-          eventsDir: join74(outputDir, "features", feature, "runs"),
+          statusPath: join78(outputDir, "features", feature, "status.json"),
+          eventsDir: join78(outputDir, "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile2(metaFile, JSON.stringify(meta3, null, 2));
@@ -60886,8 +61725,8 @@ var init_types9 = __esm(() => {
 });
 
 // src/worktree/dependencies.ts
-import { existsSync as existsSync31 } from "fs";
-import { join as join75 } from "path";
+import { existsSync as existsSync30 } from "fs";
+import { join as join79 } from "path";
 async function prepareWorktreeDependencies(options) {
   const mode = options.config.execution.worktreeDependencies.mode;
   const resolvedCwd = resolveDependencyCwd(options);
@@ -60901,7 +61740,7 @@ async function prepareWorktreeDependencies(options) {
   }
 }
 function resolveDependencyCwd(options) {
-  return options.storyWorkdir ? join75(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
+  return options.storyWorkdir ? join79(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
 }
 function resolveInheritedDependencies(options, resolvedCwd) {
   if (hasDependencyManifests(options.worktreeRoot, resolvedCwd)) {
@@ -60911,14 +61750,14 @@ function resolveInheritedDependencies(options, resolvedCwd) {
 }
 function hasDependencyManifests(worktreeRoot, resolvedCwd) {
   const directories = resolvedCwd === worktreeRoot ? [worktreeRoot] : [worktreeRoot, resolvedCwd];
-  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join75(directory, filename))));
+  return directories.some((directory) => PHASE_ONE_INHERIT_UNSUPPORTED_FILES.some((filename) => _worktreeDependencyDeps.existsSync(join79(directory, filename))));
 }
 async function provisionDependencies(config2, worktreeRoot, resolvedCwd) {
-  const setupCommand = config2.execution.worktreeDependencies.setupCommand;
-  if (!setupCommand) {
+  const setupCommand2 = config2.execution.worktreeDependencies.setupCommand;
+  if (!setupCommand2) {
     throw new WorktreeDependencyPreparationError("[worktree-deps] provision mode requires execution.worktreeDependencies.setupCommand in phase 1.", "provision");
   }
-  const argv = parseCommandToArgv(setupCommand);
+  const argv = parseCommandToArgv(setupCommand2);
   if (argv.length === 0) {
     throw new WorktreeDependencyPreparationError("[worktree-deps] setupCommand cannot be empty.", "provision");
   }
@@ -60962,7 +61801,7 @@ var init_dependencies = __esm(() => {
     "build.gradle.kts"
   ];
   _worktreeDependencyDeps = {
-    existsSync: existsSync31,
+    existsSync: existsSync30,
     spawn
   };
 });
@@ -60973,19 +61812,19 @@ __export(exports_manager, {
   _managerDeps: () => _managerDeps,
   WorktreeManager: () => WorktreeManager
 });
-import { existsSync as existsSync32, symlinkSync } from "fs";
-import { mkdir as mkdir16 } from "fs/promises";
-import { join as join76 } from "path";
+import { existsSync as existsSync31, symlinkSync } from "fs";
+import { mkdir as mkdir15 } from "fs/promises";
+import { join as join80 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join76(projectRoot, ".git", "info");
-    const excludePath = join76(infoDir, "exclude");
+    const infoDir = join80(projectRoot, ".git", "info");
+    const excludePath = join80(infoDir, "exclude");
     try {
-      await mkdir16(infoDir, { recursive: true });
+      await mkdir15(infoDir, { recursive: true });
       let existing = "";
-      if (existsSync32(excludePath)) {
+      if (existsSync31(excludePath)) {
         existing = await Bun.file(excludePath).text();
       }
       const missing = NAX_GITIGNORE_ENTRIES.filter((entry) => !existing.includes(entry));
@@ -61008,7 +61847,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join76(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join80(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -61049,9 +61888,9 @@ ${missing.join(`
       }
       throw new Error(`Failed to create worktree: ${String(error48)}`);
     }
-    const envSource = join76(projectRoot, ".env");
-    if (existsSync32(envSource)) {
-      const envTarget = join76(worktreePath, ".env");
+    const envSource = join80(projectRoot, ".env");
+    if (existsSync31(envSource)) {
+      const envTarget = join80(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -61062,7 +61901,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join76(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join80(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -61874,10 +62713,10 @@ var init_merge_conflict_rectify = __esm(() => {
 });
 
 // src/execution/pipeline-result-handler.ts
-import { join as join77 } from "path";
+import { join as join81 } from "path";
 async function removeWorktreeDirectory(projectRoot, storyId) {
   const logger = getSafeLogger();
-  const worktreePath = join77(projectRoot, ".nax-wt", storyId);
+  const worktreePath = join81(projectRoot, ".nax-wt", storyId);
   try {
     const proc = _resultHandlerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
       cwd: projectRoot,
@@ -62093,8 +62932,8 @@ var init_pipeline_result_handler = __esm(() => {
 });
 
 // src/execution/iteration-runner.ts
-import { existsSync as existsSync33 } from "fs";
-import { join as join78 } from "path";
+import { existsSync as existsSync32 } from "fs";
+import { join as join82 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
   if (ctx.dryRun) {
@@ -62119,7 +62958,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   const storyStartTime = Date.now();
   let effectiveWorkdir = ctx.workdir;
   if (ctx.config.execution.storyIsolation === "worktree") {
-    const worktreePath = join78(ctx.workdir, ".nax-wt", story.id);
+    const worktreePath = join82(ctx.workdir, ".nax-wt", story.id);
     const worktreeExists = _iterationRunnerDeps.existsSync(worktreePath);
     if (!worktreeExists) {
       await _iterationRunnerDeps.worktreeManager.ensureGitExcludes(ctx.workdir);
@@ -62139,7 +62978,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
   }
   const accumulatedAttemptCost = (story.priorFailures || []).reduce((sum, f) => sum + (f.cost || 0), 0);
   const profileOverride = ctx.config.profile && ctx.config.profile !== "default" ? { profile: ctx.config.profile } : undefined;
-  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join78(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
+  const effectiveConfig = story.workdir ? await _iterationRunnerDeps.loadConfigForWorkdir(join82(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
   let dependencyContext;
   if (ctx.config.execution.storyIsolation === "worktree") {
     try {
@@ -62166,7 +63005,7 @@ async function runIteration(ctx, prd, selection, iterations, totalCost, allStory
       };
     }
   }
-  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join78(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join78(ctx.workdir, story.workdir) : ctx.workdir;
+  const resolvedWorkdir = dependencyContext?.cwd ? dependencyContext.cwd : ctx.config.execution.storyIsolation === "worktree" ? story.workdir ? join82(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join82(ctx.workdir, story.workdir) : ctx.workdir;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -62298,7 +63137,7 @@ var init_iteration_runner = __esm(() => {
     loadConfigForWorkdir,
     prepareWorktreeDependencies,
     runPipeline,
-    existsSync: existsSync33,
+    existsSync: existsSync32,
     worktreeManager: new WorktreeManager
   };
 });
@@ -62368,7 +63207,7 @@ __export(exports_parallel_worker, {
   buildWorktreePipelineContext: () => buildWorktreePipelineContext,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
-import { join as join79 } from "path";
+import { join as join83 } from "path";
 function buildWorktreePipelineContext(base, _story) {
   return { ...base, prd: structuredClone(base.prd) };
 }
@@ -62391,7 +63230,7 @@ async function executeStoryInWorktree(story, worktreePath, dependencyContext, co
       story,
       stories: [story],
       projectDir: context.projectDir,
-      workdir: dependencyContext.cwd ?? (story.workdir ? join79(worktreePath, story.workdir) : worktreePath),
+      workdir: dependencyContext.cwd ?? (story.workdir ? join83(worktreePath, story.workdir) : worktreePath),
       worktreeDependencyContext: dependencyContext,
       routing,
       storyGitRef: storyGitRef ?? undefined
@@ -63278,7 +64117,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join80 } from "path";
+import { join as join84 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -63397,7 +64236,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join80(featureDir, "status.json");
+    const featureStatusPath = join84(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -63428,11 +64267,11 @@ __export(exports_migrate, {
   migrateCommand: () => migrateCommand,
   detectGeneratedContent: () => detectGeneratedContent
 });
-import { existsSync as existsSync34 } from "fs";
-import { mkdir as mkdir17, readdir as readdir6, rename as rename3 } from "fs/promises";
+import { existsSync as existsSync33 } from "fs";
+import { mkdir as mkdir16, readdir as readdir6, rename as rename3 } from "fs/promises";
 import path22 from "path";
 async function detectGeneratedContent(naxDir) {
-  if (!existsSync34(naxDir))
+  if (!existsSync33(naxDir))
     return [];
   const candidates = [];
   let entries = [];
@@ -63447,7 +64286,7 @@ async function detectGeneratedContent(naxDir) {
     }
   }
   const featuresDir = path22.join(naxDir, "features");
-  if (existsSync34(featuresDir)) {
+  if (existsSync33(featuresDir)) {
     let featureDirs = [];
     try {
       featureDirs = await readdir6(featuresDir);
@@ -63509,7 +64348,7 @@ async function migrateCommand(options) {
       });
     }
     const src = path22.join(globalConfigDir(), options.reclaim);
-    if (!existsSync34(src)) {
+    if (!existsSync33(src)) {
       throw new NaxError(`Nothing to reclaim: ~/.nax/${options.reclaim} does not exist`, "MIGRATE_RECLAIM_NOT_FOUND", {
         stage: "migrate",
         name: options.reclaim
@@ -63517,7 +64356,7 @@ async function migrateCommand(options) {
     }
     const archiveBase = path22.join(globalConfigDir(), "_archive");
     const archiveDest = path22.join(archiveBase, `${options.reclaim}-${Date.now()}`);
-    await mkdir17(archiveBase, { recursive: true });
+    await mkdir16(archiveBase, { recursive: true });
     await rename3(src, archiveDest);
     logger.info("migrate", `Reclaimed: archived to ${archiveDest}`, { storyId: "_migrate" });
     return;
@@ -63555,7 +64394,7 @@ async function migrateCommand(options) {
   }
   const naxDir = path22.join(options.workdir, ".nax");
   const configPath = path22.join(naxDir, "config.json");
-  if (!existsSync34(configPath)) {
+  if (!existsSync33(configPath)) {
     throw new NaxError("No .nax/config.json found \u2014 run nax init first", "MIGRATE_NO_CONFIG", {
       stage: "migrate",
       workdir: options.workdir
@@ -63585,12 +64424,12 @@ async function migrateCommand(options) {
     }
     return;
   }
-  await mkdir17(destBase, { recursive: true });
+  await mkdir16(destBase, { recursive: true });
   let moved = 0;
   for (const candidate of candidates) {
     const dest = path22.join(destBase, candidate.name);
-    await mkdir17(path22.dirname(dest), { recursive: true });
-    if (existsSync34(dest)) {
+    await mkdir16(path22.dirname(dest), { recursive: true });
+    if (existsSync33(dest)) {
       throw new NaxError(`Migration conflict: destination already exists.
   Source:      ${candidate.srcPath}
   Destination: ${dest}
@@ -63831,7 +64670,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join81 } from "path";
+import { join as join85 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -63848,7 +64687,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join81(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join85(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -64114,6 +64953,17 @@ async function setupRun(options) {
     featureName: options.feature,
     agentStreamEvents: options.agentStreamEvents
   });
+  try {
+    const workspacePackages = await discoverWorkspacePackages(workdir);
+    if (workspacePackages.length > 0) {
+      await runtime.packages.hydrate(workspacePackages);
+    }
+  } catch (err) {
+    getSafeLogger()?.warn("run-setup", "Per-package config hydration failed \u2014 using root config", {
+      storyId: "_setup",
+      error: errorMessage(err)
+    });
+  }
   await runtime.pidRegistry.cleanupStale();
   const cleanupCrashHandlers = installCrashHandlers({
     statusWriter,
@@ -64280,6 +65130,7 @@ async function setupRun(options) {
 var _runSetupDeps;
 var init_run_setup = __esm(() => {
   init_pipeline();
+  init_test_runners();
   init_paths();
   init_errors();
   init_interaction();
@@ -64289,7 +65140,6 @@ var init_run_setup = __esm(() => {
   init_project();
   init_runtime();
   init_session();
-  init_resolver();
   init_version();
   init_crash_recovery();
   init_helpers();
@@ -93641,7 +94491,7 @@ __export(exports_curator, {
 });
 import { readdirSync as readdirSync8 } from "fs";
 import { unlink as unlink4 } from "fs/promises";
-import { basename as basename15, join as join83 } from "path";
+import { basename as basename15, join as join87 } from "path";
 function getProjectKey(config2, projectDir) {
   return config2.name?.trim() || basename15(projectDir);
 }
@@ -93724,7 +94574,7 @@ async function curatorStatus(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join83(outputDir, "runs");
+  const runsDir = join87(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   let runId;
   if (options.run) {
@@ -93741,8 +94591,8 @@ async function curatorStatus(options) {
     runId = runIds[runIds.length - 1];
   }
   console.log(`Run: ${runId}`);
-  const runDir = join83(runsDir, runId);
-  const observationsPath = join83(runDir, "observations.jsonl");
+  const runDir = join87(runsDir, runId);
+  const observationsPath = join87(runDir, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const counts = new Map;
   for (const obs of observations) {
@@ -93752,7 +94602,7 @@ async function curatorStatus(options) {
   for (const [kind, count] of counts.entries()) {
     console.log(`  ${kind}: ${count}`);
   }
-  const proposalsPath = join83(runDir, "curator-proposals.md");
+  const proposalsPath = join87(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText !== null) {
     console.log("");
@@ -93766,8 +94616,8 @@ async function curatorCommit(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runDir = join83(outputDir, "runs", options.runId);
-  const proposalsPath = join83(runDir, "curator-proposals.md");
+  const runDir = join87(outputDir, "runs", options.runId);
+  const proposalsPath = join87(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText === null) {
     console.log(`curator-proposals.md not found for run ${options.runId}.`);
@@ -93783,7 +94633,7 @@ async function curatorCommit(options) {
   const dropFileState = new Map;
   const skippedDrops = new Set;
   for (const drop2 of drops) {
-    const targetPath = join83(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join87(resolved.projectDir, drop2.canonicalFile);
     if (!dropFileState.has(targetPath)) {
       const fileExists2 = await Bun.file(targetPath).exists();
       const existing = fileExists2 ? await _curatorCmdDeps.readFile(targetPath).catch(() => "") : "";
@@ -93817,7 +94667,7 @@ async function curatorCommit(options) {
     if (skippedDrops.has(drop2)) {
       continue;
     }
-    const targetPath = join83(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join87(resolved.projectDir, drop2.canonicalFile);
     const existing = await _curatorCmdDeps.readFile(targetPath).catch(() => "");
     const filtered = filterDropContent(existing, drop2.description);
     await _curatorCmdDeps.writeFile(targetPath, filtered);
@@ -93826,7 +94676,7 @@ async function curatorCommit(options) {
   }
   const adds = proposals.filter((p) => p.action === "add" || p.action === "advisory");
   for (const add2 of adds) {
-    const targetPath = join83(resolved.projectDir, add2.canonicalFile);
+    const targetPath = join87(resolved.projectDir, add2.canonicalFile);
     const content = buildAddContent(add2);
     await _curatorCmdDeps.appendFile(targetPath, content);
     modifiedFiles.add(targetPath);
@@ -93863,7 +94713,7 @@ async function curatorDryrun(options) {
   const config2 = await _curatorCmdDeps.loadConfig(resolved.projectDir);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join83(outputDir, "runs");
+  const runsDir = join87(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   if (runIds.length === 0) {
     console.log("No runs found.");
@@ -93874,7 +94724,7 @@ async function curatorDryrun(options) {
     console.log(`Run ${options.run} not found in ${runsDir}.`);
     return;
   }
-  const observationsPath = join83(runsDir, runId, "observations.jsonl");
+  const observationsPath = join87(runsDir, runId, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const thresholds = getThresholds(config2);
   const proposals = runHeuristics(observations, thresholds);
@@ -93915,12 +94765,12 @@ async function curatorGc(options) {
   await _curatorCmdDeps.writeFile(rollupPath, newContent);
   const projectKey = getProjectKey(config2, resolved.projectDir);
   const outputDir = _curatorCmdDeps.projectOutputDir(projectKey, config2.outputDir);
-  const perRunsDir = join83(outputDir, "runs");
+  const perRunsDir = join87(outputDir, "runs");
   for (const runId of uniqueRunIds) {
     if (!keepSet.has(runId)) {
-      const runDir = join83(perRunsDir, runId);
-      await _curatorCmdDeps.removeFile(join83(runDir, "observations.jsonl"));
-      await _curatorCmdDeps.removeFile(join83(runDir, "curator-proposals.md"));
+      const runDir = join87(perRunsDir, runId);
+      await _curatorCmdDeps.removeFile(join87(runDir, "observations.jsonl"));
+      await _curatorCmdDeps.removeFile(join87(runDir, "curator-proposals.md"));
     }
   }
   console.log(`[gc] Pruned rollup to ${keep} most recent runs (was ${uniqueRunIds.length}).`);
@@ -93963,9 +94813,9 @@ var init_curator2 = __esm(() => {
 
 // bin/nax.ts
 init_source();
-import { existsSync as existsSync36, mkdirSync as mkdirSync7 } from "fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename16, join as join84 } from "path";
+import { basename as basename16, join as join88 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -93989,12 +94839,12 @@ init_errors();
 init_operations();
 
 // src/plan/strategies/context-builder.ts
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 init_config();
 init_errors();
 init_interaction();
 async function buildPlanModeContext(workdir, fullConfig, options, deps) {
-  const naxDir = join38(workdir, ".nax");
+  const naxDir = join39(workdir, ".nax");
   if (!deps.existsSync(naxDir)) {
     throw new NaxError(`.nax directory not found. Run 'nax init' first in ${workdir}`, "PLAN_CONTEXT_NO_NAX_DIR", {
       stage: "plan",
@@ -94002,8 +94852,8 @@ async function buildPlanModeContext(workdir, fullConfig, options, deps) {
     });
   }
   validateFeatureName(options.feature);
-  const outputDir = join38(naxDir, "features", options.feature);
-  const outputPath = join38(outputDir, "prd.json");
+  const outputDir = join39(naxDir, "features", options.feature);
+  const outputPath = join39(outputDir, "prd.json");
   const [specContent, sourceRoots, pkg] = await Promise.all([
     deps.readFile(options.from),
     deps.scanSourceRoots(workdir),
@@ -94018,7 +94868,7 @@ async function buildPlanModeContext(workdir, fullConfig, options, deps) {
     ...new Set(sourceRoots.map((root) => root.path).filter((path7) => path7 !== ".").map((path7) => path7.startsWith("/") ? path7.replace(`${workdir}/`, "") : path7))
   ];
   const packageDetails = relativePackages.length === 0 ? [] : await Promise.all(relativePackages.map(async (relativePath) => {
-    const packageJson = await deps.readPackageJsonAt(join38(workdir, relativePath, "package.json"));
+    const packageJson = await deps.readPackageJsonAt(join39(workdir, relativePath, "package.json"));
     return buildPackageSummary(relativePath, packageJson);
   }));
   const projectName = detectProjectName(workdir, pkg);
@@ -94621,7 +95471,7 @@ init_interaction();
 init_prd();
 init_runtime();
 import { existsSync as existsSync17, readdirSync as readdirSync3 } from "fs";
-import { basename as basename7, join as join43, resolve as resolve14 } from "path";
+import { basename as basename7, join as join44, resolve as resolve14 } from "path";
 var _statusFeaturesDeps = {
   projectOutputDir,
   loadConfig
@@ -94635,7 +95485,7 @@ function isPidAlive(pid) {
   }
 }
 async function loadStatusFile(featureDir) {
-  const statusPath = join43(featureDir, "status.json");
+  const statusPath = join44(featureDir, "status.json");
   if (!existsSync17(statusPath)) {
     return null;
   }
@@ -94650,7 +95500,7 @@ async function loadProjectStatusFile(projectDir) {
   const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
   const projectKey = config2?.name?.trim() || basename7(projectDir);
   const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
-  const statusPath = join43(outputDir, "status.json");
+  const statusPath = join44(outputDir, "status.json");
   if (!existsSync17(statusPath)) {
     return null;
   }
@@ -94662,7 +95512,7 @@ async function loadProjectStatusFile(projectDir) {
   }
 }
 async function getFeatureSummary(featureName, featureDir) {
-  const prdPath = join43(featureDir, "prd.json");
+  const prdPath = join44(featureDir, "prd.json");
   if (!existsSync17(prdPath)) {
     return {
       name: featureName,
@@ -94705,7 +95555,7 @@ async function getFeatureSummary(featureName, featureDir) {
       };
     }
   }
-  const runsDir = join43(featureDir, "runs");
+  const runsDir = join44(featureDir, "runs");
   if (existsSync17(runsDir)) {
     const runs = readdirSync3(runsDir, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".jsonl") && e.name !== "latest.jsonl").map((e) => e.name).sort().reverse();
     if (runs.length > 0) {
@@ -94719,7 +95569,7 @@ async function displayAllFeatures(projectDir) {
   const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
   const projectKey = config2?.name?.trim() || basename7(projectDir);
   const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
-  const featuresDir = join43(outputDir, "features");
+  const featuresDir = join44(outputDir, "features");
   if (!existsSync17(featuresDir)) {
     console.log(source_default.dim("No features found."));
     return;
@@ -94760,7 +95610,7 @@ async function displayAllFeatures(projectDir) {
       console.log();
     }
   }
-  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join43(featuresDir, name))));
+  const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join44(featuresDir, name))));
   console.log(source_default.bold(`\uD83D\uDCCA Features
 `));
   const header = `  ${"Feature".padEnd(25)} ${"Done".padEnd(6)} ${"Failed".padEnd(8)} ${"Pending".padEnd(9)} ${"Last Run".padEnd(22)} ${"Cost".padEnd(10)} Status`;
@@ -94786,7 +95636,7 @@ async function displayAllFeatures(projectDir) {
   console.log();
 }
 async function displayFeatureDetails(featureName, featureDir) {
-  const prdPath = join43(featureDir, "prd.json");
+  const prdPath = join44(featureDir, "prd.json");
   if (!existsSync17(prdPath)) {
     console.log(source_default.bold(`
 \uD83D\uDCCA ${featureName}
@@ -94932,7 +95782,7 @@ async function displayFeatureStatus(options = {}) {
       const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
       const projectKey = config2?.name?.trim() || basename7(projectDir);
       const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
-      featureDir = join43(outputDir, "features", options.feature);
+      featureDir = join44(outputDir, "features", options.feature);
     } else {
       const resolved = resolveProject({ feature: options.feature });
       if (!resolved.featureDir) {
@@ -94952,7 +95802,7 @@ init_errors();
 init_logger2();
 init_runtime();
 import { existsSync as existsSync18, readdirSync as readdirSync4 } from "fs";
-import { basename as basename8, join as join44 } from "path";
+import { basename as basename8, join as join45 } from "path";
 async function resolveOutputDir2(workdir, override) {
   if (override)
     return override;
@@ -94976,7 +95826,7 @@ async function runsListCommand(options) {
   const logger = getLogger();
   const { feature, workdir } = options;
   const outputDir = await resolveOutputDir2(workdir, options.outputDir);
-  const runsDir = join44(outputDir, "features", feature, "runs");
+  const runsDir = join45(outputDir, "features", feature, "runs");
   if (!existsSync18(runsDir)) {
     logger.info("cli", "No runs found for feature", { feature, hint: `Directory not found: ${runsDir}` });
     return;
@@ -94988,7 +95838,7 @@ async function runsListCommand(options) {
   }
   logger.info("cli", `Runs for ${feature}`, { count: files.length });
   for (const file3 of files.sort().reverse()) {
-    const logPath = join44(runsDir, file3);
+    const logPath = join45(runsDir, file3);
     const entries = await parseRunLog(logPath);
     const startEvent = entries.find((e) => e.message === "run.start");
     const completeEvent = entries.find((e) => e.message === "run.complete");
@@ -95015,7 +95865,7 @@ async function runsShowCommand(options) {
   const logger = getLogger();
   const { runId, feature, workdir } = options;
   const outputDir = await resolveOutputDir2(workdir, options.outputDir);
-  const logPath = join44(outputDir, "features", feature, "runs", `${runId}.jsonl`);
+  const logPath = join45(outputDir, "features", feature, "runs", `${runId}.jsonl`);
   if (!existsSync18(logPath)) {
     logger.error("cli", "Run not found", { runId, feature, logPath });
     throw new NaxError("Run not found", "RUN_NOT_FOUND", { runId, feature, logPath });
@@ -95055,6 +95905,7 @@ async function runsShowCommand(options) {
 // src/cli/index.ts
 init_prompts2();
 init_init2();
+init_setup();
 
 // src/cli/plugins.ts
 init_paths();
@@ -95129,8 +95980,8 @@ init_interaction();
 init_source();
 init_loader();
 init_generator2();
-import { existsSync as existsSync25 } from "fs";
-import { join as join58 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { join as join62 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -95173,7 +96024,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join58(workdir, options.package);
+    const packageDir = join62(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -95193,10 +96044,10 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join58(workdir, options.context) : join58(workdir, ".nax/context.md");
-  const outputDir = options.output ? join58(workdir, options.output) : workdir;
+  const contextPath = options.context ? join62(workdir, options.context) : join62(workdir, ".nax/context.md");
+  const outputDir = options.output ? join62(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
-  if (!existsSync25(contextPath)) {
+  if (!existsSync24(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
     console.error(source_default.yellow("  Create .nax/context.md first, or run `nax init` to scaffold it."));
     process.exit(1);
@@ -95299,8 +96150,8 @@ async function generateCommand(options) {
 }
 // src/cli/config-display.ts
 init_loader();
-import { existsSync as existsSync27 } from "fs";
-import { join as join60 } from "path";
+import { existsSync as existsSync26 } from "fs";
+import { join as join64 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -95551,10 +96402,10 @@ function deepEqual(a, b) {
 // src/cli/config-get.ts
 init_defaults();
 init_loader();
-import { existsSync as existsSync26 } from "fs";
-import { join as join59 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { join as join63 } from "path";
 async function loadConfigFile(path18) {
-  if (!existsSync26(path18))
+  if (!existsSync25(path18))
     return null;
   try {
     return await Bun.file(path18).json();
@@ -95574,7 +96425,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join59(projectDir, "config.json");
+  const projectPath = join63(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -95634,14 +96485,14 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join60(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join64(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
   };
 }
 function fileExists(path18) {
-  return existsSync27(path18);
+  return existsSync26(path18);
 }
 function displayConfigWithDescriptions(obj, path18, sources, indent = 0) {
   const indentStr = "  ".repeat(indent);
@@ -95783,15 +96634,15 @@ init_paths();
 init_profile();
 import { mkdirSync as mkdirSync5 } from "fs";
 import { readdirSync as readdirSync5 } from "fs";
-import { join as join61 } from "path";
+import { join as join65 } from "path";
 var _profileCLIDeps = {
   env: process.env
 };
 var SENSITIVE_KEY_PATTERN = /key|token|secret|password|credential/i;
 var VAR_PATTERN = /\$[A-Za-z_][A-Za-z0-9_]*/;
 async function profileListCommand(startDir) {
-  const globalProfilesDir = join61(globalConfigDir(), "profiles");
-  const projectProfilesDir = join61(projectConfigDir(startDir), "profiles");
+  const globalProfilesDir = join65(globalConfigDir(), "profiles");
+  const projectProfilesDir = join65(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -95850,7 +96701,7 @@ function maskProfileValues(obj) {
   return result;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join61(projectConfigDir(startDir), "config.json");
+  const configPath = join65(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -95869,8 +96720,8 @@ async function profileCurrentCommand(startDir) {
   return resolveProfileName({}, _profileCLIDeps.env, startDir);
 }
 async function profileCreateCommand(profileName, startDir) {
-  const profilesDir = join61(projectConfigDir(startDir), "profiles");
-  const profilePath = join61(profilesDir, `${profileName}.json`);
+  const profilesDir = join65(projectConfigDir(startDir), "profiles");
+  const profilePath = join65(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
@@ -95991,8 +96842,8 @@ async function contextInspectCommand(options) {
 // src/cli/rules.ts
 init_canonical_loader();
 init_errors();
-import { mkdir as mkdir12 } from "fs/promises";
-import { basename as basename12, join as join62 } from "path";
+import { mkdir as mkdir11 } from "fs/promises";
+import { basename as basename12, join as join66 } from "path";
 var _rulesCLIDeps = {
   readFile: async (path18) => Bun.file(path18).text(),
   writeFile: async (path18, content) => {
@@ -96001,13 +96852,13 @@ var _rulesCLIDeps = {
   fileExists: async (path18) => Bun.file(path18).exists(),
   globInDir: (dir) => {
     try {
-      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join62(dir, f));
+      return [...new Bun.Glob("*.md").scanSync({ cwd: dir })].sort().map((f) => join66(dir, f));
     } catch {
       return [];
     }
   },
   mkdir: async (path18) => {
-    await mkdir12(path18, { recursive: true });
+    await mkdir11(path18, { recursive: true });
   },
   globCanonicalRuleFiles: (workdir) => {
     try {
@@ -96050,7 +96901,7 @@ ${r.content}`).join(`
 `);
   const shimContent = `${header + body}
 `;
-  const shimPath = join62(workdir, shimFileName);
+  const shimPath = join66(workdir, shimFileName);
   if (options.dryRun) {
     console.log(`[dry-run] Would write ${shimPath} (${shimContent.length} bytes)`);
     return;
@@ -96079,14 +96930,14 @@ function neutralizeContent(content) {
 }
 async function collectMigrationSources(workdir) {
   const sources = [];
-  const claudeMdPath = join62(workdir, "CLAUDE.md");
+  const claudeMdPath = join66(workdir, "CLAUDE.md");
   if (await _rulesCLIDeps.fileExists(claudeMdPath)) {
     const content = await _rulesCLIDeps.readFile(claudeMdPath);
     if (content.trim()) {
       sources.push({ sourcePath: claudeMdPath, targetFileName: "project-conventions.md", content });
     }
   }
-  const rulesDir = join62(workdir, ".claude", "rules");
+  const rulesDir = join66(workdir, ".claude", "rules");
   const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
   for (const filePath of ruleFiles) {
     try {
@@ -96106,7 +96957,7 @@ async function rulesMigrateCommand(options) {
     console.log("[WARN] No source files found (checked CLAUDE.md and .claude/rules/*.md). Nothing to migrate.");
     return;
   }
-  const targetDir = join62(workdir, CANONICAL_RULES_DIR);
+  const targetDir = join66(workdir, CANONICAL_RULES_DIR);
   if (!options.dryRun) {
     try {
       await _rulesCLIDeps.mkdir(targetDir);
@@ -96117,7 +96968,7 @@ async function rulesMigrateCommand(options) {
   let written = 0;
   let skipped = 0;
   for (const { sourcePath, targetFileName, content } of sources) {
-    const targetPath = join62(targetDir, targetFileName);
+    const targetPath = join66(targetDir, targetFileName);
     if (!force && !options.dryRun && await _rulesCLIDeps.fileExists(targetPath)) {
       console.log(`[skip] ${targetFileName} already exists (use --force to overwrite)`);
       skipped++;
@@ -96156,7 +97007,7 @@ function collectCanonicalRuleRoots(workdir) {
     const packageRel = normalized.slice(0, idx);
     if (!packageRel)
       continue;
-    roots.add(join62(workdir, packageRel));
+    roots.add(join66(workdir, packageRel));
   }
   return [...roots].sort();
 }
@@ -96178,7 +97029,7 @@ init_logger2();
 init_detect2();
 init_workspace();
 init_common();
-import { join as join63 } from "path";
+import { join as join67 } from "path";
 function resolveEffective(detected, configPatterns) {
   if (configPatterns !== undefined)
     return "config";
@@ -96263,7 +97114,7 @@ async function detectCommand(options) {
   const rootDetected = detectionMap[""] ?? { patterns: [], confidence: "empty", sources: [] };
   const pkgEntries = await Promise.all(packageDirs.map(async (dir) => {
     const det = detectionMap[dir] ?? { patterns: [], confidence: "empty", sources: [] };
-    const pkgConfigPath = join63(workdir, ".nax", "mono", dir, "config.json");
+    const pkgConfigPath = join67(workdir, ".nax", "mono", dir, "config.json");
     const pkgRaw = await loadRawConfig(pkgConfigPath);
     const pkgPatterns = deepGet(pkgRaw, TEST_PATTERNS_KEY);
     const effective = Array.isArray(pkgPatterns) ? pkgPatterns : undefined;
@@ -96317,13 +97168,13 @@ async function detectCommand(options) {
     if (rootDetected.confidence === "empty") {
       console.log(source_default.yellow("  root: skipped (empty detection)"));
     } else {
-      const rootConfigPath = join63(workdir, ".nax", "config.json");
+      const rootConfigPath = join67(workdir, ".nax", "config.json");
       try {
         const status = await applyToConfig(rootConfigPath, rootDetected.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim("  root: skipped (testFilePatterns already set; use --force to overwrite)"));
         } else {
-          console.log(source_default.green(`  root: ${status} \u2192 ${join63(".nax", "config.json")}`));
+          console.log(source_default.green(`  root: ${status} \u2192 ${join67(".nax", "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  root: write failed \u2014 ${err.message}`));
@@ -96336,13 +97187,13 @@ async function detectCommand(options) {
         console.log(source_default.dim(`  ${dir}: skipped (empty detection)`));
         continue;
       }
-      const pkgConfigPath = join63(workdir, ".nax", "mono", dir, "config.json");
+      const pkgConfigPath = join67(workdir, ".nax", "mono", dir, "config.json");
       try {
         const status = await applyToConfig(pkgConfigPath, det.patterns, options.force ?? false);
         if (status === "skipped") {
           console.log(source_default.dim(`  ${dir}: skipped (already set)`));
         } else {
-          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join63(".nax", "mono", dir, "config.json")}`));
+          console.log(source_default.green(`  ${dir}: ${status} \u2192 ${join67(".nax", "mono", dir, "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  ${dir}: write failed \u2014 ${err.message}`));
@@ -96359,20 +97210,20 @@ async function detectCommand(options) {
 
 // src/commands/logs.ts
 init_common();
-import { existsSync as existsSync29 } from "fs";
-import { join as join67 } from "path";
+import { existsSync as existsSync28 } from "fs";
+import { join as join71 } from "path";
 
 // src/commands/logs-formatter.ts
 init_source();
 init_formatter();
 import { readdirSync as readdirSync7 } from "fs";
-import { join as join66 } from "path";
+import { join as join70 } from "path";
 
 // src/commands/logs-reader.ts
 init_paths3();
-import { existsSync as existsSync28, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync27, readdirSync as readdirSync6 } from "fs";
 import { readdir as readdir4 } from "fs/promises";
-import { join as join65 } from "path";
+import { join as join69 } from "path";
 var _logsReaderDeps = {
   getRunsDir
 };
@@ -96386,7 +97237,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join65(runsDir, entry, "meta.json");
+    const metaPath = join69(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -96398,7 +97249,7 @@ async function resolveRunFileFromRegistry(runId) {
   if (!matched) {
     throw new Error(`Run not found in registry: ${runId}`);
   }
-  if (!existsSync28(matched.eventsDir)) {
+  if (!existsSync27(matched.eventsDir)) {
     console.log(`Log directory unavailable for run: ${runId}`);
     return null;
   }
@@ -96408,14 +97259,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join65(matched.eventsDir, specificFile ?? files[0]);
+  return join69(matched.eventsDir, specificFile ?? files[0]);
 }
 async function selectRunFile(runsDir) {
   const files = readdirSync6(runsDir).filter((f) => f.endsWith(".jsonl") && f !== "latest.jsonl").sort().reverse();
   if (files.length === 0) {
     return null;
   }
-  return join65(runsDir, files[0]);
+  return join69(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -96501,7 +97352,7 @@ Runs:
   console.log(source_default.gray("  Timestamp            Stories  Duration  Cost      Status"));
   console.log(source_default.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   for (const file3 of files) {
-    const filePath = join66(runsDir, file3);
+    const filePath = join70(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -96615,7 +97466,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join67(resolved.projectDir, ".nax");
+  const naxDir = join71(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -96623,9 +97474,9 @@ async function logsCommand(options) {
   if (!featureName) {
     throw new Error("No feature specified in config.json");
   }
-  const featureDir = join67(naxDir, "features", featureName);
-  const runsDir = join67(featureDir, "runs");
-  if (!existsSync29(runsDir)) {
+  const featureDir = join71(naxDir, "features", featureName);
+  const runsDir = join71(featureDir, "runs");
+  if (!existsSync28(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
   if (options.list) {
@@ -96649,8 +97500,8 @@ init_config();
 init_prd();
 init_precheck();
 init_common();
-import { existsSync as existsSync30 } from "fs";
-import { join as join68 } from "path";
+import { existsSync as existsSync29 } from "fs";
+import { join as join72 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -96672,14 +97523,14 @@ async function precheckCommand(options) {
       process.exit(1);
     }
   }
-  const naxDir = join68(resolved.projectDir, ".nax");
-  const featureDir = join68(naxDir, "features", featureName);
-  const prdPath = join68(featureDir, "prd.json");
-  if (!existsSync30(featureDir)) {
+  const naxDir = join72(resolved.projectDir, ".nax");
+  const featureDir = join72(naxDir, "features", featureName);
+  const prdPath = join72(featureDir, "prd.json");
+  if (!existsSync29(featureDir)) {
     console.error(source_default.red(`Feature not found: ${featureName}`));
     process.exit(1);
   }
-  if (!existsSync30(prdPath)) {
+  if (!existsSync29(prdPath)) {
     console.error(source_default.red(`Missing prd.json for feature: ${featureName}`));
     console.error(source_default.dim(`Run: nax plan -f ${featureName} --from spec.md --auto`));
     process.exit(EXIT_CODES.INVALID_PRD);
@@ -96697,7 +97548,7 @@ async function precheckCommand(options) {
 init_source();
 init_paths3();
 import { readdir as readdir5 } from "fs/promises";
-import { join as join69 } from "path";
+import { join as join73 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -96752,7 +97603,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join69(runsDir, entry, "meta.json");
+    const metaPath = join73(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -96829,7 +97680,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join70 } from "path";
+import { join as join74 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -96844,7 +97695,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join70(workdir, "nax.lock");
+  const lockPath = join74(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -97392,6 +98243,7 @@ init_run_regression();
 
 // src/execution/index.ts
 init_story_orchestrator();
+init_story_orchestrator_logging();
 init_plan_inputs();
 init_build_plan_for_strategy();
 init_post_run();
@@ -105268,8 +106120,8 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join84(workdir, ".nax");
-  if (existsSync36(naxDir) && !options.force) {
+  const naxDir = join88(workdir, ".nax");
+  if (existsSync35(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
@@ -105297,11 +106149,11 @@ Next: nax generate --package ${options.package}`));
       }
     }
   }
-  mkdirSync7(join84(naxDir, "features"), { recursive: true });
-  mkdirSync7(join84(naxDir, "hooks"), { recursive: true });
+  mkdirSync7(join88(naxDir, "features"), { recursive: true });
+  mkdirSync7(join88(naxDir, "hooks"), { recursive: true });
   const initConfig = options.name ? { ...DEFAULT_CONFIG, name: options.name } : DEFAULT_CONFIG;
-  await Bun.write(join84(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
-  await Bun.write(join84(naxDir, "hooks.json"), JSON.stringify({
+  await Bun.write(join88(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
+  await Bun.write(join88(naxDir, "hooks.json"), JSON.stringify({
     hooks: {
       "on-start": { command: 'echo "nax started: $NAX_FEATURE"', enabled: false },
       "on-complete": { command: 'echo "nax complete: $NAX_FEATURE"', enabled: false },
@@ -105309,12 +106161,12 @@ Next: nax generate --package ${options.package}`));
       "on-error": { command: 'echo "nax error: $NAX_REASON"', enabled: false }
     }
   }, null, 2));
-  await Bun.write(join84(naxDir, ".gitignore"), `# nax temp files
+  await Bun.write(join88(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join84(naxDir, "context.md"), `# Project Context
+  await Bun.write(join88(naxDir, "context.md"), `# Project Context
 
 This document defines coding standards, architectural decisions, and forbidden patterns for this project.
 Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cursorrules, etc.) from this file.
@@ -105399,6 +106251,24 @@ Run \`nax generate\` to regenerate agent config files (CLAUDE.md, AGENTS.md, .cu
   console.log(source_default.dim(`
 Next: nax features create <name>`));
 });
+program2.command("setup").description("Analyze repo and generate .nax/config.json via LLM").option("-d, --dir <path>", "Project directory", process.cwd()).option("-a, --agent <name>", "Force a specific agent").option("--fill-scripts", "Add missing quality-gate scripts to package.json", false).option("--dry-run", "Preview planned config without writing files", false).option("--force", "Overwrite existing .nax/config.json", false).action(async (options) => {
+  let workdir;
+  try {
+    workdir = validateDirectory(options.dir);
+  } catch (err) {
+    console.error(source_default.red(`Invalid directory: ${err.message}`));
+    process.exit(1);
+  }
+  const { setupCommand: setupCommand2 } = await Promise.resolve().then(() => (init_setup(), exports_setup));
+  const exitCode = await setupCommand2({
+    dir: workdir,
+    agent: options.agent,
+    fillScripts: options.fillScripts,
+    dryRun: options.dryRun,
+    force: options.force
+  });
+  process.exit(exitCode);
+});
 program2.command("run").description("Run the orchestration loop for a feature").requiredOption("-f, --feature <name>", "Feature name").option("-a, --agent <name>", "Force a specific agent").option("-m, --max-iterations <n>", "Max iterations", "20").option("--dry-run", "Show plan without executing", false).option("--no-context", "Disable context builder (skip file context in prompts)").option("--no-batch", "Disable story batching (execute all stories individually)").option("--parallel <n>", "Max parallel sessions (0=auto, omit=sequential)").option("--plan", "Run plan phase first before execution", false).option("--from <spec-path>", "Path to spec file (required when --plan is used)").option("--one-shot", "Skip interactive planning Q&A, use single LLM call (ACP only)", false).option("--force", "Force overwrite existing prd.json when using --plan", false).option("--headless", "Force headless mode (disable TUI, use pipe mode)", false).option("--verbose", "Enable verbose logging (debug level)", false).option("--quiet", "Quiet mode (warnings and errors only)", false).option("--silent", "Silent mode (errors only)", false).option("--json", "JSON mode (raw JSONL output to stdout)", false).option("-d, --dir <path>", "Working directory", process.cwd()).option("--skip-precheck", "Skip precheck validations (advanced users only)", false).option("--profile <name>", "Profile to use (overrides config.json profile)").action(async (options) => {
   let workdir;
   try {
@@ -105411,7 +106281,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("Error: --plan requires --from <spec-path>"));
     process.exit(1);
   }
-  if (options.from && !existsSync36(options.from)) {
+  if (options.from && !existsSync35(options.from)) {
     console.error(source_default.red(`Error: File not found: ${options.from} (required with --plan)`));
     process.exit(1);
   }
@@ -105444,10 +106314,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join84(naxDir, "features", options.feature);
-  const prdPath = join84(featureDir, "prd.json");
+  const featureDir = join88(naxDir, "features", options.feature);
+  const prdPath = join88(featureDir, "prd.json");
   if (options.plan && options.from) {
-    if (existsSync36(prdPath) && !options.force) {
+    if (existsSync35(prdPath) && !options.force) {
       console.error(source_default.red(`Error: prd.json already exists for feature "${options.feature}".`));
       console.error(source_default.dim("   Use --force to overwrite, or run without --plan to use the existing PRD."));
       process.exit(1);
@@ -105467,10 +106337,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join84(featureDir, "plan");
+      const planLogDir = join88(featureDir, "plan");
       mkdirSync7(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join84(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join88(planLogDir, `${planLogId}.jsonl`);
       initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
       console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
       console.log(source_default.dim("   [Planning phase: generating PRD from spec]"));
@@ -105509,17 +106379,17 @@ program2.command("run").description("Run the orchestration loop for a feature").
       process.exit(1);
     }
   }
-  if (!existsSync36(prdPath)) {
+  if (!existsSync35(prdPath)) {
     console.error(source_default.red(`Feature "${options.feature}" not found or missing prd.json`));
     process.exit(1);
   }
   resetLogger();
   const projectKey = config2.name?.trim() || basename16(workdir);
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
-  const runsDir = join84(outputDir, "features", options.feature, "runs");
+  const runsDir = join88(outputDir, "features", options.feature, "runs");
   mkdirSync7(runsDir, { recursive: true });
   const runId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const logFilePath = join84(runsDir, `${runId}.jsonl`);
+  const logFilePath = join88(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -105537,7 +106407,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.agent.default = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
-  const globalNaxDir = join84(homedir3(), ".nax");
+  const globalNaxDir = join88(homedir3(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   const agentStreamEvents = useHeadless ? undefined : new AgentStreamEventBus;
@@ -105557,12 +106427,12 @@ program2.command("run").description("Run the orchestration loop for a feature").
       events: eventEmitter,
       ptyOptions: null,
       agentStreamEvents,
-      queueFilePath: join84(workdir, ".queue.txt")
+      queueFilePath: join88(workdir, ".queue.txt")
     });
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join84(outputDir, "status.json");
+  const statusFilePath = join88(outputDir, "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -105589,9 +106459,9 @@ program2.command("run").description("Run the orchestration loop for a feature").
     skipPrecheck: options.skipPrecheck ?? false,
     agentStreamEvents
   });
-  const latestSymlink = join84(runsDir, "latest.jsonl");
+  const latestSymlink = join88(runsDir, "latest.jsonl");
   try {
-    if (existsSync36(latestSymlink)) {
+    if (existsSync35(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
     }
     Bun.spawnSync(["ln", "-s", `${runId}.jsonl`, latestSymlink], {
@@ -105650,9 +106520,9 @@ features.command("create <name>").description("Create a new feature").option("-d
     console.error(source_default.red("nax not initialized. Run: nax init"));
     process.exit(1);
   }
-  const featureDir = join84(naxDir, "features", name);
+  const featureDir = join88(naxDir, "features", name);
   mkdirSync7(featureDir, { recursive: true });
-  await Bun.write(join84(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join88(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -105685,7 +106555,7 @@ features.command("create <name>").description("Create a new feature").option("-d
 
 <!-- What this feature explicitly does NOT cover. -->
 `);
-  await Bun.write(join84(featureDir, "progress.txt"), `# Progress: ${name}
+  await Bun.write(join88(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -105711,8 +106581,8 @@ features.command("list").description("List all features").option("-d, --dir <pat
     console.error(source_default.red("nax not initialized."));
     process.exit(1);
   }
-  const featuresDir = join84(naxDir, "features");
-  if (!existsSync36(featuresDir)) {
+  const featuresDir = join88(naxDir, "features");
+  if (!existsSync35(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
   }
@@ -105726,8 +106596,8 @@ features.command("list").description("List all features").option("-d, --dir <pat
 Features:
 `));
   for (const name of entries) {
-    const prdPath = join84(featuresDir, name, "prd.json");
-    if (existsSync36(prdPath)) {
+    const prdPath = join88(featuresDir, name, "prd.json");
+    if (existsSync35(prdPath)) {
       const prd = await loadPRD(prdPath);
       const c = countStories(prd);
       console.log(`  ${name} \u2014 ${c.passed}/${c.total} stories done`);
@@ -105761,10 +106631,10 @@ Use: nax plan -f <feature> --from <spec>`));
     cliOverrides.profile = options.profile;
   }
   const config2 = await loadConfig(workdir, cliOverrides);
-  const featureLogDir = join84(naxDir, "features", options.feature, "plan");
+  const featureLogDir = join88(naxDir, "features", options.feature, "plan");
   mkdirSync7(featureLogDir, { recursive: true });
   const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-  const planLogPath = join84(featureLogDir, `${planLogId}.jsonl`);
+  const planLogPath = join88(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {