@nathapp/nax 0.70.8 → 0.71.1

package/dist/nax.js

@@ -16813,7 +16813,7 @@ var init_schemas_debate = __esm(() => {
 });
 
 // src/config/schemas-execution.ts
-var AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, WorktreeDependenciesConfigSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema;
+var AutoModeConfigSchema, RectificationConfigSchema, RegressionGateConfigSchema, SmartTestRunnerConfigSchema, SMART_TEST_RUNNER_DEFAULT, smartTestRunnerFieldSchema, WorktreeDependenciesConfigSchema, FlakeDetectionConfigSchema, ExecutionConfigSchema, QualityConfigSchema, TddConfigSchema, ConstitutionConfigSchema;
 var init_schemas_execution = __esm(() => {
   init_zod();
   init_schemas_model();
@@ -16879,6 +16879,12 @@ var init_schemas_execution = __esm(() => {
       });
     }
   });
+  FlakeDetectionConfigSchema = exports_external.object({
+    enabled: exports_external.boolean().default(true),
+    probeRuns: exports_external.number().int().min(1).max(20).default(2),
+    maxProbesPerGate: exports_external.number().int().min(1).max(100).default(5),
+    probeTimeoutSeconds: exports_external.number().int().min(5).max(600).default(60)
+  });
   ExecutionConfigSchema = exports_external.object({
     maxIterations: exports_external.number().int().positive({ message: "maxIterations must be > 0" }),
     iterationDelayMs: exports_external.number().int().nonnegative(),
@@ -16904,7 +16910,13 @@ var init_schemas_execution = __esm(() => {
       mode: "off",
       setupCommand: null
     }),
-    storyIsolation: exports_external.enum(["shared", "worktree"]).default("shared")
+    storyIsolation: exports_external.enum(["shared", "worktree"]).default("shared"),
+    flakeDetection: FlakeDetectionConfigSchema.default({
+      enabled: true,
+      probeRuns: 2,
+      maxProbesPerGate: 5,
+      probeTimeoutSeconds: 60
+    })
   });
   QualityConfigSchema = exports_external.object({
     requireTypecheck: exports_external.boolean().default(true),
@@ -17407,7 +17419,13 @@ var init_schemas3 = __esm(() => {
         mode: "off",
         setupCommand: null
       },
-      storyIsolation: "shared"
+      storyIsolation: "shared",
+      flakeDetection: {
+        enabled: true,
+        probeRuns: 2,
+        maxProbesPerGate: 5,
+        probeTimeoutSeconds: 60
+      }
     }),
     quality: QualityConfigSchema.default({
       requireTypecheck: true,
@@ -17738,6 +17756,22 @@ var init_schema = __esm(() => {
   init_defaults();
 });
 
+// src/review/severity.ts
+function isBlockingSeverity(sev, threshold = "error") {
+  return (SEVERITY_RANK[sev] ?? 0) >= SEVERITY_RANK[threshold];
+}
+var SEVERITY_RANK;
+var init_severity = __esm(() => {
+  SEVERITY_RANK = {
+    info: 0,
+    unverifiable: 0,
+    low: 1,
+    warning: 1,
+    error: 2,
+    critical: 3
+  };
+});
+
 // src/log-format/types.ts
 var EMOJI;
 var init_types2 = __esm(() => {
@@ -18037,6 +18071,31 @@ function formatRunSummary(summary, options) {
   return lines.join(`
 `);
 }
+function formatAdvisorySummary(findings, options) {
+  if (findings.length === 0)
+    return "";
+  const { mode, useColor = true } = options;
+  if (mode === "json") {
+    return JSON.stringify(findings);
+  }
+  const c = useColor ? source_default : createNoopChalk();
+  const sorted = [...findings].sort((a, b) => (SEVERITY_RANK[b.severity] ?? 0) - (SEVERITY_RANK[a.severity] ?? 0));
+  const lines = [];
+  lines.push("");
+  lines.push(c.yellow("\u2500".repeat(60)));
+  lines.push(c.bold(c.yellow(`  ${EMOJI.warning} NON-BLOCKING REVIEW FINDINGS (${findings.length})`)));
+  lines.push(c.yellow("\u2500".repeat(60)));
+  for (const f of sorted) {
+    const location = f.file ? `${f.file}${f.line ? `:${f.line}` : ""}` : undefined;
+    const parts = [`[${f.severity}]`, f.storyId ?? "unknown", location, f.category].filter((v) => typeof v === "string" && v.length > 0);
+    lines.push(`  ${c.gray(parts.join(" \xB7 "))}`);
+    lines.push(`    ${f.issue}`);
+  }
+  lines.push(c.yellow("\u2500".repeat(60)));
+  lines.push("");
+  return lines.join(`
+`);
+}
 function createNoopChalk() {
   const noop = (s) => s;
   return {
@@ -18054,6 +18113,7 @@ function createNoopChalk() {
 var CONSUMED_META_KEYS;
 var init_formatter = __esm(() => {
   init_source();
+  init_severity();
   init_types2();
   CONSUMED_META_KEYS = [
     "agentName",
@@ -18397,7 +18457,11 @@ function mergePackageConfig(root, packageOverride) {
         ...root.execution.regressionGate,
         ...packageOverride.execution?.regressionGate
       },
-      verificationTimeoutSeconds: packageOverride.execution?.verificationTimeoutSeconds ?? root.execution.verificationTimeoutSeconds
+      verificationTimeoutSeconds: packageOverride.execution?.verificationTimeoutSeconds ?? root.execution.verificationTimeoutSeconds,
+      flakeDetection: {
+        ...root.execution.flakeDetection,
+        ...packageOverride.execution?.flakeDetection
+      }
     },
     review: {
       ...root.review,
@@ -28560,7 +28624,10 @@ function getNextStory(prd, currentStoryId, maxRetries) {
       return currentStory;
     }
   }
-  return prd.userStories.find((s) => !s.passes && s.status !== "passed" && s.status !== "skipped" && s.status !== "blocked" && s.status !== "failed" && s.status !== "paused" && s.status !== "decomposed" && hasSatisfiedDependencies(s, storyIds, completedIds)) ?? null;
+  const eligible = prd.userStories.filter((s) => !s.passes && s.status !== "passed" && s.status !== "skipped" && s.status !== "blocked" && s.status !== "failed" && s.status !== "paused" && s.status !== "decomposed" && hasSatisfiedDependencies(s, storyIds, completedIds));
+  if (eligible.length === 0)
+    return null;
+  return eligible.reduce((best, s) => (s.priority ?? 0) > (best.priority ?? 0) ? s : best);
 }
 function isComplete(prd) {
   return prd.userStories.every((s) => s.passes || s.status === "passed" || s.status === "skipped");
@@ -28643,6 +28710,31 @@ function markStorySkipped(prd, storyId) {
     story.status = "skipped";
   }
 }
+function resetStoryToPending(prd, storyId) {
+  const story = prd.userStories.find((s) => s.id === storyId);
+  if (!story)
+    return;
+  story.status = "pending";
+  story.attempts = 0;
+  story.failureCategory = undefined;
+  story.failureStage = undefined;
+  if (story.routing) {
+    story.routing = {
+      ...story.routing,
+      ...story.routing.initialModelTier !== undefined && {
+        modelTier: story.routing.initialModelTier
+      },
+      agent: story.routing.initialAgent
+    };
+  }
+  story.escalations = [];
+}
+function setStoryPriority(prd, storyId, priority) {
+  const story = prd.userStories.find((s) => s.id === storyId);
+  if (story) {
+    story.priority = priority;
+  }
+}
 function markStoryPaused(prd, storyId) {
   const story = prd.userStories.find((s) => s.id === storyId);
   if (story) {
@@ -32739,22 +32831,6 @@ var init_category_fix_target = __esm(() => {
   init_ac_structural_counterfactual();
 });
 
-// src/review/severity.ts
-function isBlockingSeverity(sev, threshold = "error") {
-  return (SEVERITY_RANK[sev] ?? 0) >= SEVERITY_RANK[threshold];
-}
-var SEVERITY_RANK;
-var init_severity = __esm(() => {
-  SEVERITY_RANK = {
-    info: 0,
-    unverifiable: 0,
-    low: 1,
-    warning: 1,
-    error: 2,
-    critical: 3
-  };
-});
-
 // src/review/adversarial-helpers.ts
 function validateAdversarialShape(parsed) {
   if (typeof parsed !== "object" || parsed === null)
@@ -33849,15 +33925,36 @@ function createNoOpReviewAuditor() {
   return {
     recordDispatch() {},
     recordDecision() {},
-    async flush() {}
+    async flush() {},
+    getAdvisoryFindings() {
+      return [];
+    }
   };
 }
+function toAdvisorySummaryEntries(entry) {
+  if (!entry.advisoryFindings || entry.advisoryFindings.length === 0)
+    return [];
+  return entry.advisoryFindings.map((raw) => {
+    const f = raw;
+    return {
+      storyId: entry.storyId,
+      featureName: entry.featureName,
+      reviewer: entry.reviewer,
+      severity: f.severity ?? "info",
+      category: f.category,
+      file: f.file,
+      line: f.line,
+      issue: f.issue ?? "(no description)"
+    };
+  });
+}
 
 class ReviewAuditor {
   _runId;
   _outputDir;
   _queue = Promise.resolve();
   _dispatches = new Map;
+  _advisoryFindings = [];
   constructor(_runId, _outputDir) {
     this._runId = _runId;
     this._outputDir = _outputDir;
@@ -33866,6 +33963,7 @@ class ReviewAuditor {
     this._dispatches.set(auditKey(entry.reviewer, entry.storyId), entry);
   }
   recordDecision(entry) {
+    this._advisoryFindings.push(...toAdvisorySummaryEntries(entry));
     const key = auditKey(entry.reviewer, entry.storyId);
     const dispatch = this._dispatches.get(key);
     this._dispatches.delete(key);
@@ -33894,6 +33992,9 @@ class ReviewAuditor {
   async flush() {
     await this._queue;
   }
+  getAdvisoryFindings() {
+    return [...this._advisoryFindings];
+  }
 }
 async function writeReviewAudit(entry) {
   try {
@@ -34841,6 +34942,17 @@ var init_self_verification = __esm(() => {
 });
 
 // src/quality/index.ts
+var exports_quality = {};
+__export(exports_quality, {
+  runQualityCommand: () => runQualityCommand,
+  resolveSelfVerificationPromptInput: () => resolveSelfVerificationPromptInput,
+  resolveQualityTestCommands: () => resolveQualityTestCommands,
+  resolveDefaultQualityCommands: () => resolveDefaultQualityCommands,
+  parseSelfVerificationMarker: () => parseSelfVerificationMarker,
+  clearCommandDefaultsCache: () => clearCommandDefaultsCache,
+  _commandResolverDeps: () => _commandResolverDeps,
+  _commandDefaultsDeps: () => _commandDefaultsDeps
+});
 var init_quality = __esm(() => {
   init_runner();
   init_command_resolver();
@@ -39527,7 +39639,8 @@ var init_full_suite_gate = __esm(() => {
           status: "skipped",
           estimatedCostUsd: 0,
           attempts: 0,
-          findings: []
+          findings: [],
+          rawOutput: ""
         };
       }
       const gateCtx = await deps.resolveGateContext(input, ctx);
@@ -39546,7 +39659,15 @@ var init_full_suite_gate = __esm(() => {
       });
       const testResult = await deps.runTests(input, gateCtx);
       if (testResult.passed) {
-        return { success: true, passed: true, status: "passed", estimatedCostUsd: 0, attempts: 0, findings: [] };
+        return {
+          success: true,
+          passed: true,
+          status: "passed",
+          estimatedCostUsd: 0,
+          attempts: 0,
+          findings: [],
+          rawOutput: testResult.output
+        };
       }
       if (testResult.timedOut) {
         const acceptOnTimeout = ctxConfig?.execution?.regressionGate?.acceptOnTimeout ?? true;
@@ -39560,7 +39681,8 @@ var init_full_suite_gate = __esm(() => {
             status: "passed-on-timeout",
             estimatedCostUsd: 0,
             attempts: 0,
-            findings: []
+            findings: [],
+            rawOutput: testResult.output
           };
         }
         logger.warn("verify[regression]", "Full-suite timed out (failing)", {
@@ -39572,7 +39694,8 @@ var init_full_suite_gate = __esm(() => {
           status: "timeout",
           estimatedCostUsd: 0,
           attempts: 0,
-          findings: []
+          findings: [],
+          rawOutput: testResult.output
         };
       }
       const findings = testSummaryToFindings(testResult.parsedSummary);
@@ -39597,10 +39720,19 @@ var init_full_suite_gate = __esm(() => {
           status: "execution-failed",
           estimatedCostUsd: 0,
           attempts: 0,
-          findings: [synth]
+          findings: [synth],
+          rawOutput: testResult.output
         };
       }
-      return { success: false, passed: false, status: "failed", estimatedCostUsd: 0, attempts: 0, findings };
+      return {
+        success: false,
+        passed: false,
+        status: "failed",
+        estimatedCostUsd: 0,
+        attempts: 0,
+        findings,
+        rawOutput: testResult.output
+      };
     }
   };
 });
@@ -47347,6 +47479,190 @@ var init_session = __esm(() => {
   init_types7();
 });
 
+// src/verification/flake-probe.ts
+function escapeRegex2(input) {
+  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildIsolationCommand(baseCommand, failure, framework) {
+  const file3 = failure.file;
+  const name = failure.testName;
+  switch (framework) {
+    case "pytest":
+      return `${baseCommand} ${shellQuote(`${file3}::${name}`)}`;
+    case "go":
+      return `${baseCommand} -run ${shellQuote(`^${escapeRegex2(name)}$`)}`;
+    case "bun":
+    case "jest":
+    case "vitest":
+      return `${baseCommand} ${file3} -t ${shellQuote(escapeRegex2(name))}`;
+    default:
+      throw new NaxError(`[flake-probe] unsupported framework: ${framework}`, "FLAKE_PROBE_UNSUPPORTED_FRAMEWORK", {
+        stage: "verify",
+        framework
+      });
+  }
+}
+async function runFlakeProbe(input) {
+  const { framework, baseCommand, failure, cwd, probeRuns, probeTimeoutSeconds } = input;
+  if (failure.file === "unknown" || framework === "unknown") {
+    return {
+      verdict: "unprobeable",
+      reason: failure.file === "unknown" && framework === "unknown" ? "unknown file and framework" : failure.file === "unknown" ? "unknown file" : "unknown framework"
+    };
+  }
+  const command = buildIsolationCommand(baseCommand, failure, framework);
+  let probePasses = 0;
+  for (let i = 0;i < probeRuns; i += 1) {
+    let result;
+    try {
+      result = await _flakeProbeDeps.execute(command, probeTimeoutSeconds, undefined, { cwd });
+    } catch {
+      continue;
+    }
+    if (result.success && result.countsTowardEscalation) {
+      probePasses += 1;
+    }
+  }
+  if (probePasses > 0) {
+    return { verdict: "flaky", probeRuns, probePasses };
+  }
+  return { verdict: "consistent-failure", probeRuns };
+}
+var _flakeProbeDeps;
+var init_flake_probe = __esm(() => {
+  init_errors();
+  init_executor();
+  _flakeProbeDeps = {
+    execute: executeWithTimeout
+  };
+});
+
+// src/verification/flake-triage.ts
+function flakeMemoKey(failure) {
+  return `${failure.file ?? ""}::${failure.rule ?? ""}`;
+}
+function createQuarantineMemo() {
+  const keys = new Set;
+  return {
+    has: (key) => keys.has(key),
+    add: (key) => {
+      keys.add(key);
+    }
+  };
+}
+async function triageFlakyFindings(input) {
+  const { findings, diff, flakeDetection, baseCommand, cwd, framework, quarantineMemo } = input;
+  const logger = getSafeLogger();
+  const result = [];
+  const keys = [];
+  const reasons = [];
+  if (findings.length === 0) {
+    return { findings: result, quarantineReport: { keys, reasons } };
+  }
+  if (!flakeDetection.enabled) {
+    for (const f of findings)
+      result.push({ ...f });
+    return { findings: result, quarantineReport: { keys, reasons } };
+  }
+  const changedTestSet = new Set(diff.changedTestFiles.map(basename5));
+  const mappedTestSet = new Set(diff.mappedTestFiles.map(basename5));
+  const candidates = findings.filter((f) => isProbeCandidate(f, changedTestSet, mappedTestSet));
+  if (candidates.length > flakeDetection.maxProbesPerGate) {
+    logger?.info("flake-triage", `Skipping flake triage \u2014 ${candidates.length} candidates exceed maxProbesPerGate=${flakeDetection.maxProbesPerGate}`);
+    reasons.push(`skipped: ${candidates.length} candidates exceed maxProbesPerGate=${flakeDetection.maxProbesPerGate}`);
+    for (const f of findings)
+      result.push({ ...f });
+    return { findings: result, quarantineReport: { keys, reasons } };
+  }
+  for (const finding of findings) {
+    const copy = { ...finding };
+    if (copy.category !== "failed-test") {
+      result.push(copy);
+      continue;
+    }
+    const key = flakeMemoKey(copy);
+    if (quarantineMemo.has(key)) {
+      copy.category = "flaky-test";
+      keys.push(key);
+      reasons.push(`quarantined (memo): ${key}`);
+      result.push(copy);
+      continue;
+    }
+    if (!isProbeCandidate(copy, changedTestSet, mappedTestSet)) {
+      result.push(copy);
+      continue;
+    }
+    const failure = {
+      file: copy.file ?? "unknown",
+      testName: copy.rule ?? "",
+      error: copy.message,
+      stackTrace: []
+    };
+    const probeInput = {
+      framework,
+      baseCommand,
+      failure,
+      cwd,
+      probeRuns: flakeDetection.probeRuns,
+      probeTimeoutSeconds: flakeDetection.probeTimeoutSeconds
+    };
+    let verdict;
+    try {
+      verdict = await _flakeTriageDeps.runFlakeProbe({ failure, config: flakeDetection, probeInput });
+    } catch (err) {
+      logger?.warn("flake-triage", `Probe dependency threw for ${key} \u2014 keeping finding blocking`, {
+        file: copy.file,
+        testName: copy.rule,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      result.push(copy);
+      continue;
+    }
+    if (verdict.verdict === "flaky") {
+      copy.category = "flaky-test";
+      copy.meta = { ...copy.meta ?? {}, probeRuns: verdict.probeRuns, probePasses: verdict.probePasses };
+      quarantineMemo.add(key);
+      keys.push(key);
+      reasons.push(`quarantined: ${key}`);
+    }
+    result.push(copy);
+  }
+  return { findings: result, quarantineReport: { keys, reasons } };
+}
+function basename5(path7) {
+  const i = path7.lastIndexOf("/");
+  return i === -1 ? path7 : path7.slice(i + 1);
+}
+function isProbeCandidate(finding, changedTestSet, mappedTestSet) {
+  if (finding.category !== "failed-test")
+    return false;
+  if (!finding.file || finding.file === "unknown")
+    return false;
+  if (!finding.rule)
+    return false;
+  const base = basename5(finding.file);
+  if (changedTestSet.has(base) || changedTestSet.has(finding.file))
+    return false;
+  if (mappedTestSet.has(base) || mappedTestSet.has(finding.file))
+    return false;
+  return true;
+}
+var NULL_QUARANTINE_MEMO, _flakeTriageDeps;
+var init_flake_triage = __esm(() => {
+  init_logger2();
+  init_flake_probe();
+  NULL_QUARANTINE_MEMO = {
+    has: () => false,
+    add: () => {}
+  };
+  _flakeTriageDeps = {
+    runFlakeProbe: async (call) => runFlakeProbe(call.probeInput)
+  };
+});
+
 // src/runtime/session-run-hop.ts
 function createSessionRunHop(sessionManager, getAgentManager) {
   return async (agentName, options) => {
@@ -47470,7 +47786,7 @@ __export(exports_runtime, {
   CostAggregator: () => CostAggregator,
   AgentStreamEventBus: () => AgentStreamEventBus
 });
-import { basename as basename5, join as join30 } from "path";
+import { basename as basename6, join as join30 } from "path";
 function createRuntime(config2, workdir, opts) {
   const runId = crypto.randomUUID();
   const controller = new AbortController;
@@ -47482,7 +47798,7 @@ function createRuntime(config2, workdir, opts) {
   const configLoader = createConfigLoader(config2);
   const dispatchEvents = new DispatchEventBus;
   const agentStreamEvents = opts?.agentStreamEvents ?? new AgentStreamEventBus;
-  const projectKey = config2.name?.trim() || basename5(workdir);
+  const projectKey = config2.name?.trim() || basename6(workdir);
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
   const globalDir = globalOutputDir();
   const curatorRollupPathValue = curatorRollupPath(globalDir, config2.curator?.rollupPath);
@@ -47544,6 +47860,7 @@ function createRuntime(config2, workdir, opts) {
   const offWatchdog = attachAgentIdleWatchdog(agentStreamEvents, watchdogControllerRegistry, config2);
   const packages = createPackageRegistry(configLoader, workdir);
   const logger = getLogger();
+  const quarantineMemo = createQuarantineMemo();
   let closed = false;
   return {
     runId,
@@ -47564,6 +47881,7 @@ function createRuntime(config2, workdir, opts) {
     packages,
     pidRegistry,
     logger,
+    quarantineMemo,
     get signal() {
       return controller.signal;
     },
@@ -47612,6 +47930,7 @@ var init_runtime = __esm(() => {
   init_logger2();
   init_review_audit();
   init_session();
+  init_flake_triage();
   init_agent_stream_events();
   init_cost_aggregator();
   init_dispatch_events();
@@ -55463,6 +55782,12 @@ async function runNonBlockingFix(args, overrides = {}) {
     exhausted = true;
   }
   if (!exhausted) {
+    if (args.keptTreeRegressed?.()) {
+      logger?.info("non-blocking-fix", "kept tree regressed the full-suite gate \u2014 restoring (ADR-024 \xA73)", {
+        storyId: args.storyId
+      });
+      return restoreToSnapshot(args, _deps, restoreRef, phaseOutputsSnapshot, phaseCostsSnapshot, logger);
+    }
     const cap = args.cfg.sourceDiffCap;
     if (cap) {
       let metrics;
@@ -55638,6 +55963,8 @@ function gateFailureKeys(gateOutput) {
   for (const f of extractPhaseFindings(gateOutput)) {
     if (f.source !== "test-runner")
       continue;
+    if (f.category === "flaky-test")
+      continue;
     keys.add(`${f.file ?? ""}::${f.rule ?? ""}`);
   }
   return keys;
@@ -55775,6 +56102,85 @@ function logDeterministicPhaseOutcome(storyId, opName, output, durationMs, isTdd
 var init_story_orchestrator_logging = __esm(() => {
   init_logger2();
 });
+// src/verification/flake-baseline-diff.ts
+async function resolveFlakeBaselineDiff(config2, workdir, storyWorkdir) {
+  try {
+    const resolved = await resolveTestFilePatterns(config2, workdir, storyWorkdir);
+    const baseRef = await getMergeBase(workdir);
+    const changedTestFiles = await getChangedTestFiles(workdir, workdir, baseRef, storyWorkdir, [...resolved.regex]);
+    const changedNonTestFiles = await getChangedNonTestFiles(workdir, baseRef, storyWorkdir, [...resolved.regex], undefined, workdir);
+    const mappedTestFiles = await mapSourceToTests(changedNonTestFiles, workdir, storyWorkdir, [...resolved.globs]);
+    return { changedTestFiles, mappedTestFiles };
+  } catch (err) {
+    getSafeLogger()?.warn("flake-triage", "Baseline diff resolution failed \u2014 skipping triage this gate (fail closed)", {
+      error: errorMessage(err)
+    });
+    return null;
+  }
+}
+var init_flake_baseline_diff = __esm(() => {
+  init_logger2();
+  init_test_runners();
+  init_git();
+  init_smart_runner();
+});
+
+// src/verification/index.ts
+var init_verification = __esm(() => {
+  init_executor();
+  init_runners();
+  init_flake_probe();
+  init_flake_triage();
+  init_flake_baseline_diff();
+});
+
+// src/execution/story-orchestrator/flake-triage-seam.ts
+var productionTriageSeam = async (gateFindings, { ctx, rawOutput }) => {
+  const config2 = ctx.packageView.config;
+  const flakeDetection = config2.execution?.flakeDetection;
+  if (!flakeDetection?.enabled) {
+    return [gateFindings, { quarantinedKeys: [] }];
+  }
+  const framework = detectFramework(rawOutput);
+  if (framework === "unknown") {
+    return [gateFindings, { quarantinedKeys: [] }];
+  }
+  const workdir = ctx.runtime.workdir;
+  const storyWorkdir = ctx.story?.workdir;
+  try {
+    const { resolveQualityTestCommands: resolveQualityTestCommands2 } = await Promise.resolve().then(() => (init_quality(), exports_quality));
+    const { testCommand } = await resolveQualityTestCommands2(config2, workdir, storyWorkdir);
+    const baseCommand = testCommand ?? config2.quality?.commands?.test;
+    if (!baseCommand) {
+      return [gateFindings, { quarantinedKeys: [] }];
+    }
+    const diff = await resolveFlakeBaselineDiff(config2, workdir, storyWorkdir);
+    if (diff === null) {
+      return [gateFindings, { quarantinedKeys: [] }];
+    }
+    const result = await triageFlakyFindings({
+      findings: gateFindings,
+      diff,
+      flakeDetection,
+      baseCommand,
+      cwd: ctx.packageDir,
+      framework,
+      quarantineMemo: ctx.runtime.quarantineMemo
+    });
+    return [result.findings, { quarantinedKeys: result.quarantineReport.keys }];
+  } catch (err) {
+    getSafeLogger()?.warn("story-orchestrator", "Flake triage seam failed resolving context \u2014 keeping findings blocking (no quarantine)", {
+      storyId: ctx.storyId,
+      error: errorMessage(err)
+    });
+    return [gateFindings, { quarantinedKeys: [] }];
+  }
+};
+var init_flake_triage_seam = __esm(() => {
+  init_logger2();
+  init_test_runners();
+  init_verification();
+});
 
 // src/execution/story-orchestrator/review-decision.ts
 function toReviewDecisionPayload(opName, output) {
@@ -56051,6 +56457,7 @@ var init_run_phase = __esm(() => {
   init_git();
   init_non_blocking_fix();
   init_story_orchestrator_logging();
+  init_flake_triage_seam();
   init_review_decision();
   init_types9();
   _storyOrchestratorDeps = {
@@ -56059,7 +56466,8 @@ var init_run_phase = __esm(() => {
     captureGitRef,
     prepareSemanticReviewInput,
     prepareAdversarialReviewInput,
-    runNonBlockingFix
+    runNonBlockingFix,
+    triage: productionTriageSeam
   };
 });
 
@@ -56077,10 +56485,63 @@ function gatherRectificationFindings(phaseOutputs, phases, state) {
   for (const phase of phases) {
     if (shouldSkipPhaseForRectification(phase, state, phaseOutputs))
       continue;
-    findings.push(...extractPhaseFindings(phaseOutputs[phase.slot.op.name]));
+    for (const f of extractPhaseFindings(phaseOutputs[phase.slot.op.name])) {
+      if (f.category === "flaky-test")
+        continue;
+      findings.push(f);
+    }
   }
   return findings;
 }
+async function triageGateFindings(phaseOutputs, gateName, ctx) {
+  if (!gateName)
+    return { triaged: false, quarantinedKeys: [], skipped: true };
+  const triage = _storyOrchestratorDeps.triage;
+  if (typeof triage !== "function")
+    return { triaged: false, quarantinedKeys: [], skipped: true };
+  const output = phaseOutputs[gateName];
+  if (output === null || output === undefined || typeof output !== "object") {
+    return { triaged: false, quarantinedKeys: [], skipped: true };
+  }
+  const record2 = output;
+  const findings = extractPhaseFindings(output);
+  if (findings.length === 0) {
+    return { triaged: false, quarantinedKeys: [], skipped: true };
+  }
+  const rawOutput = typeof record2.rawOutput === "string" ? record2.rawOutput : "";
+  let triagedFindings;
+  let quarantinedKeys;
+  try {
+    const [triaged, report] = await triage(findings, { ctx, rawOutput });
+    triagedFindings = triaged;
+    quarantinedKeys = report.quarantinedKeys;
+  } catch (err) {
+    getSafeLogger()?.warn("story-orchestrator", "Flake triage threw \u2014 keeping findings blocking (no quarantine)", {
+      storyId: ctx.storyId,
+      gateName,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return { triaged: false, quarantinedKeys: [], skipped: true };
+  }
+  const allTestRunnersQuarantined = triagedFindings.every((f) => f.source !== "test-runner" || f.category === "flaky-test");
+  const nextRecord = { ...record2, findings: triagedFindings };
+  if (allTestRunnersQuarantined) {
+    nextRecord.success = true;
+    nextRecord.passed = true;
+  }
+  phaseOutputs[gateName] = nextRecord;
+  if (quarantinedKeys.length > 0) {
+    const logger = getSafeLogger();
+    for (const key of quarantinedKeys) {
+      logger?.warn("story-orchestrator", `Flake quarantined: ${key}`, {
+        storyId: ctx.storyId,
+        key,
+        previousFailureCount: findings.length
+      });
+    }
+  }
+  return { triaged: true, quarantinedKeys, skipped: false };
+}
 function collectRectificationPhases(state) {
   return [
     state.fullSuiteGate,
@@ -56093,16 +56554,32 @@ function collectRectificationPhases(state) {
   ].filter((phase) => phase !== undefined);
 }
 async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides) {
-  const rectification = state.rectification;
+  const rectification2 = state.rectification;
   const baseValidationPhases = collectRectificationPhases(state);
   const validationPhases = overrides?.excludePhaseKinds ? baseValidationPhases.filter((p) => !overrides.excludePhaseKinds?.includes(p.kind)) : baseValidationPhases;
-  if (!rectification || validationPhases.length === 0) {
+  if (!rectification2 || validationPhases.length === 0) {
     return {};
   }
   if (ctx.runtime.signal?.aborted) {
     return {};
   }
-  const initialFindings = overrides?.initialFindings ? [...overrides.initialFindings] : gatherRectificationFindings(phaseOutputs, validationPhases, state);
+  let initialFindings;
+  if (overrides?.initialFindings) {
+    initialFindings = [...overrides.initialFindings];
+  } else {
+    const gateName = state.fullSuiteGate?.slot.op.name;
+    if (overrides?.skipGateTriage !== true) {
+      const triageReport = await triageGateFindings(phaseOutputs, gateName, ctx);
+      if (triageReport.skipped && gateName !== undefined) {
+        getSafeLogger()?.debug("story-orchestrator", "Gate triage skipped \u2014 passthrough to fix cycle", {
+          storyId: ctx.storyId,
+          gateName,
+          triaged: triageReport.triaged
+        });
+      }
+    }
+    initialFindings = gatherRectificationFindings(phaseOutputs, validationPhases, state);
+  }
   if (initialFindings.length === 0) {
     return {};
   }
@@ -56117,8 +56594,8 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
   const cycle = {
     findings: [...initialFindings],
     iterations: [],
-    strategies: withIncreasingFailuresBail(overrides?.strategies ?? rectification.strategies, rectification.abortOnIncreasingFailures, rectification.consecutiveIncreasesToBail ?? 1),
-    config: { maxAttemptsTotal: overrides?.maxAttempts ?? rectification.maxAttempts, validatorRetries: 1 },
+    strategies: withIncreasingFailuresBail(overrides?.strategies ?? rectification2.strategies, rectification2.abortOnIncreasingFailures, rectification2.consecutiveIncreasesToBail ?? 1),
+    config: { maxAttemptsTotal: overrides?.maxAttempts ?? rectification2.maxAttempts, validatorRetries: 1 },
     validate: async (_validateCtx, opts) => {
       if (ctx.runtime.signal?.aborted)
         return { findings: [], shortCircuited: false };
@@ -56150,7 +56627,7 @@ async function runRectification(ctx, state, phaseCosts, phaseOutputs, overrides)
           break;
         }
       }
-      const postValidateFn = overrides?.postValidate ?? rectification.postValidate;
+      const postValidateFn = overrides?.postValidate ?? rectification2.postValidate;
       const validated = postValidateFn ? await postValidateFn(findings, _validateCtx) : findings;
       return { findings: validated, shortCircuited };
     }
@@ -56270,7 +56747,9 @@ class ExecutionPlan {
           if (!resumeRectifyUsed) {
             resumeRectifyUsed = true;
             logger?.info("story-orchestrator", "Phase failed in post-rectification resume \u2014 invoking second rectification pass", { storyId: this.ctx.storyId, phase: name, source: "post-rectification-resume" });
-            const secondRect = await runRectification(this.ctx, this.state, phaseCosts, phaseOutputs);
+            const secondRect = await runRectification(this.ctx, this.state, phaseCosts, phaseOutputs, {
+              skipGateTriage: true
+            });
             if (secondRect.rectificationExhausted) {
               logger?.warn("story-orchestrator", "Second rectification pass exhausted \u2014 terminal failure", {
                 storyId: this.ctx.storyId,
@@ -56339,7 +56818,8 @@ class ExecutionPlan {
           extraRevalidationKinds: nonBlockingExtraPhases(advCfg),
           maxAttempts,
           postValidate: this.state.nonBlockingFixPostValidate
-        })
+        }),
+        keptTreeRegressed: () => gateName !== undefined && gateRegressedAfterRectification(phaseOutputs[gateName], preRectGateFailureKeys, gateName, this.ctx.storyId)
       }, {
         measureSourceDiff: createMeasureSourceDiff({
           config: this.ctx.runtime.configLoader.current(),
@@ -57874,6 +58354,27 @@ function parseQueueFile(content) {
       }
     } else if (upper === "SKIP") {
       guidance.push(trimmed);
+    } else if (upper.startsWith("RETRY ")) {
+      const storyId = trimmed.substring(6).trim();
+      if (storyId) {
+        commands.push({ type: "RETRY", storyId });
+      } else {
+        guidance.push(trimmed);
+      }
+    } else if (upper === "RETRY") {
+      guidance.push(trimmed);
+    } else if (upper.startsWith("PRIORITY ")) {
+      const rest = trimmed.substring(9).trim();
+      const parts = rest.split(/\s+/);
+      const storyId = parts[0];
+      const value = parts[1] !== undefined ? Number(parts[1]) : Number.NaN;
+      if (storyId && parts.length === 2 && Number.isFinite(value)) {
+        commands.push({ type: "PRIORITY", storyId, value });
+      } else {
+        guidance.push(trimmed);
+      }
+    } else if (upper === "PRIORITY") {
+      guidance.push(trimmed);
     } else {
       if (inPendingSection) {
         guidance.push(trimmed);
@@ -57974,6 +58475,23 @@ var init_queue_check = __esm(() => {
           await clearQueueFile(ctx.workdir);
           return { action: "pause", reason: "User requested abort" };
         }
+        if (cmd.type === "RETRY") {
+          logger.warn("queue", "Retrying story by user request", { storyId: cmd.storyId });
+          resetStoryToPending(ctx.prd, cmd.storyId);
+          const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
+          await savePRD(ctx.prd, prdPath);
+          continue;
+        }
+        if (cmd.type === "PRIORITY") {
+          logger.warn("queue", "Setting story priority by user request", {
+            storyId: cmd.storyId,
+            priority: cmd.value
+          });
+          setStoryPriority(ctx.prd, cmd.storyId, cmd.value);
+          const prdPath = ctx.featureDir ? `${ctx.featureDir}/prd.json` : `${ctx.workdir}/nax/features/unknown/prd.json`;
+          await savePRD(ctx.prd, prdPath);
+          continue;
+        }
         if (cmd.type === "SKIP") {
           const isTargeted = ctx.stories.some((s) => s.id === cmd.storyId);
           if (isTargeted) {
@@ -58163,6 +58681,7 @@ var init_pipeline = __esm(() => {
   init_runner4();
   init_events();
   init_stages();
+  init_queue_check();
   init_execution_helpers();
   init_event_bus();
 });
@@ -58568,7 +59087,7 @@ __export(exports_init_context, {
   generatePackageContextTemplate: () => generatePackageContextTemplate,
   generateContextTemplate: () => generateContextTemplate
 });
-import { basename as basename9, join as join53 } from "path";
+import { basename as basename10, join as join53 } from "path";
 async function bunFileExists(path15) {
   return Bun.file(path15).exists();
 }
@@ -58663,7 +59182,7 @@ async function scanProject(projectRoot) {
   const readmeSnippet = await readReadmeSnippet(projectRoot);
   const entryPoints = await detectEntryPoints(projectRoot);
   const configFiles = await detectConfigFiles(projectRoot);
-  const projectName = packageManifest?.name || basename9(projectRoot);
+  const projectName = packageManifest?.name || basename10(projectRoot);
   return {
     projectName,
     fileTree,
@@ -60800,11 +61319,11 @@ function getSafeLogger6() {
   return getSafeLogger();
 }
 function extractPluginName(pluginPath) {
-  const basename11 = path18.basename(pluginPath);
-  if (basename11 === "index.ts" || basename11 === "index.js" || basename11 === "index.mjs") {
+  const basename12 = path18.basename(pluginPath);
+  if (basename12 === "index.ts" || basename12 === "index.js" || basename12 === "index.mjs") {
     return path18.basename(path18.dirname(pluginPath));
   }
-  return basename11.replace(/\.(ts|js|mjs)$/, "");
+  return basename12.replace(/\.(ts|js|mjs)$/, "");
 }
 async function loadPlugins(globalDir, projectDir, configPlugins, projectRoot, disabledPlugins, isTestFileFn) {
   const loadedPlugins = [];
@@ -61190,7 +61709,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.70.8",
+    version: "0.71.1",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -61201,7 +61720,7 @@ var init_package = __esm(() => {
       dev: "bun run bin/nax.ts",
       build: 'bun build bin/nax.ts --outdir dist --target bun --define "GIT_COMMIT=\\"$(git rev-parse --short HEAD)\\""',
       typecheck: "bun x tsc --noEmit && bun x tsc --noEmit -p tsconfig.contracts.json",
-      lint: "bun x biome check src/ bin/ && bun run check:no-real-global-nax && bun run check:alias-internals && bun run check:deep-relatives && bun run check:nax-error && bun run check:logger-storyid && bun run check:file-sizes",
+      lint: "bun x biome check src/ bin/ && bun run check:no-real-global-nax && bun run check:alias-internals && bun run check:deep-relatives && bun run check:nax-error && bun run check:logger-storyid && bun run check:log-format-layering && bun run check:file-sizes",
       "lint:json": "bun x biome check src/ bin/ --reporter json && bun run check:nax-error 1>&2 && bun run check:logger-storyid 1>&2",
       "lint:fix": "bun x biome check --write src/ bin/",
       "check:no-real-global-nax": "bun run scripts/check-no-real-global-nax.ts",
@@ -61212,6 +61731,7 @@ var init_package = __esm(() => {
       "check:nax-error:update": "bun run scripts/check-nax-error.ts --update-baseline",
       "check:logger-storyid": "bun run scripts/check-logger-storyid.ts",
       "check:logger-storyid:update": "bun run scripts/check-logger-storyid.ts --update-baseline",
+      "check:log-format-layering": "bun run scripts/check-log-format-layering.ts",
       "check:file-sizes": "bun run scripts/check-file-sizes.ts",
       "check:file-sizes:update": "bun run scripts/check-file-sizes.ts --update-baseline",
       release: "bun scripts/release.ts",
@@ -61290,8 +61810,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("54e59fa6"))
-        return "54e59fa6";
+      if (/^[0-9a-f]{6,10}$/.test("62eedccd"))
+        return "62eedccd";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -62247,10 +62767,134 @@ var init_scratch_purge = __esm(() => {
     now: () => Date.now()
   };
 });
-// src/verification/index.ts
-var init_verification = __esm(() => {
-  init_executor();
-  init_runners();
+
+// src/execution/lifecycle/backfill-story-metrics.ts
+function isExecutionFailure(story) {
+  return story != null && (story.status === "failed" || story.status === "regression-failed") && (story.attempts ?? 0) > 0;
+}
+function synthesizeBackfillMetric(args) {
+  const { storyId, story, totalCostUsd, config: config2, defaultAgent, timestamp } = args;
+  if (story != null && isExecutionFailure(story)) {
+    const tier = story.routing?.modelTier ?? "balanced";
+    const agent = story.routing?.agent ?? defaultAgent;
+    let modelUsed = agent;
+    try {
+      modelUsed = resolveModelForAgent(config2.models, agent, tier, defaultAgent).model;
+    } catch {}
+    const escalations = story.escalations ?? [];
+    const finalTier = escalations.length > 0 ? escalations[escalations.length - 1].toTier : tier;
+    const attempts = (story.priorFailures?.length ?? 0) + Math.max(1, story.attempts ?? 1);
+    return {
+      storyId,
+      complexity: story.routing?.complexity ?? "medium",
+      initialComplexity: story.routing?.initialComplexity ?? story.routing?.complexity,
+      modelTier: tier,
+      modelUsed,
+      agentUsed: agent,
+      attempts,
+      finalTier,
+      success: false,
+      cost: totalCostUsd,
+      durationMs: 0,
+      firstPassSuccess: false,
+      startedAt: timestamp,
+      completedAt: timestamp,
+      source: "execution-failed",
+      runtimeCrashes: 0
+    };
+  }
+  return {
+    storyId,
+    complexity: story?.routing?.complexity ?? "medium",
+    modelTier: "balanced",
+    modelUsed: defaultAgent,
+    attempts: 0,
+    finalTier: "balanced",
+    success: story?.passes ?? true,
+    cost: totalCostUsd,
+    durationMs: 0,
+    firstPassSuccess: story?.passes ?? true,
+    startedAt: timestamp,
+    completedAt: timestamp,
+    source: "completion-phase",
+    runtimeCrashes: 0
+  };
+}
+var init_backfill_story_metrics = __esm(() => {
+  init_config();
+});
+
+// src/execution/lifecycle/run-regression-triage.ts
+async function runRegressionFlakeTriage(params) {
+  const {
+    regressionFindings,
+    testSummary,
+    rawOutput,
+    config: config2,
+    workdir,
+    testCommand,
+    quarantineMemo,
+    triageFn,
+    flakeDetection
+  } = params;
+  const logger = getSafeLogger();
+  const baselineDiff = await resolveFlakeBaselineDiff(config2, workdir);
+  if (baselineDiff === null) {
+    const untriaged = regressionFindings.filter((f) => f.category === "failed-test");
+    const testFilesInFailures2 = new Set;
+    for (const finding of untriaged) {
+      if (finding.file)
+        testFilesInFailures2.add(finding.file);
+    }
+    return { shortCircuit: false, triagedFailedFindings: untriaged, testFilesInFailures: testFilesInFailures2, quarantineReport: undefined };
+  }
+  const triageResult = await triageFn({
+    findings: regressionFindings,
+    diff: baselineDiff,
+    flakeDetection,
+    baseCommand: testCommand,
+    cwd: workdir,
+    framework: detectFramework(rawOutput),
+    quarantineMemo
+  });
+  const quarantineReport = triageResult.quarantineReport.keys.length > 0 ? triageResult.quarantineReport : undefined;
+  const triagedFailedFindings = triageResult.findings.filter((f) => f.category === "failed-test");
+  logger?.warn("regression", "Regression detected", {
+    failedTests: testSummary.failed,
+    passedTests: testSummary.passed,
+    quarantined: triageResult.quarantineReport.keys.length
+  });
+  const testFilesInFailures = new Set;
+  for (const finding of triagedFailedFindings) {
+    if (finding.file)
+      testFilesInFailures.add(finding.file);
+  }
+  if (testFilesInFailures.size === 0 && triagedFailedFindings.length === 0 && quarantineReport) {
+    logger?.info("regression", "All regression failures quarantined as flaky \u2014 accepting as pass", {
+      quarantined: quarantineReport.keys.length
+    });
+    return {
+      shortCircuit: true,
+      result: {
+        success: true,
+        failedTests: 0,
+        failedTestFiles: [],
+        passedTests: testSummary.passed,
+        rectificationAttempts: 0,
+        affectedStories: [],
+        storyCosts: {},
+        storyDurations: {},
+        storyOutcomes: {},
+        quarantineReport
+      }
+    };
+  }
+  return { shortCircuit: false, triagedFailedFindings, testFilesInFailures, quarantineReport };
+}
+var init_run_regression_triage = __esm(() => {
+  init_logger2();
+  init_test_runners();
+  init_verification();
 });
 
 // src/execution/lifecycle/run-regression.ts
@@ -62405,18 +63049,25 @@ async function runDeferredRegression(options) {
       storyOutcomes: {}
     };
   }
-  const affectedStories = new Set;
-  const affectedStoriesObjs = new Map;
-  logger?.warn("regression", "Regression detected", {
-    failedTests: testSummary.failed,
-    passedTests: testSummary.passed
+  const regressionFindings = buildRegressionFindings(testSummary, fullSuiteResult.output);
+  const quarantineMemo = options.quarantineMemo ?? NULL_QUARANTINE_MEMO;
+  const triageOutcome = await runRegressionFlakeTriage({
+    regressionFindings,
+    testSummary,
+    rawOutput: fullSuiteResult.output,
+    config: config2,
+    workdir,
+    testCommand,
+    quarantineMemo,
+    triageFn: _regressionDeps.triageFlakyFindings,
+    flakeDetection: config2.execution.flakeDetection
   });
-  const testFilesInFailures = new Set;
-  for (const failure of testSummary.failures) {
-    if (failure.file) {
-      testFilesInFailures.add(failure.file);
-    }
+  if (triageOutcome.shortCircuit) {
+    return triageOutcome.result;
   }
+  const { testFilesInFailures, quarantineReport } = triageOutcome;
+  const affectedStories = new Set;
+  const affectedStoriesObjs = new Map;
   if (testFilesInFailures.size === 0) {
     logger?.warn("regression", "No test files found in failures (unmapped)");
     for (const story of passedStories) {
@@ -62459,7 +63110,8 @@ async function runDeferredRegression(options) {
       affectedStories: Array.from(affectedStories),
       storyCosts: {},
       storyDurations: {},
-      storyOutcomes: {}
+      storyOutcomes: {},
+      ...quarantineReport ? { quarantineReport } : {}
     };
   }
   for (const storyId of affectedStories) {
@@ -62543,7 +63195,8 @@ async function runDeferredRegression(options) {
           affectedStories: Array.from(affectedStories),
           storyCosts: storyCostAccum,
           storyDurations: storyDurationAccum,
-          storyOutcomes: storyOutcomeAccum
+          storyOutcomes: storyOutcomeAccum,
+          ...quarantineReport ? { quarantineReport } : {}
         };
       }
       logger?.warn("regression", "Full suite still failing after story rectification \u2014 continuing", {
@@ -62574,7 +63227,8 @@ async function runDeferredRegression(options) {
     affectedStories: Array.from(affectedStories),
     storyCosts: storyCostAccum,
     storyDurations: storyDurationAccum,
-    storyOutcomes: storyOutcomeAccum
+    storyOutcomes: storyOutcomeAccum,
+    ...quarantineReport ? { quarantineReport } : {}
   };
 }
 var SYNTHETIC_FINDING_OUTPUT_LIMIT = 2000, _regressionDeps;
@@ -62587,10 +63241,12 @@ var init_run_regression = __esm(() => {
   init_test_runners();
   init_git();
   init_verification();
+  init_run_regression_triage();
   _regressionDeps = {
     runVerification: fullSuite,
     runFixCycle: (cycle, ctx, name) => runFixCycle(cycle, ctx, name),
-    parseTestOutput
+    parseTestOutput,
+    triageFlakyFindings
   };
 });
 
@@ -62614,8 +63270,10 @@ async function handleRunCompletion(options) {
     workdir,
     statusWriter,
     config: config2,
-    hooksConfig
+    hooksConfig,
+    exitReason
   } = options;
+  let regressionGateFailed = false;
   const regressionMode = config2.execution.regressionGate?.mode;
   if (options.skipRegression) {} else if ((regressionMode === "deferred" || regressionMode === "per-story") && config2.quality.commands.test) {
     statusWriter.setPostRunPhase("regression", { status: "running" });
@@ -62625,6 +63283,7 @@ async function handleRunCompletion(options) {
       prd,
       workdir,
       runtime: options.runtime,
+      quarantineMemo: options.runtime.quarantineMemo,
       storyMetrics: options.isSequential === false ? undefined : allStoryMetrics.map((m) => ({
         storyId: m.storyId,
         completedAt: m.completedAt,
@@ -62655,6 +63314,7 @@ async function handleRunCompletion(options) {
         }
       }
       statusWriter.setRunStatus("failed");
+      regressionGateFailed = true;
       if (hooksConfig) {
         await _runCompletionDeps.fireHook(hooksConfig, "on-final-regression-fail", {
           event: "on-final-regression-fail",
@@ -62739,22 +63399,14 @@ async function handleRunCompletion(options) {
       const existingIdx = existingIndex.get(storyId);
       if (existingIdx === undefined) {
         const story = prd.userStories.find((s) => s.id === storyId);
-        allStoryMetrics.push({
+        allStoryMetrics.push(synthesizeBackfillMetric({
           storyId,
-          complexity: story?.routing?.complexity ?? "medium",
-          modelTier: "balanced",
-          modelUsed: defaultAgent,
-          attempts: 0,
-          finalTier: "balanced",
-          success: story?.passes ?? true,
-          cost: snap.totalCostUsd,
-          durationMs: 0,
-          firstPassSuccess: story?.passes ?? true,
-          startedAt: completionCompletedAt,
-          completedAt: completionCompletedAt,
-          source: "completion-phase",
-          runtimeCrashes: 0
-        });
+          story,
+          totalCostUsd: snap.totalCostUsd,
+          config: config2,
+          defaultAgent,
+          timestamp: completionCompletedAt
+        }));
       } else {
         const existing = allStoryMetrics[existingIdx];
         if (snap.totalCostUsd > (existing.cost ?? 0)) {
@@ -62856,7 +63508,7 @@ async function handleRunCompletion(options) {
   });
   statusWriter.setPrd(prd);
   statusWriter.setCurrentStory(null);
-  statusWriter.setRunStatus(isComplete(prd) ? "completed" : isStalled(prd) ? "stalled" : "running");
+  statusWriter.setRunStatus(regressionGateFailed ? "failed" : exitReason === "cost-limit" ? "cost-limit" : isComplete(prd) ? "completed" : isStalled(prd) ? "stalled" : "running");
   await statusWriter.update(reportedTotal, iterations);
   return {
     durationMs,
@@ -62884,6 +63536,7 @@ var init_run_completion = __esm(() => {
   init_scratch_purge();
   init_workspace();
   init_smart_runner();
+  init_backfill_story_metrics();
   init_run_regression();
   _runCompletionDeps = {
     runDeferredRegression,
@@ -62896,7 +63549,8 @@ var init_run_completion = __esm(() => {
 var exports_headless_formatter = {};
 __export(exports_headless_formatter, {
   outputRunHeader: () => outputRunHeader,
-  outputRunFooter: () => outputRunFooter
+  outputRunFooter: () => outputRunFooter,
+  outputAdvisoryFindingsSummary: () => outputAdvisoryFindingsSummary
 });
 async function outputRunHeader(options) {
   const { feature, totalStories, pendingStories, workdir, formatterMode } = options;
@@ -62934,10 +63588,19 @@ function outputRunFooter(options) {
   });
   console.log(summaryOutput);
 }
+function outputAdvisoryFindingsSummary(findings, formatterMode) {
+  if (findings.length === 0 || formatterMode === "json") {
+    return;
+  }
+  const output = formatAdvisorySummary(findings, { mode: formatterMode, useColor: true });
+  if (output) {
+    console.log(output);
+  }
+}
 var init_headless_formatter = __esm(() => {
-  init_source();
   init_log_format();
   init_version();
+  init_source();
 });
 
 // src/execution/batching.ts
@@ -62982,10 +63645,10 @@ var DEFAULT_MAX_BATCH_SIZE = 4;
 
 // src/pipeline/subscribers/events-writer.ts
 import { appendFile as appendFile4, mkdir as mkdir13 } from "fs/promises";
-import { basename as basename13, join as join80 } from "path";
+import { basename as basename14, join as join80 } from "path";
 function wireEventsWriter(bus, feature, runId, workdir) {
   const logger = getSafeLogger();
-  const project = basename13(workdir);
+  const project = basename14(workdir);
   const eventsDir = join80(getEventsRootDir(), project);
   const eventsFile = join80(eventsDir, "events.jsonl");
   let dirReady = false;
@@ -63168,10 +63831,10 @@ var init_interaction2 = __esm(() => {
 
 // src/pipeline/subscribers/registry.ts
 import { mkdir as mkdir14, writeFile as writeFile2 } from "fs/promises";
-import { basename as basename14, join as join81 } from "path";
+import { basename as basename15, join as join81 } from "path";
 function wireRegistry(bus, feature, runId, workdir, outputDir) {
   const logger = getSafeLogger();
-  const project = basename14(workdir);
+  const project = basename15(workdir);
   const runDir = join81(getRunsDir(), `${project}-${feature}-${runId}`);
   const metaFile = join81(runDir, "meta.json");
   const unsub = bus.on("run:started", (_ev) => {
@@ -96308,9 +96971,9 @@ __export(exports_curator, {
 });
 import { readdirSync as readdirSync9 } from "fs";
 import { unlink as unlink4 } from "fs/promises";
-import { basename as basename15, join as join90 } from "path";
+import { basename as basename16, join as join90 } from "path";
 function getProjectKey(config2, projectDir) {
-  return config2.name?.trim() || basename15(projectDir);
+  return config2.name?.trim() || basename16(projectDir);
 }
 function listRunIds(runsDir) {
   try {
@@ -96632,7 +97295,7 @@ var init_curator2 = __esm(() => {
 init_source();
 import { existsSync as existsSync37, mkdirSync as mkdirSync7 } from "fs";
 import { homedir as homedir3 } from "os";
-import { basename as basename16, join as join91 } from "path";
+import { basename as basename17, join as join91 } from "path";
 
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -97203,10 +97866,10 @@ init_config();
 init_logger2();
 init_metrics();
 init_runtime();
-import { basename as basename6 } from "path";
+import { basename as basename7 } from "path";
 async function resolveOutputDir(workdir) {
   const config2 = await loadConfig(workdir).catch(() => null);
-  const projectKey = config2?.name?.trim() || basename6(workdir);
+  const projectKey = config2?.name?.trim() || basename7(workdir);
   return projectOutputDir(projectKey, config2?.outputDir);
 }
 async function displayCostMetrics(workdir) {
@@ -97321,7 +97984,7 @@ init_interaction();
 init_prd();
 init_runtime();
 import { existsSync as existsSync17, readdirSync as readdirSync3 } from "fs";
-import { basename as basename7, join as join44, resolve as resolve14 } from "path";
+import { basename as basename8, join as join44, resolve as resolve14 } from "path";
 var _statusFeaturesDeps = {
   projectOutputDir,
   loadConfig
@@ -97348,7 +98011,7 @@ async function loadStatusFile(featureDir) {
 }
 async function loadProjectStatusFile(projectDir) {
   const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
-  const projectKey = config2?.name?.trim() || basename7(projectDir);
+  const projectKey = config2?.name?.trim() || basename8(projectDir);
   const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
   const statusPath = join44(outputDir, "status.json");
   if (!existsSync17(statusPath)) {
@@ -97403,6 +98066,8 @@ async function getFeatureSummary(featureName, featureDir) {
         pid: status.run.pid,
         crashedAt: status.run.crashedAt
       };
+    } else if (status.run.status === "cost-limit") {
+      summary.costLimitStopped = true;
     }
   }
   const runsDir = join44(featureDir, "runs");
@@ -97417,7 +98082,7 @@ async function getFeatureSummary(featureName, featureDir) {
 }
 async function displayAllFeatures(projectDir) {
   const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
-  const projectKey = config2?.name?.trim() || basename7(projectDir);
+  const projectKey = config2?.name?.trim() || basename8(projectDir);
   const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
   const featuresDir = join44(outputDir, "features");
   if (!existsSync17(featuresDir)) {
@@ -97458,6 +98123,14 @@ async function displayAllFeatures(projectDir) {
         console.log(source_default.dim(`   Signal:     ${projectStatus.run.crashSignal}`));
       }
       console.log();
+    } else if (projectStatus.run.status === "cost-limit") {
+      console.log(source_default.magenta(`\uD83D\uDCB0 Cost Limit Reached:
+`));
+      console.log(source_default.dim(`   Feature:    ${projectStatus.run.feature}`));
+      console.log(source_default.dim(`   Run ID:     ${projectStatus.run.id}`));
+      console.log(source_default.dim(`   Spent:      $${projectStatus.cost.spent.toFixed(4)}`));
+      console.log(source_default.dim(`   Limit:      $${(projectStatus.cost.limit ?? 0).toFixed(4)}`));
+      console.log();
     }
   }
   const summaries = await Promise.all(features.map((name) => getFeatureSummary(name, join44(featuresDir, name))));
@@ -97478,6 +98151,8 @@ async function displayAllFeatures(projectDir) {
       status = source_default.yellow("\u26A1 Running");
     } else if (summary.crashedRun) {
       status = source_default.red("\uD83D\uDCA5 Crashed");
+    } else if (summary.costLimitStopped) {
+      status = source_default.magenta("\uD83D\uDCB0 Cost limit");
     } else {
       status = source_default.dim("\u2014");
     }
@@ -97630,7 +98305,7 @@ async function displayFeatureStatus(options = {}) {
     if (options.dir) {
       const projectDir = resolve14(options.dir);
       const config2 = await _statusFeaturesDeps.loadConfig(projectDir).catch(() => null);
-      const projectKey = config2?.name?.trim() || basename7(projectDir);
+      const projectKey = config2?.name?.trim() || basename8(projectDir);
       const outputDir = _statusFeaturesDeps.projectOutputDir(projectKey, config2?.outputDir);
       featureDir = join44(outputDir, "features", options.feature);
     } else {
@@ -97652,12 +98327,12 @@ init_errors();
 init_logger2();
 init_runtime();
 import { existsSync as existsSync18, readdirSync as readdirSync4 } from "fs";
-import { basename as basename8, join as join45 } from "path";
+import { basename as basename9, join as join45 } from "path";
 async function resolveOutputDir2(workdir, override) {
   if (override)
     return override;
   const config2 = await loadConfig(workdir).catch(() => null);
-  const projectKey = config2?.name?.trim() || basename8(workdir);
+  const projectKey = config2?.name?.trim() || basename9(workdir);
   return projectOutputDir(projectKey, config2?.outputDir);
 }
 async function parseRunLog(logPath) {
@@ -98044,7 +98719,7 @@ var FIELD_DESCRIPTIONS = {
   execution: "Execution limits and timeouts",
   "execution.maxIterations": "Max iterations per feature run (auto-calculated if not set)",
   "execution.iterationDelayMs": "Delay between iterations in milliseconds",
-  "execution.costLimit": "Max cost in USD before pausing execution",
+  "execution.costLimit": "Max cost in USD before pausing execution (override per run with `nax run --max-cost`)",
   "execution.sessionTimeoutSeconds": "Timeout per agent coding session in seconds",
   "execution.verificationTimeoutSeconds": "Verification subprocess timeout in seconds",
   "execution.maxStoriesPerFeature": "Max stories per feature (prevents memory exhaustion)",
@@ -98092,7 +98767,7 @@ var FIELD_DESCRIPTIONS = {
   "tdd.autoApproveVerifier": "Auto-approve legitimate fixes in verifier session",
   "tdd.sessionTiers": "Per-session model tier overrides",
   "tdd.sessionTiers.testWriter": "Model tier for test-writer session",
-  "tdd.sessionTiers.implementer": "Model tier for implementer session",
+  "tdd.sessionTiers.implementer": "Ignored by design \u2014 implementer follows story.routing.modelTier + escalation, not this field. Kept optional so legacy configs still parse.",
   "tdd.sessionTiers.verifier": "Model tier for verifier session",
   "tdd.testWriterAllowedPaths": "Glob patterns for files test-writer can modify",
   "tdd.rollbackOnFailure": "Rollback git changes when TDD fails",
@@ -98695,7 +99370,7 @@ async function contextInspectCommand(options) {
 init_canonical_loader();
 init_errors();
 import { mkdir as mkdir11 } from "fs/promises";
-import { basename as basename12, join as join68 } from "path";
+import { basename as basename13, join as join68 } from "path";
 var _rulesCLIDeps = {
   readFile: async (path20) => Bun.file(path20).text(),
   writeFile: async (path20, content) => {
@@ -98795,7 +99470,7 @@ async function collectMigrationSources(workdir) {
     try {
       const content = await _rulesCLIDeps.readFile(filePath);
       if (content.trim()) {
-        sources.push({ sourcePath: filePath, targetFileName: basename12(filePath), content });
+        sources.push({ sourcePath: filePath, targetFileName: basename13(filePath), content });
       }
     } catch {}
   }
@@ -99680,6 +100355,8 @@ function colorStatus(status) {
       return source_default.red(status);
     case "running":
       return source_default.yellow(status);
+    case "cost-limit":
+      return source_default.magenta(status);
     case "[unavailable]":
       return source_default.dim(status);
     default:
@@ -99970,17 +100647,27 @@ async function runCompletionPhase(options) {
     sessionManager: options.sessionManager,
     pluginProviderCache: options.pluginProviderCache,
     deferredReview: options.deferredReview,
+    exitReason: options.exitReason,
     runtime: options.runtime,
     abortSignal: options.abortSignal
   });
   const { durationMs, runCompletedAt, finalCounts, reportedTotal, pluginGateFailed } = completionResult;
   if (options.featureDir) {
-    const finalStatus = isComplete(options.prd) && !pluginGateFailed ? "completed" : "failed";
+    const finalStatus = pluginGateFailed ? "failed" : options.exitReason === "cost-limit" ? "cost-limit" : isComplete(options.prd) ? "completed" : "failed";
     options.statusWriter.setRunStatus(finalStatus);
     await options.statusWriter.writeFeatureStatus(options.featureDir, reportedTotal, options.iterations);
   }
+  const advisoryFindings = options.runtime?.reviewAuditor?.getAdvisoryFindings() ?? [];
+  if (advisoryFindings.length > 0) {
+    logger?.warn("review", `${advisoryFindings.length} non-blocking review finding(s) surfaced at run end`, {
+      storyId: "_run",
+      count: advisoryFindings.length,
+      findings: advisoryFindings
+    });
+  }
   if (options.headless && options.formatterMode !== "json") {
-    const { outputRunFooter: outputRunFooter2 } = await Promise.resolve().then(() => (init_headless_formatter(), exports_headless_formatter));
+    const { outputAdvisoryFindingsSummary: outputAdvisoryFindingsSummary2, outputRunFooter: outputRunFooter2 } = await Promise.resolve().then(() => (init_headless_formatter(), exports_headless_formatter));
+    outputAdvisoryFindingsSummary2(advisoryFindings, options.formatterMode);
     outputRunFooter2({
       finalCounts: {
         total: finalCounts.total,
@@ -100175,7 +100862,8 @@ async function runExecutionPhase(options, prd, pluginRegistry) {
     storiesCompleted,
     totalCost,
     allStoryMetrics,
-    deferredReview: unifiedResult.deferredReview
+    deferredReview: unifiedResult.deferredReview,
+    exitReason: unifiedResult.exitReason
   };
 }
 
@@ -100344,6 +101032,7 @@ async function run(options) {
       agentManager,
       pluginProviderCache,
       deferredReview: executionResult.deferredReview,
+      exitReason: executionResult.exitReason,
       runtime,
       abortSignal: shutdownController.signal
     });
@@ -100411,6 +101100,7 @@ init_pid_registry();
 init_acceptance_loop();
 init_headless_formatter();
 init_run_completion();
+init_backfill_story_metrics();
 init_run_cleanup();
 init_run_setup();
 init_run_regression();
@@ -100428,6 +101118,128 @@ init_logger2();
 init_prd();
 init_runtime();
 
+// src/schedule/parse.ts
+var ACCEPTED = "Accepted: relative (30m, 2h, 90s, 1h30m, 1d), time-of-day (17:00), or ISO datetime (2026-07-02T02:00).";
+var UNIT_MS = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+var DURATION_RE = /^(\d+[smhd])+$/;
+var SEGMENT_RE = /(\d+)([smhd])/g;
+var TIME_RE = /^([01]\d|2[0-3]):([0-5]\d)$/;
+var NAIVE_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?$/;
+var DATE_ONLY_RE = /^\d{4}-\d{2}-\d{2}$/;
+var OFFSET_RE = /T\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(Z|[+-]\d{2}:?\d{2})$/;
+function parseTimeOfDay(input, now2) {
+  const m = TIME_RE.exec(input);
+  if (!m)
+    return null;
+  const hours = Number(m[1]);
+  const minutes = Number(m[2]);
+  const target = new Date(now2.getFullYear(), now2.getMonth(), now2.getDate(), hours, minutes, 0, 0);
+  if (target.getTime() <= now2.getTime()) {
+    target.setDate(target.getDate() + 1);
+  }
+  return { ok: true, target };
+}
+function parseIso(input, now2) {
+  if (DATE_ONLY_RE.test(input)) {
+    return {
+      ok: false,
+      error: `Date-only value "${input}" has no time \u2014 specify a time, e.g. ${input}T02:00.`
+    };
+  }
+  let target = null;
+  const naive = NAIVE_RE.exec(input);
+  if (naive) {
+    const [, y, mo, d, h, mi, s] = naive;
+    target = new Date(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi), Number(s ?? "0"), 0);
+  } else if (OFFSET_RE.test(input)) {
+    const parsed = new Date(input);
+    if (!Number.isNaN(parsed.getTime()))
+      target = parsed;
+  }
+  if (!target || Number.isNaN(target.getTime())) {
+    return { ok: false, error: `Unrecognized schedule "${input}". ${ACCEPTED}` };
+  }
+  if (target.getTime() <= now2.getTime()) {
+    return { ok: false, error: `Scheduled time ${input} is in the past.` };
+  }
+  return { ok: true, target };
+}
+function parseRelative(input, now2) {
+  if (!DURATION_RE.test(input))
+    return null;
+  let totalMs = 0;
+  for (const [, n, unit] of input.matchAll(SEGMENT_RE)) {
+    totalMs += Number(n) * UNIT_MS[unit];
+  }
+  if (totalMs <= 0)
+    return { ok: false, error: `Duration must be positive. ${ACCEPTED}` };
+  return { ok: true, target: new Date(now2.getTime() + totalMs) };
+}
+function resolveScheduleGate(input, now2) {
+  if (input === undefined)
+    return { ok: true, target: null };
+  const parsed = parseSchedule(input, now2);
+  if (!parsed.ok)
+    return { ok: false, error: parsed.error };
+  return { ok: true, target: parsed.target };
+}
+function parseSchedule(input, now2) {
+  const trimmed = input.trim();
+  if (trimmed === "")
+    return { ok: false, error: `Empty schedule value. ${ACCEPTED}` };
+  const relative16 = parseRelative(trimmed, now2);
+  if (relative16)
+    return relative16;
+  const timeOfDay = parseTimeOfDay(trimmed, now2);
+  if (timeOfDay)
+    return timeOfDay;
+  return parseIso(trimmed, now2);
+}
+// src/schedule/wait.ts
+init_logger2();
+init_bun_deps();
+function formatRemaining(ms) {
+  const total = Math.max(0, Math.floor(ms / 1000));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const pad4 = (n) => String(n).padStart(2, "0");
+  return `${pad4(h)}:${pad4(m)}:${pad4(s)}`;
+}
+var TICK_MS = 1000;
+var DEFAULT_DEPS2 = {
+  now: () => Date.now(),
+  delay: (ms, signal) => cancellableDelay(ms, signal),
+  render: (line) => {
+    process.stdout.write(`\r${line}`);
+  },
+  log: (message, data) => getSafeLogger()?.info("schedule", message, data)
+};
+async function waitForSchedule(target, opts) {
+  const deps = { ...DEFAULT_DEPS2, ...opts._deps };
+  const targetMs = target.getTime();
+  if (opts.headless) {
+    deps.log("Scheduled run waiting", { label: opts.label, targetIso: target.toISOString() });
+  }
+  while (deps.now() < targetMs) {
+    if (opts.signal.aborted)
+      return "cancelled";
+    const remaining = targetMs - deps.now();
+    if (!opts.headless) {
+      deps.render(`[WAIT] Scheduled run of "${opts.label}" \u2014 starting in ${formatRemaining(remaining)}   (Ctrl-C to cancel)`);
+    }
+    const wait = Math.min(TICK_MS, remaining);
+    try {
+      await deps.delay(wait, opts.signal);
+    } catch {
+      return "cancelled";
+    }
+  }
+  if (!opts.headless)
+    deps.render(`
+`);
+  return "fired";
+}
 // node_modules/ink/build/render.js
 import { Stream } from "stream";
 import process14 from "process";
@@ -106591,6 +107403,12 @@ async function writeQueueCommand(queueFilePath, command) {
     case "SKIP":
       commandLine2 = `SKIP ${command.storyId}`;
       break;
+    case "RETRY":
+      commandLine2 = `RETRY ${command.storyId}`;
+      break;
+    case "PRIORITY":
+      commandLine2 = `PRIORITY ${command.storyId} ${command.value}`;
+      break;
     default: {
       const _exhaustive = command;
       throw new Error(`Unhandled queue command: ${_exhaustive}`);
@@ -108456,7 +109274,7 @@ program2.command("setup").description("Analyze repo and generate .nax/config.jso
   });
   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(s) to overlay (comma-separated or repeated; later overrides earlier)", collectProfile, []).action(async (options) => {
+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("--max-cost <usd>", "Override cost limit (USD) for this run \u2014 aborts execution when exceeded").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(s) to overlay (comma-separated or repeated; later overrides earlier)", collectProfile, []).option("--schedule <when>", "Defer run start until <when> (e.g. 30m, 1h30m, 17:00, 2026-07-02T02:00)").action(async (options) => {
   let workdir;
   try {
     workdir = validateDirectory(options.dir);
@@ -108464,6 +109282,11 @@ program2.command("run").description("Run the orchestration loop for a feature").
     console.error(source_default.red(`Invalid directory: ${err.message}`));
     process.exit(1);
   }
+  const scheduleGate = resolveScheduleGate(options.schedule, new Date);
+  if (!scheduleGate.ok) {
+    console.error(source_default.red(`Invalid --schedule: ${scheduleGate.error}`));
+    process.exit(1);
+  }
   if (options.plan && !options.from) {
     console.error(source_default.red("Error: --plan requires --from <spec-path>"));
     process.exit(1);
@@ -108578,7 +109401,7 @@ program2.command("run").description("Run the orchestration loop for a feature").
     process.exit(1);
   }
   resetLogger();
-  const projectKey = config2.name?.trim() || basename16(workdir);
+  const projectKey = config2.name?.trim() || basename17(workdir);
   const outputDir = projectOutputDir(projectKey, config2.outputDir);
   const runsDir = join91(outputDir, "features", options.feature, "runs");
   mkdirSync7(runsDir, { recursive: true });
@@ -108601,6 +109424,14 @@ program2.command("run").description("Run the orchestration loop for a feature").
     config2.agent.default = options.agent;
   }
   config2.execution.maxIterations = Number.parseInt(options.maxIterations, 10);
+  if (options.maxCost !== undefined) {
+    const maxCost = Number(options.maxCost);
+    if (!Number.isFinite(maxCost) || maxCost <= 0) {
+      console.error(source_default.red("--max-cost must be a positive number"));
+      process.exit(1);
+    }
+    config2.execution.costLimit = maxCost;
+  }
   const globalNaxDir = join91(homedir3(), ".nax");
   const hooks = await loadHooksConfig(naxDir, globalNaxDir);
   const eventEmitter = new PipelineEventEmitter;
@@ -108635,6 +109466,22 @@ program2.command("run").description("Run the orchestration loop for a feature").
       process.exit(1);
     }
   }
+  if (scheduleGate.target) {
+    const scheduleController = new AbortController;
+    const onSigint = () => scheduleController.abort();
+    process.once("SIGINT", onSigint);
+    const outcome = await waitForSchedule(scheduleGate.target, {
+      label: options.feature,
+      headless: useHeadless || formatterMode === "json",
+      signal: scheduleController.signal
+    });
+    process.removeListener("SIGINT", onSigint);
+    if (outcome === "cancelled") {
+      console.log(source_default.dim(`
+Scheduled run cancelled.`));
+      process.exit(0);
+    }
+  }
   const result2 = await run({
     prdPath,
     workdir,
@@ -109105,7 +109952,7 @@ program2.command("unlock").description("Release stale lock from crashed nax proc
     process.exit(1);
   }
 });
-var runs = program2.command("runs").description("Show all registered runs from the central registry (~/.nax/runs/)").option("--project <name>", "Filter by project name").option("--last <N>", "Limit to N most recent runs (default: 20)").option("--status <status>", "Filter by status (running|completed|failed|crashed)").action(async (options) => {
+var runs = program2.command("runs").description("Show all registered runs from the central registry (~/.nax/runs/)").option("--project <name>", "Filter by project name").option("--last <N>", "Limit to N most recent runs (default: 20)").option("--status <status>", "Filter by status (running|completed|failed|crashed|cost-limit)").action(async (options) => {
   try {
     await runsCommand({
       project: options.project,