@nathapp/nax 0.68.8 → 0.69.1

package/dist/nax.js

@@ -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({
@@ -19004,6 +19010,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,6 +19392,73 @@ 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,
+  loadProfileEnv: () => loadProfileEnv,
+  loadProfile: () => loadProfile,
+  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,
+  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();
@@ -20944,12 +21117,21 @@ function parseAcpxJsonLine(line, state) {
         }
         if (update.sessionUpdate === "usage_update") {
           const activity = { kind: "usage_update" };
-          if (typeof update.used === "number") {
+          const metaUsage = update._meta != null && typeof update._meta === "object" ? update._meta.usage : undefined;
+          if (metaUsage != null && typeof metaUsage === "object") {
+            const inp = metaUsage.inputTokens ?? metaUsage.input_tokens;
+            if (typeof inp === "number")
+              activity.inputTokens = inp;
+            const out = metaUsage.outputTokens ?? metaUsage.output_tokens;
+            if (typeof out === "number")
+              activity.outputTokens = out;
+          }
+          if (activity.outputTokens == null && typeof update.used === "number") {
             activity.outputTokens = update.used;
           }
           if (typeof update.cost?.amount === "number") {
             activity.costUsd = update.cost.amount;
-            state.exactCostUsd = update.cost.amount;
+            state.exactCostUsd = activity.costUsd;
           }
           return activity;
         }
@@ -32632,12 +32814,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
       };
     }
@@ -34337,7 +34521,25 @@ async function readSpecDriftViolations(input) {
     return [];
   }
 }
