@nathapp/nax 0.74.0 → 0.75.0

package/dist/nax.js

@@ -16949,9 +16949,6 @@ var init_schemas_execution = __esm(() => {
     })
   });
   QualityConfigSchema = exports_external.object({
-    requireTypecheck: exports_external.boolean().default(true),
-    requireLint: exports_external.boolean().default(true),
-    requireTests: exports_external.boolean().default(true),
     scopeTestThreshold: exports_external.number().int().min(0).default(10),
     commands: exports_external.object({
       typecheck: exports_external.string().optional(),
@@ -17047,7 +17044,7 @@ var init_schemas_execution = __esm(() => {
 });
 
 // src/config/schemas-infra.ts
-var PlanConfigSchema, AcceptanceFixConfigSchema, AcceptanceConfigSchema, LlmRoutingConfigSchema, AgentRoutingProfileSchema, AgentRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, PromptAuditConfigSchema, AgentFallbackConfigSchema, DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG, AgentIdleWatchdogConfigSchema, AgentAcpConfigSchema, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, ProjectProfileSchema, VALID_AGENT_TYPES, GenerateConfigSchema, CuratorThresholdsSchema, CuratorConfigSchema;
+var PlanConfigSchema, AcceptanceFixConfigSchema, AcceptanceConfigSchema, LlmRoutingConfigSchema, AgentRoutingProfileSchema, AgentRoutingConfigSchema, RoutingConfigSchema, OptimizerConfigSchema, PluginConfigEntrySchema, HooksConfigSchema, InteractionConfigSchema, StorySizeGateConfigSchema, PromptAuditConfigSchema, AgentFallbackConfigSchema, DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG, AgentIdleWatchdogConfigSchema, AgentAcpConfigSchema, AgentTimeoutRetryConfigSchema, DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG, AgentConfigSchema, PrecheckConfigSchema, PromptsConfigSchema, ProjectProfileSchema, VALID_AGENT_TYPES, GenerateConfigSchema, CuratorThresholdsSchema, CuratorConfigSchema;
 var init_schemas_infra = __esm(() => {
   init_zod();
   init_schemas_model();
@@ -17225,6 +17222,14 @@ var init_schemas_infra = __esm(() => {
   AgentAcpConfigSchema = exports_external.object({
     promptRetries: exports_external.number().int().min(0).max(5).default(0)
   });
+  AgentTimeoutRetryConfigSchema = exports_external.object({
+    maxAttempts: exports_external.number().int().nonnegative().default(1),
+    budgetMultiplier: exports_external.number().gt(0).max(1).default(0.5)
+  });
+  DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG = {
+    maxAttempts: 1,
+    budgetMultiplier: 0.5
+  };
   AgentConfigSchema = exports_external.object({
     protocol: exports_external.literal("acp").default("acp"),
     default: exports_external.string().trim().min(1, "agent.default must be non-empty").default("claude"),
@@ -17238,7 +17243,8 @@ var init_schemas_infra = __esm(() => {
       rebuildContext: true
     }),
     acp: AgentAcpConfigSchema.default({ promptRetries: 0 }),
-    idleWatchdog: AgentIdleWatchdogConfigSchema.default(DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG)
+    idleWatchdog: AgentIdleWatchdogConfigSchema.default(DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG),
+    timeoutRetry: AgentTimeoutRetryConfigSchema.default(DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG)
   });
   PrecheckConfigSchema = exports_external.object({
     storySizeGate: StorySizeGateConfigSchema
@@ -17525,9 +17531,6 @@ var init_schemas3 = __esm(() => {
       }
     }),
     quality: QualityConfigSchema.default({
-      requireTypecheck: true,
-      requireLint: true,
-      requireTests: true,
       scopeTestThreshold: 10,
       commands: {},
       lintOutput: {
@@ -17714,7 +17717,8 @@ var init_schemas3 = __esm(() => {
       promptAudit: { enabled: false },
       fallback: { enabled: false, map: {}, maxHopsPerStory: 2, onQualityFailure: false, rebuildContext: true },
       acp: { promptRetries: 0 },
-      idleWatchdog: DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG
+      idleWatchdog: DEFAULT_AGENT_IDLE_WATCHDOG_CONFIG,
+      timeoutRetry: DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG
     }),
     precheck: PrecheckConfigSchema.optional().default({
       storySizeGate: {
@@ -18328,15 +18332,22 @@ function redactString(value) {
   }
   return out;
 }
-function redactSecrets(input) {
+function redactEntry(entry) {
+  return {
+    ...entry,
+    message: redactString(entry.message),
+    ...entry.data ? { data: redactValue(entry.data) } : {}
+  };
+}
+function redactValue(input) {
   if (typeof input === "string")
     return redactString(input);
   if (Array.isArray(input))
-    return input.map(redactSecrets);
+    return input.map(redactValue);
   if (input !== null && typeof input === "object") {
     const out = {};
     for (const [key, value] of Object.entries(input)) {
-      out[key] = SECRET_KEY_PATTERN.test(key) ? REDACTED : redactSecrets(value);
+      out[key] = SECRET_KEY_PATTERN.test(key) ? REDACTED : redactValue(value);
     }
     return out;
   }
@@ -18367,6 +18378,7 @@ class Logger {
   formatterMode;
   suppressConsole;
   writeQueueTail = Promise.resolve();
+  pendingLines = [];
   constructor(options) {
     this.level = options.level;
     this.filePath = options.filePath;
@@ -18401,7 +18413,7 @@ class Logger {
       const { sessionRole: _omit, ...rest } = data;
       strippedData = Object.keys(rest).length > 0 ? rest : undefined;
     }
-    const entry = {
+    const rawEntry = {
       timestamp: new Date().toISOString(),
       level,
       stage,
@@ -18410,7 +18422,11 @@ class Logger {
       ...sessionRole && { sessionRole },
       ...strippedData && { data: strippedData }
     };
-    if (this.shouldLog(level) && !this.suppressConsole) {
+    const consoleEnabled = this.shouldLog(level) && !this.suppressConsole;
+    if (!consoleEnabled && !this.filePath)
+      return;
+    const entry = redactEntry(rawEntry);
+    if (consoleEnabled) {
       let consoleOutput = null;
       if (this.formatterMode) {
         const formatterOptions = {
@@ -18451,14 +18467,24 @@ ${JSON.stringify(entry.data, null, 2)}`;
   writeToFile(entry) {
     if (!this.filePath)
       return;
-    const safeEntry = entry.data ? { ...entry, data: redactSecrets(entry.data) } : entry;
-    const line = `${formatJsonl(safeEntry)}
-`;
     const filePath = this.filePath;
-    this.writeQueueTail = this.writeQueueTail.then(() => appendFile(filePath, line).catch((error48) => {
-      process.stderr.write(`[logger] Failed to write to log file: ${error48}
+    this.pendingLines.push(`${formatJsonl(entry)}
 `);
-    }));
+    this.writeQueueTail = this.writeQueueTail.then(async () => {
+      while (this.pendingLines.length > 0) {
+        let bytes = 0;
+        let count = 0;
+        while (count < this.pendingLines.length && bytes < MAX_BATCH_BYTES) {
+          bytes += this.pendingLines[count].length;
+          count++;
+        }
+        const batch = this.pendingLines.splice(0, count).join("");
+        await appendFile(filePath, batch).catch((error48) => {
+          process.stderr.write(`[logger] Failed to write to log file: ${error48}
+`);
+        });
+      }
+    });
   }
   async flush() {
     await this.writeQueueTail;
@@ -18511,7 +18537,7 @@ function resetLogger() {
   }
   instance = null;
 }
-var LOG_LEVEL_PRIORITY, instance = null, noopLogger;
+var LOG_LEVEL_PRIORITY, MAX_BATCH_BYTES, instance = null, noopLogger;
 var init_logger = __esm(() => {
   init_log_format();
   init_formatters();
@@ -18523,6 +18549,7 @@ var init_logger = __esm(() => {
     info: 2,
     debug: 3
   };
+  MAX_BATCH_BYTES = 64 * 1024;
   noopLogger = new Logger({ level: "silent", useChalk: false, headless: false });
 });
 
@@ -18567,6 +18594,121 @@ var init_json_file = __esm(() => {
   init_logger2();
 });
 
+// src/config/config-guards.ts
+function rejectLegacyAgentKeys(conf) {
+  const legacyKeys = [];
+  const migrationHints = [];
+  const autoMode = conf.autoMode;
+  if (autoMode && typeof autoMode === "object") {
+    if ("defaultAgent" in autoMode) {
+      legacyKeys.push("autoMode.defaultAgent");
+      migrationHints.push("- Move `autoMode.defaultAgent` \u2192 `agent.default`");
+    }
+    if ("fallbackOrder" in autoMode) {
+      legacyKeys.push("autoMode.fallbackOrder");
+      migrationHints.push("- Move `autoMode.fallbackOrder: [primary, ...]` \u2192 `agent.fallback.map: { <primary>: [<rest>] }` and `agent.fallback.enabled: true`");
+    }
+  }
+  const context = conf.context;
+  const contextV2 = context?.v2;
+  if (contextV2 && typeof contextV2 === "object" && "fallback" in contextV2) {
+    legacyKeys.push("context.v2.fallback");
+    migrationHints.push("- Move `context.v2.fallback` \u2192 `agent.fallback` (see ADR-012 Phase 6)");
+  }
+  if (legacyKeys.length === 0)
+    return;
+  const message = [
+    `Invalid configuration \u2014 legacy agent keys detected: ${legacyKeys.join(", ")}.`,
+    "These were removed in ADR-012 Phase 6. Migrate to the canonical `agent.*` shape:",
+    ...migrationHints,
+    "See docs/adr/ADR-012-agent-manager-ownership.md for the full migration guide."
+  ].join(`
+`);
+  throw new NaxError(message, "CONFIG_LEGACY_AGENT_KEYS", { stage: "config", legacyKeys });
+}
+function rejectLegacyRectificationKeys(conf) {
+  const legacyKeys = [];
+  const migrationHints = [];
+  const quality = conf.quality;
+  const autofix = quality?.autofix;
+  if (autofix && typeof autofix === "object") {
+    if ("maxTotalAttempts" in autofix) {
+      legacyKeys.push("quality.autofix.maxTotalAttempts");
+      migrationHints.push("- Move `quality.autofix.maxTotalAttempts` \u2192 `execution.rectification.maxAttemptsTotal`");
+    }
+    if ("rethinkAtAttempt" in autofix) {
+      legacyKeys.push("quality.autofix.rethinkAtAttempt");
+      migrationHints.push("- Move `quality.autofix.rethinkAtAttempt` \u2192 `execution.rectification.rethinkAtAttempt`");
+    }
+    if ("urgencyAtAttempt" in autofix) {
+      legacyKeys.push("quality.autofix.urgencyAtAttempt");
+      migrationHints.push("- Move `quality.autofix.urgencyAtAttempt` \u2192 `execution.rectification.urgencyAtAttempt`");
+    }
+  }
+  const execution = conf.execution;
+  const rectification = execution?.rectification;
+  if (rectification && typeof rectification === "object" && "maxRetries" in rectification) {
+    legacyKeys.push("execution.rectification.maxRetries");
+    migrationHints.push("- Rename `execution.rectification.maxRetries` \u2192 `execution.rectification.maxAttemptsTotal` (default changed from 2 to 12)");
+  }
+  const regressionGate = execution?.regressionGate;
+  if (regressionGate && typeof regressionGate === "object" && "maxRectificationAttempts" in regressionGate) {
+    legacyKeys.push("execution.regressionGate.maxRectificationAttempts");
+    migrationHints.push("- Remove `execution.regressionGate.maxRectificationAttempts` \u2014 the regression cycle now shares `execution.rectification.maxAttemptsTotal`");
+  }
+  if (legacyKeys.length === 0)
+    return;
+  const message = [
+    `Invalid configuration \u2014 legacy rectification-cap keys detected: ${legacyKeys.join(", ")}.`,
+    "These were consolidated under `execution.rectification.*` so one config controls the unified",
+    "fix cycle (semantic + adversarial + mechanical + regression). Migrate as follows:",
+    ...migrationHints
+  ].join(`
+`);
+  throw new NaxError(message, "CONFIG_LEGACY_RECTIFICATION_KEYS", { stage: "config", legacyKeys });
+}
+function rejectDeadQualityFlags(conf) {
+  const quality = conf.quality;
+  if (!quality || typeof quality !== "object")
+    return;
+  const dead = Object.entries(DEAD_QUALITY_FLAGS).filter(([flag]) => (flag in quality));
+  if (dead.length === 0)
+    return;
+  const deadKeys = dead.map(([flag]) => `quality.${flag}`);
+  const message = [
+    `Invalid configuration \u2014 removed quality flags detected: ${deadKeys.join(", ")}.`,
+    "These flags were never read at any gate site: typecheck, lint, and test gates fire",
+    "whenever a command resolves, so setting one to `false` never skipped its gate.",
+    "",
+    "To skip a gate, remove its command from `quality.commands` instead:",
+    ...dead.map(([flag, command]) => `- Delete \`quality.${flag}\`; to disable that gate, unset \`quality.commands.${command}\``)
+  ].join(`
+`);
+  throw new NaxError(message, "CONFIG_DEAD_QUALITY_FLAGS", { stage: "config", deadKeys });
+}
+function rejectUnimplementedScopedProfile(conf) {
+  const execution = conf.execution;
+  if (execution?.permissionProfile !== "scoped")
+    return;
+  const message = [
+    'Invalid configuration \u2014 execution.permissionProfile: "scoped" is not yet implemented.',
+    "The scoped (per-stage tool allowlist) profile is tracked by GitHub #374 and would",
+    'otherwise silently run as "safe", giving you weaker permissions than intended.',
+    'Use "unrestricted" or "safe" for now.'
+  ].join(`
+`);
+  throw new NaxError(message, "CONFIG_SCOPED_PROFILE_UNIMPLEMENTED", { stage: "config" });
+}
+var DEAD_QUALITY_FLAGS;
+var init_config_guards = __esm(() => {
+  init_errors();
+  DEAD_QUALITY_FLAGS = {
+    requireTypecheck: "typecheck",
+    requireLint: "lint",
+    requireTests: "test"
+  };
+});
+
 // src/config/merge.ts
 function mergePackageConfig(root, packageOverride) {
   const hasAnyMergeableField = packageOverride.agent !== undefined || packageOverride.models !== undefined || packageOverride.routing !== undefined || packageOverride.execution !== undefined || packageOverride.review !== undefined || packageOverride.acceptance !== undefined || packageOverride.quality !== undefined || packageOverride.context !== undefined || packageOverride.project !== undefined;
@@ -18649,9 +18791,6 @@ function mergePackageConfig(root, packageOverride) {
     },
     quality: {
       ...root.quality,
-      requireTests: packageOverride.quality?.requireTests ?? root.quality.requireTests,
-      requireTypecheck: packageOverride.quality?.requireTypecheck ?? root.quality.requireTypecheck,
-      requireLint: packageOverride.quality?.requireLint ?? root.quality.requireLint,
       commands: {
         ...root.quality.commands,
         ...packageOverride.quality?.commands
@@ -19102,91 +19241,6 @@ function applyRemovedStrategyCompat(conf) {
   }
   return conf;
 }
-function rejectLegacyAgentKeys(conf) {
-  const legacyKeys = [];
-  const migrationHints = [];
-  const autoMode = conf.autoMode;
-  if (autoMode && typeof autoMode === "object") {
-    if ("defaultAgent" in autoMode) {
-      legacyKeys.push("autoMode.defaultAgent");
-      migrationHints.push("- Move `autoMode.defaultAgent` \u2192 `agent.default`");
-    }
-    if ("fallbackOrder" in autoMode) {
-      legacyKeys.push("autoMode.fallbackOrder");
-      migrationHints.push("- Move `autoMode.fallbackOrder: [primary, ...]` \u2192 `agent.fallback.map: { <primary>: [<rest>] }` and `agent.fallback.enabled: true`");
-    }
-  }
-  const context = conf.context;
-  const contextV2 = context?.v2;
-  if (contextV2 && typeof contextV2 === "object" && "fallback" in contextV2) {
-    legacyKeys.push("context.v2.fallback");
-    migrationHints.push("- Move `context.v2.fallback` \u2192 `agent.fallback` (see ADR-012 Phase 6)");
-  }
-  if (legacyKeys.length === 0)
-    return;
-  const message = [
-    `Invalid configuration \u2014 legacy agent keys detected: ${legacyKeys.join(", ")}.`,
-    "These were removed in ADR-012 Phase 6. Migrate to the canonical `agent.*` shape:",
-    ...migrationHints,
-    "See docs/adr/ADR-012-agent-manager-ownership.md for the full migration guide."
-  ].join(`
-`);
-  throw new NaxError(message, "CONFIG_LEGACY_AGENT_KEYS", { stage: "config", legacyKeys });
-}
-function rejectLegacyRectificationKeys(conf) {
-  const legacyKeys = [];
-  const migrationHints = [];
-  const quality = conf.quality;
-  const autofix = quality?.autofix;
-  if (autofix && typeof autofix === "object") {
-    if ("maxTotalAttempts" in autofix) {
-      legacyKeys.push("quality.autofix.maxTotalAttempts");
-      migrationHints.push("- Move `quality.autofix.maxTotalAttempts` \u2192 `execution.rectification.maxAttemptsTotal`");
-    }
-    if ("rethinkAtAttempt" in autofix) {
-      legacyKeys.push("quality.autofix.rethinkAtAttempt");
-      migrationHints.push("- Move `quality.autofix.rethinkAtAttempt` \u2192 `execution.rectification.rethinkAtAttempt`");
-    }
-    if ("urgencyAtAttempt" in autofix) {
-      legacyKeys.push("quality.autofix.urgencyAtAttempt");
-      migrationHints.push("- Move `quality.autofix.urgencyAtAttempt` \u2192 `execution.rectification.urgencyAtAttempt`");
-    }
-  }
-  const execution = conf.execution;
-  const rectification = execution?.rectification;
-  if (rectification && typeof rectification === "object" && "maxRetries" in rectification) {
-    legacyKeys.push("execution.rectification.maxRetries");
-    migrationHints.push("- Rename `execution.rectification.maxRetries` \u2192 `execution.rectification.maxAttemptsTotal` (default changed from 2 to 12)");
-  }
-  const regressionGate = execution?.regressionGate;
-  if (regressionGate && typeof regressionGate === "object" && "maxRectificationAttempts" in regressionGate) {
-    legacyKeys.push("execution.regressionGate.maxRectificationAttempts");
-    migrationHints.push("- Remove `execution.regressionGate.maxRectificationAttempts` \u2014 the regression cycle now shares `execution.rectification.maxAttemptsTotal`");
-  }
-  if (legacyKeys.length === 0)
-    return;
-  const message = [
-    `Invalid configuration \u2014 legacy rectification-cap keys detected: ${legacyKeys.join(", ")}.`,
-    "These were consolidated under `execution.rectification.*` so one config controls the unified",
-    "fix cycle (semantic + adversarial + mechanical + regression). Migrate as follows:",
-    ...migrationHints
-  ].join(`
-`);
-  throw new NaxError(message, "CONFIG_LEGACY_RECTIFICATION_KEYS", { stage: "config", legacyKeys });
-}
-function rejectUnimplementedScopedProfile(conf) {
-  const execution = conf.execution;
-  if (execution?.permissionProfile !== "scoped")
-    return;
-  const message = [
-    'Invalid configuration \u2014 execution.permissionProfile: "scoped" is not yet implemented.',
-    "The scoped (per-stage tool allowlist) profile is tracked by GitHub #374 and would",
-    'otherwise silently run as "safe", giving you weaker permissions than intended.',
-    'Use "unrestricted" or "safe" for now.'
-  ].join(`
-`);
-  throw new NaxError(message, "CONFIG_SCOPED_PROFILE_UNIMPLEMENTED", { stage: "config" });
-}
 function applyBatchModeCompat(conf) {
   const routing = conf.routing;
   const llm = routing?.llm;
@@ -19296,6 +19350,7 @@ async function loadConfig(startDir, cliOverrides) {
   }
   rejectLegacyAgentKeys(rawConfig);
   rejectLegacyRectificationKeys(rawConfig);
+  rejectDeadQualityFlags(rawConfig);
   rejectUnimplementedScopedProfile(rawConfig);
   const result = NaxConfigSchema.safeParse(rawConfig);
   if (!result.success) {
@@ -19366,6 +19421,7 @@ async function loadConfigForWorkdir(rootConfigPath, packageDir, cliOverrides) {
     rawMerged.profileChain = packageChain;
     rejectLegacyAgentKeys(rawMerged);
     rejectLegacyRectificationKeys(rawMerged);
+    rejectDeadQualityFlags(rawMerged);
     rejectUnimplementedScopedProfile(rawMerged);
     const result = NaxConfigSchema.safeParse(rawMerged);
     if (!result.success) {
@@ -19386,6 +19442,7 @@ var init_loader = __esm(() => {
   init_errors();
   init_logger2();
   init_json_file();
+  init_config_guards();
   init_path_security();
   init_paths();
   init_profile();
@@ -19679,7 +19736,7 @@ GOOD (write ACs like these):
 
 When a spec is provided, these rules govern acceptance criteria generation:
 
-1. **Preserve spec ACs.** Every acceptance criterion stated in the spec must appear in \`acceptanceCriteria\`. Never silently drop a spec AC. ACs the spec tags \`[verbatim]\` (typically executable greps, file-existence checks, regex/count assertions, or architectural invariants) MUST be copied **character-for-character** into an \`acceptanceCriteria\` entry \u2014 preserve every backtick-quoted command, file path, regex, and count exactly; do not paraphrase, retag, split, or move them into a description. Untagged ACs may be lightly rephrased for testability, but must retain the same assertion and concrete identifiers.
+1. **Preserve spec ACs.** Every acceptance criterion stated in the spec must appear in \`acceptanceCriteria\`. Never silently drop a spec AC. ACs may be lightly rephrased for testability, but must retain the same assertion and concrete identifiers. An AC carrying a deprecated \`[grep]\`/\`[file]\`/\`[verbatim]\` tag describes a file-content check rather than a runtime behaviour: rewrite it as the behaviour that check was meant to prove, and drop the tag.
 2. **Do not invent spec ACs.** If you identify useful behavioral edge cases or negative paths that the spec did not explicitly list, place them in \`suggestedCriteria\` (a string array on the same story object) \u2014 never in \`acceptanceCriteria\`. These go through a separate hardening pass.
 3. **Respect story scope.** Each story's criteria must only cover what the spec says for that story. Do not assign criteria that belong to a different story's scope (wrong feature area, wrong file, wrong dependency chain).
 4. **\`suggestedCriteria\` format.** Each element must be a plain behavioral assertion \u2014 an observable output, return value, state change, or error condition that a test can assert. Never include implementation details (imports, internal structure), design suggestions, or vague descriptions.
@@ -19850,6 +19907,7 @@ __export(exports_config, {
   DebateConfigSchema: () => DebateConfigSchema,
   DESCRIPTION_QUALITY_RULES: () => DESCRIPTION_QUALITY_RULES,
   DEFAULT_CONFIG: () => DEFAULT_CONFIG,
+  DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG: () => DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG,
   ConfiguredModelSchema: () => ConfiguredModelSchema,
   COMPLEXITY_GUIDE: () => COMPLEXITY_GUIDE,
   AutoRouteConfigSchema: () => AutoRouteConfigSchema,
@@ -21075,8 +21133,23 @@ function buildRunInteractionHandler(options) {
     }
   };
 }
+function buildTurnResult(input) {
+  const { lastResponse, totalTokenUsage, totalExactCostUsd, turnCount, interactions, timedOut, modelDef } = input;
+  const output = timedOut ? "" : extractOutput(lastResponse);
+  const estimatedCostUsd = totalTokenUsage.inputTokens > 0 || totalTokenUsage.outputTokens > 0 ? estimateCostFromTokenUsage(totalTokenUsage, modelDef.model) : 0;
+  return {
+    output,
+    tokenUsage: totalTokenUsage,
+    estimatedCostUsd,
+    exactCostUsd: totalExactCostUsd,
+    internalRoundTrips: turnCount,
+    ...interactions.length > 0 ? { interactions } : {},
+    timedOut
+  };
+}
 var CONTEXT_TOOL_CALL_PATTERN;
 var init_adapter_output = __esm(() => {
+  init_cost();
   CONTEXT_TOOL_CALL_PATTERN = /<nax_tool_call\s+name="([^"]+)">\s*([\s\S]*?)\s*<\/nax_tool_call>/i;
 });
 
@@ -21435,18 +21508,15 @@ class AcpAgentAdapter {
     if (lastResponse?.stopReason === "error") {
       throw new SessionTurnError(lastResponse.cancelled ? "Agent session ended with stop reason: error (externally cancelled)" : "Agent session ended with stop reason: error", lastResponse.cancelled === true, lastResponse.retryable === true);
     }
-    const output = extractOutput(lastResponse);
-    const tokenUsage = totalTokenUsage;
-    const estimatedCostUsd = totalTokenUsage.inputTokens > 0 || totalTokenUsage.outputTokens > 0 ? estimateCostFromTokenUsage(totalTokenUsage, modelDef.model) : 0;
-    const exactCostUsd = totalExactCostUsd;
-    return {
-      output,
-      tokenUsage,
-      estimatedCostUsd,
-      exactCostUsd,
-      internalRoundTrips: turnCount,
-      ...interactions.length > 0 ? { interactions } : {}
-    };
+    return buildTurnResult({
+      lastResponse,
+      totalTokenUsage,
+      totalExactCostUsd,
+      turnCount,
+      interactions,
+      timedOut,
+      modelDef
+    });
   }
   async closeSession(handle) {
     const impl = handle;
@@ -21927,6 +21997,108 @@ var init_default_strategy = __esm(() => {
   };
 });
 
+// src/agents/retry/hop-retry-policy.ts
+function trySameAgentRetry(result, state, deps) {
+  const { staleRetryAttempts, timeoutRetryAttempts, adapterErrorRetries, currentRunOptions } = state;
+  const { config: config2, requestRunOptions, signal } = deps;
+  const isFailStale = result.adapterFailure?.outcome === "fail-stale";
+  const maxStaleRetries = config2.agent?.idleWatchdog?.maxRetryAttempts ?? 3;
+  if (isFailStale && result.adapterFailure?.retriable && staleRetryAttempts < maxStaleRetries) {
+    const newAttempts = staleRetryAttempts + 1;
+    return {
+      outcome: "stale-retry",
+      staleRetryAttempts: newAttempts,
+      kind: { kind: "stale-retry", attempt: newAttempts },
+      fallbackRecord: {
+        outcome: result.adapterFailure?.outcome ?? "fail-stale",
+        category: result.adapterFailure?.category ?? "availability",
+        costUsd: result.estimatedCostUsd ?? 0,
+        reason: result.adapterFailure?.reason
+      }
+    };
+  }
+  const isFailTimeout = result.adapterFailure?.outcome === "fail-timeout";
+  if (isFailTimeout && result.adapterFailure?.retriable) {
+    const timeoutConfig = extractTimeoutRetryConfig(config2);
+    if (timeoutRetryShouldRetry(timeoutRetryAttempts, timeoutConfig)) {
+      const newAttempts = timeoutRetryAttempts + 1;
+      return {
+        outcome: "timeout-retry",
+        timeoutRetryAttempts: newAttempts,
+        kind: { kind: "timeout-retry", attempt: newAttempts },
+        currentRunOptions: resolveTimeoutRetryOptions(currentRunOptions, timeoutConfig, config2.execution),
+        fallbackRecord: {
+          outcome: result.adapterFailure?.outcome ?? "fail-timeout",
+          category: result.adapterFailure?.category ?? "quality",
+          costUsd: result.estimatedCostUsd ?? 0,
+          reason: result.adapterFailure?.reason
+        }
+      };
+    }
+  }
+  const isFailAdapterError = result.adapterFailure?.outcome === "fail-adapter-error";
+  if (isFailAdapterError && !signal?.aborted) {
+    const runConfig = requestRunOptions.config ?? config2;
+    const maxAdapterRetries = result.adapterFailure?.retriable ? runConfig.execution?.sessionErrorRetryableMaxRetries ?? 3 : runConfig.execution?.sessionErrorMaxRetries ?? 1;
+    if (adapterErrorRetries < maxAdapterRetries) {
+      const newAttempts = adapterErrorRetries + 1;
+      return {
+        outcome: "adapter-error",
+        adapterErrorRetries: newAttempts,
+        kind: { kind: "stale-retry", attempt: newAttempts },
+        fallbackRecord: {
+          outcome: result.adapterFailure?.outcome ?? "fail-adapter-error",
+          category: result.adapterFailure?.category ?? "availability",
+          costUsd: result.estimatedCostUsd ?? 0,
+          retriable: result.adapterFailure?.retriable ?? false,
+          maxAttempts: maxAdapterRetries
+        }
+      };
+    }
+  }
+  return null;
+}
+function extractTimeoutRetryConfig(config2) {
+  const fromConfig = config2.agent?.timeoutRetry;
+  return {
+    maxAttempts: fromConfig?.maxAttempts ?? DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG.maxAttempts,
+    budgetMultiplier: fromConfig?.budgetMultiplier ?? DEFAULT_AGENT_TIMEOUT_RETRY_CONFIG.budgetMultiplier
+  };
+}
+function resolveTimeoutRetryOptions(prev, timeoutConfig, executionConfig) {
+  const budget = prev.timeoutSeconds ?? executionConfig?.sessionTimeoutSeconds ?? DEFAULT_CONFIG.execution.sessionTimeoutSeconds;
+  return { ...prev, timeoutSeconds: budget * timeoutConfig.budgetMultiplier };
+}
+function timeoutRetryShouldRetry(attempts, config2) {
+  return attempts < config2.maxAttempts;
+}
+function describeRetryLogEvent(retryDecision, storyId, agent) {
+  const attempt = retryDecision.kind.attempt;
+  if (retryDecision.outcome === "adapter-error") {
+    return {
+      recordFallback: false,
+      level: "warn",
+      message: "fail-adapter-error: same-agent retry with fresh session",
+      fields: {
+        storyId,
+        attempt,
+        maxAttempts: retryDecision.fallbackRecord.maxAttempts,
+        retriable: retryDecision.fallbackRecord.retriable,
+        agent
+      }
+    };
+  }
+  return {
+    recordFallback: true,
+    level: "info",
+    message: retryDecision.outcome === "stale-retry" ? "fail-stale: immediate same-agent retry" : "fail-timeout: same-agent retry with reduced budget",
+    fields: { storyId, attempt, agent, reason: retryDecision.fallbackRecord.reason }
+  };
+}
+var init_hop_retry_policy = __esm(() => {
+  init_config();
+});
+
 // src/agents/manager.ts
 import { EventEmitter } from "events";
 
@@ -22033,7 +22205,7 @@ class AgentManager {
   shouldSwap(failure, hopsSoFar, hasBundle) {
     if (!failure)
       return false;
-    if (failure.outcome === "fail-aborted")
+    if (failure.outcome === "fail-aborted" || failure.outcome === "fail-timeout")
       return false;
     const fallback = this._config.agent?.fallback;
     if (!fallback?.enabled)
@@ -22059,8 +22231,10 @@ class AgentManager {
     let hopsSoFar = 0;
     let rateLimitRetry = 0;
     let staleRetryAttempts = 0;
+    let timeoutRetryAttempts = 0;
     let adapterErrorRetries = 0;
     let currentBundle = request.bundle;
+    let currentRunOptions = request.runOptions;
     let currentHopKind = { kind: "primary" };
     let finalPrompt;
     const _opStartMs = Date.now();
@@ -22072,7 +22246,7 @@ class AgentManager {
         let result;
         let updatedBundle = currentBundle;
         if (request.executeHop) {
-          const hopOut = await request.executeHop(currentAgent, currentBundle, currentHopKind, request.runOptions);
+          const hopOut = await request.executeHop(currentAgent, currentBundle, currentHopKind, currentRunOptions);
           result = hopOut.result;
           updatedBundle = hopOut.bundle ?? currentBundle;
           finalPrompt = hopOut.prompt ?? finalPrompt;
@@ -22089,7 +22263,7 @@ class AgentManager {
             _finalStatus = "error";
             return { result: unboundResult, fallbacks, finalBundle: currentBundle, finalPrompt };
           }
-          const rawHopOut = await this._runHop(currentAgent, request.runOptions);
+          const rawHopOut = await this._runHop(currentAgent, currentRunOptions);
           const hopOut = "result" in rawHopOut && rawHopOut.result != null ? rawHopOut : { result: rawHopOut, prompt: undefined };
           result = hopOut.result;
           finalPrompt = hopOut.prompt ?? finalPrompt;
@@ -22100,51 +22274,49 @@ class AgentManager {
           return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
         }
         const bundleForSwapCheck = updatedBundle ?? request.bundle;
-        if (request.noFallback) {
-          _finalStatus = "error";
-          return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-        }
         const isFailStale = result.adapterFailure?.outcome === "fail-stale";
-        const maxStaleRetries = this._config.agent?.idleWatchdog?.maxRetryAttempts ?? 3;
-        if (isFailStale && result.adapterFailure?.retriable && staleRetryAttempts < maxStaleRetries) {
-          staleRetryAttempts++;
+        const retryState = {
+          staleRetryAttempts,
+          timeoutRetryAttempts,
+          adapterErrorRetries,
+          currentRunOptions
+        };
+        const retryDecision = trySameAgentRetry(result, retryState, {
+          config: this._config,
+          requestRunOptions: request.runOptions,
+          signal: request.signal
+        });
+        if (retryDecision) {
+          staleRetryAttempts = retryDecision.outcome === "stale-retry" ? retryDecision.staleRetryAttempts : staleRetryAttempts;
+          timeoutRetryAttempts = retryDecision.outcome === "timeout-retry" ? retryDecision.timeoutRetryAttempts : timeoutRetryAttempts;
+          adapterErrorRetries = retryDecision.outcome === "adapter-error" ? retryDecision.adapterErrorRetries : adapterErrorRetries;
+          currentRunOptions = retryDecision.outcome === "timeout-retry" ? retryDecision.currentRunOptions : currentRunOptions;
           const retryHop = {
             storyId: request.runOptions.storyId,
             priorAgent: currentAgent,
             newAgent: currentAgent,
-            hop: staleRetryAttempts,
-            outcome: result.adapterFailure?.outcome ?? "fail-stale",
-            category: result.adapterFailure?.category ?? "availability",
+            hop: retryDecision.kind.attempt,
+            outcome: retryDecision.fallbackRecord.outcome,
+            category: retryDecision.fallbackRecord.category,
             timestamp: new Date().toISOString(),
-            costUsd: result.estimatedCostUsd ?? 0
+            costUsd: retryDecision.fallbackRecord.costUsd
           };
-          fallbacks.push(retryHop);
-          this._emitter.emit("onSwapAttempt", retryHop);
-          logger?.info("agent-manager", "fail-stale: immediate same-agent retry", {
-            storyId: request.runOptions.storyId,
-            attempt: staleRetryAttempts,
-            agent: currentAgent,
-            reason: result.adapterFailure?.reason
-          });
-          currentHopKind = { kind: "stale-retry", attempt: staleRetryAttempts };
+          const logEvent = describeRetryLogEvent(retryDecision, request.runOptions.storyId, currentAgent);
+          if (logEvent.recordFallback) {
+            fallbacks.push(retryHop);
+            this._emitter.emit("onSwapAttempt", retryHop);
+          }
+          if (logEvent.level === "warn") {
+            logger?.warn("agent-manager", logEvent.message, logEvent.fields);
+          } else {
+            logger?.info("agent-manager", logEvent.message, logEvent.fields);
+          }
+          currentHopKind = retryDecision.kind;
           continue;
         }
-        const isFailAdapterError = result.adapterFailure?.outcome === "fail-adapter-error";
-        if (isFailAdapterError && !request.signal?.aborted) {
-          const runConfig = request.runOptions.config ?? this._config;
-          const maxAdapterRetries = result.adapterFailure?.retriable ? runConfig.execution?.sessionErrorRetryableMaxRetries ?? 3 : runConfig.execution?.sessionErrorMaxRetries ?? 1;
-          if (adapterErrorRetries < maxAdapterRetries) {
-            adapterErrorRetries++;
-            logger?.warn("agent-manager", "fail-adapter-error: same-agent retry with fresh session", {
-              storyId: request.runOptions.storyId,
-              attempt: adapterErrorRetries,
-              maxAttempts: maxAdapterRetries,
-              retriable: result.adapterFailure?.retriable ?? false,
-              agent: currentAgent
-            });
-            currentHopKind = { kind: "stale-retry", attempt: adapterErrorRetries };
-            continue;
-          }
+        if (request.noFallback) {
+          _finalStatus = "error";
+          return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
         }
         const hasBundleForSwap = !!bundleForSwapCheck || isFailStale;
         if (!this.shouldSwap(result.adapterFailure, hopsSoFar, hasBundleForSwap)) {
@@ -22558,6 +22730,7 @@ var init_manager = __esm(() => {
   init_bun_deps();
   init_registry();
   init_default_strategy();
+  init_hop_retry_policy();
   _agentManagerDeps = {
     sleep: (ms, signal) => cancellableDelay(ms, signal)
   };
@@ -22835,6 +23008,7 @@ var init_retry = __esm(() => {
   init_compose();
   init_parse_retry();
   init_tiered_parse_retry();
+  init_hop_retry_policy();
 });
 
 // src/agents/index.ts
@@ -25288,7 +25462,7 @@ async function getGitRoot(workdir) {
     return null;
   }
 }
-async function gitWithTimeout(args, workdir) {
+async function gitWithTimeout(args, workdir, timeoutMs = GIT_TIMEOUT_MS) {
   const proc = _gitDeps.spawn(["git", ...args], {
     cwd: workdir,
     stdout: "pipe",
@@ -25300,7 +25474,7 @@ async function gitWithTimeout(args, workdir) {
     try {
       proc.kill("SIGKILL");
     } catch {}
-  }, GIT_TIMEOUT_MS);
+  }, timeoutMs);
   const exitCode = await proc.exited;
   clearTimeout(timerId);
   if (timedOut) {
@@ -25432,6 +25606,38 @@ async function captureOutputFiles(workdir, baseRef, scopePrefix) {
     return [];
   }
 }
+async function captureWorkingTreeChanges(workdir, baseRef, scopePrefix) {
+  if (!baseRef)
+    return [];
+  const runDiff = async (args) => {
+    const fullArgs = scopePrefix ? [...args, "--", `${scopePrefix}/`] : args;
+    const { stdout, exitCode } = await gitWithTimeout(fullArgs, workdir, TIMEOUT_RETRY_GIT_TIMEOUT_MS);
+    if (exitCode !== 0)
+      return [];
+    return stdout.trim().split(`
+`).filter(Boolean);
+  };
+  try {
+    const [committed, uncommitted, untracked] = await Promise.all([
+      runDiff(["diff", "--name-only", `${baseRef}..HEAD`]),
+      runDiff(["diff", "--name-only", "HEAD"]),
+      runDiff(["ls-files", "--others", "--exclude-standard"])
+    ]);
+    const seen = new Set;
+    const merged = [];
+    for (const list of [committed, uncommitted, untracked]) {
+      for (const file3 of list) {
+        if (!seen.has(file3)) {
+          seen.add(file3);
+          merged.push(file3);
+        }
+      }
+    }
+    return merged;
+  } catch {
+    return [];
+  }
+}
 async function captureDiffSummary(workdir, baseRef, scopePrefix) {
   if (!baseRef)
     return "";
@@ -25454,7 +25660,7 @@ async function captureDiffSummary(workdir, baseRef, scopePrefix) {
     return "";
   }
 }
-var _gitDeps, GIT_TIMEOUT_MS = 1e4;
+var _gitDeps, GIT_TIMEOUT_MS = 1e4, TIMEOUT_RETRY_GIT_TIMEOUT_MS = 3000;
 var init_git = __esm(() => {
   init_logger2();
   init_bun_deps();
@@ -28697,81 +28903,12 @@ function generateHumanHaltSummary(prd) {
 `);
 }
 
-// src/prd/verbatim-fidelity.ts
-function normalizeWs(text) {
-  return text.replace(/\s+/g, " ").trim();
-}
-function stripBackticks(text) {
-  return text.replace(/`/g, "");
-}
-function canonical2(text) {
-  return normalizeWs(stripBackticks(text));
-}
-function leadingTagGroup(line) {
-  return line.match(LEADING_TAG_GROUP)?.[1] ?? null;
-}
-function isVerbatimBullet(line) {
-  const tags = leadingTagGroup(line);
-  return tags !== null && /\[verbatim\]/i.test(tags);
-}
-function isContinuation(line) {
-  if (line.trim().length === 0)
-    return false;
-  if (HEADING.test(line))
-    return false;
-  if (LIST_ITEM_START2.test(line))
-    return false;
-  return true;
-}
-function stripTagPrefix(block) {
-  return block.replace(LEADING_TAG_GROUP, "");
-}
-function extractVerbatimAcs(specContent) {
-  const lines = specContent.split(`
-`);
-  const blocks = [];
-  for (let i = 0;i < lines.length; i++) {
-    if (!isVerbatimBullet(lines[i]))
-      continue;
-    const parts = [lines[i].trim()];
-    let j = i + 1;
-    while (j < lines.length && isContinuation(lines[j])) {
-      parts.push(lines[j].trim());
-      j += 1;
-    }
-    blocks.push(parts.join(" "));
-    i = j - 1;
-  }
-  return blocks;
-}
-function prdAcPayloads(prd) {
-  return (prd.userStories ?? []).flatMap((story) => (story.acceptanceCriteria ?? []).map(canonical2));
-}
-function findMissingVerbatimAcs(specContent, prd) {
-  const prdAcs = prdAcPayloads(prd);
-  const missing = [];
-  for (const block of extractVerbatimAcs(specContent)) {
-    const payload = canonical2(stripTagPrefix(block));
-    if (payload.length === 0)
-      continue;
-    if (!prdAcs.some((ac) => ac.includes(payload)))
-      missing.push(block);
-  }
-  return missing;
-}
-var LEADING_TAG_GROUP, LIST_ITEM_START2, HEADING;
-var init_verbatim_fidelity = __esm(() => {
-  LEADING_TAG_GROUP = /^\s*(?:[-*]|\d+\.)?\s*((?:\[[a-z][a-z-]*\]\s*)+)/i;
-  LIST_ITEM_START2 = /^\s*(?:[-*]|\d+\.)\s/;
-  HEADING = /^\s*#/;
-});
-
 // src/prd/spec-drift.ts
-function leadingTagGroup2(ac) {
-  return ac.match(LEADING_TAG_GROUP2)?.[1] ?? null;
+function leadingTagGroup(ac) {
+  return ac.match(LEADING_TAG_GROUP)?.[1] ?? null;
 }
 function hasDeprecatedTag(ac) {
-  const tags = leadingTagGroup2(ac);
+  const tags = leadingTagGroup(ac);
   return tags !== null && DEPRECATED_TAG.test(tags);
 }
 function hasShellPattern(ac) {
@@ -28791,9 +28928,9 @@ function findSpecDriftViolations(prd) {
   }
   return violations;
 }
-var LEADING_TAG_GROUP2, DEPRECATED_TAG, SHELL_PIPE, SHELL_WC, SHELL_GREP_FLAG;
+var LEADING_TAG_GROUP, DEPRECATED_TAG, SHELL_PIPE, SHELL_WC, SHELL_GREP_FLAG;
 var init_spec_drift = __esm(() => {
-  LEADING_TAG_GROUP2 = /^\s*(?:[-*]|\d+\.)?\s*((?:\[[a-z][a-z-]*\]\s*)+)/i;
+  LEADING_TAG_GROUP = /^\s*(?:[-*]|\d+\.)?\s*((?:\[[a-z][a-z-]*\]\s*)+)/i;
   DEPRECATED_TAG = /\[(grep|file|verbatim)\]/i;
   SHELL_PIPE = /`[^`]*\b(grep|find|wc|awk|sed|sort|head|tail|xargs|cut|uniq)\b[^`]*\|[^`]*`/i;
   SHELL_WC = /`[^`]*\bwc\b[^`]*`/;
@@ -29221,9 +29358,7 @@ __export(exports_prd, {
   getContextFiles: () => getContextFiles,
   generateHumanHaltSummary: () => generateHumanHaltSummary,
   findSpecDriftViolations: () => findSpecDriftViolations,
-  findMissingVerbatimAcs: () => findMissingVerbatimAcs,
   findMissingOutOfScope: () => findMissingOutOfScope,
-  extractVerbatimAcs: () => extractVerbatimAcs,
   extractSpecOutOfScope: () => extractSpecOutOfScope,
   deriveNextStoryId: () => deriveNextStoryId,
   countStories: () => countStories,
@@ -29421,7 +29556,6 @@ var init_prd = __esm(() => {
   init_errors();
   init_json_file();
   init_out_of_scope();
-  init_verbatim_fidelity();
   init_spec_drift();
   init_out_of_scope();
   init_inject();
@@ -29878,6 +30012,13 @@ var init_plugin_loader = __esm(() => {
 });
 
 // src/context/engine/providers/plugin-cache.ts
+function withDisposeDeadline(p, deadlineMs) {
+  let handle;
+  const deadline = new Promise((resolve8) => {
+    handle = setTimeout(resolve8, deadlineMs);
+  });
+  return Promise.race([p, deadline]).finally(() => clearTimeout(handle));
+}
 function stableCacheKey(configs, workdir) {
   const sorted = [...configs].sort((a, b) => a.module.localeCompare(b.module));
   return `${workdir}:${JSON.stringify(sorted)}`;
@@ -29908,31 +30049,32 @@ class PluginProviderCache {
       return;
     this.disposed = true;
     const logger = getLogger();
+    const disposals = [];
     for (const providers of this.cache.values()) {
       for (const provider of providers) {
         const initialisable = provider;
         if (typeof initialisable.dispose !== "function")
           continue;
-        try {
-          await Promise.race([initialisable.dispose(), Bun.sleep(DISPOSE_TIMEOUT_MS)]);
-        } catch (err) {
+        disposals.push(withDisposeDeadline(Promise.resolve().then(() => initialisable.dispose?.()).then(() => {}), _pluginCacheDeps.disposeTimeoutMs).catch((err) => {
           logger.warn("context-engine", "Plugin provider dispose() threw \u2014 continuing teardown", {
             providerId: provider.id,
             error: err instanceof Error ? err.message : String(err)
           });
-        }
+        }));
       }
     }
+    await Promise.all(disposals);
     this.cache.clear();
   }
 }
-var _pluginCacheDeps, DISPOSE_TIMEOUT_MS = 5000;
+var DISPOSE_TIMEOUT_MS = 5000, _pluginCacheDeps;
 var init_plugin_cache = __esm(() => {
   init_errors();
   init_logger2();
   init_plugin_loader();
   _pluginCacheDeps = {
-    loadProviders: loadPluginProviders
+    loadProviders: loadPluginProviders,
+    disposeTimeoutMs: DISPOSE_TIMEOUT_MS
   };
 });
 
@@ -33450,7 +33592,7 @@ var init_acceptance_builder = __esm(() => {
 });
 
 // src/review/ac-quote-validator.ts
-function normalizeWs2(s) {
+function normalizeWs(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 function stripMarkdownInline(s) {
@@ -33485,8 +33627,8 @@ function validateAcQuote(finding, acceptanceCriteria) {
   if (typeof acIndex !== "number" || acIndex < 1 || acIndex > acceptanceCriteria.length) {
     return { valid: false, code: "ac_index_out_of_range" };
   }
-  const acText = normalizeWs2(stripMarkdownInline(acceptanceCriteria[acIndex - 1]));
-  const normalizedQuote = normalizeWs2(stripMarkdownInline(acQuote));
+  const acText = normalizeWs(stripMarkdownInline(acceptanceCriteria[acIndex - 1]));
+  const normalizedQuote = normalizeWs(stripMarkdownInline(acQuote));
   if (!acText.toLowerCase().includes(normalizedQuote.toLowerCase())) {
     return { valid: false, code: "ac_quote_not_substring" };
   }
@@ -33560,8 +33702,8 @@ function validateScopeQuote(finding, outOfScope) {
   if (typeof scopeIndex !== "number" || scopeIndex < 1 || scopeIndex > outOfScope.length) {
     return { valid: false, code: "scope_index_out_of_range" };
   }
-  const entry = normalizeWs2(stripMarkdownInline(outOfScope[scopeIndex - 1]));
-  const quote = normalizeWs2(stripMarkdownInline(scopeQuote));
+  const entry = normalizeWs(stripMarkdownInline(outOfScope[scopeIndex - 1]));
+  const quote = normalizeWs(stripMarkdownInline(scopeQuote));
   if (!entry.toLowerCase().includes(quote.toLowerCase())) {
     return { valid: false, code: "scope_quote_not_substring" };
   }
@@ -33780,13 +33922,31 @@ var init_adapters = __esm(() => {
   init_typecheck();
 });
 
-// src/operations/verbatim-warn.ts
-function warnOnDroppedVerbatimAcs(prd, specContent, featureName) {
-  const missing = findMissingVerbatimAcs(specContent, prd);
-  if (missing.length > 0) {
-    getSafeLogger()?.warn("plan", "[verbatim] spec acceptance criteria dropped from PRD \u2014 run spec-review --prd before executing", { featureName, missingCount: missing.length, missing });
+// src/operations/turn-failure-classification.ts
+function classifyEmptyOutputFailure(turn) {
+  if (turn.adapterFailure)
+    return turn.adapterFailure;
+  if (turn.output && turn.output.trim().length > 0)
+    return null;
+  if (turn.timedOut) {
+    return {
+      category: "quality",
+      outcome: "fail-timeout",
+      retriable: true,
+      message: "[callOp] agent timed out before producing output",
+      reason: "wall-clock-timeout"
+    };
   }
+  return {
+    category: "availability",
+    outcome: "fail-stale",
+    retriable: true,
+    message: "[callOp] agent returned no output",
+    reason: "empty-output"
+  };
 }
+
+// src/operations/plan-fidelity.ts
 function backfillOutOfScope(prd, specContent, featureName) {
   const missing = findMissingOutOfScope(specContent, prd);
   if (missing.length === 0)
@@ -33808,7 +33968,7 @@ function warnOnSpecDrift(prd, featureName) {
     });
   }
 }
-var init_verbatim_warn = __esm(() => {
+var init_plan_fidelity = __esm(() => {
   init_logger2();
   init_prd();
 });
@@ -33820,7 +33980,7 @@ var init_plan = __esm(() => {
   init_config();
   init_schema2();
   init_prompts();
-  init_verbatim_warn();
+  init_plan_fidelity();
   planInteractiveOp = {
     kind: "run",
     name: "plan-interactive",
@@ -33865,7 +34025,6 @@ ${outputFormat}`, overridable: false }
     verify: async (parsed, input, _ctx) => {
       if (!parsed.userStories || parsed.userStories.length === 0)
         return null;
-      warnOnDroppedVerbatimAcs(parsed, input.specContent, input.featureName);
       return backfillOutOfScope(parsed, input.specContent, input.featureName);
     },
     recover: async (input, ctx) => {
@@ -33951,20 +34110,6 @@ function validateRefinedPrd(prd) {
     validateRefinedStory(story);
   return prd;
 }
-async function readMissingVerbatimAcs(input) {
-  const content = await _planRefineDeps.readFile(input.outputPath);
-  if (!content)
-    return [];
-  try {
-    const prd = validatePlanOutput(content, input.featureName, input.branchName);
-    return findMissingVerbatimAcs(input.specContent, prd);
-  } catch {
-    getSafeLogger()?.debug("plan", "Skipped [verbatim] self-heal \u2014 draft PRD not yet parseable", {
-      featureName: input.featureName
-    });
-    return [];
-  }
-}
 async function readSpecDriftViolations(input) {
   const content = await _planRefineDeps.readFile(input.outputPath);
   if (!content)
@@ -34053,17 +34198,6 @@ async function normalizeCreatedContextFiles(prd, workdir, fileExists) {
     return prd;
   return { ...prd, userStories: results.map((r) => r.story) };
 }
-function verbatimSelfHealStep(builder) {
-  return makeSelfHealStep({
-    detect: (input) => readMissingVerbatimAcs(input),
-    buildRepair: (missing, input) => builder.buildVerbatimRepair(missing, input.outputPath),
-    log: {
-      kind: "plan",
-      message: "Refine dropped [verbatim] spec ACs \u2014 issuing one repair turn",
-      meta: (input, missing) => ({ featureName: input.featureName, missingCount: missing.length })
-    }
-  });
-}
 async function readMissingOutOfScope(input) {
   const content = await _planRefineDeps.readFile(input.outputPath);
   if (!content)
@@ -34110,8 +34244,8 @@ var init_plan_refine = __esm(() => {
   init_prd();
   init_schema2();
   init_prompts();
+  init_plan_fidelity();
   init_self_heal();
-  init_verbatim_warn();
   _planRefineDeps = {
     readFile: async (path3) => {
       try {
@@ -34195,7 +34329,6 @@ ${outputFormat}`,
         estimatedCostUsd: (turn1.estimatedCostUsd ?? 0) + (turn2.estimatedCostUsd ?? 0)
       };
       const steps = [
-        verbatimSelfHealStep(builder),
         outOfScopeSelfHealStep(builder),
         ...specGuard ? [specDriftSelfHealStep(builder)] : []
       ];
@@ -34206,7 +34339,6 @@ ${outputFormat}`,
     },
     verify: async (parsed, input, ctx) => {
       const validated = validateRefinedPrd(parsed);
-      warnOnDroppedVerbatimAcs(validated, input.specContent, input.featureName);
       if (ctx.config.plan.specGuard) {
         warnOnSpecDrift(validated, input.featureName);
       }
@@ -35638,6 +35770,11 @@ function categoryToFixTarget(category) {
     return "source";
   return category != null && BLOCKING_CATEGORIES.has(category) ? "source" : "test";
 }
+function resolveFixTarget({ base, file: file3, isTestFile: isTestFile3 }) {
+  if (file3 && isTestFile3?.(file3))
+    return "test";
+  return base;
+}
 var init_category_fix_target = __esm(() => {
   init_ac_structural_counterfactual();
 });
@@ -35665,7 +35802,7 @@ function normalizeSeverity(sev) {
     return sev;
   return "info";
 }
-function toAdversarialReviewFindings(findings) {
+function toAdversarialReviewFindings(findings, opts = {}) {
   return findings.map((f) => {
     const metaExtras = {};
     if (f.acQuote)
@@ -35686,7 +35823,7 @@ function toAdversarialReviewFindings(findings) {
       line: f.line,
       message: f.issue,
       suggestion: f.suggestion,
-      fixTarget: categoryToFixTarget(f.category),
+      fixTarget: resolveFixTarget({ base: categoryToFixTarget(f.category), file: f.file, isTestFile: opts.isTestFile }),
       meta: Object.keys(metaExtras).length > 0 ? metaExtras : undefined
     };
   });
@@ -35750,7 +35887,7 @@ function downgradeToUnverifiable(finding) {
     severity: "unverifiable"
   };
 }
-function llmFindingToFinding(f) {
+function llmFindingToFinding(f, opts = {}) {
   const metaExtras = {};
   if (f.verifiedBy)
     metaExtras.verifiedBy = f.verifiedBy;
@@ -35766,15 +35903,16 @@ function llmFindingToFinding(f) {
     line: f.line,
     message: f.issue,
     suggestion: f.suggestion ?? undefined,
-    fixTarget: "source",
+    fixTarget: resolveFixTarget({ base: "source", file: f.file, isTestFile: opts.isTestFile }),
     meta: Object.keys(metaExtras).length > 0 ? metaExtras : undefined
   };
 }
-function toReviewFindings(findings) {
-  return findings.map(llmFindingToFinding);
+function toReviewFindings(findings, opts = {}) {
+  return findings.map((f) => llmFindingToFinding(f, opts));
 }
 var UNVERIFIED_FINDING_PATTERNS;
 var init_semantic_helpers = __esm(() => {
+  init_category_fix_target();
   init_severity();
   UNVERIFIED_FINDING_PATTERNS = [
     "cannot verify",
@@ -35918,9 +36056,9 @@ function parseRequoteResponse(output) {
   const parsed = tryParseLLMJson(output);
   if (!isRecord(parsed))
     return null;
-  const canonical3 = extractCanonical(parsed);
-  if (canonical3)
-    return canonical3;
+  const canonical2 = extractCanonical(parsed);
+  if (canonical2)
+    return canonical2;
   const findings = parsed.findings;
   if (!Array.isArray(findings) || findings.length !== 1)
     return null;
@@ -35967,6 +36105,10 @@ function withRepromptMarker(output, info) {
     return output;
   return JSON.stringify({ ...parsed, _repromptInfo: info });
 }
+function semanticTestFileMatch(input) {
+  const patterns = input.resolvedTestPatterns?.regex ?? [];
+  return (file3) => patterns.some((re) => re.test(file3));
+}
 function extractRepromptInfo(raw) {
   if (!raw || typeof raw !== "object")
     return;
@@ -36258,7 +36400,7 @@ var init_semantic_review = __esm(() => {
         ...parsed,
         passed,
         findings: accepted,
-        normalizedFindings: toReviewFindings(blocking),
+        normalizedFindings: toReviewFindings(blocking, { isTestFile: semanticTestFileMatch(input) }),
         acDropped: dropped
       };
     }
@@ -36674,10 +36816,10 @@ var init_adversarial_review = __esm(() => {
         ...parsed,
         passed,
         findings: accepted,
-        normalizedFindings: toAdversarialReviewFindings(blocking),
+        normalizedFindings: toAdversarialReviewFindings(blocking, { isTestFile: testFileMatch }),
         advisoryFindings: [
-          ...toAdversarialReviewFindings(advisory),
-          ...tagCoverageGap(toAdversarialReviewFindings(demoted))
+          ...toAdversarialReviewFindings(advisory, { isTestFile: testFileMatch }),
+          ...tagCoverageGap(toAdversarialReviewFindings(demoted, { isTestFile: testFileMatch }))
         ],
         acDropped: dropped
       };
@@ -39063,14 +39205,9 @@ async function executeWithTimeout(command, timeoutSeconds, env2, options) {
     const pid = proc.pid;
     killProcessGroup(pid, "SIGTERM");
     let exitedDuringGrace = false;
-    await Promise.race([
-      proc.exited.then(() => {
-        exitedDuringGrace = true;
-      }),
-      new Promise((resolve11) => {
-        setTimeout(resolve11, gracePeriodMs);
-      })
-    ]);
+    await raceWithDeadline(proc.exited.then(() => {
+      exitedDuringGrace = true;
+    }).catch(() => {}), gracePeriodMs);
     if (!exitedDuringGrace) {
       killProcessGroup(pid, "SIGKILL");
     }
@@ -39946,7 +40083,7 @@ async function runQualityCommand(opts) {
     let sigkillTimer;
     proc.exited.then(() => {
       exitedBeforeSigkill = true;
-    });
+    }).catch(() => {});
     const killTimer = setTimeout(() => {
       timedOut = true;
       killProcessGroup(proc.pid, "SIGTERM");
@@ -41378,7 +41515,7 @@ var init_operations = __esm(() => {
   init_plan();
   init_plan_refine();
   init_self_heal();
-  init_verbatim_warn();
+  init_plan_fidelity();
   init_decompose2();
   init_build_hop_callback();
   init_classify_route();
@@ -41495,11 +41632,15 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
   const storyId = ctx.storyId;
   const packageDir = ctx.packageDir;
   let totalCostUsd = 0;
+  const spentStrategies = new Set;
+  let unresolvedDetail;
+  const finish = (result) => unresolvedDetail !== undefined && result.unresolvedDetail === undefined ? { ...result, unresolvedDetail } : result;
   for (;; ) {
     if (cycle.findings.length === 0 && cycle.verdict === undefined) {
       return { iterations: cycle.iterations, finalFindings: [], exitReason: "resolved", costUsd: totalCostUsd };
     }
-    const active = selectActiveStrategies(cycle.strategies, cycle.findings, cycle.verdict);
+    const selectable = cycle.strategies.filter((s) => !spentStrategies.has(s.name));
+    const active = selectActiveStrategies(selectable, cycle.findings, cycle.verdict);
     if (active.length === 0) {
       const orphanSources = [...new Set(cycle.findings.map((f) => f.source))];
       logger?.warn("findings.cycle", "cycle exited \u2014 no matching strategy (orphaned findings)", {
@@ -41508,14 +41649,15 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         cycleName,
         reason: "no-strategy",
         findingsCount: cycle.findings.length,
-        orphanSources
+        orphanSources,
+        ...spentStrategies.size > 0 ? { retiredStrategies: [...spentStrategies] } : {}
       });
-      return {
+      return finish({
         iterations: cycle.iterations,
         finalFindings: cycle.findings,
         exitReason: "no-strategy",
         costUsd: totalCostUsd
-      };
+      });
     }
     const uncappedActive = active.filter((s) => countStrategyAttempts(cycle.iterations, s.name) < s.maxAttempts);
     if (uncappedActive.length === 0) {
@@ -41527,13 +41669,13 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         reason: "max-attempts-per-strategy",
         exhaustedStrategy: exhaustedStrategy?.name
       });
-      return {
+      return finish({
         iterations: cycle.iterations,
         finalFindings: cycle.findings,
         exitReason: "max-attempts-per-strategy",
         exhaustedStrategy: exhaustedStrategy?.name,
         costUsd: totalCostUsd
-      };
+      });
     }
     const totalAttempts = countTotalAttempts(cycle.iterations);
     if (totalAttempts >= cycle.config.maxAttemptsTotal) {
@@ -41545,12 +41687,12 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         totalAttempts,
         maxAttemptsTotal: cycle.config.maxAttemptsTotal
       });
-      return {
+      return finish({
         iterations: cycle.iterations,
         finalFindings: cycle.findings,
         exitReason: "max-attempts-total",
         costUsd: totalCostUsd
-      };
+      });
     }
     for (const strategy of uncappedActive) {
       const bailReason = strategy.bailWhen?.(cycle.iterations) ?? null;
@@ -41563,13 +41705,13 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
           strategyName: strategy.name,
           bailDetail: bailReason
         });
-        return {
+        return finish({
           iterations: cycle.iterations,
           finalFindings: cycle.findings,
           exitReason: "bail-when",
           bailDetail: bailReason,
           costUsd: totalCostUsd
-        };
+        });
       }
     }
     const group = selectExecutionGroup(uncappedActive);
@@ -41590,33 +41732,49 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         costUsd: extracted.costUsd
       });
     }
-    const unresolvedFa = fixesApplied.find((fa) => fa.unresolved);
-    if (unresolvedFa) {
-      const finishedAt2 = now();
-      cycle.iterations.push({
-        iterationNum: cycle.iterations.length + 1,
-        findingsBefore,
-        fixesApplied,
-        findingsAfter: cycle.findings,
-        outcome: "unchanged",
-        startedAt,
-        finishedAt: finishedAt2
-      });
-      logger?.info("findings.cycle", "cycle exited \u2014 agent gave up", {
+    const unresolvedFas = fixesApplied.filter((fa) => fa.unresolved);
+    if (unresolvedFas.length > 0) {
+      const firstUnresolved = unresolvedFas[0];
+      unresolvedDetail = firstUnresolved.unresolved;
+      for (const fa of unresolvedFas)
+        spentStrategies.add(fa.strategyName);
+      const allGaveUp = unresolvedFas.length === fixesApplied.length;
+      if (allGaveUp) {
+        const finishedAt2 = now();
+        cycle.iterations.push({
+          iterationNum: cycle.iterations.length + 1,
+          findingsBefore,
+          fixesApplied,
+          findingsAfter: cycle.findings,
+          outcome: "unchanged",
+          startedAt,
+          finishedAt: finishedAt2
+        });
+        totalCostUsd += fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
+        logger?.info("findings.cycle", "cycle exited \u2014 agent gave up", {
+          storyId,
+          packageDir,
+          cycleName,
+          reason: "agent-gave-up",
+          strategyName: firstUnresolved.strategyName,
+          unresolvedDetail: firstUnresolved.unresolved
+        });
+        return finish({
+          iterations: cycle.iterations,
+          finalFindings: cycle.findings,
+          exitReason: "agent-gave-up",
+          unresolvedDetail: firstUnresolved.unresolved,
+          costUsd: totalCostUsd
+        });
+      }
+      logger?.info("findings.cycle", "strategy gave up \u2014 retired, continuing with co-run siblings", {
         storyId,
         packageDir,
         cycleName,
-        reason: "agent-gave-up",
-        strategyName: unresolvedFa.strategyName,
-        unresolvedDetail: unresolvedFa.unresolved
+        strategyName: firstUnresolved.strategyName,
+        unresolvedDetail: firstUnresolved.unresolved,
+        ranWithoutGivingUp: fixesApplied.filter((fa) => !fa.unresolved).map((fa) => fa.strategyName)
       });
-      return {
-        iterations: cycle.iterations,
-        finalFindings: cycle.findings,
-        exitReason: "agent-gave-up",
-        unresolvedDetail: unresolvedFa.unresolved,
-        costUsd: totalCostUsd
-      };
     }
     const allExhausted = group.every((s) => {
       const prior = countStrategyAttempts(cycle.iterations, s.name);
@@ -41624,6 +41782,7 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
       return prior + current >= s.maxAttempts;
     });
     if (allExhausted) {
+      totalCostUsd += fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
       let liteFindingsAfter;
       let liteShortCircuited = false;
       try {
@@ -41648,13 +41807,13 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
           cycleName,
           error: errorMessage(err)
         });
-        return {
+        return finish({
           iterations: cycle.iterations,
           finalFindings: cycle.findings,
           exitReason: "max-attempts-per-strategy",
           exhaustedStrategy: group[0]?.name,
           costUsd: totalCostUsd
-        };
+        });
       }
       const outcome2 = classifyOutcome(findingsBefore, liteFindingsAfter);
       const finishedAt2 = now();
@@ -41675,18 +41834,16 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
           cycleName,
           reason: "resolved"
         });
-        return {
+        return finish({
           iterations: cycle.iterations,
           finalFindings: [],
           exitReason: "resolved",
           costUsd: totalCostUsd
-        };
+        });
       }
       if (liteShortCircuited) {
         const companions = uncappedActive.filter((s) => !group.includes(s));
         if (companions.length > 0) {
-          const iterCostUsd = fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
-          totalCostUsd += iterCostUsd;
           logger?.info("findings.cycle", "exclusive strategy exhausted \u2014 continuing to companion strategies", {
             storyId,
             packageDir,
@@ -41703,12 +41860,12 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
           reason: "validate-short-circuit",
           liteFindingsAfterCount: liteFindingsAfter.length
         });
-        return {
+        return finish({
           iterations: cycle.iterations,
           finalFindings: liteFindingsAfter,
           exitReason: "validate-short-circuit",
           costUsd: totalCostUsd
-        };
+        });
       }
       logger?.info("findings.cycle", "cycle exited \u2014 strategy attempt cap reached (lite validate)", {
         storyId,
@@ -41718,13 +41875,13 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
         exhaustedStrategy: group[0]?.name,
         liteFindingsAfterCount: liteFindingsAfter.length
       });
-      return {
+      return finish({
         iterations: cycle.iterations,
         finalFindings: liteFindingsAfter,
         exitReason: "max-attempts-per-strategy",
         exhaustedStrategy: group[0]?.name,
         costUsd: totalCostUsd
-      };
+      });
     }
     let findingsAfter;
     let validatorAttempt = 0;
@@ -41742,12 +41899,12 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
             reason: "validator-error",
             error: errorMessage(err)
           });
-          return {
+          return finish({
             iterations: cycle.iterations,
             finalFindings: cycle.findings,
             exitReason: "validator-error",
             costUsd: totalCostUsd
-          };
+          });
         }
         logger?.warn("findings.cycle", "validator retry", {
           storyId,
@@ -42084,11 +42241,9 @@ function buildMeta(f, originalSeverity) {
 function findingCategory(f) {
   return "category" in f && f.category ? f.category : undefined;
 }
-function deriveFixTargetForReviewFinding(category, source) {
-  if (source === "semantic-review" || source === "semantic-debate-review") {
-    return "source";
-  }
-  return categoryToFixTarget(category);
+function deriveFixTargetForReviewFinding(category, source, file3, isTestFile3) {
+  const base = source === "semantic-review" || source === "semantic-debate-review" ? "source" : categoryToFixTarget(category);
+  return resolveFixTarget({ base, file: file3, isTestFile: isTestFile3 });
 }
 function llmFindingToReviewFinding(f, opts = {}) {
   const category = findingCategory(f);
@@ -42105,7 +42260,7 @@ function llmFindingToReviewFinding(f, opts = {}) {
     result.category = category;
   if (source)
     result.source = source;
-  result.fixTarget = deriveFixTargetForReviewFinding(category, source);
+  result.fixTarget = deriveFixTargetForReviewFinding(category, source, f.file, opts.isTestFile);
   const meta3 = buildMeta(f, f.severity !== narrowed ? f.severity : undefined);
   if (meta3)
     result.meta = meta3;
@@ -42275,7 +42430,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.74.0",
+    version: "0.75.0",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -42378,8 +42533,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("91bb7306"))
-        return "91bb7306";
+      if (/^[0-9a-f]{6,10}$/.test("05b2a123"))
+        return "05b2a123";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -42785,12 +42940,12 @@ async function runAdversarialReview(opts) {
   } = classifyRecurrence(allFindings, priorAdversarialIterations ?? [], recurrenceCfg, testFileMatch, threshold);
   const advisoryFindings = [...advisoryOnly, ...demoted];
   const advisoryReviewFindings = [
-    ...llmFindingsToReviewFindings(advisoryOnly, { source: "adversarial-review" }),
-    ...tagCoverageGap(llmFindingsToReviewFindings(demoted, { source: "adversarial-review" }))
+    ...llmFindingsToReviewFindings(advisoryOnly, { source: "adversarial-review", isTestFile: testFileMatch }),
+    ...tagCoverageGap(llmFindingsToReviewFindings(demoted, { source: "adversarial-review", isTestFile: testFileMatch }))
   ];
   const advisoryFindingsAsFindings = [
-    ...toAdversarialReviewFindings(advisoryOnly),
-    ...tagCoverageGap(toAdversarialReviewFindings(demoted))
+    ...toAdversarialReviewFindings(advisoryOnly, { isTestFile: testFileMatch }),
+    ...tagCoverageGap(toAdversarialReviewFindings(demoted, { isTestFile: testFileMatch }))
   ];
   const acDropped = opResult.acDropped ?? [];
   let diffFiles;
@@ -42870,7 +43025,7 @@ async function runAdversarialReview(opts) {
       blockingThreshold: threshold,
       result: {
         passed: false,
-        findings: llmFindingsToReviewFindings(allFindings, { source: "adversarial-review" })
+        findings: llmFindingsToReviewFindings(allFindings, { source: "adversarial-review", isTestFile: testFileMatch })
       },
       advisoryFindings: advisoryFindings.length > 0 ? advisoryReviewFindings : undefined,
       diffAvailable,
@@ -42887,7 +43042,7 @@ ${formatFindings(blockingFindings)}` : "Adversarial review failed (no findings)"
       exitCode: 1,
       output,
       durationMs,
-      findings: blockingFindings.length > 0 ? toAdversarialReviewFindings(blockingFindings) : undefined,
+      findings: blockingFindings.length > 0 ? toAdversarialReviewFindings(blockingFindings, { isTestFile: testFileMatch }) : undefined,
       advisoryFindings: advisoryFindings.length > 0 ? advisoryFindingsAsFindings : undefined,
       cost: llmCost
     };
@@ -42895,7 +43050,7 @@ ${formatFindings(blockingFindings)}` : "Adversarial review failed (no findings)"
   if (!opResult.passed && acDropped.length > 0) {
     const allHallucinated = acDropped.every((d) => d.code === "ac_quote_not_substring");
     if (allHallucinated) {
-      const demotedFindings = toAdversarialReviewFindings(acDropped.map((d) => ({ ...d.finding, severity: "warning", acQuote: undefined, acIndex: undefined })));
+      const demotedFindings = toAdversarialReviewFindings(acDropped.map((d) => ({ ...d.finding, severity: "warning", acQuote: undefined, acIndex: undefined })), { isTestFile: testFileMatch });
       const existingAdvisory = advisoryFindings.length > 0 ? advisoryFindingsAsFindings : [];
       const allAdvisory = [...existingAdvisory, ...demotedFindings];
       logger?.warn("review", "Adversarial review passed: all blocking findings discarded as hallucinated AC quotes", {
@@ -42983,7 +43138,7 @@ ${dropSummary}`,
     blockingThreshold: threshold,
     result: {
       passed: true,
-      findings: llmFindingsToReviewFindings(allFindings, { source: "adversarial-review" })
+      findings: llmFindingsToReviewFindings(allFindings, { source: "adversarial-review", isTestFile: testFileMatch })
     },
     advisoryFindings: advisoryFindings.length > 0 ? advisoryReviewFindings : undefined,
     diffAvailable,
@@ -43488,7 +43643,8 @@ async function runSemanticDebate(opts) {
     prompt,
     productionExcludePatterns,
     blockingThreshold,
-    createDebateRunner
+    createDebateRunner,
+    isTestFile: isTestFile3
   } = opts;
   const logger = getSafeLogger();
   const configuredStageConfig = naxConfig.debate?.stages.review;
@@ -43564,9 +43720,9 @@ async function runSemanticDebate(opts) {
         blockingThreshold: debateThreshold,
         result: {
           passed: false,
-          findings: llmFindingsToReviewFindings(debateFindings, { source: "semantic-debate-review" })
+          findings: llmFindingsToReviewFindings(debateFindings, { source: "semantic-debate-review", isTestFile: isTestFile3 })
         },
-        advisoryFindings: debateAdvisory.length > 0 ? llmFindingsToReviewFindings(debateAdvisory, { source: "semantic-debate-review" }) : undefined
+        advisoryFindings: debateAdvisory.length > 0 ? llmFindingsToReviewFindings(debateAdvisory, { source: "semantic-debate-review", isTestFile: isTestFile3 }) : undefined
       });
       return {
         check: "semantic",
@@ -43577,8 +43733,8 @@ async function runSemanticDebate(opts) {
 
 ${formatFindings2(debateBlocking)}`,
         durationMs,
-        findings: toReviewFindings(debateBlocking),
-        advisoryFindings: debateAdvisory.length > 0 ? toReviewFindings(debateAdvisory) : undefined,
+        findings: toReviewFindings(debateBlocking, { isTestFile: isTestFile3 }),
+        advisoryFindings: debateAdvisory.length > 0 ? toReviewFindings(debateAdvisory, { isTestFile: isTestFile3 }) : undefined,
         cost: debateCost
       };
     }
@@ -43596,9 +43752,9 @@ ${formatFindings2(debateBlocking)}`,
       blockingThreshold: debateThreshold,
       result: {
         passed: true,
-        findings: llmFindingsToReviewFindings(debateFindings, { source: "semantic-debate-review" })
+        findings: llmFindingsToReviewFindings(debateFindings, { source: "semantic-debate-review", isTestFile: isTestFile3 })
       },
-      advisoryFindings: debateAdvisory.length > 0 ? llmFindingsToReviewFindings(debateAdvisory, { source: "semantic-debate-review" }) : undefined
+      advisoryFindings: debateAdvisory.length > 0 ? llmFindingsToReviewFindings(debateAdvisory, { source: "semantic-debate-review", isTestFile: isTestFile3 }) : undefined
     });
     return {
       check: "semantic",
@@ -43607,7 +43763,7 @@ ${formatFindings2(debateBlocking)}`,
       exitCode: 0,
       output: "Semantic review passed (debate, all findings were advisory \u2014 below blocking threshold)",
       durationMs,
-      advisoryFindings: debateAdvisory.length > 0 ? toReviewFindings(debateAdvisory) : undefined,
+      advisoryFindings: debateAdvisory.length > 0 ? toReviewFindings(debateAdvisory, { isTestFile: isTestFile3 }) : undefined,
       cost: debateCost
     };
   }
@@ -43622,9 +43778,9 @@ ${formatFindings2(debateBlocking)}`,
     blockingThreshold: debateThreshold,
     result: {
       passed: true,
-      findings: llmFindingsToReviewFindings(debateFindings, { source: "semantic-debate-review" })
+      findings: llmFindingsToReviewFindings(debateFindings, { source: "semantic-debate-review", isTestFile: isTestFile3 })
     },
-    advisoryFindings: debateAdvisory.length > 0 ? llmFindingsToReviewFindings(debateAdvisory, { source: "semantic-debate-review" }) : undefined
+    advisoryFindings: debateAdvisory.length > 0 ? llmFindingsToReviewFindings(debateAdvisory, { source: "semantic-debate-review", isTestFile: isTestFile3 }) : undefined
   });
   return {
     check: "semantic",
@@ -43633,7 +43789,7 @@ ${formatFindings2(debateBlocking)}`,
     exitCode: 0,
     output: "Semantic review passed",
     durationMs,
-    advisoryFindings: debateAdvisory.length > 0 ? toReviewFindings(debateAdvisory) : undefined,
+    advisoryFindings: debateAdvisory.length > 0 ? toReviewFindings(debateAdvisory, { isTestFile: isTestFile3 }) : undefined,
     cost: debateCost
   };
 }
@@ -43679,10 +43835,13 @@ async function runSemanticReview(opts) {
     contextBundle,
     projectDir,
     naxIgnoreIndex,
-    runtime
+    runtime,
+    resolvedTestPatterns
   } = opts;
   const startTime = Date.now();
   const logger = getSafeLogger();
+  const testFilePatterns = resolvedTestPatterns?.regex ?? [];
+  const testFileMatch = (file3) => testFilePatterns.some((re) => re.test(file3));
   if (featureName === undefined) {
     logger?.debug("semantic", "featureName missing \u2014 semantic session name will not include feature", {
       storyId: story.id
@@ -43815,6 +43974,7 @@ async function runSemanticReview(opts) {
       prompt,
       productionExcludePatterns: excludePatterns,
       blockingThreshold,
+      isTestFile: testFileMatch,
       createDebateRunner: _semanticDeps.createDebateRunner
     });
   }
@@ -43974,9 +44134,9 @@ ${formatFindings2(blockingFindings)}`;
       blockingThreshold: threshold,
       result: {
         passed: false,
-        findings: llmFindingsToReviewFindings(allFindings, { source: "semantic-review" })
+        findings: llmFindingsToReviewFindings(allFindings, { source: "semantic-review", isTestFile: testFileMatch })
       },
-      advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review" }) : undefined
+      advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review", isTestFile: testFileMatch }) : undefined
     });
     return {
       check: "semantic",
@@ -43985,8 +44145,8 @@ ${formatFindings2(blockingFindings)}`;
       exitCode: 1,
       output,
       durationMs,
-      findings: toReviewFindings(blockingFindings),
-      advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings) : undefined,
+      findings: toReviewFindings(blockingFindings, { isTestFile: testFileMatch }),
+      advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings, { isTestFile: testFileMatch }) : undefined,
       cost: llmCost
     };
   }
@@ -44006,7 +44166,7 @@ ${formatFindings2(blockingFindings)}`;
       passed: false,
       blockingThreshold: threshold,
       result: { passed: false, findings: [] },
-      advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review" }) : undefined
+      advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review", isTestFile: testFileMatch }) : undefined
     });
     return {
       check: "semantic",
@@ -44015,7 +44175,7 @@ ${formatFindings2(blockingFindings)}`;
       exitCode: 1,
       output: 'Semantic review failed: blocking finding(s) were dropped \u2014 acIndex was missing or out of range. The model emitted "passed: false" without valid AC attribution.',
       durationMs,
-      advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings) : undefined,
+      advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings, { isTestFile: testFileMatch }) : undefined,
       cost: llmCost
     };
   }
@@ -44032,9 +44192,9 @@ ${formatFindings2(blockingFindings)}`;
     blockingThreshold: threshold,
     result: {
       passed: true,
-      findings: llmFindingsToReviewFindings(allFindings, { source: "semantic-review" })
+      findings: llmFindingsToReviewFindings(allFindings, { source: "semantic-review", isTestFile: testFileMatch })
     },
-    advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review" }) : undefined
+    advisoryFindings: advisoryFindings.length > 0 ? llmFindingsToReviewFindings(advisoryFindings, { source: "semantic-review", isTestFile: testFileMatch }) : undefined
   });
   return {
     check: "semantic",
@@ -44043,7 +44203,7 @@ ${formatFindings2(blockingFindings)}`;
     exitCode: 0,
     output: allFindings.length === 0 ? "Semantic review passed" : "Semantic review passed (all findings were advisory \u2014 below blocking threshold)",
     durationMs,
-    advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings) : undefined,
+    advisoryFindings: advisoryFindings.length > 0 ? toReviewFindings(advisoryFindings, { isTestFile: testFileMatch }) : undefined,
     cost: llmCost
   };
 }
@@ -45339,6 +45499,43 @@ var init_rectifier_builder = __esm(() => {
   ];
 });
 
+// src/prompts/builders/timeout-retry-builder.ts
+function formatDuration2(ms) {
+  const totalSeconds = Math.max(0, Math.round(ms / 1000));
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (minutes === 0)
+    return `${seconds}s`;
+  return `${minutes}m ${seconds}s`;
+}
+function timeoutRetry(input) {
+  const { prompt, changedFiles, elapsedMs, attempt } = input;
+  const duration3 = formatDuration2(elapsedMs);
+  const attemptNumber = attempt + 1;
+  if (changedFiles.length === 0) {
+    return `The previous attempt hit a timeout after ${elapsedMs}ms (${duration3}) with no file changes on disk.
+This is attempt ${attemptNumber} of the same story \u2014 the previous attempt left nothing behind, so the approach was wrong.
+Change your approach: pick a narrower scope, fewer file edits, or a different angle on the acceptance criteria.
+
+---
+
+${prompt}`;
+  }
+  const fileList = changedFiles.map((p) => `- ${p}`).join(`
+`);
+  return `The previous attempt hit a timeout after ${elapsedMs}ms (${duration3}), but left these files on disk:
+
+${fileList}
+
+This is attempt ${attemptNumber} of the same story \u2014 continue from the existing state above.
+Read the files listed, pick up where the previous attempt stopped, and finish the story.
+Do NOT delete or revert the existing work; treat the working tree as the starting point.
+
+---
+
+${prompt}`;
+}
+
 // src/prompts/builders/one-shot-builder.ts
 class OneShotPromptBuilder {
   acc = new SectionAccumulator;
@@ -45501,7 +45698,7 @@ No acceptance criterion may use a deprecated verification tag (\`[grep]\`, \`[fi
 Review the draft with a strict self-audit mindset. Re-read the codebase context and compare the PRD against it. Focus only on the issues below, then rewrite the PRD if needed.
 
 #### spec-ac-preservation
-Enumerate every acceptance criterion the spec states. Confirm each one appears in some story's acceptanceCriteria \u2014 never drop a spec AC during this audit. If an AC looks unsupported by the current codebase, keep it: the story may be adding that capability. Any AC the spec tags \`[verbatim]\` MUST appear character-for-character in an acceptanceCriteria entry \u2014 preserve every backtick-quoted command, file path, regex, and count exactly. If a \`[verbatim]\` AC is missing or altered, restore it verbatim.
+Enumerate every acceptance criterion the spec states. Confirm each one appears in some story's acceptanceCriteria \u2014 never drop a spec AC during this audit. If an AC looks unsupported by the current codebase, keep it: the story may be adding that capability. An AC carrying a deprecated \`[grep]\`/\`[file]\`/\`[verbatim]\` tag is a file-content check, not a runtime behaviour \u2014 rewrite it as the behaviour it was meant to prove and drop the tag; that rewrite is required, not a dropped AC.
 
 #### ac-testable
 For each acceptance criterion, ask whether the assertion is observable through a return value, exception, log output, file content, or state change. If any AC is not directly testable, rewrite it so it is observable.
@@ -45553,23 +45750,6 @@ For each one:
 - Remove any shell-command patterns (\`grep -\`, \`wc\`, pipe \`|\` inside backticks). Express the same invariant as an assertion on the runtime value.
 - Do not remove or weaken acceptance criteria that are already correct.
 
-Write the corrected PRD to this file path: ${outputFilePath}
-Do not output the PRD in chat. After writing the file, reply with a brief text confirmation only.`;
-  }
-  buildVerbatimRepair(missingAcs, outputFilePath) {
-    const list = missingAcs.map((ac) => `- ${ac}`).join(`
-`);
-    return `Your revised PRD dropped or altered acceptance criteria the spec marked \`[verbatim]\`. These are load-bearing executable checks (greps, file-existence checks, regex/count assertions, or architectural invariants) and MUST survive character-for-character \u2014 paraphrasing destroys the verification mechanism.
-
-The following \`[verbatim]\` spec acceptance criteria are missing or altered in the PRD:
-
-${list}
-
-For each one:
-- Add it to the \`acceptanceCriteria\` array of the single most relevant user story.
-- Preserve every backtick-quoted command, file path, regex, and count exactly as written in the spec. Do not paraphrase, retag, split, or move them into a description.
-- Do not remove or weaken any acceptance criteria that are already correct.
-
 Write the corrected PRD to this file path: ${outputFilePath}
 Do not output the PRD in chat. After writing the file, reply with a brief text confirmation only.`;
   }
@@ -46310,10 +46490,17 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
     hopBodyInput
   } = ctx;
   const stage = pipelineStage ?? "run";
+  let preAttemptGitRefPromise;
+  let priorHopStartedAt;
   return async (agentName, hopBundle, hopKind, resolvedRunOptions) => {
     const logger = getLogger();
     let workingBundle = hopBundle;
     let prompt = resolvedRunOptions.prompt;
+    const elapsedSincePriorHop = priorHopStartedAt ? Date.now() - priorHopStartedAt : 0;
+    priorHopStartedAt = Date.now();
+    if (hopKind.kind === "primary" && !preAttemptGitRefPromise) {
+      preAttemptGitRefPromise = _buildHopCallbackDeps.captureGitRef(workdir);
+    }
     if (hopKind.kind === "swap" && hopBundle) {
       workingBundle = _buildHopCallbackDeps.rebuildForAgent(hopBundle, agentName, hopKind.failure, story.id);
       if (projectDir && featureName && workingBundle.manifest.rebuildInfo) {
@@ -46342,6 +46529,17 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
     if (hopKind.kind === "swap" && sessionId) {
       sessionManager.handoff?.(sessionId, agentName, hopKind.failure.outcome);
     }
+    if (hopKind.kind === "timeout-retry") {
+      const preAttemptGitRef = preAttemptGitRefPromise ? await preAttemptGitRefPromise : undefined;
+      const changedFiles = preAttemptGitRef ? await _buildHopCallbackDeps.captureWorkingTreeChanges(workdir, preAttemptGitRef) : [];
+      const elapsedMs = elapsedSincePriorHop;
+      prompt = _buildHopCallbackDeps.timeoutRetry({
+        prompt: resolvedRunOptions.prompt,
+        changedFiles,
+        elapsedMs,
+        attempt: hopKind.attempt
+      });
+    }
     const contextToolRuntime = workingBundle ? _buildHopCallbackDeps.createContextToolRuntime({
       bundle: workingBundle,
       story,
@@ -46400,6 +46598,7 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
         signal: resolvedRunOptions.abortSignal
       });
     }
+    let timedOut = false;
     try {
       const send = (turnPrompt) => agentManager.runAsSession(agentName, handle, turnPrompt, {
         storyId: story.id,
@@ -46417,9 +46616,12 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
         ...maxInteractionTurns !== undefined ? { maxTurns: maxInteractionTurns } : {}
       });
       const turnResult = hopBody ? await hopBody(prompt, { send, input: hopBodyInput }) : await send(prompt);
+      if (turnResult.timedOut)
+        timedOut = true;
       return { result: turnResultToAgentResult(turnResult), bundle: workingBundle, prompt };
     } catch (err) {
       const sessionFailure = err instanceof SessionFailureError ? err.adapterFailure : undefined;
+      timedOut = sessionFailure?.outcome === "fail-timeout";
       const turnError = err instanceof SessionTurnError ? err : undefined;
       const errMessage = err instanceof Error ? err.message : String(err);
       return {
@@ -46441,7 +46643,7 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
         prompt
       };
     } finally {
-      if (hopKind.kind !== "stale-retry" && !resolvedRunOptions.keepOpen) {
+      if (hopKind.kind !== "stale-retry" && (!resolvedRunOptions.keepOpen || timedOut)) {
         await sessionManager.closeSession(handle);
       }
     }
@@ -46456,10 +46658,14 @@ var init_build_hop_callback = __esm(() => {
   init_manifest_store();
   init_logger2();
   init_prompts();
+  init_git();
   _buildHopCallbackDeps = {
     rebuildForAgent: (prior, newAgentId, failure, storyId) => new ContextOrchestrator([]).rebuildForAgent(prior, { newAgentId, failure, storyId }),
     writeRebuildManifest,
-    createContextToolRuntime
+    createContextToolRuntime,
+    captureGitRef,
+    captureWorkingTreeChanges,
+    timeoutRetry: (input) => timeoutRetry(input)
   };
 });
 
@@ -46664,17 +46870,10 @@ async function callOp(ctx, op, input) {
         effective = { ...turn, output: fileContent };
       }
     }
-    if (!effective.output?.trim() && !effective.adapterFailure) {
-      return {
-        ...effective,
-        adapterFailure: {
-          outcome: "fail-stale",
-          category: "availability",
-          retriable: true,
-          message: `[${op.name}] agent returned no output`,
-          reason: "empty-output"
-        }
-      };
+    if (!effective.output?.trim()) {
+      const failure = classifyEmptyOutputFailure(effective);
+      if (failure)
+        return { ...effective, adapterFailure: failure };
     }
     return effective;
   };
@@ -52249,11 +52448,142 @@ var init_cli = __esm(() => {
   CLIConfigSchema = exports_external.object({}).passthrough();
 });
 
+// src/interaction/plugins/telegram-format.ts
+function buildHeader(request) {
+  const emoji3 = getStageEmoji(request.stage);
+  let text = `${emoji3} *${request.stage.toUpperCase()}*
+`;
+  text += `*Feature:* ${request.featureName}
+`;
+  if (request.storyId) {
+    text += `*Story:* ${request.storyId}
+`;
+  }
+  text += `
+`;
+  return text;
+}
+function buildBody(request) {
+  let text = `${sanitizeMarkdown(request.summary)}
+`;
+  if (request.detail) {
+    text += `
+${sanitizeMarkdown(request.detail)}
+`;
+  }
+  if (request.options && request.options.length > 0) {
+    text += `
+*Options:*
+`;
+    for (const opt of request.options) {
+      const desc = opt.description ? ` - ${sanitizeMarkdown(opt.description)}` : "";
+      text += `  - ${opt.label}${desc}
+`;
+    }
+  }
+  if (request.timeout) {
+    const timeoutSec = Math.floor(request.timeout / 1000);
+    text += `
+\u23F1 Timeout: ${timeoutSec}s | Fallback: ${request.fallback}`;
+  }
+  return text;
+}
+function sanitizeMarkdown(text) {
+  return text.replace(/\\(?=[_*`\[])/g, "\\\\").replace(/_/g, "\\_").replace(/`/g, "\\`").replace(/\*/g, "\\*").replace(/\[/g, "\\[");
+}
+function splitText(text, maxChars) {
+  if (text.length <= maxChars)
+    return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > maxChars) {
+    const slice = remaining.slice(0, maxChars);
+    const lastNewline = slice.lastIndexOf(`
+`);
+    if (lastNewline > maxChars * 0.5) {
+      chunks.push(remaining.slice(0, lastNewline));
+      remaining = remaining.slice(lastNewline + 1);
+    } else {
+      chunks.push(slice);
+      remaining = remaining.slice(maxChars);
+    }
+  }
+  if (remaining.length > 0)
+    chunks.push(remaining);
+  return chunks;
+}
+function buildKeyboard(request) {
+  switch (request.type) {
+    case "confirm":
+      return [
+        [
+          { text: "\u2705 Approve", callback_data: `${request.id}:approve` },
+          { text: "\u274C Reject", callback_data: `${request.id}:reject` }
+        ],
+        [
+          { text: "\u23ED Skip", callback_data: `${request.id}:skip` },
+          { text: "\uD83D\uDED1 Abort", callback_data: `${request.id}:abort` }
+        ]
+      ];
+    case "choose": {
+      if (!request.options || request.options.length === 0)
+        return null;
+      const rows = [];
+      for (const opt of request.options) {
+        rows.push([{ text: opt.label, callback_data: `${request.id}:choose:${opt.key}` }]);
+      }
+      rows.push([
+        { text: "\u23ED Skip", callback_data: `${request.id}:skip` },
+        { text: "\uD83D\uDED1 Abort", callback_data: `${request.id}:abort` }
+      ]);
+      return rows;
+    }
+    case "review":
+      return [
+        [
+          { text: "\u2705 Approve", callback_data: `${request.id}:approve` },
+          { text: "\u274C Reject", callback_data: `${request.id}:reject` }
+        ],
+        [
+          { text: "\u23ED Skip", callback_data: `${request.id}:skip` },
+          { text: "\uD83D\uDED1 Abort", callback_data: `${request.id}:abort` }
+        ]
+      ];
+    default:
+      return null;
+  }
+}
+function getStageEmoji(stage) {
+  switch (stage) {
+    case "pre-flight":
+      return "\uD83D\uDE80";
+    case "execution":
+      return "\u2699\uFE0F";
+    case "review":
+      return "\uD83D\uDD0D";
+    case "merge":
+      return "\uD83D\uDD00";
+    case "cost":
+      return "\uD83D\uDCB0";
+    default:
+      return "\uD83D\uDCCC";
+  }
+}
+var MAX_MESSAGE_CHARS = 4000;
+
 // src/interaction/plugins/telegram.ts
-var MAX_MESSAGE_CHARS = 4000, CALLBACK_API_TIMEOUT_MS = 4000, TelegramConfigSchema, TelegramInteractionPlugin;
+function normalizeChatId(raw) {
+  const chatId = raw.trim();
+  return { chatId, unmatchable: !NUMERIC_CHAT_ID.test(chatId) };
+}
+var _telegramPluginDeps, CALLBACK_API_TIMEOUT_MS = 4000, NUMERIC_CHAT_ID, TelegramConfigSchema, TelegramInteractionPlugin;
 var init_telegram = __esm(() => {
   init_zod();
   init_logger2();
+  _telegramPluginDeps = {
+    fetch: globalThis.fetch.bind(globalThis)
+  };
+  NUMERIC_CHAT_ID = /^-?\d+$/;
   TelegramConfigSchema = exports_external.object({
     botToken: exports_external.string().optional(),
     chatId: exports_external.string().optional()
@@ -52267,6 +52597,7 @@ var init_telegram = __esm(() => {
     lastUpdateId = 0;
     backoffMs = 1000;
     maxBackoffMs = 30000;
+    static MAX_DRAIN_PAGES = 10;
     static INTERACTIVE_REQUEST_TYPES = new Set([
       "confirm",
       "choose",
@@ -52276,10 +52607,29 @@ var init_telegram = __esm(() => {
     async init(config2) {
       const cfg = TelegramConfigSchema.parse(config2);
       this.botToken = cfg.botToken ?? process.env.NAX_TELEGRAM_TOKEN ?? process.env.TELEGRAM_BOT_TOKEN ?? null;
-      this.chatId = cfg.chatId ?? process.env.NAX_TELEGRAM_CHAT_ID ?? null;
+      const rawChatId = cfg.chatId ?? process.env.NAX_TELEGRAM_CHAT_ID ?? null;
+      const normalized = rawChatId === null ? null : normalizeChatId(rawChatId);
+      this.chatId = normalized?.chatId || null;
       if (!this.botToken || !this.chatId) {
         throw new Error("Telegram plugin requires botToken and chatId (env: NAX_TELEGRAM_TOKEN or TELEGRAM_BOT_TOKEN, NAX_TELEGRAM_CHAT_ID)");
       }
+      if (normalized?.unmatchable) {
+        this.logger?.warn("interaction", "Telegram chatId is not numeric \u2014 inbound updates cannot be matched, so interactive prompts will always fall back to their timeout. Use the numeric chat id (see getUpdates or @userinfobot).", { chatId: this.chatId });
+      }
+    }
+    async drainBacklog() {
+      for (let page = 0;page < TelegramInteractionPlugin.MAX_DRAIN_PAGES; page++) {
+        const result = await this.fetchUpdates();
+        if (!result.ok) {
+          this.logger?.warn("interaction", "Telegram backlog drain failed \u2014 stale updates may be misread as a response");
+          return;
+        }
+        if (result.rawCount === 0)
+          return;
+      }
+      this.logger?.warn("interaction", "Telegram backlog drain hit page cap \u2014 stale updates may remain", {
+        pages: TelegramInteractionPlugin.MAX_DRAIN_PAGES
+      });
     }
     async destroy() {
       this.pendingMessages.clear();
@@ -52288,10 +52638,13 @@ var init_telegram = __esm(() => {
       if (!this.botToken || !this.chatId) {
         throw new Error("Telegram plugin not initialized");
       }
-      const header = this.buildHeader(request);
-      const keyboard = this.buildKeyboard(request);
-      const body = this.buildBody(request);
-      const chunks = this.splitText(body, MAX_MESSAGE_CHARS - header.length - 10);
+      if (TelegramInteractionPlugin.INTERACTIVE_REQUEST_TYPES.has(request.type)) {
+        await this.drainBacklog();
+      }
+      const header = buildHeader(request);
+      const keyboard = buildKeyboard(request);
+      const body = buildBody(request);
+      const chunks = splitText(body, MAX_MESSAGE_CHARS - header.length - 10);
       try {
         const sentIds = [];
         for (let i = 0;i < chunks.length; i++) {
@@ -52299,7 +52652,7 @@ var init_telegram = __esm(() => {
           const partLabel = chunks.length > 1 ? `[${i + 1}/${chunks.length}] ` : "";
           const text = `${header}
 ${partLabel}${chunks[i]}`;
-          const response = await fetch(`https://api.telegram.org/bot${this.botToken}/sendMessage`, {
+          const response = await _telegramPluginDeps.fetch(`https://api.telegram.org/bot${this.botToken}/sendMessage`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
@@ -52320,7 +52673,7 @@ ${partLabel}${chunks[i]}`;
           sentIds.push(data.result.message_id);
         }
         if (TelegramInteractionPlugin.INTERACTIVE_REQUEST_TYPES.has(request.type)) {
-          this.pendingMessages.set(request.id, sentIds);
+          this.pendingMessages.set(request.id, { type: request.type, ids: sentIds });
         }
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -52380,140 +52733,25 @@ ${partLabel}${chunks[i]}`;
       await this.sendTimeoutMessage(requestId);
       this.pendingMessages.delete(requestId);
     }
-    buildHeader(request) {
-      const emoji3 = this.getStageEmoji(request.stage);
-      let text = `${emoji3} *${request.stage.toUpperCase()}*
-`;
-      text += `*Feature:* ${request.featureName}
-`;
-      if (request.storyId) {
-        text += `*Story:* ${request.storyId}
-`;
-      }
-      text += `
-`;
-      return text;
-    }
-    buildBody(request) {
-      let text = `${this.sanitizeMarkdown(request.summary)}
-`;
-      if (request.detail) {
-        text += `
-${this.sanitizeMarkdown(request.detail)}
-`;
-      }
-      if (request.options && request.options.length > 0) {
-        text += `
-*Options:*
-`;
-        for (const opt of request.options) {
-          const desc = opt.description ? ` - ${this.sanitizeMarkdown(opt.description)}` : "";
-          text += `  - ${opt.label}${desc}
-`;
-        }
-      }
-      if (request.timeout) {
-        const timeoutSec = Math.floor(request.timeout / 1000);
-        text += `
-\u23F1 Timeout: ${timeoutSec}s | Fallback: ${request.fallback}`;
-      }
-      return text;
-    }
-    sanitizeMarkdown(text) {
-      return text.replace(/\\(?=[_*`\[])/g, "\\\\").replace(/_/g, "\\_").replace(/`/g, "\\`").replace(/\*/g, "\\*").replace(/\[/g, "\\[");
-    }
-    splitText(text, maxChars) {
-      if (text.length <= maxChars)
-        return [text];
-      const chunks = [];
-      let remaining = text;
-      while (remaining.length > maxChars) {
-        const slice = remaining.slice(0, maxChars);
-        const lastNewline = slice.lastIndexOf(`
-`);
-        if (lastNewline > maxChars * 0.5) {
-          chunks.push(remaining.slice(0, lastNewline));
-          remaining = remaining.slice(lastNewline + 1);
-        } else {
-          chunks.push(slice);
-          remaining = remaining.slice(maxChars);
-        }
-      }
-      if (remaining.length > 0)
-        chunks.push(remaining);
-      return chunks;
-    }
-    buildKeyboard(request) {
-      switch (request.type) {
-        case "confirm":
-          return [
-            [
-              { text: "\u2705 Approve", callback_data: `${request.id}:approve` },
-              { text: "\u274C Reject", callback_data: `${request.id}:reject` }
-            ],
-            [
-              { text: "\u23ED Skip", callback_data: `${request.id}:skip` },
-              { text: "\uD83D\uDED1 Abort", callback_data: `${request.id}:abort` }
-            ]
-          ];
-        case "choose": {
-          if (!request.options || request.options.length === 0)
-            return null;
-          const rows = [];
-          for (const opt of request.options) {
-            rows.push([{ text: opt.label, callback_data: `${request.id}:choose:${opt.key}` }]);
-          }
-          rows.push([
-            { text: "\u23ED Skip", callback_data: `${request.id}:skip` },
-            { text: "\uD83D\uDED1 Abort", callback_data: `${request.id}:abort` }
-          ]);
-          return rows;
-        }
-        case "review":
-          return [
-            [
-              { text: "\u2705 Approve", callback_data: `${request.id}:approve` },
-              { text: "\u274C Reject", callback_data: `${request.id}:reject` }
-            ],
-            [
-              { text: "\u23ED Skip", callback_data: `${request.id}:skip` },
-              { text: "\uD83D\uDED1 Abort", callback_data: `${request.id}:abort` }
-            ]
-          ];
-        default:
-          return null;
-      }
-    }
-    getStageEmoji(stage) {
-      switch (stage) {
-        case "pre-flight":
-          return "\uD83D\uDE80";
-        case "execution":
-          return "\u2699\uFE0F";
-        case "review":
-          return "\uD83D\uDD0D";
-        case "merge":
-          return "\uD83D\uDD00";
-        case "cost":
-          return "\uD83D\uDCB0";
-        default:
-          return "\uD83D\uDCCC";
-      }
-    }
     async getUpdates() {
+      const result = await this.fetchUpdates();
+      return result.updates;
+    }
+    async fetchUpdates() {
       if (!this.botToken)
-        return [];
+        return { ok: true, updates: [], rawCount: 0 };
       try {
         const controller = new AbortController;
         const timer = setTimeout(() => controller.abort(), 8000);
         let response;
         try {
-          response = await fetch(`https://api.telegram.org/bot${this.botToken}/getUpdates`, {
+          response = await _telegramPluginDeps.fetch(`https://api.telegram.org/bot${this.botToken}/getUpdates`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
               offset: this.lastUpdateId + 1,
-              timeout: 1
+              timeout: 1,
+              limit: 100
             }),
             signal: controller.signal
           });
@@ -52528,17 +52766,31 @@ ${this.sanitizeMarkdown(request.detail)}
         if (!data.ok || !data.result) {
           throw new Error("Telegram API returned ok=false or missing result");
         }
-        const updates = data.result;
-        if (updates.length > 0) {
-          this.lastUpdateId = Math.max(...updates.map((u) => u.update_id));
+        const raw = data.result;
+        if (raw.length > 0) {
+          this.lastUpdateId = Math.max(...raw.map((u) => u.update_id));
+        }
+        const updates = raw.filter((u) => this.isFromConfiguredChat(u));
+        if (updates.length !== raw.length) {
+          this.logger?.debug("interaction", "Telegram updates rejected -- not from the configured chat", {
+            rejected: raw.length - updates.length
+          });
         }
         this.backoffMs = 1000;
-        return updates;
+        return { ok: true, updates, rawCount: raw.length };
       } catch (err) {
         this.backoffMs = Math.min(this.backoffMs * 2, this.maxBackoffMs);
-        return [];
+        this.logger?.debug("interaction", "Telegram getUpdates failed \u2014 retrying with backoff", {
+          error: err instanceof Error ? err.message : String(err),
+          backoffMs: this.backoffMs
+        });
+        return { ok: false, updates: [], rawCount: 0 };
       }
     }
+    isFromConfiguredChat(update) {
+      const chatId = update.callback_query?.message?.chat?.id ?? update.message?.chat?.id;
+      return chatId !== undefined && String(chatId) === this.chatId;
+    }
     parseUpdate(requestId, update) {
       if (update.callback_query) {
         const data = update.callback_query.data;
@@ -52558,11 +52810,11 @@ ${this.sanitizeMarkdown(request.detail)}
         };
       }
       if (update.message?.text) {
-        const messageIds = this.pendingMessages.get(requestId);
-        if (!messageIds)
+        const pending = this.pendingMessages.get(requestId);
+        if (!pending || pending.type !== "input")
           return null;
         const replyToId = update.message.reply_to_message?.message_id;
-        if (replyToId !== undefined && !messageIds.includes(replyToId))
+        if (replyToId !== undefined && !pending.ids.includes(replyToId))
           return null;
         return {
           requestId,
@@ -52581,7 +52833,7 @@ ${this.sanitizeMarkdown(request.detail)}
         const controller = new AbortController;
         const timer = setTimeout(() => controller.abort(), CALLBACK_API_TIMEOUT_MS);
         try {
-          await fetch(`https://api.telegram.org/bot${this.botToken}/answerCallbackQuery`, {
+          await _telegramPluginDeps.fetch(`https://api.telegram.org/bot${this.botToken}/answerCallbackQuery`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
@@ -52601,7 +52853,7 @@ ${this.sanitizeMarkdown(request.detail)}
         const controller = new AbortController;
         const timer = setTimeout(() => controller.abort(), CALLBACK_API_TIMEOUT_MS);
         try {
-          await fetch(`https://api.telegram.org/bot${this.botToken}/editMessageReplyMarkup`, {
+          await _telegramPluginDeps.fetch(`https://api.telegram.org/bot${this.botToken}/editMessageReplyMarkup`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
@@ -52617,14 +52869,14 @@ ${this.sanitizeMarkdown(request.detail)}
       } catch {}
     }
     async sendTimeoutMessage(requestId) {
-      const messageIds = this.pendingMessages.get(requestId);
-      if (!messageIds || !this.botToken || !this.chatId) {
+      const pending = this.pendingMessages.get(requestId);
+      if (!pending || !this.botToken || !this.chatId) {
         this.pendingMessages.delete(requestId);
         return;
       }
-      const lastId = messageIds[messageIds.length - 1];
+      const lastId = pending.ids[pending.ids.length - 1];
       try {
-        await fetch(`https://api.telegram.org/bot${this.botToken}/editMessageText`, {
+        await _telegramPluginDeps.fetch(`https://api.telegram.org/bot${this.botToken}/editMessageText`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
@@ -58708,7 +58960,8 @@ async function refreshReviewInputForDispatch(opName, input) {
         stat: fresh2.stat,
         diff: fresh2.diff,
         excludePatterns: fresh2.excludePatterns,
-        storyGitRef: fresh2.effectiveRef ?? semInput.storyGitRef
+        storyGitRef: fresh2.effectiveRef ?? semInput.storyGitRef,
+        resolvedTestPatterns: _refresh.resolvedTestPatterns
       };
     }
     const { _refresh: __, ...advInput } = input;
@@ -59755,6 +60008,7 @@ async function assemblePlanInputsFromCtx(ctx) {
       excludePatterns: prepared.excludePatterns,
       featureCtxBlock: buildFeatureCtxBlock(ctx, "reviewer-semantic"),
       priorSemanticIterations: ctx.priorSemanticIterations,
+      resolvedTestPatterns,
       blockingThreshold: ctx.config.review.blockingThreshold,
       _refresh: {
         projectDir: ctx.projectDir,
@@ -59792,6 +60046,7 @@ async function assemblePlanInputsFromCtx(ctx) {
       refExcludePatterns: prepared.refExcludePatterns,
       featureCtxBlock: buildFeatureCtxBlock(ctx, "reviewer-adversarial"),
       priorAdversarialIterations: ctx.priorAdversarialIterations,
+      resolvedTestPatterns,
       blockingThreshold: ctx.config.review.blockingThreshold,
       _refresh: {
         projectDir: ctx.projectDir,
@@ -62784,7 +63039,7 @@ var init_forge = __esm(() => {
 function buildTitle(ctx) {
   return `feat: ${ctx.feature}`;
 }
-function formatDuration2(totalMs) {
+function formatDuration3(totalMs) {
   const clampedMs = Math.max(0, Math.round(totalMs));
   const totalSeconds = Math.floor(clampedMs / MS_PER_SECOND);
   const minutes = Math.floor(totalSeconds / SECONDS_PER_MINUTE);
@@ -62800,7 +63055,7 @@ function buildSummaryLines(ctx) {
     "## Run summary",
     `- Feature: ${ctx.feature}`,
     `- Stories: ${passed} / ${failed} / ${skipped}`,
-    `- Duration: ${formatDuration2(ctx.totalDurationMs)}`,
+    `- Duration: ${formatDuration3(ctx.totalDurationMs)}`,
     `- PRD: ${ctx.prdPath}`,
     ""
   ];
@@ -62821,7 +63076,7 @@ function buildStoryTable(stories) {
   lines.push("");
   return lines;
 }
-function buildBody(ctx, template) {
+function buildBody2(ctx, template) {
   const blocks = [];
   blocks.push("> Auto-opened by nax \u2014 review pending. Run nax-finish before merge.");
   blocks.push("");
@@ -62996,7 +63251,7 @@ var init_auto_pr = __esm(() => {
         });
         const prCtx = toPrBodyContext(context);
         const title = buildTitle(prCtx);
-        const body = buildBody(prCtx, template);
+        const body = buildBody2(prCtx, template);
         return await _autoPrDeps.openDraft(forge, { title, body, branch: context.branch, draft: cfg.draft }, { run: _autoPrDeps.run, readText: _autoPrDeps.readText }, context.workdir);
       } catch (err) {
         context.logger.warn("Auto-PR execute failed", { error: String(err) });
@@ -68780,7 +69035,7 @@ function extractQuoteTriples(reason) {
   }
   return triples;
 }
-function normalizeWs3(s) {
+function normalizeWs2(s) {
   return s.replace(/\s+/g, " ").trim();
 }
 async function verifyQuoteTriple(triple, workdir, deps = _quoteIntegrityDeps) {
@@ -68794,7 +69049,7 @@ async function verifyQuoteTriple(triple, workdir, deps = _quoteIntegrityDeps) {
   const end = Math.min(lines.length, triple.line + CONTEXT_LINES);
   const window2 = lines.slice(start, end).join(`
 `);
-  return normalizeWs3(window2).toLowerCase().includes(normalizeWs3(triple.quote).toLowerCase());
+  return normalizeWs2(window2).toLowerCase().includes(normalizeWs2(triple.quote).toLowerCase());
 }
 async function verifyEscalationQuotes(reason, workdir, storyId, deps = _quoteIntegrityDeps) {
   const triples = extractQuoteTriples(reason);
@@ -69792,6 +70047,12 @@ async function executeParallelBatch(stories, _projectRoot, config2, context, wor
           error: result.error
         });
       }
+    }).catch((error48) => {
+      results.failed.push({ story, error: errorMessage(error48) });
+      logger?.error("parallel", "Story execution threw", {
+        storyId: story.id,
+        error: errorMessage(error48)
+      });
     }).finally(() => {
       executing.delete(executePromise);
     });
@@ -69800,7 +70061,7 @@ async function executeParallelBatch(stories, _projectRoot, config2, context, wor
       await Promise.race(executing);
     }
   }
-  await Promise.all(executing);
+  await Promise.allSettled(executing);
   return results;
 }
 var _parallelWorkerDeps;
@@ -102438,7 +102699,6 @@ class DebatePlanStrategy {
       });
       if (debateResult.outcome !== "failed" && debateResult.output) {
         const prd2 = validatePlanOutput(debateResult.output, ctx.options.feature, ctx.branchName);
-        warnOnDroppedVerbatimAcs(prd2, ctx.specContent, ctx.options.feature);
         const scoped2 = backfillOutOfScope(prd2, ctx.specContent, ctx.options.feature);
         const withProject2 = { ...scoped2, project: ctx.projectName };
         return _debatePlanDeps.writeOrRecoverPrd(ctx, withProject2);
@@ -103247,9 +103507,6 @@ var FIELD_DESCRIPTIONS = {
   "execution.regressionGate.timeoutSeconds": "Timeout for regression run in seconds",
   "execution.storyIsolation": 'Story isolation mode. "shared" (default): all stories run on the main branch. "worktree": each story runs in an isolated git worktree (.nax-wt/<storyId>/); passed stories merge into main, failed commits never reach main.',
   quality: "Quality gate configuration",
-  "quality.requireTypecheck": "Require typecheck to pass",
-  "quality.requireLint": "Require lint to pass",
-  "quality.requireTests": "Require tests to pass",
   "quality.commands": "Custom quality commands",
   "quality.commands.typecheck": "Custom typecheck command",
   "quality.commands.lint": "Custom lint command",
@@ -105478,7 +105735,7 @@ var DEFAULT_LIMIT = 20;
 var _runsCmdDeps = {
   getRunsDir
 };
-function formatDuration3(ms) {
+function formatDuration4(ms) {
   if (ms <= 0)
     return "-";
   const minutes = Math.floor(ms / 60000);
@@ -105593,7 +105850,7 @@ async function runsCommand(options = {}) {
       pad3(row.feature, COL.feature),
       pad3(colored, COL.status + (colored.length - visibleLength(colored))),
       pad3(`${row.passed}/${row.total}`, COL.stories),
-      pad3(formatDuration3(row.durationMs), COL.duration),
+      pad3(formatDuration4(row.durationMs), COL.duration),
       formatDate(row.registeredAt)
     ].join("  ");
     console.log(line);
@@ -112874,7 +113131,7 @@ function useAgentStreamEvents(bus) {
     if (!bus)
       return;
     const unsubscribe = bus.onAgentStream((event) => {
-      const next = new Map(activeCallsRef.current);
+      const next = activeCallsRef.current;
       switch (event.kind) {
         case "agent.call_started": {
           next.set(event.callId, {
@@ -112958,10 +113215,13 @@ function useAgentStreamEvents(bus) {
         default:
           break;
       }
-      activeCallsRef.current = next;
       dirtyRef.current = true;
     });
-    return unsubscribe;
+    return () => {
+      unsubscribe();
+      activeCallsRef.current.clear();
+      lastTokensRef.current.clear();
+    };
   }, [bus]);
   import_react31.useEffect(() => {
     const interval = setInterval(() => {