@nathapp/nax 0.69.0 → 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();
@@ -32641,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
       };
     }
@@ -38840,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: [] };
@@ -39441,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();
@@ -44655,7 +44984,8 @@ var init_session_role = __esm(() => {
     "fix-gen",
     "auto",
     "synthesis",
-    "judge"
+    "judge",
+    "setup"
   ];
 });
 
@@ -53532,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")
@@ -53971,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 {};
   }
@@ -53995,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",
@@ -54154,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]);
@@ -54246,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" });
@@ -54263,6 +54722,7 @@ var init_story_orchestrator = __esm(() => {
   init_event_bus();
   init_prepare_inputs();
   init_git();
+  init_non_blocking_fix();
   _storyOrchestratorDeps = {
     callOp,
     runFixCycle,
@@ -54415,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(() => {
@@ -54678,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)
@@ -56287,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([
@@ -56318,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 {
@@ -56336,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 {
@@ -56354,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);
     }
   }
@@ -56365,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);
     }
   }
@@ -56495,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);
   }
 }
@@ -56527,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;
@@ -56557,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(() => {
@@ -56570,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"));
@@ -56616,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)
@@ -56792,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)
@@ -56832,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));
@@ -56912,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 });
@@ -56925,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 });
@@ -56977,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);
@@ -56993,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 });
@@ -57002,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 });
@@ -57069,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() {
@@ -57770,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()) {
@@ -57792,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;
@@ -57867,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 ? `
 ` : ""));
@@ -58443,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();
@@ -58508,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) => {
@@ -58527,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;
@@ -58704,7 +59439,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.69.0",
+    version: "0.69.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -58799,8 +59534,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("ce4d8f0e"))
-        return "ce4d8f0e";
+      if (/^[0-9a-f]{6,10}$/.test("3b2af55b"))
+        return "3b2af55b";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -59676,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;
@@ -59701,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);
@@ -59728,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()
@@ -60438,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)}
@@ -60624,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));
@@ -60886,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);
@@ -60901,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)) {
@@ -60911,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");
   }
@@ -60962,7 +61697,7 @@ var init_dependencies = __esm(() => {
     "build.gradle.kts"
   ];
   _worktreeDependencyDeps = {
-    existsSync: existsSync31,
+    existsSync: existsSync30,
     spawn
   };
 });
@@ -60973,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));
@@ -61008,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"], {
@@ -61049,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) {
@@ -61062,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"], {
@@ -61874,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,
@@ -62093,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) {
@@ -62119,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);
@@ -62139,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 {
@@ -62166,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,
@@ -62298,7 +63033,7 @@ var init_iteration_runner = __esm(() => {
     loadConfigForWorkdir,
     prepareWorktreeDependencies,
     runPipeline,
-    existsSync: existsSync33,
+    existsSync: existsSync32,
     worktreeManager: new WorktreeManager
   };
 });
@@ -62368,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) };
 }
@@ -62391,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
@@ -63278,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;
@@ -63397,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);
@@ -63428,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 = [];
@@ -63447,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);
@@ -63509,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
@@ -63517,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;
@@ -63555,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
@@ -63585,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}
@@ -63831,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;
@@ -63848,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) {
@@ -93641,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);
 }
@@ -93724,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) {
@@ -93741,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) {
@@ -93752,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("");
@@ -93766,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}.`);
@@ -93783,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(() => "") : "";
@@ -93817,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);
@@ -93826,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);
@@ -93863,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.");
@@ -93874,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);
@@ -93915,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}).`);
@@ -93963,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);
@@ -95055,6 +95790,7 @@ async function runsShowCommand(options) {
 // src/cli/index.ts
 init_prompts2();
 init_init2();
+init_setup();
 
 // src/cli/plugins.ts
 init_paths();
@@ -95129,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();
@@ -95173,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"));
     }
@@ -95193,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);
@@ -95299,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 = {
@@ -95551,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();
@@ -95574,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);
 }
 
@@ -95634,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);
@@ -95783,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);
@@ -95850,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()) {
@@ -95869,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}`);
@@ -95991,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) => {
@@ -96001,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 {
@@ -96050,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;
@@ -96079,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 {
@@ -96106,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);
@@ -96117,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++;
@@ -96156,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();
 }
@@ -96178,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";
@@ -96263,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;
@@ -96317,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}`));
@@ -96336,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}`));
@@ -96359,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
 };
@@ -96386,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)) {
@@ -96398,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;
   }
@@ -96408,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);
@@ -96501,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}` : "?/?";
@@ -96615,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();
@@ -96623,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) {
@@ -96649,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,
@@ -96672,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);
@@ -96697,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
@@ -96752,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();
@@ -96829,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);
@@ -96844,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) {
@@ -105268,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;
   }
@@ -105297,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 },
@@ -105309,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.
@@ -105399,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 {
@@ -105411,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);
   }
@@ -105444,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);
@@ -105467,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]"));
@@ -105509,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";
@@ -105537,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;
@@ -105557,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);
@@ -105589,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], {
@@ -105650,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
 
@@ -105685,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()}
 
@@ -105711,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;
   }
@@ -105726,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`);
@@ -105761,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 {