-async function normalizeStoryFiles(story, workdir, fileExists) {
+function collectUpstreamProducedFiles(story, byId) {
+  const produced = new Set;
+  const seen = new Set;
+  const stack = [...story.dependencies ?? []];
+  while (stack.length > 0) {
+    const depId = stack.pop();
+    if (!depId || seen.has(depId))
+      continue;
+    seen.add(depId);
+    const dep = byId.get(depId);
+    if (!dep)
+      continue;
+    for (const filePath of getExpectedFiles(dep))
+      produced.add(filePath);
+    stack.push(...dep.dependencies ?? []);
+  }
+  return produced;
+}
+async function normalizeStoryFiles(story, workdir, fileExists, upstreamProduced) {
   const contextFiles = story.contextFiles ?? [];
   if (contextFiles.length === 0)
     return { story, changed: false };
@@ -34352,6 +34554,14 @@ async function normalizeStoryFiles(story, workdir, fileExists) {
       kept.push(entry);
       continue;
     }
+    if (upstreamProduced.has(filePath)) {
+      kept.push(entry);
+      logger?.debug("plan", "Kept cross-story produced file in contextFiles (upstream dependency creates it)", {
+        storyId: story.id,
+        filePath
+      });
+      continue;
+    }
     if (factId) {
       logger?.warn("plan", "Context file cites a manifest fact but is absent on disk", {
         storyId: story.id,
@@ -34379,7 +34589,8 @@ async function normalizeStoryFiles(story, workdir, fileExists) {
 async function normalizeCreatedContextFiles(prd, workdir, fileExists) {
   if (!workdir)
     return prd;
-  const results = await Promise.all(prd.userStories.map((story) => normalizeStoryFiles(story, workdir, fileExists)));
+  const byId = new Map(prd.userStories.map((story) => [story.id, story]));
+  const results = await Promise.all(prd.userStories.map((story) => normalizeStoryFiles(story, workdir, fileExists, collectUpstreamProducedFiles(story, byId))));
   if (!results.some((r) => r.changed))
     return prd;
   return { ...prd, userStories: results.map((r) => r.story) };
@@ -38804,6 +39015,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: [] };
@@ -39405,6 +39769,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();
@@ -42566,9 +42931,9 @@ ${rows.join(`
 `)}
 `;
 }
-var CONTEXT_VS_EXPECTED_FILES_RULE = `**\`contextFiles\` rule \u2014 existing files only.** Only list paths that already exist in the repo today. The pipeline verifies every \`contextFiles\` entry against the filesystem; a path that does not exist is treated as a missing-context warning.
+var CONTEXT_VS_EXPECTED_FILES_RULE = `**\`contextFiles\` rule \u2014 files readable when this story runs.** List paths that already exist in the repo today, PLUS any file an UPSTREAM dependency story creates (it does not exist now but will exist by the time this story runs, because dependencies execute first). The pipeline verifies every \`contextFiles\` entry against the filesystem; a path that exists neither on disk nor in an upstream dependency's outputs is treated as a missing-context warning.
 
-**\`expectedFiles\` rule \u2014 files this story CREATES.** List every NEW file the story authors (relative paths). A file the story will create belongs here, NEVER in \`contextFiles\` \u2014 these are the story's outputs, not files to read first. A single path may appear in \`contextFiles\` (an existing sibling to mirror) AND \`expectedFiles\` (the new file itself), but the same path must never be in both.`, EXPECTED_FILES_SCHEMA_FIELD = `"expectedFiles": ["string \u2014 NEW files this story creates (relative paths, omit if none)"],`;
+**\`expectedFiles\` rule \u2014 files THIS story CREATES.** List every NEW file this story authors (relative paths). A file this story creates belongs here, NEVER in \`contextFiles\` \u2014 these are the story's outputs, not files to read first. A file created by an upstream dependency and only read/modified here belongs in \`contextFiles\`, NOT here (this story does not author it). A single path may appear in \`contextFiles\` (an existing sibling to mirror) AND \`expectedFiles\` (the new file itself), but the same path must never be in both.`, EXPECTED_FILES_SCHEMA_FIELD = `"expectedFiles": ["string \u2014 NEW files this story creates (relative paths, omit if none)"],`;
 var init_plan_builder = __esm(() => {
   init_config();
 });
@@ -44619,7 +44984,8 @@ var init_session_role = __esm(() => {
     "fix-gen",
     "auto",
     "synthesis",
-    "judge"
+    "judge",
+    "setup"
   ];
 });
 
@@ -53496,6 +53862,108 @@ 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.ts
 async function refreshReviewInputForDispatch(opName, input) {
   if (opName !== "semantic-review" && opName !== "adversarial-review")
@@ -53935,16 +54403,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 {};
   }
@@ -53959,14 +54428,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",
@@ -54118,6 +54589,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]);
@@ -54210,6 +54700,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" });
@@ -54227,6 +54722,7 @@ var init_story_orchestrator = __esm(() => {
   init_event_bus();
   init_prepare_inputs();
   init_git();
+  init_non_blocking_fix();
   _storyOrchestratorDeps = {
     callOp,
     runFixCycle,
@@ -54379,6 +54875,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(() => {
@@ -54642,41 +55154,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)
@@ -56251,9 +56728,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";
+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([
@@ -56282,7 +56764,7 @@ async function findFiles(dir, maxFiles = 200) {
 }
 async function readPackageManifest(projectRoot) {
   const packageJsonPath = join51(projectRoot, "package.json");
-  if (!existsSync22(packageJsonPath)) {
+  if (!await bunFileExists(packageJsonPath)) {
     return null;
   }
   try {
@@ -56300,7 +56782,7 @@ async function readPackageManifest(projectRoot) {
 }
 async function readReadmeSnippet(projectRoot) {
   const readmePath = join51(projectRoot, "README.md");
-  if (!existsSync22(readmePath)) {
+  if (!await bunFileExists(readmePath)) {
     return null;
   }
   try {
@@ -56318,7 +56800,7 @@ async function detectEntryPoints(projectRoot) {
   const found = [];
   for (const candidate of candidates) {
     const path13 = join51(projectRoot, candidate);
-    if (existsSync22(path13)) {
+    if (await bunFileExists(path13)) {
       found.push(candidate);
     }
   }
@@ -56329,7 +56811,7 @@ async function detectConfigFiles(projectRoot) {
   const found = [];
   for (const candidate of candidates) {
     const path13 = join51(projectRoot, candidate);
-    if (existsSync22(path13)) {
+    if (await bunFileExists(path13)) {
       found.push(candidate);
     }
   }
@@ -56459,10 +56941,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);
   }
 }
@@ -56491,27 +56973,33 @@ 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 });
+  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 });
+  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;
@@ -56521,7 +57009,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(() => {
@@ -56534,11 +57025,11 @@ var init_init_context = __esm(() => {
 });
 
 // src/cli/init-detect.ts
-import { existsSync as existsSync23, readFileSync } from "fs";
+import { existsSync as existsSync22, readFileSync } from "fs";
 import { join as join52 } from "path";
 function readPackageJson(projectRoot) {
   const pkgPath = join52(projectRoot, "package.json");
-  if (!existsSync23(pkgPath))
+  if (!existsSync22(pkgPath))
     return;
   try {
     return JSON.parse(readFileSync(pkgPath, "utf-8"));
@@ -56580,41 +57071,41 @@ function detectStack(projectRoot) {
   };
 }
 function detectRuntime(projectRoot) {
-  if (existsSync23(join52(projectRoot, "bun.lockb")) || existsSync23(join52(projectRoot, "bunfig.toml"))) {
+  if (existsSync22(join52(projectRoot, "bun.lockb")) || existsSync22(join52(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(join52(projectRoot, "package-lock.json")) || existsSync22(join52(projectRoot, "yarn.lock")) || existsSync22(join52(projectRoot, "pnpm-lock.yaml"))) {
     return "node";
   }
   return "unknown";
 }
 function detectLanguage2(projectRoot) {
-  if (existsSync23(join52(projectRoot, "tsconfig.json")))
+  if (existsSync22(join52(projectRoot, "tsconfig.json")))
     return "typescript";
-  if (existsSync23(join52(projectRoot, "pyproject.toml")) || existsSync23(join52(projectRoot, "setup.py"))) {
+  if (existsSync22(join52(projectRoot, "pyproject.toml")) || existsSync22(join52(projectRoot, "setup.py"))) {
     return "python";
   }
-  if (existsSync23(join52(projectRoot, "Cargo.toml")))
+  if (existsSync22(join52(projectRoot, "Cargo.toml")))
     return "rust";
-  if (existsSync23(join52(projectRoot, "go.mod")))
+  if (existsSync22(join52(projectRoot, "go.mod")))
     return "go";
   return "unknown";
 }
 function detectLinter(projectRoot) {
-  if (existsSync23(join52(projectRoot, "biome.json")) || existsSync23(join52(projectRoot, "biome.jsonc"))) {
+  if (existsSync22(join52(projectRoot, "biome.json")) || existsSync22(join52(projectRoot, "biome.jsonc"))) {
     return "biome";
   }
-  if (existsSync23(join52(projectRoot, ".eslintrc.json")) || existsSync23(join52(projectRoot, ".eslintrc.js")) || existsSync23(join52(projectRoot, "eslint.config.js"))) {
+  if (existsSync22(join52(projectRoot, ".eslintrc.json")) || existsSync22(join52(projectRoot, ".eslintrc.js")) || existsSync22(join52(projectRoot, "eslint.config.js"))) {
     return "eslint";
   }
   return "unknown";
 }
 function detectMonorepo(projectRoot) {
-  if (existsSync23(join52(projectRoot, "turbo.json")))
+  if (existsSync22(join52(projectRoot, "turbo.json")))
     return "turborepo";
-  if (existsSync23(join52(projectRoot, "nx.json")))
+  if (existsSync22(join52(projectRoot, "nx.json")))
     return "nx";
-  if (existsSync23(join52(projectRoot, "pnpm-workspace.yaml")))
+  if (existsSync22(join52(projectRoot, "pnpm-workspace.yaml")))
     return "pnpm-workspaces";
   const pkg = readPackageJson(projectRoot);
   if (pkg?.workspaces)
@@ -56756,8 +57247,8 @@ __export(exports_init, {
   checkInitCollision: () => checkInitCollision,
   _initDeps: () => _initDeps
 });
-import { existsSync as existsSync24 } from "fs";
-import { mkdir as mkdir9 } from "fs/promises";
+import { existsSync as existsSync23 } from "fs";
+import { mkdir as mkdir8 } from "fs/promises";
 import { join as join53 } from "path";
 function validateProjectName(name) {
   if (!name)
@@ -56796,7 +57287,7 @@ async function updateGitignore(projectRoot) {
   const logger = getLogger();
   const gitignorePath = join53(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));
@@ -56876,12 +57367,12 @@ 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)) {
+  if (!existsSync23(configPath)) {
     await Bun.write(configPath, `${JSON.stringify(MINIMAL_GLOBAL_CONFIG, null, 2)}
 `);
     logger.info("init", "Created global config", { path: configPath });
@@ -56889,15 +57380,15 @@ async function initGlobal() {
     logger.info("init", "Global config already exists", { path: configPath });
   }
   const constitutionPath = join53(globalDir, "constitution.md");
-  if (!existsSync24(constitutionPath)) {
+  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 });
+  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 });
@@ -56941,8 +57432,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);
@@ -56957,7 +57448,7 @@ async function initProject(projectRoot, options) {
     monorepo: stack.monorepo
   });
   const configPath = join53(projectDir, "config.json");
-  if (!existsSync24(configPath)) {
+  if (!existsSync23(configPath)) {
     await Bun.write(configPath, `${JSON.stringify(projectConfig, null, 2)}
 `);
     logger.info("init", "Created project config", { path: configPath });
@@ -56966,15 +57457,15 @@ async function initProject(projectRoot, options) {
   }
   await initContext(projectRoot, { ai: options?.ai, force: options?.force });
   const constitutionPath = join53(projectDir, "constitution.md");
-  if (!existsSync24(constitutionPath) || options?.force) {
+  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 });
+  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 });
@@ -57033,6 +57524,286 @@ var init_init2 = __esm(() => {
   };
 });
 
+// src/cli/setup-analyze.ts
+import { join as join54 } from "path";
+async function detectPackageManager(workdir) {
+  const { fileExists } = _analyzeRepoDeps;
+  if (await fileExists(join54(workdir, "bun.lock")))
+    return { pmRunPrefix: "bun run", pmDlx: "bunx" };
+  if (await fileExists(join54(workdir, "bun.lockb")))
+    return { pmRunPrefix: "bun run", pmDlx: "bunx" };
+  if (await fileExists(join54(workdir, "package-lock.json")))
+    return { pmRunPrefix: "npm run", pmDlx: "npx" };
+  if (await fileExists(join54(workdir, "yarn.lock")))
+    return { pmRunPrefix: "yarn", pmDlx: "yarn dlx" };
+  if (await fileExists(join54(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(join54(workdir, "turbo.json")))
+    return "turbo";
+  if (await fileExists(join54(workdir, "nx.json")))
+    return "nx";
+  return "none";
+}
+async function getMissingScripts(packageDir) {
+  const pkg = await _analyzeRepoDeps.readJson(join54(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 : join54(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 join55 } 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(join55(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(join55(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(join55(workdir, "turbo.json"), TYPE_CHECK_KEY);
+    await addScriptToPackageJson(join55(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 join56 } from "path";
+async function setupCommand(options = {}) {
+  const workdir = options.dir ?? process.cwd();
+  const naxDir = join56(workdir, ".nax");
+  const naxConfigPath = join56(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 = join56(naxDir, "mono", mc.relativeDir);
+      await _setupDeps.mkdir(monoDir);
+      await _setupDeps.writeFile(join56(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() {
@@ -57734,12 +58505,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()) {
@@ -57756,7 +58527,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;
@@ -57831,7 +58602,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 ? `
 ` : ""));
@@ -58407,12 +59178,12 @@ var init_loader4 = __esm(() => {
 });
 
 // src/utils/paths.ts
-import { join as join64 } from "path";
+import { join as join67 } from "path";
 function getRunsDir() {
-  return process.env.NAX_RUNS_DIR ?? join64(globalConfigDir(), "runs");
+  return process.env.NAX_RUNS_DIR ?? join67(globalConfigDir(), "runs");
 }
 function getEventsRootDir() {
-  return join64(globalConfigDir(), "events");
+  return join67(globalConfigDir(), "events");
 }
 var init_paths3 = __esm(() => {
   init_paths();
@@ -58472,7 +59243,7 @@ var init_command_argv = __esm(() => {
 });
 
 // src/hooks/runner.ts
-import { join as join71 } from "path";
+import { join as join74 } from "path";
 function createDrainDeadline2(deadlineMs) {
   let timeoutId;
   const promise2 = new Promise((resolve16) => {
@@ -58491,14 +59262,14 @@ async function loadHooksConfig(projectDir, globalDir) {
   let globalHooks = { hooks: {} };
   let projectHooks = { hooks: {} };
   let skipGlobal = false;
-  const projectPath = join71(projectDir, "hooks.json");
+  const projectPath = join74(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 = join74(globalDir, "hooks.json");
     const globalData = await loadJsonFile(globalPath, "hooks");
     if (globalData) {
       globalHooks = globalData;
@@ -58668,7 +59439,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.68.8",
+    version: "0.69.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -58763,8 +59534,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("00515ea8"))
-        return "00515ea8";
+      if (/^[0-9a-f]{6,10}$/.test("3b2af55b"))
+        return "3b2af55b";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -59640,16 +60411,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 join75 } from "path";
 async function purgeStaleScratch(projectDir, featureName, retentionDays, archiveInsteadOfDelete = false) {
-  const sessionsDir = join72(projectDir, ".nax", "features", featureName, "sessions");
+  const sessionsDir = join75(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 = join75(sessionsDir, sessionId);
+    const descriptorPath = join75(sessionDir, "descriptor.json");
     if (!await _scratchPurgeDeps.fileExists(descriptorPath))
       continue;
     let lastActivityAt;
@@ -59665,7 +60436,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 = join75(projectDir, ".nax", "features", featureName, "_archive", "sessions", sessionId);
       await _scratchPurgeDeps.move(sessionDir, archiveDest);
     } else {
       await _scratchPurgeDeps.remove(sessionDir);
@@ -59692,7 +60463,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()
@@ -60402,19 +61173,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 join76 } 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 = join76(getEventsRootDir(), project);
+  const eventsFile = join76(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)}
@@ -60588,24 +61359,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 join77 } 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 = join77(getRunsDir(), `${project}-${feature}-${runId}`);
+  const metaFile = join77(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: join77(outputDir, "features", feature, "status.json"),
+          eventsDir: join77(outputDir, "features", feature, "runs"),
           registeredAt: new Date().toISOString()
         };
         await writeFile2(metaFile, JSON.stringify(meta3, null, 2));
@@ -60850,8 +61621,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 join78 } from "path";
 async function prepareWorktreeDependencies(options) {
   const mode = options.config.execution.worktreeDependencies.mode;
   const resolvedCwd = resolveDependencyCwd(options);
@@ -60865,7 +61636,7 @@ async function prepareWorktreeDependencies(options) {
   }
 }
 function resolveDependencyCwd(options) {
-  return options.storyWorkdir ? join75(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
+  return options.storyWorkdir ? join78(options.worktreeRoot, options.storyWorkdir) : options.worktreeRoot;
 }
 function resolveInheritedDependencies(options, resolvedCwd) {
   if (hasDependencyManifests(options.worktreeRoot, resolvedCwd)) {
@@ -60875,14 +61646,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(join78(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");
   }
@@ -60926,7 +61697,7 @@ var init_dependencies = __esm(() => {
     "build.gradle.kts"
   ];
   _worktreeDependencyDeps = {
-    existsSync: existsSync31,
+    existsSync: existsSync30,
     spawn
   };
 });
@@ -60937,19 +61708,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 join79 } from "path";
 
 class WorktreeManager {
   async ensureGitExcludes(projectRoot) {
     const logger = getSafeLogger();
-    const infoDir = join76(projectRoot, ".git", "info");
-    const excludePath = join76(infoDir, "exclude");
+    const infoDir = join79(projectRoot, ".git", "info");
+    const excludePath = join79(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));
@@ -60972,7 +61743,7 @@ ${missing.join(`
   }
   async create(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join76(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join79(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const pruneProc = _managerDeps.spawn(["git", "worktree", "prune"], {
@@ -61013,9 +61784,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 = join79(projectRoot, ".env");
+    if (existsSync31(envSource)) {
+      const envTarget = join79(worktreePath, ".env");
       try {
         symlinkSync(envSource, envTarget, "file");
       } catch (error48) {
@@ -61026,7 +61797,7 @@ ${missing.join(`
   }
   async remove(projectRoot, storyId) {
     validateStoryId(storyId);
-    const worktreePath = join76(projectRoot, ".nax-wt", storyId);
+    const worktreePath = join79(projectRoot, ".nax-wt", storyId);
     const branchName = `nax/${storyId}`;
     try {
       const proc = _managerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
@@ -61838,10 +62609,10 @@ var init_merge_conflict_rectify = __esm(() => {
 });
 
 // src/execution/pipeline-result-handler.ts
-import { join as join77 } from "path";
+import { join as join80 } from "path";
 async function removeWorktreeDirectory(projectRoot, storyId) {
   const logger = getSafeLogger();
-  const worktreePath = join77(projectRoot, ".nax-wt", storyId);
+  const worktreePath = join80(projectRoot, ".nax-wt", storyId);
   try {
     const proc = _resultHandlerDeps.spawn(["git", "worktree", "remove", worktreePath, "--force"], {
       cwd: projectRoot,
@@ -62057,8 +62828,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 join81 } from "path";
 async function runIteration(ctx, prd, selection, iterations, totalCost, allStoryMetrics) {
   const { story, storiesToExecute, routing, isBatchExecution } = selection;
   if (ctx.dryRun) {
@@ -62083,7 +62854,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 = join81(ctx.workdir, ".nax-wt", story.id);
     const worktreeExists = _iterationRunnerDeps.existsSync(worktreePath);
     if (!worktreeExists) {
       await _iterationRunnerDeps.worktreeManager.ensureGitExcludes(ctx.workdir);
@@ -62103,7 +62874,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(join81(ctx.workdir, ".nax", "config.json"), story.workdir, profileOverride) : ctx.config;
   let dependencyContext;
   if (ctx.config.execution.storyIsolation === "worktree") {
     try {
@@ -62130,7 +62901,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 ? join81(effectiveWorkdir, story.workdir) : effectiveWorkdir : story.workdir ? join81(ctx.workdir, story.workdir) : ctx.workdir;
   const pipelineContext = {
     config: effectiveConfig,
     rootConfig: ctx.config,
@@ -62262,7 +63033,7 @@ var init_iteration_runner = __esm(() => {
     loadConfigForWorkdir,
     prepareWorktreeDependencies,
     runPipeline,
-    existsSync: existsSync33,
+    existsSync: existsSync32,
     worktreeManager: new WorktreeManager
   };
 });
@@ -62332,7 +63103,7 @@ __export(exports_parallel_worker, {
   buildWorktreePipelineContext: () => buildWorktreePipelineContext,
   _parallelWorkerDeps: () => _parallelWorkerDeps
 });
-import { join as join79 } from "path";
+import { join as join82 } from "path";
 function buildWorktreePipelineContext(base, _story) {
   return { ...base, prd: structuredClone(base.prd) };
 }
@@ -62355,7 +63126,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 ? join82(worktreePath, story.workdir) : worktreePath),
       worktreeDependencyContext: dependencyContext,
       routing,
       storyGitRef: storyGitRef ?? undefined
@@ -63242,7 +64013,7 @@ async function writeStatusFile(filePath, status) {
 var init_status_file = () => {};
 
 // src/execution/status-writer.ts
-import { join as join80 } from "path";
+import { join as join83 } from "path";
 
 class StatusWriter {
   statusFile;
@@ -63361,7 +64132,7 @@ class StatusWriter {
     if (!this._prd)
       return;
     const safeLogger = getSafeLogger();
-    const featureStatusPath = join80(featureDir, "status.json");
+    const featureStatusPath = join83(featureDir, "status.json");
     const write = async () => {
       try {
         const base = this.getSnapshot(totalCost, iterations);
@@ -63392,11 +64163,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 = [];
@@ -63411,7 +64182,7 @@ async function detectGeneratedContent(naxDir) {
     }
   }
   const featuresDir = path22.join(naxDir, "features");
-  if (existsSync34(featuresDir)) {
+  if (existsSync33(featuresDir)) {
     let featureDirs = [];
     try {
       featureDirs = await readdir6(featuresDir);
@@ -63473,7 +64244,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
@@ -63481,7 +64252,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;
@@ -63519,7 +64290,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
@@ -63549,12 +64320,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}
@@ -63795,7 +64566,7 @@ __export(exports_run_initialization, {
   initializeRun: () => initializeRun,
   _reconcileDeps: () => _reconcileDeps
 });
-import { join as join81 } from "path";
+import { join as join84 } from "path";
 async function reconcileState(prd, prdPath, workdir, config2) {
   const logger = getSafeLogger();
   let reconciledCount = 0;
@@ -63812,7 +64583,7 @@ async function reconcileState(prd, prdPath, workdir, config2) {
       });
       continue;
     }
-    const effectiveWorkdir = story.workdir ? join81(workdir, story.workdir) : workdir;
+    const effectiveWorkdir = story.workdir ? join84(workdir, story.workdir) : workdir;
     try {
       const reviewResult = await _reconcileDeps.runReview(config2.review, effectiveWorkdir, config2.execution);
       if (!reviewResult.success) {
@@ -93605,7 +94376,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 join86 } from "path";
 function getProjectKey(config2, projectDir) {
   return config2.name?.trim() || basename15(projectDir);
 }
@@ -93688,7 +94459,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 = join86(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   let runId;
   if (options.run) {
@@ -93705,8 +94476,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 = join86(runsDir, runId);
+  const observationsPath = join86(runDir, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const counts = new Map;
   for (const obs of observations) {
@@ -93716,7 +94487,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 = join86(runDir, "curator-proposals.md");
   const proposalText = await _curatorCmdDeps.readFile(proposalsPath).catch(() => null);
   if (proposalText !== null) {
     console.log("");
@@ -93730,8 +94501,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 = join86(outputDir, "runs", options.runId);
+  const proposalsPath = join86(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}.`);
@@ -93747,7 +94518,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 = join86(resolved.projectDir, drop2.canonicalFile);
     if (!dropFileState.has(targetPath)) {
       const fileExists2 = await Bun.file(targetPath).exists();
       const existing = fileExists2 ? await _curatorCmdDeps.readFile(targetPath).catch(() => "") : "";
@@ -93781,7 +94552,7 @@ async function curatorCommit(options) {
     if (skippedDrops.has(drop2)) {
       continue;
     }
-    const targetPath = join83(resolved.projectDir, drop2.canonicalFile);
+    const targetPath = join86(resolved.projectDir, drop2.canonicalFile);
     const existing = await _curatorCmdDeps.readFile(targetPath).catch(() => "");
     const filtered = filterDropContent(existing, drop2.description);
     await _curatorCmdDeps.writeFile(targetPath, filtered);
@@ -93790,7 +94561,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 = join86(resolved.projectDir, add2.canonicalFile);
     const content = buildAddContent(add2);
     await _curatorCmdDeps.appendFile(targetPath, content);
     modifiedFiles.add(targetPath);
@@ -93827,7 +94598,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 = join86(outputDir, "runs");
   const runIds = listRunIds(runsDir);
   if (runIds.length === 0) {
     console.log("No runs found.");
@@ -93838,7 +94609,7 @@ async function curatorDryrun(options) {
     console.log(`Run ${options.run} not found in ${runsDir}.`);
     return;
   }
-  const observationsPath = join83(runsDir, runId, "observations.jsonl");
+  const observationsPath = join86(runsDir, runId, "observations.jsonl");
   const observations = await parseObservations(observationsPath);
   const thresholds = getThresholds(config2);
   const proposals = runHeuristics(observations, thresholds);
@@ -93879,12 +94650,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 = join86(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 = join86(perRunsDir, runId);
+      await _curatorCmdDeps.removeFile(join86(runDir, "observations.jsonl"));
+      await _curatorCmdDeps.removeFile(join86(runDir, "curator-proposals.md"));
     }
   }
   console.log(`[gc] Pruned rollup to ${keep} most recent runs (was ${uniqueRunIds.length}).`);
@@ -93927,9 +94698,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 join87 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -95019,6 +95790,7 @@ async function runsShowCommand(options) {
 // src/cli/index.ts
 init_prompts2();
 init_init2();
+init_setup();
 
 // src/cli/plugins.ts
 init_paths();
@@ -95093,8 +95865,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 join61 } from "path";
 var VALID_AGENTS = ["claude", "codex", "opencode", "cursor", "windsurf", "aider", "gemini"];
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
@@ -95137,7 +95909,7 @@ async function generateCommand(options) {
     return;
   }
   if (options.package) {
-    const packageDir = join58(workdir, options.package);
+    const packageDir = join61(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -95157,10 +95929,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 ? join61(workdir, options.context) : join61(workdir, ".nax/context.md");
+  const outputDir = options.output ? join61(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);
@@ -95263,8 +96035,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 join63 } from "path";
 
 // src/cli/config-descriptions.ts
 var FIELD_DESCRIPTIONS = {
@@ -95515,10 +96287,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 join62 } from "path";
 async function loadConfigFile(path18) {
-  if (!existsSync26(path18))
+  if (!existsSync25(path18))
     return null;
   try {
     return await Bun.file(path18).json();
@@ -95538,7 +96310,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join59(projectDir, "config.json");
+  const projectPath = join62(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 
@@ -95598,14 +96370,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 ? join63(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);
@@ -95747,15 +96519,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 join64 } 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 = join64(globalConfigDir(), "profiles");
+  const projectProfilesDir = join64(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -95814,7 +96586,7 @@ function maskProfileValues(obj) {
   return result;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join61(projectConfigDir(startDir), "config.json");
+  const configPath = join64(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -95833,8 +96605,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 = join64(projectConfigDir(startDir), "profiles");
+  const profilePath = join64(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
@@ -95955,8 +96727,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 join65 } from "path";
 var _rulesCLIDeps = {
   readFile: async (path18) => Bun.file(path18).text(),
   writeFile: async (path18, content) => {
@@ -95965,13 +96737,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) => join65(dir, f));
     } catch {
       return [];
     }
   },
   mkdir: async (path18) => {
-    await mkdir12(path18, { recursive: true });
+    await mkdir11(path18, { recursive: true });
   },
   globCanonicalRuleFiles: (workdir) => {
     try {
@@ -96014,7 +96786,7 @@ ${r.content}`).join(`
 `);
   const shimContent = `${header + body}
 `;
-  const shimPath = join62(workdir, shimFileName);
+  const shimPath = join65(workdir, shimFileName);
   if (options.dryRun) {
     console.log(`[dry-run] Would write ${shimPath} (${shimContent.length} bytes)`);
     return;
@@ -96043,14 +96815,14 @@ function neutralizeContent(content) {
 }
 async function collectMigrationSources(workdir) {
   const sources = [];
-  const claudeMdPath = join62(workdir, "CLAUDE.md");
+  const claudeMdPath = join65(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 = join65(workdir, ".claude", "rules");
   const ruleFiles = _rulesCLIDeps.globInDir(rulesDir);
   for (const filePath of ruleFiles) {
     try {
@@ -96070,7 +96842,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 = join65(workdir, CANONICAL_RULES_DIR);
   if (!options.dryRun) {
     try {
       await _rulesCLIDeps.mkdir(targetDir);
@@ -96081,7 +96853,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 = join65(targetDir, targetFileName);
     if (!force && !options.dryRun && await _rulesCLIDeps.fileExists(targetPath)) {
       console.log(`[skip] ${targetFileName} already exists (use --force to overwrite)`);
       skipped++;
@@ -96120,7 +96892,7 @@ function collectCanonicalRuleRoots(workdir) {
     const packageRel = normalized.slice(0, idx);
     if (!packageRel)
       continue;
-    roots.add(join62(workdir, packageRel));
+    roots.add(join65(workdir, packageRel));
   }
   return [...roots].sort();
 }
@@ -96142,7 +96914,7 @@ init_logger2();
 init_detect2();
 init_workspace();
 init_common();
-import { join as join63 } from "path";
+import { join as join66 } from "path";
 function resolveEffective(detected, configPatterns) {
   if (configPatterns !== undefined)
     return "config";
@@ -96227,7 +96999,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 = join66(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;
@@ -96281,13 +97053,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 = join66(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 ${join66(".nax", "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  root: write failed \u2014 ${err.message}`));
@@ -96300,13 +97072,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 = join66(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 ${join66(".nax", "mono", dir, "config.json")}`));
         }
       } catch (err) {
         console.error(source_default.red(`  ${dir}: write failed \u2014 ${err.message}`));
@@ -96323,20 +97095,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 join70 } 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 join69 } 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 join68 } from "path";
 var _logsReaderDeps = {
   getRunsDir
 };
@@ -96350,7 +97122,7 @@ async function resolveRunFileFromRegistry(runId) {
   }
   let matched = null;
   for (const entry of entries) {
-    const metaPath = join65(runsDir, entry, "meta.json");
+    const metaPath = join68(runsDir, entry, "meta.json");
     try {
       const meta3 = await Bun.file(metaPath).json();
       if (meta3.runId === runId || meta3.runId.startsWith(runId)) {
@@ -96362,7 +97134,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;
   }
@@ -96372,14 +97144,14 @@ async function resolveRunFileFromRegistry(runId) {
     return null;
   }
   const specificFile = files.find((f) => f === `${matched.runId}.jsonl`);
-  return join65(matched.eventsDir, specificFile ?? files[0]);
+  return join68(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 join68(runsDir, files[0]);
 }
 async function extractRunSummary(filePath) {
   const file3 = Bun.file(filePath);
@@ -96465,7 +97237,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 = join69(runsDir, file3);
     const summary = await extractRunSummary(filePath);
     const timestamp = file3.replace(".jsonl", "");
     const stories = summary ? `${summary.passed}/${summary.total}` : "?/?";
@@ -96579,7 +97351,7 @@ async function logsCommand(options) {
     return;
   }
   const resolved = resolveProject({ dir: options.dir });
-  const naxDir = join67(resolved.projectDir, ".nax");
+  const naxDir = join70(resolved.projectDir, ".nax");
   const configPath = resolved.configPath;
   const configFile = Bun.file(configPath);
   const config2 = await configFile.json();
@@ -96587,9 +97359,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 = join70(naxDir, "features", featureName);
+  const runsDir = join70(featureDir, "runs");
+  if (!existsSync28(runsDir)) {
     throw new Error(`No runs directory found for feature: ${featureName}`);
   }
   if (options.list) {
@@ -96613,8 +97385,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 join71 } from "path";
 async function precheckCommand(options) {
   const resolved = resolveProject({
     dir: options.dir,
@@ -96636,14 +97408,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 = join71(resolved.projectDir, ".nax");
+  const featureDir = join71(naxDir, "features", featureName);
+  const prdPath = join71(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);
@@ -96661,7 +97433,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 join72 } from "path";
 var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
@@ -96716,7 +97488,7 @@ async function runsCommand(options = {}) {
   }
   const rows = [];
   for (const entry of entries) {
-    const metaPath = join69(runsDir, entry, "meta.json");
+    const metaPath = join72(runsDir, entry, "meta.json");
     let meta3;
     try {
       meta3 = await Bun.file(metaPath).json();
@@ -96793,7 +97565,7 @@ async function runsCommand(options = {}) {
 
 // src/commands/unlock.ts
 init_source();
-import { join as join70 } from "path";
+import { join as join73 } from "path";
 function isProcessAlive2(pid) {
   try {
     process.kill(pid, 0);
@@ -96808,7 +97580,7 @@ function formatLockAge(ageMs) {
 }
 async function unlockCommand(options) {
   const workdir = options.dir ?? process.cwd();
-  const lockPath = join70(workdir, "nax.lock");
+  const lockPath = join73(workdir, "nax.lock");
   const lockFile = Bun.file(lockPath);
   const exists = await lockFile.exists();
   if (!exists) {
@@ -103850,7 +104622,8 @@ function LiveActivityPanel({
   storySteps,
   runSummary,
   runErrored,
-  escalationLog = []
+  escalationLog = [],
+  currentStage
 }) {
   const borderColor = focused ? "cyan" : "gray";
   const activeCallList = activeCalls ? Array.from(activeCalls.values()) : [];
@@ -103907,7 +104680,8 @@ function LiveActivityPanel({
         paddingY: 1,
         children: activeCallList.map((call) => /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(ActiveCallRow, {
           call,
-          step: call.storyId ? storySteps?.[call.storyId] : undefined
+          step: call.storyId ? storySteps?.[call.storyId] : undefined,
+          currentStage
         }, call.callId, false, undefined, this))
       }, undefined, false, undefined, this),
       hasEscalations && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
@@ -103948,7 +104722,24 @@ function LiveActivityPanel({
       !hasActiveCalls && !hasSummary && !hasError && (!storySteps || Object.keys(storySteps).length === 0) && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         paddingX: 1,
         paddingY: 1,
-        children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+        children: currentStage ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+          flexDirection: "row",
+          gap: 1,
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+              color: "yellow",
+              children: [
+                "[",
+                currentStage,
+                "]"
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+              dimColor: true,
+              children: "preparing..."
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
           dimColor: true,
           children: "Waiting for agent..."
         }, undefined, false, undefined, this)
@@ -103956,7 +104747,29 @@ function LiveActivityPanel({
     ]
   }, undefined, true, undefined, this);
 }
-function ActiveCallRow({ call, step }) {
+function ActiveCallRow({ call, step, currentStage }) {
+  const stageLabel = step ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+    color: "yellow",
+    children: [
+      "[",
+      step,
+      "]"
+    ]
+  }, undefined, true, undefined, this) : call.stage ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+    dimColor: true,
+    children: [
+      "[",
+      call.stage,
+      "]"
+    ]
+  }, undefined, true, undefined, this) : currentStage ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+    dimColor: true,
+    children: [
+      "[",
+      currentStage,
+      "]"
+    ]
+  }, undefined, true, undefined, this) : null;
   return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
     flexDirection: "column",
     marginBottom: 1,
@@ -103972,21 +104785,7 @@ function ActiveCallRow({ call, step }) {
           call.storyId && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
             children: call.storyId
           }, undefined, false, undefined, this),
-          step ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-            color: "yellow",
-            children: [
-              "[",
-              step,
-              "]"
-            ]
-          }, undefined, true, undefined, this) : call.stage ? /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
-            dimColor: true,
-            children: [
-              "[",
-              call.stage,
-              "]"
-            ]
-          }, undefined, true, undefined, this) : null
+          stageLabel
         ]
       }, undefined, true, undefined, this),
       /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
@@ -104193,7 +104992,14 @@ function getStatusIcon(status) {
       return "\u23F8\uFE0F";
   }
 }
-function StoriesPanel({ stories, postRunPhases, width, compact: compact2 = false, maxHeight }) {
+function StoriesPanel({
+  stories,
+  preRunPhases,
+  postRunPhases,
+  width,
+  compact: compact2 = false,
+  maxHeight
+}) {
   const maxVisible = compact2 ? COMPACT_MAX_VISIBLE_STORIES : MAX_VISIBLE_STORIES;
   const needsScrolling = stories.length > maxVisible;
   const [scrollOffset, setScrollOffset] = import_react30.useState(0);
@@ -104225,7 +105031,7 @@ function StoriesPanel({ stories, postRunPhases, width, compact: compact2 = false
         children: [
           /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
             bold: true,
-            children: "Stories"
+            children: "Progress"
           }, undefined, false, undefined, this),
           needsScrolling && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
             dimColor: true,
@@ -104237,6 +105043,16 @@ function StoriesPanel({ stories, postRunPhases, width, compact: compact2 = false
           }, undefined, true, undefined, this)
         ]
       }, undefined, true, undefined, this),
+      preRunPhases && Object.keys(preRunPhases).length > 0 && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
+        flexDirection: "column",
+        paddingX: 1,
+        paddingTop: 1,
+        children: Object.entries(preRunPhases).map(([name, phase]) => /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(PreRunPhaseRow, {
+          label: name,
+          phase,
+          compact: compact2
+        }, name, false, undefined, this))
+      }, undefined, false, undefined, this),
       needsScrolling && canScrollUp && /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
         paddingX: 1,
         children: /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
@@ -104315,11 +105131,6 @@ function StoriesPanel({ stories, postRunPhases, width, compact: compact2 = false
         paddingX: 1,
         paddingTop: 1,
         children: [
-          /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
-            borderStyle: "single",
-            borderTop: true,
-            borderColor: "gray"
-          }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
             dimColor: true,
             children: "Post-Run"
@@ -104344,6 +105155,21 @@ function StoriesPanel({ stories, postRunPhases, width, compact: compact2 = false
     ]
   }, undefined, true, undefined, this);
 }
+function PreRunPhaseRow({ label, phase, compact: compact2 }) {
+  const icon = phase.status === "running" ? "\u25CF" : phase.status === "passed" ? "\u2713" : "\u2717";
+  const color = phase.status === "running" ? "yellow" : phase.status === "passed" ? "green" : "red";
+  const displayLabel = compact2 ? label.slice(0, 6) : label;
+  return /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Box_default, {
+    children: /* @__PURE__ */ jsx_dev_runtime5.jsxDEV(Text, {
+      color,
+      children: [
+        icon,
+        " ",
+        displayLabel
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
 function PostRunPhaseRow({ label, phase, compact: compact2 }) {
   const icon = phase.status === "running" ? ">" : phase.status === "passed" ? "[OK]" : "[X]";
   const color = phase.status === "running" ? "cyan" : phase.status === "passed" ? "green" : "red";
@@ -104361,110 +105187,120 @@ function PostRunPhaseRow({ label, phase, compact: compact2 }) {
 
 // src/tui/hooks/useAgentStreamEvents.ts
 var import_react31 = __toESM(require_react(), 1);
+var RENDER_INTERVAL_MS = 150;
 function useAgentStreamEvents(bus) {
+  const activeCallsRef = import_react31.useRef(new Map);
+  const inputTokensRef = import_react31.useRef(0);
+  const outputTokensRef = import_react31.useRef(0);
+  const lastTokensRef = import_react31.useRef(new Map);
+  const dirtyRef = import_react31.useRef(false);
   const [activeCalls, setActiveCalls] = import_react31.useState(new Map);
   const [inputTokens, setInputTokens] = import_react31.useState(0);
   const [outputTokens, setOutputTokens] = import_react31.useState(0);
-  const lastTokensRef = import_react31.useRef(new Map);
   import_react31.useEffect(() => {
     if (!bus)
       return;
     const unsubscribe = bus.onAgentStream((event) => {
-      setActiveCalls((prev) => {
-        const next = new Map(prev);
-        switch (event.kind) {
-          case "agent.call_started": {
-            const now3 = event.timestamp;
+      const next = new Map(activeCallsRef.current);
+      switch (event.kind) {
+        case "agent.call_started": {
+          next.set(event.callId, {
+            callId: event.callId,
+            agentName: event.agentName,
+            storyId: event.storyId,
+            stage: event.stage,
+            startedAt: event.timestamp,
+            lastActivityAt: event.timestamp,
+            messageUpdates: 0,
+            thinkingUpdates: 0,
+            usageUpdates: 0,
+            toolCallUpdates: 0,
+            status: "active",
+            model: event.model
+          });
+          break;
+        }
+        case "agent.message_update": {
+          const state = next.get(event.callId);
+          if (state) {
             next.set(event.callId, {
-              callId: event.callId,
-              agentName: event.agentName,
-              storyId: event.storyId,
-              stage: event.stage,
-              startedAt: now3,
-              lastActivityAt: now3,
-              messageUpdates: 0,
-              thinkingUpdates: 0,
-              usageUpdates: 0,
-              toolCallUpdates: 0,
-              status: "active",
-              model: event.model
+              ...state,
+              messageUpdates: state.messageUpdates + 1,
+              lastActivityAt: event.timestamp
             });
-            break;
-          }
-          case "agent.message_update": {
-            const state = next.get(event.callId);
-            if (state) {
-              next.set(event.callId, {
-                ...state,
-                messageUpdates: state.messageUpdates + 1,
-                lastActivityAt: event.timestamp
-              });
-            }
-            break;
           }
-          case "agent.thinking_update": {
-            const state = next.get(event.callId);
-            if (state) {
-              next.set(event.callId, {
-                ...state,
-                thinkingUpdates: state.thinkingUpdates + 1,
-                lastActivityAt: event.timestamp
-              });
-            }
-            break;
+          break;
+        }
+        case "agent.thinking_update": {
+          const state = next.get(event.callId);
+          if (state) {
+            next.set(event.callId, {
+              ...state,
+              thinkingUpdates: state.thinkingUpdates + 1,
+              lastActivityAt: event.timestamp
+            });
           }
-          case "agent.usage_update": {
-            const state = next.get(event.callId);
-            if (state) {
-              next.set(event.callId, {
-                ...state,
-                usageUpdates: state.usageUpdates + 1,
-                lastActivityAt: event.timestamp
-              });
-            }
-            {
-              const last2 = lastTokensRef.current.get(event.callId) ?? { input: 0, output: 0 };
-              const newInput = event.inputTokens ?? last2.input;
-              const newOutput = event.outputTokens ?? last2.output;
-              const deltaIn = newInput - last2.input;
-              const deltaOut = newOutput - last2.output;
-              lastTokensRef.current.set(event.callId, { input: newInput, output: newOutput });
-              if (deltaIn > 0)
-                setInputTokens((prev2) => prev2 + deltaIn);
-              if (deltaOut > 0)
-                setOutputTokens((prev2) => prev2 + deltaOut);
-            }
-            break;
+          break;
+        }
+        case "agent.usage_update": {
+          const state = next.get(event.callId);
+          if (state) {
+            next.set(event.callId, {
+              ...state,
+              usageUpdates: state.usageUpdates + 1,
+              lastActivityAt: event.timestamp
+            });
           }
-          case "agent.tool_call_update": {
-            const state = next.get(event.callId);
-            if (state) {
-              next.set(event.callId, {
-                ...state,
-                toolCallUpdates: state.toolCallUpdates + 1,
-                lastActivityAt: event.timestamp,
-                lastToolName: event.toolName
-              });
-            }
-            break;
+          {
+            const last2 = lastTokensRef.current.get(event.callId) ?? { input: 0, output: 0 };
+            const newInput = event.inputTokens ?? last2.input;
+            const newOutput = event.outputTokens ?? last2.output;
+            const deltaIn = newInput - last2.input;
+            const deltaOut = newOutput - last2.output;
+            lastTokensRef.current.set(event.callId, { input: newInput, output: newOutput });
+            if (deltaIn > 0)
+              inputTokensRef.current += deltaIn;
+            if (deltaOut > 0)
+              outputTokensRef.current += deltaOut;
           }
-          case "agent.call_ended": {
-            const state = next.get(event.callId);
-            if (state) {
-              next.set(event.callId, { ...state, status: "ended" });
-              next.delete(event.callId);
-            }
-            lastTokensRef.current.delete(event.callId);
-            break;
+          break;
+        }
+        case "agent.tool_call_update": {
+          const state = next.get(event.callId);
+          if (state) {
+            next.set(event.callId, {
+              ...state,
+              toolCallUpdates: state.toolCallUpdates + 1,
+              lastActivityAt: event.timestamp,
+              lastToolName: event.toolName
+            });
           }
-          default:
-            break;
+          break;
         }
-        return next;
-      });
+        case "agent.call_ended": {
+          next.delete(event.callId);
+          lastTokensRef.current.delete(event.callId);
+          break;
+        }
+        default:
+          break;
+      }
+      activeCallsRef.current = next;
+      dirtyRef.current = true;
     });
     return unsubscribe;
   }, [bus]);
+  import_react31.useEffect(() => {
+    const interval = setInterval(() => {
+      if (!dirtyRef.current)
+        return;
+      dirtyRef.current = false;
+      setActiveCalls(new Map(activeCallsRef.current));
+      setInputTokens(inputTokensRef.current);
+      setOutputTokens(outputTokensRef.current);
+    }, RENDER_INTERVAL_MS);
+    return () => clearInterval(interval);
+  }, []);
   return { activeCalls, inputTokens, outputTokens };
 }
 
@@ -104660,14 +105496,33 @@ function usePipelineBusEvents(initialStories) {
 
 // src/tui/hooks/usePipelineEvents.ts
 var import_react33 = __toESM(require_react(), 1);
+var PRE_RUN_STAGES = new Set(["acceptance-setup"]);
 function usePipelineEvents(events) {
   const [currentStage, setCurrentStage] = import_react33.useState(undefined);
+  const [preRunPhases, setPreRunPhases] = import_react33.useState({});
   import_react33.useEffect(() => {
-    const onStageEnter = (stage) => setCurrentStage(stage);
+    const onStageEnter = (stage) => {
+      setCurrentStage(stage);
+      if (PRE_RUN_STAGES.has(stage)) {
+        setPreRunPhases((prev) => ({ ...prev, [stage]: { status: "running" } }));
+      }
+    };
+    const onStageExit = (stage, result2) => {
+      if (PRE_RUN_STAGES.has(stage)) {
+        setPreRunPhases((prev) => ({
+          ...prev,
+          [stage]: { status: result2.action === "fail" ? "failed" : "passed" }
+        }));
+      }
+    };
     events.on("stage:enter", onStageEnter);
-    return () => events.off("stage:enter", onStageEnter);
+    events.on("stage:exit", onStageExit);
+    return () => {
+      events.off("stage:enter", onStageEnter);
+      events.off("stage:exit", onStageExit);
+    };
   }, [events]);
-  return { currentStage };
+  return { currentStage, preRunPhases };
 }
 
 // src/tui/hooks/usePty.ts
@@ -104799,7 +105654,7 @@ function App2({
 }) {
   const layout = useLayout();
   const busState = usePipelineBusEvents(initialStories);
-  const { currentStage } = usePipelineEvents(events);
+  const { currentStage, preRunPhases } = usePipelineEvents(events);
   const { exit } = use_app_default();
   const startTimeRef = import_react35.useRef(Date.now());
   const [elapsedMs, setElapsedMs] = import_react35.useState(0);
@@ -104820,6 +105675,8 @@ function App2({
   const runningStories = busState.stories.filter((s) => s.status === "running");
   const isParallel = runningStories.length > 1;
   const currentRunningStory = runningStories[0];
+  const runningPostRunPhase = busState.postRunPhases.acceptance?.status === "running" ? "post-run: acceptance" : busState.postRunPhases.regression?.status === "running" ? "post-run: regression" : busState.postRunPhases.review?.status === "running" ? "post-run: review" : undefined;
+  const currentPhaseLabel = runningPostRunPhase ?? currentStage;
   const runErroredForPanel = busState.runErrored ? "Run encountered an error" : undefined;
   const handleKeyboardAction = async (action) => {
     switch (action.type) {
@@ -104903,7 +105760,11 @@ function App2({
   const isTooSmall = layout.width < MIN_TERMINAL_WIDTH;
   const activeCount = runningStories.length;
   const displayElapsed = busState.runSummary ? busState.runSummary.durationMs : elapsedMs;
-  const tokensStr = inputTokens > 0 || outputTokens > 0 ? `${formatTokens(inputTokens)} in / ${formatTokens(outputTokens)} out` : null;
+  const tokenParts = [
+    inputTokens > 0 ? `${formatTokens(inputTokens)} in` : null,
+    outputTokens > 0 ? `${formatTokens(outputTokens)} out` : null
+  ].filter(Boolean);
+  const tokensStr = tokenParts.length > 0 ? tokenParts.join(" / ") : null;
   const headerRight = [
     activeCount > 0 ? `${activeCount} running` : null,
     formatCost3(busState.totalCost),
@@ -104964,6 +105825,7 @@ function App2({
         children: [
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(MemoStoriesPanel, {
             stories: busState.stories,
+            preRunPhases,
             postRunPhases: busState.postRunPhases,
             width: layout.mode === "single" ? layout.width : layout.storiesPanelWidth,
             compact: layout.mode === "single",
@@ -104975,7 +105837,8 @@ function App2({
             storySteps: busState.storySteps,
             runSummary: busState.runSummary,
             runErrored: runErroredForPanel,
-            escalationLog: busState.escalationLog
+            escalationLog: busState.escalationLog,
+            currentStage: currentPhaseLabel
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
@@ -105141,8 +106004,8 @@ Next: nax generate --package ${options.package}`));
     }
     return;
   }
-  const naxDir = join84(workdir, ".nax");
-  if (existsSync36(naxDir) && !options.force) {
+  const naxDir = join87(workdir, ".nax");
+  if (existsSync35(naxDir) && !options.force) {
     console.log(source_default.yellow("nax already initialized. Use --force to overwrite."));
     return;
   }
@@ -105170,11 +106033,11 @@ Next: nax generate --package ${options.package}`));
       }
     }
   }
-  mkdirSync7(join84(naxDir, "features"), { recursive: true });
-  mkdirSync7(join84(naxDir, "hooks"), { recursive: true });
+  mkdirSync7(join87(naxDir, "features"), { recursive: true });
+  mkdirSync7(join87(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(join87(naxDir, "config.json"), JSON.stringify(initConfig, null, 2));
+  await Bun.write(join87(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 },
@@ -105182,12 +106045,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(join87(naxDir, ".gitignore"), `# nax temp files
 *.tmp
 .paused.json
 .nax-verifier-verdict.json
 `);
-  await Bun.write(join84(naxDir, "context.md"), `# Project Context
+  await Bun.write(join87(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.
@@ -105272,6 +106135,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 {
@@ -105284,7 +106165,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);
   }
@@ -105317,10 +106198,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 = join87(naxDir, "features", options.feature);
+  const prdPath = join87(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);
@@ -105340,10 +106221,10 @@ program2.command("run").description("Run the orchestration loop for a feature").
       }
     }
     try {
-      const planLogDir = join84(featureDir, "plan");
+      const planLogDir = join87(featureDir, "plan");
       mkdirSync7(planLogDir, { recursive: true });
       const planLogId = new Date().toISOString().replace(/:/g, "-").replace(/\..+/, "");
-      const planLogPath = join84(planLogDir, `${planLogId}.jsonl`);
+      const planLogPath = join87(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]"));
@@ -105382,17 +106263,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 = join87(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 = join87(runsDir, `${runId}.jsonl`);
   const isTTY = process.stdout.isTTY ?? false;
   const headlessFlag = options.headless ?? false;
   const headlessEnv = process.env.NAX_HEADLESS === "1";
@@ -105410,7 +106291,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 = join87(homedir3(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
   const agentStreamEvents = useHeadless ? undefined : new AgentStreamEventBus;
@@ -105430,12 +106311,12 @@ program2.command("run").description("Run the orchestration loop for a feature").
       events: eventEmitter,
       ptyOptions: null,
       agentStreamEvents,
-      queueFilePath: join84(workdir, ".queue.txt")
+      queueFilePath: join87(workdir, ".queue.txt")
     });
   } else {
     console.log(source_default.dim("   [Headless mode \u2014 pipe output]"));
   }
-  const statusFilePath = join84(outputDir, "status.json");
+  const statusFilePath = join87(outputDir, "status.json");
   let parallel;
   if (options.parallel !== undefined) {
     parallel = Number.parseInt(options.parallel, 10);
@@ -105462,9 +106343,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 = join87(runsDir, "latest.jsonl");
   try {
-    if (existsSync36(latestSymlink)) {
+    if (existsSync35(latestSymlink)) {
       Bun.spawnSync(["rm", latestSymlink]);
     }
     Bun.spawnSync(["ln", "-s", `${runId}.jsonl`, latestSymlink], {
@@ -105523,9 +106404,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 = join87(naxDir, "features", name);
   mkdirSync7(featureDir, { recursive: true });
-  await Bun.write(join84(featureDir, "spec.md"), `# Feature: ${name}
+  await Bun.write(join87(featureDir, "spec.md"), `# Feature: ${name}
 
 ## Overview
 
@@ -105558,7 +106439,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(join87(featureDir, "progress.txt"), `# Progress: ${name}
 
 Created: ${new Date().toISOString()}
 
@@ -105584,8 +106465,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 = join87(naxDir, "features");
+  if (!existsSync35(featuresDir)) {
     console.log(source_default.dim("No features yet."));
     return;
   }
@@ -105599,8 +106480,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 = join87(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`);
@@ -105634,10 +106515,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 = join87(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 = join87(featureLogDir, `${planLogId}.jsonl`);
   initLogger({ level: "info", filePath: planLogPath, useChalk: false, headless: true });
   console.log(source_default.dim(`   [Plan log: ${planLogPath}]`));
   try {