@nathapp/nax 0.82.0-canary.4 → 0.82.0-canary.5

package/dist/nax.js

@@ -23676,8 +23676,9 @@ var init_client = __esm(() => {
 });
 
 // src/agents/native/errors.ts
-function toAdapterFailure(kind) {
-  return FAILURES[kind] ?? UNKNOWN;
+function toAdapterFailure(protocolError) {
+  const base = FAILURES[protocolError.kind] ?? UNKNOWN;
+  return protocolError.retryAfter === undefined ? base : { ...base, retryAfterSeconds: protocolError.retryAfter };
 }
 var FAILURES, UNKNOWN;
 var init_errors4 = __esm(() => {
@@ -24270,6 +24271,9 @@ function turnRetryDelayMs(err, retryIndex, config2, random = Math.random, remain
   const delayMs = retryAfter !== undefined ? retryAfter * 1000 : backoffMs(retryIndex, config2.baseDelayMs, random);
   return remainingMs === undefined ? delayMs : Math.min(delayMs, remainingMs);
 }
+function turnRetryFitsBudget(delayMs, remainingMs) {
+  return remainingMs === undefined || delayMs <= remainingMs;
+}
 function abortError(signal) {
   return signal.reason ?? new DOMException("Aborted", "AbortError");
 }
@@ -24303,7 +24307,10 @@ async function retryTransportFault(firstError, deps) {
     if (deps.deadline?.expired() === true || deps.signal?.aborted === true)
       throw err;
     const fault = err;
-    const delayMs = turnRetryDelayMs(fault, retryIndex, deps.config, random, deps.deadline?.remainingMs());
+    const remainingMs = deps.deadline?.remainingMs();
+    const delayMs = turnRetryDelayMs(fault, retryIndex, deps.config, random);
+    if (!turnRetryFitsBudget(delayMs, remainingMs))
+      throw fault;
     deps.onRetry?.(retryIndex + 1, delayMs, fault);
     try {
       await abortableSleep(delayMs, sleep2, deps.signal);
@@ -24320,7 +24327,7 @@ async function retryTransportFault(firstError, deps) {
 }
 var RETRYABLE_KINDS;
 var init_turn_retry = __esm(() => {
-  RETRYABLE_KINDS = new Set(["transport", "overloaded"]);
+  RETRYABLE_KINDS = new Set(["transport", "overloaded", "rate-limit"]);
 });
 
 // src/agents/native/session/turn-loop.ts
@@ -24682,7 +24689,7 @@ class NativeAgentAdapter {
           output: "",
           tokenUsage: { inputTokens: 0, outputTokens: 0 },
           estimatedCostUsd: 0,
-          adapterFailure: toAdapterFailure(err.protocolError.kind)
+          adapterFailure: toAdapterFailure(err.protocolError)
         };
       }
       throw err;
@@ -24789,7 +24796,7 @@ class NativeAgentAdapter {
       });
       markNativeTurnOutcome(handle.id, true);
       if (isProtocolStreamError(err)) {
-        const adapterFailure = toAdapterFailure(err.protocolError.kind);
+        const adapterFailure = toAdapterFailure(err.protocolError);
         const usage = readNativeTurnFailureUsage(err);
         throw new SessionTurnError(err.protocolError.message, false, adapterFailure.retriable, usage?.tokenUsage, usage?.costUsd, undefined, adapterFailure);
       }
@@ -29606,6 +29613,100 @@ var init_idle_watchdog = __esm(() => {
   };
 });
 
+// src/agents/retry/failure-policy.ts
+function failurePolicyFor(outcome) {
+  return POLICIES[outcome];
+}
+function resolveCooldownExpiry(failure, now) {
+  const { cooldown } = failurePolicyFor(failure.outcome);
+  if (cooldown === "none")
+    return null;
+  if (cooldown === "run")
+    return "run";
+  const retryAfter = failure.retryAfterSeconds;
+  const fromProvider = retryAfter !== undefined && Number.isFinite(retryAfter) && retryAfter >= 0 ? retryAfter * 1000 : undefined;
+  return now + (fromProvider ?? cooldown.ms);
+}
+var TRANSIENT_COOLDOWN_MS = 60000, POLICIES;
+var init_failure_policy = __esm(() => {
+  POLICIES = Object.freeze({
+    "fail-auth": { sameAgentRetry: "none", swap: "immediate", cooldown: "run", terminalBackoff: false },
+    "fail-quota": { sameAgentRetry: "none", swap: "immediate", cooldown: "run", terminalBackoff: false },
+    "fail-rate-limit": {
+      sameAgentRetry: "none",
+      swap: "immediate",
+      cooldown: { ms: TRANSIENT_COOLDOWN_MS },
+      terminalBackoff: true
+    },
+    "fail-service-down": {
+      sameAgentRetry: "adapter-error",
+      swap: "immediate",
+      cooldown: { ms: TRANSIENT_COOLDOWN_MS },
+      terminalBackoff: true
+    },
+    "fail-stale": {
+      sameAgentRetry: "stale",
+      swap: "immediate",
+      cooldown: { ms: TRANSIENT_COOLDOWN_MS },
+      terminalBackoff: true
+    },
+    "fail-timeout": { sameAgentRetry: "timeout", swap: "after-retry-lane", cooldown: "none", terminalBackoff: false },
+    "fail-adapter-error": {
+      sameAgentRetry: "adapter-error",
+      swap: "quality-gated",
+      cooldown: "none",
+      terminalBackoff: false
+    },
+    "fail-quality": { sameAgentRetry: "none", swap: "quality-gated", cooldown: "none", terminalBackoff: false },
+    "fail-unknown": { sameAgentRetry: "none", swap: "quality-gated", cooldown: "none", terminalBackoff: false },
+    "fail-aborted": { sameAgentRetry: "none", swap: "never", cooldown: "none", terminalBackoff: false }
+  });
+});
+
+// src/agents/cooldown-store.ts
+class CooldownStore {
+  _now;
+  _entries = new Map;
+  constructor(_now) {
+    this._now = _now;
+  }
+  mark(agent, failure) {
+    const expiresAt = resolveCooldownExpiry(failure, this._now());
+    if (expiresAt === null)
+      return;
+    this._entries.set(agent, { failure, expiresAt });
+  }
+  isCooling(agent) {
+    return this._live(agent) !== undefined;
+  }
+  failureFor(agent) {
+    return this._live(agent)?.failure;
+  }
+  sweepTransient() {
+    for (const [agent, entry] of this._entries) {
+      if (entry.expiresAt !== "run")
+        this._entries.delete(agent);
+    }
+  }
+  clear() {
+    this._entries.clear();
+  }
+  _live(agent) {
+    const entry = this._entries.get(agent);
+    if (!entry)
+      return;
+    if (entry.expiresAt === "run")
+      return entry;
+    if (entry.expiresAt > this._now())
+      return entry;
+    this._entries.delete(agent);
+    return;
+  }
+}
+var init_cooldown_store = __esm(() => {
+  init_failure_policy();
+});
+
 // src/agents/hop-budget.ts
 function resolveStartAgent(source, primary, fallbackEnabled, storyId, logger) {
   if (!fallbackEnabled || !source.isUnavailable(primary))
@@ -29806,95 +29907,56 @@ var init_manager_dispatch = __esm(() => {
   init_session_types();
 });
 
-// src/agents/registry.ts
-function adapterFor(name) {
-  return name === NATIVE_AGENT ? new NativeAgentAdapter : new AcpAgentAdapter(name);
-}
-function buildAdapterList() {
-  return [...Array.from(_registryTestAdapters.values()), ...KNOWN_AGENT_NAMES.map(adapterFor)];
-}
-function getAllAgents() {
-  return buildAdapterList();
-}
-async function getInstalledAgents() {
-  const allAdapters = buildAdapterList();
-  const results = await Promise.all(allAdapters.map(async (agent) => ({ agent, installed: await agent.isInstalled() })));
-  return results.filter((r) => r.installed).map((r) => r.agent);
-}
-function createAgentRegistry(config2) {
-  const logger = getLogger();
-  const adapterCache = new Map;
-  const protocol = config2.agent?.protocol ?? "acp";
-  logger?.info("agents", `Agent protocol: ${protocol}`, { protocol, hasConfig: !!config2.agent });
-  function cachedAdapter(name) {
-    let adapter = adapterCache.get(name);
-    if (adapter === undefined) {
-      adapter = name === NATIVE_AGENT ? new NativeAgentAdapter : new AcpAgentAdapter(name);
-      adapterCache.set(name, adapter);
-      logger?.debug("agents", `Created ${adapter.constructor.name} for ${name}`, { name });
-    }
-    return adapter;
-  }
-  function getAgent(name) {
-    if (_registryTestAdapters.has(name))
-      return _registryTestAdapters.get(name);
-    if (!KNOWN_AGENT_NAMES.includes(name))
-      return;
-    return cachedAdapter(name);
-  }
-  async function getInstalledAgents2() {
-    const testAdapters = Array.from(_registryTestAdapters.values());
-    const adapters = KNOWN_AGENT_NAMES.map(cachedAdapter);
-    const allAdapters = [...testAdapters, ...adapters];
-    const results = await Promise.all(allAdapters.map(async (agent) => ({ agent, installed: await agent.isInstalled() })));
-    return results.filter((r) => r.installed).map((r) => r.agent);
-  }
-  async function checkAgentHealth() {
-    const testAdapters = Array.from(_registryTestAdapters.values());
-    const adapters = KNOWN_AGENT_NAMES.map(cachedAdapter);
-    const allAdapters = [...testAdapters, ...adapters];
-    return Promise.all(allAdapters.map(async (agent) => ({
-      name: agent.name,
-      displayName: agent.displayName,
-      installed: await agent.isInstalled()
-    })));
-  }
-  return { getAgent, getInstalledAgents: getInstalledAgents2, checkAgentHealth, protocol };
+// src/agents/retry/resolve-exhaustion.ts
+async function resolveExhaustion(input) {
+  const { failure, retryStrategy, retryCtx, signal, sleep: sleep2, onExhausted } = input;
+  if (signal?.aborted)
+    return "cancelled";
+  if (failure && failurePolicyFor(failure.outcome).terminalBackoff) {
+    const decision = retryStrategy.shouldRetry(failure, input.attempt, retryCtx);
+    if (decision.retry) {
+      await sleep2(decision.delayMs, signal);
+      return signal?.aborted ? "cancelled" : "retry";
+    }
+  }
+  if (input.swapWasPossible)
+    onExhausted(input.hopsSoFar);
+  return "exhausted";
+}
+var init_resolve_exhaustion = __esm(() => {
+  init_failure_policy();
+});
+
+// src/agents/manager-exhaustion.ts
+function resolveManagerExhaustion(options) {
+  return resolveExhaustion({
+    failure: options.failure,
+    attempt: options.attempt,
+    hopsSoFar: options.hopsSoFar,
+    swapWasPossible: options.swapWasPossible,
+    retryStrategy: options.retryStrategy,
+    retryCtx: {
+      site: options.site,
+      agentName: options.agent,
+      stage: options.stage,
+      storyId: options.storyId
+    },
+    signal: options.signal,
+    sleep: options.sleep,
+    onExhausted: options.onExhausted
+  });
 }
-var KNOWN_AGENT_NAMES, _registryTestAdapters;
-var init_registry2 = __esm(() => {
-  init_logger2();
-  init_adapter2();
-  init_native();
-  KNOWN_AGENT_NAMES = ["claude", "codex", "opencode", "gemini", "aider", "pi", NATIVE_AGENT];
-  _registryTestAdapters = new Map;
-});
-
-// src/agents/retry/default-strategy.ts
-var MAX_RETRIES = 3, defaultRetryStrategy;
-var init_default_strategy = __esm(() => {
-  defaultRetryStrategy = {
-    shouldRetry(failure, attempt, _ctx) {
-      if (attempt >= MAX_RETRIES)
-        return { retry: false };
-      if (failure instanceof Error)
-        return { retry: false };
-      const af = failure;
-      if (af.retriable === false)
-        return { retry: false };
-      if (af.outcome !== "fail-rate-limit" && af.outcome !== "fail-stale")
-        return { retry: false };
-      const delayMs = 2 ** (attempt + 1) * 1000;
-      return { retry: true, delayMs };
-    }
-  };
+var init_manager_exhaustion = __esm(() => {
+  init_resolve_exhaustion();
 });
 
 // src/agents/retry/hop-retry-policy.ts
 function trySameAgentRetry(result, state, deps) {
   const { staleRetryAttempts, timeoutRetryAttempts, adapterErrorRetries, currentRunOptions, tier } = state;
   const { config: config2, requestRunOptions, signal } = deps;
-  const isFailStale = result.adapterFailure?.outcome === "fail-stale";
+  const outcome = result.adapterFailure?.outcome;
+  const lane = outcome ? failurePolicyFor(outcome).sameAgentRetry : "none";
+  const isFailStale = lane === "stale";
   const maxStaleRetries = resolveIdleWatchdogSettings(config2.agent?.idleWatchdog).maxRetryAttempts;
   if (isFailStale && result.adapterFailure?.retriable && staleRetryAttempts < maxStaleRetries) {
     const newAttempts = staleRetryAttempts + 1;
@@ -29910,7 +29972,7 @@ function trySameAgentRetry(result, state, deps) {
       }
     };
   }
-  const isFailTimeout = result.adapterFailure?.outcome === "fail-timeout";
+  const isFailTimeout = lane === "timeout";
   if (isFailTimeout && result.adapterFailure?.retriable) {
     const timeoutConfig = extractTimeoutRetryConfig(config2);
     if (timeoutRetryShouldRetry(timeoutRetryAttempts, timeoutConfig)) {
@@ -29929,7 +29991,7 @@ function trySameAgentRetry(result, state, deps) {
       };
     }
   }
-  const isFailAdapterError = result.adapterFailure?.outcome === "fail-adapter-error";
+  const isFailAdapterError = lane === "adapter-error";
   if (isFailAdapterError && !signal?.aborted) {
     const runConfig = requestRunOptions.config ?? config2;
     const maxAdapterRetries = result.adapterFailure?.retriable ? runConfig.execution?.sessionErrorRetryableMaxRetries ?? 3 : runConfig.execution?.sessionErrorMaxRetries ?? 1;
@@ -29992,23 +30054,25 @@ function describeRetryLogEvent(retryDecision, storyId, agent) {
 var init_hop_retry_policy = __esm(() => {
   init_config();
   init_idle_watchdog();
+  init_failure_policy();
 });
 
 // src/agents/swap-decision.ts
 function decideSwap(failure, hopsSoFar, fallback) {
   if (!failure)
     return { swap: false, reason: "no-failure" };
-  if (failure.outcome === "fail-aborted" || failure.outcome === "fail-timeout") {
+  const policy = failurePolicyFor(failure.outcome);
+  if (policy.swap === "never")
     return { swap: false, reason: "outcome-refused" };
-  }
   if (!fallback?.enabled)
     return { swap: false, reason: "fallback-disabled" };
   if (hopsSoFar >= (fallback.maxHopsPerStory ?? DEFAULT_MAX_HOPS)) {
     return { swap: false, reason: "hop-cap-reached" };
   }
-  if (failure.category === "availability")
-    return { swap: true };
-  return fallback.onQualityFailure ? { swap: true } : { swap: false, reason: "quality-failure-declined" };
+  if (policy.swap === "quality-gated") {
+    return fallback.onQualityFailure ? { swap: true } : { swap: false, reason: "quality-failure-declined" };
+  }
+  return { swap: true };
 }
 function normaliseFallbackTarget(value) {
   return typeof value === "string" ? { agent: value } : { agent: value.agent, tier: value.tier };
@@ -30036,6 +30100,290 @@ function logSwapDecline(logger, reason, input) {
   });
 }
 var DEFAULT_MAX_HOPS = 2;
+var init_swap_decision = __esm(() => {
+  init_failure_policy();
+});
+
+// src/agents/manager-run-fallback.ts
+async function runWithFallback(input) {
+  const { request, config: config2, budget, logger } = input;
+  const fallbacks = [];
+  const primaryAgent = input.primaryAgentOverride ?? input.getDefault();
+  const storyId = request.runOptions.storyId;
+  const start = resolveStartAgent(input, primaryAgent, config2.agent?.fallback?.enabled, storyId, logger);
+  let currentAgent = start.agent;
+  let currentHopKind = "tier" in start ? { kind: "primary", tier: start.tier } : { kind: "primary" };
+  let hopsSoFar = budget.spent(storyId);
+  let rateLimitRetry = 0;
+  let staleRetryAttempts = 0;
+  let timeoutRetryAttempts = 0;
+  let adapterErrorRetries = 0;
+  let currentBundle = request.bundle;
+  let currentRunOptions = request.runOptions;
+  let finalPrompt;
+  const startedAt = Date.now();
+  const agentChain = [primaryAgent];
+  let finalStatus = "error";
+  let totalCostUsd = 0;
+  try {
+    while (true) {
+      const hop = await executeHop(input, currentAgent, currentBundle, currentHopKind, currentRunOptions);
+      const { result } = hop;
+      const updatedBundle = hop.bundle ?? currentBundle;
+      finalPrompt = hop.prompt ?? finalPrompt;
+      totalCostUsd += result.estimatedCostUsd ?? 0;
+      if (result.success) {
+        finalStatus = "ok";
+        return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
+      }
+      const retry = trySameAgentRetry(result, { staleRetryAttempts, timeoutRetryAttempts, adapterErrorRetries, currentRunOptions, tier: currentHopKind.tier }, { config: config2, requestRunOptions: request.runOptions, signal: request.signal });
+      if (retry) {
+        ({ staleRetryAttempts, timeoutRetryAttempts, adapterErrorRetries, currentRunOptions } = applyRetry(retry, {
+          staleRetryAttempts,
+          timeoutRetryAttempts,
+          adapterErrorRetries,
+          currentRunOptions
+        }));
+        recordRetry(input, fallbacks, retry, currentAgent, storyId);
+        currentHopKind = retry.kind;
+        continue;
+      }
+      if (request.noFallback) {
+        finalStatus = "error";
+        return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
+      }
+      const swap = decideSwap(result.adapterFailure, hopsSoFar, config2.agent?.fallback);
+      if (!swap.swap) {
+        logSwapDecline(logger, swap.reason, {
+          storyId,
+          agent: currentAgent,
+          hopsSoFar,
+          failure: result.adapterFailure
+        });
+        if (result.adapterFailure?.outcome === "fail-stale") {
+          logger?.warn("agent-manager", "fail-stale: no swap candidate, returning terminal failure", { storyId });
+          finalStatus = "error";
+          return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
+        }
+        const outcome = await input.resolveExhaustion({
+          failure: result.adapterFailure,
+          hopsSoFar,
+          attempt: rateLimitRetry,
+          swapWasPossible: swap.reason === "hop-cap-reached",
+          agent: currentAgent,
+          site: "run",
+          storyId,
+          stage: request.runOptions.pipelineStage ?? "run",
+          signal: request.signal
+        });
+        if (outcome === "retry") {
+          rateLimitRetry += 1;
+          continue;
+        }
+        finalStatus = outcome === "cancelled" ? "cancelled" : hopsSoFar > 0 ? "exhausted" : "error";
+        return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
+      }
+      const failure = result.adapterFailure ?? unknownFailure();
+      input.markUnavailable(currentAgent, failure);
+      const next = input.nextCandidate(primaryAgent, hopsSoFar, currentAgent);
+      if (!next) {
+        const outcome = await input.resolveExhaustion({
+          failure,
+          hopsSoFar,
+          attempt: rateLimitRetry,
+          swapWasPossible: true,
+          agent: currentAgent,
+          site: "run",
+          storyId,
+          stage: request.runOptions.pipelineStage ?? "run",
+          signal: request.signal
+        });
+        if (outcome === "retry") {
+          rateLimitRetry += 1;
+          continue;
+        }
+        finalStatus = outcome === "cancelled" ? "cancelled" : "exhausted";
+        return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
+      }
+      hopsSoFar = budget.spend(storyId, hopsSoFar);
+      rateLimitRetry = 0;
+      currentBundle = updatedBundle;
+      currentHopKind = { kind: "swap", failure, ...next.tier ? { tier: next.tier } : {} };
+      const fallback = buildFallbackRecord({
+        storyId,
+        priorAgent: currentAgent,
+        newAgent: next.agent,
+        hop: hopsSoFar,
+        failure,
+        costUsd: result.estimatedCostUsd ?? 0
+      });
+      fallbacks.push(fallback);
+      input.emitSwapAttempt(fallback);
+      logger?.info("agent-manager", "Agent swap triggered", {
+        storyId,
+        fromAgent: currentAgent,
+        toAgent: next.agent,
+        hop: hopsSoFar
+      });
+      agentChain.push(next.agent);
+      currentAgent = next.agent;
+    }
+  } finally {
+    input.dispatchEvents.emitOperationCompleted({
+      kind: "operation-completed",
+      operation: "run-with-fallback",
+      agentChain,
+      hopCount: hopsSoFar,
+      fallbackTriggered: fallbacks.length > 0,
+      totalElapsedMs: Date.now() - startedAt,
+      totalCostUsd,
+      finalStatus,
+      storyId,
+      stage: request.runOptions.pipelineStage ?? "run",
+      timestamp: Date.now(),
+      ...request.runOptions.callId !== undefined ? { callId: request.runOptions.callId } : {},
+      ...request.runOptions.scopeId !== undefined ? { scopeId: request.runOptions.scopeId } : {}
+    });
+  }
+}
+async function executeHop(input, agent, bundle, kind, options) {
+  if (input.request.executeHop)
+    return input.request.executeHop(agent, bundle, kind, options);
+  if (!input.runHop)
+    return { result: unboundResult(agent), bundle };
+  const raw = await input.runHop(agent, options);
+  const hop = "result" in raw && raw.result != null ? raw : { result: raw };
+  return { ...hop, bundle };
+}
+function unboundResult(agent) {
+  return {
+    success: false,
+    exitCode: 1,
+    output: `AgentManager run hop is not wired for agent "${agent}"`,
+    rateLimited: false,
+    durationMs: 0,
+    estimatedCostUsd: 0
+  };
+}
+function unknownFailure() {
+  return { category: "quality", outcome: "fail-unknown", retriable: false, message: "" };
+}
+function applyRetry(retry, state) {
+  return {
+    staleRetryAttempts: retry.outcome === "stale-retry" ? retry.staleRetryAttempts : state.staleRetryAttempts,
+    timeoutRetryAttempts: retry.outcome === "timeout-retry" ? retry.timeoutRetryAttempts : state.timeoutRetryAttempts,
+    adapterErrorRetries: retry.outcome === "adapter-error" ? retry.adapterErrorRetries : state.adapterErrorRetries,
+    currentRunOptions: retry.outcome === "timeout-retry" ? retry.currentRunOptions : state.currentRunOptions,
+    tier: state.tier
+  };
+}
+function recordRetry(input, fallbacks, retry, agent, storyId) {
+  const fallback = buildFallbackRecord({
+    storyId,
+    priorAgent: agent,
+    newAgent: agent,
+    hop: retry.kind.attempt,
+    failure: retry.fallbackRecord,
+    costUsd: retry.fallbackRecord.costUsd
+  });
+  const event = describeRetryLogEvent(retry, storyId, agent);
+  if (event.recordFallback) {
+    fallbacks.push(fallback);
+    input.emitSwapAttempt(fallback);
+  }
+  input.logger?.[event.level]("agent-manager", event.message, event.fields);
+}
+var init_manager_run_fallback = __esm(() => {
+  init_manager_dispatch();
+  init_hop_retry_policy();
+  init_swap_decision();
+});
+
+// src/agents/registry.ts
+function adapterFor(name) {
+  return name === NATIVE_AGENT ? new NativeAgentAdapter : new AcpAgentAdapter(name);
+}
+function buildAdapterList() {
+  return [...Array.from(_registryTestAdapters.values()), ...KNOWN_AGENT_NAMES.map(adapterFor)];
+}
+function getAllAgents() {
+  return buildAdapterList();
+}
+async function getInstalledAgents() {
+  const allAdapters = buildAdapterList();
+  const results = await Promise.all(allAdapters.map(async (agent) => ({ agent, installed: await agent.isInstalled() })));
+  return results.filter((r) => r.installed).map((r) => r.agent);
+}
+function createAgentRegistry(config2) {
+  const logger = getLogger();
+  const adapterCache = new Map;
+  const protocol = config2.agent?.protocol ?? "acp";
+  logger?.info("agents", `Agent protocol: ${protocol}`, { protocol, hasConfig: !!config2.agent });
+  function cachedAdapter(name) {
+    let adapter = adapterCache.get(name);
+    if (adapter === undefined) {
+      adapter = name === NATIVE_AGENT ? new NativeAgentAdapter : new AcpAgentAdapter(name);
+      adapterCache.set(name, adapter);
+      logger?.debug("agents", `Created ${adapter.constructor.name} for ${name}`, { name });
+    }
+    return adapter;
+  }
+  function getAgent(name) {
+    if (_registryTestAdapters.has(name))
+      return _registryTestAdapters.get(name);
+    if (!KNOWN_AGENT_NAMES.includes(name))
+      return;
+    return cachedAdapter(name);
+  }
+  async function getInstalledAgents2() {
+    const testAdapters = Array.from(_registryTestAdapters.values());
+    const adapters = KNOWN_AGENT_NAMES.map(cachedAdapter);
+    const allAdapters = [...testAdapters, ...adapters];
+    const results = await Promise.all(allAdapters.map(async (agent) => ({ agent, installed: await agent.isInstalled() })));
+    return results.filter((r) => r.installed).map((r) => r.agent);
+  }
+  async function checkAgentHealth() {
+    const testAdapters = Array.from(_registryTestAdapters.values());
+    const adapters = KNOWN_AGENT_NAMES.map(cachedAdapter);
+    const allAdapters = [...testAdapters, ...adapters];
+    return Promise.all(allAdapters.map(async (agent) => ({
+      name: agent.name,
+      displayName: agent.displayName,
+      installed: await agent.isInstalled()
+    })));
+  }
+  return { getAgent, getInstalledAgents: getInstalledAgents2, checkAgentHealth, protocol };
+}
+var KNOWN_AGENT_NAMES, _registryTestAdapters;
+var init_registry2 = __esm(() => {
+  init_logger2();
+  init_adapter2();
+  init_native();
+  KNOWN_AGENT_NAMES = ["claude", "codex", "opencode", "gemini", "aider", "pi", NATIVE_AGENT];
+  _registryTestAdapters = new Map;
+});
+
+// src/agents/retry/default-strategy.ts
+var MAX_RETRIES = 3, defaultRetryStrategy;
+var init_default_strategy = __esm(() => {
+  init_failure_policy();
+  defaultRetryStrategy = {
+    shouldRetry(failure, attempt, _ctx) {
+      if (attempt >= MAX_RETRIES)
+        return { retry: false };
+      if (failure instanceof Error)
+        return { retry: false };
+      const af = failure;
+      if (af.retriable === false)
+        return { retry: false };
+      if (!failurePolicyFor(af.outcome).terminalBackoff)
+        return { retry: false };
+      const retryAfterSeconds = af.retryAfterSeconds;
+      const delayMs = retryAfterSeconds !== undefined && Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0 ? retryAfterSeconds * 1000 : 2 ** (attempt + 1) * 1000;
+      return { retry: true, delayMs };
+    }
+  };
+});
 
 // src/agents/manager.ts
 import { EventEmitter } from "events";
@@ -30043,7 +30391,7 @@ import { EventEmitter } from "events";
 class AgentManager {
   _config;
   _registry;
-  _unavailable = new Map;
+  _cooldowns = new CooldownStore(() => _agentManagerDeps.now());
   _prunedFallback = new Set;
   _budget = new StoryHopBudget;
   _emitter = (() => {
@@ -30099,22 +30447,19 @@ class AgentManager {
     return "claude";
   }
   isUnavailable(agent) {
-    return this._unavailable.has(agent);
+    return this._cooldowns.isCooling(agent);
   }
   markUnavailable(agent, reason) {
-    this._unavailable.set(agent, reason);
+    this._cooldowns.mark(agent, reason);
     this._emitter.emit("onAgentUnavailable", { agent, failure: reason });
   }
   reset() {
-    this._unavailable.clear();
+    this._cooldowns.clear();
     this._prunedFallback.clear();
     this._budget.clear();
   }
   resetTransientUnavailable() {
-    for (const [agent, failure] of this._unavailable) {
-      if (failure.outcome !== "fail-auth" && failure.outcome !== "fail-quota")
-        this._unavailable.delete(agent);
-    }
+    this._cooldowns.sweepTransient();
   }
   async validateCredentials() {
     const primary = this.getDefault();
@@ -30145,211 +30490,26 @@ class AgentManager {
   shouldSwap(failure, hopsSoFar) {
     return decideSwap(failure, hopsSoFar, this._config.agent?.fallback).swap;
   }
-  nextCandidate(current, _hopsSoFar) {
-    return availableCandidates(this._config.agent?.fallback?.map, current, this._isExcluded)[0] ?? null;
+  nextCandidate(current, _hopsSoFar, exclude) {
+    const excluded = (candidate) => candidate === exclude || this._isExcluded(candidate);
+    return availableCandidates(this._config.agent?.fallback?.map, current, excluded)[0] ?? null;
   }
   async runWithFallback(request, primaryAgentOverride) {
-    const logger = this._loggerOverride ?? getSafeLogger();
-    const fallbacks = [];
-    const primaryAgent = primaryAgentOverride ?? this.getDefault();
-    const storyId = request.runOptions.storyId;
-    const start = resolveStartAgent(this, primaryAgent, this._config.agent?.fallback?.enabled, storyId, logger);
-    let currentAgent = start.agent;
-    let currentHopKind = "tier" in start ? { kind: "primary", tier: start.tier } : { kind: "primary" };
-    let hopsSoFar = this._budget.spent(storyId);
-    let rateLimitRetry = 0;
-    let staleRetryAttempts = 0;
-    let timeoutRetryAttempts = 0;
-    let adapterErrorRetries = 0;
-    let currentBundle = request.bundle;
-    let currentRunOptions = request.runOptions;
-    let finalPrompt;
-    const _opStartMs = Date.now();
-    const _agentChain = [primaryAgent];
-    let _finalStatus = "error";
-    let _totalCostUsd = 0;
-    try {
-      while (true) {
-        let result;
-        let updatedBundle = currentBundle;
-        if (request.executeHop) {
-          const hopOut = await request.executeHop(currentAgent, currentBundle, currentHopKind, currentRunOptions);
-          result = hopOut.result;
-          updatedBundle = hopOut.bundle ?? currentBundle;
-          finalPrompt = hopOut.prompt ?? finalPrompt;
-        } else {
-          if (!this._runHop) {
-            const unboundResult = {
-              success: false,
-              exitCode: 1,
-              output: `AgentManager run hop is not wired for agent "${currentAgent}"`,
-              rateLimited: false,
-              durationMs: 0,
-              estimatedCostUsd: 0
-            };
-            _finalStatus = "error";
-            return { result: unboundResult, fallbacks, finalBundle: currentBundle, finalPrompt };
-          }
-          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;
-        }
-        _totalCostUsd += result.estimatedCostUsd ?? 0;
-        if (result.success) {
-          _finalStatus = "ok";
-          return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-        }
-        const isFailStale = result.adapterFailure?.outcome === "fail-stale";
-        const retryState = {
-          staleRetryAttempts,
-          timeoutRetryAttempts,
-          adapterErrorRetries,
-          currentRunOptions,
-          tier: "tier" in currentHopKind ? currentHopKind.tier : undefined
-        };
-        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 = buildFallbackRecord({
-            storyId: request.runOptions.storyId,
-            priorAgent: currentAgent,
-            newAgent: currentAgent,
-            hop: retryDecision.kind.attempt,
-            failure: retryDecision.fallbackRecord,
-            costUsd: retryDecision.fallbackRecord.costUsd
-          });
-          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;
-        }
-        if (request.noFallback) {
-          _finalStatus = "error";
-          return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-        }
-        const fb = this._config.agent?.fallback;
-        const swapDecision = decideSwap(result.adapterFailure, hopsSoFar, fb);
-        if (!swapDecision.swap) {
-          logSwapDecline(logger, swapDecision.reason, {
-            storyId: request.runOptions.storyId,
-            agent: currentAgent,
-            hopsSoFar,
-            failure: result.adapterFailure
-          });
-          if (isFailStale) {
-            logger?.warn("agent-manager", "fail-stale: no swap candidate, returning terminal failure", {
-              storyId: request.runOptions.storyId
-            });
-            _finalStatus = "error";
-            return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-          }
-          if (result.adapterFailure) {
-            const retryCtx = {
-              site: "run",
-              agentName: currentAgent,
-              stage: request.runOptions.pipelineStage ?? "run",
-              storyId: request.runOptions.storyId
-            };
-            const decision = this._retryStrategy.shouldRetry(result.adapterFailure, rateLimitRetry, retryCtx);
-            if (decision.retry) {
-              if (request.signal?.aborted) {
-                logger?.info("agent-manager", "Rate-limited backoff aborted \u2014 shutdown in progress", {
-                  storyId: request.runOptions.storyId
-                });
-                _finalStatus = "cancelled";
-                return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-              }
-              rateLimitRetry += 1;
-              logger?.info("agent-manager", "Rate-limited with no swap candidate \u2014 backing off", {
-                storyId: request.runOptions.storyId,
-                attempt: rateLimitRetry,
-                backoffMs: decision.delayMs
-              });
-              await _agentManagerDeps.sleep(decision.delayMs, request.signal);
-              if (request.signal?.aborted) {
-                _finalStatus = "cancelled";
-                return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-              }
-              continue;
-            }
-          }
-          if (hopsSoFar > 0) {
-            this._emitter.emit("onSwapExhausted", { storyId: request.runOptions.storyId, hops: hopsSoFar });
-            _finalStatus = "exhausted";
-          } else {
-            _finalStatus = "error";
-          }
-          return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-        }
-        const adapterFailure = result.adapterFailure ?? {
-          category: "quality",
-          outcome: "fail-unknown",
-          retriable: false,
-          message: ""
-        };
-        this.markUnavailable(currentAgent, adapterFailure);
-        const next = this.nextCandidate(primaryAgent, hopsSoFar);
-        if (!next) {
-          this._emitter.emit("onSwapExhausted", { storyId: request.runOptions.storyId, hops: hopsSoFar });
-          _finalStatus = "exhausted";
-          return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
-        }
-        hopsSoFar = this._budget.spend(storyId, hopsSoFar);
-        rateLimitRetry = 0;
-        currentBundle = updatedBundle;
-        currentHopKind = { kind: "swap", failure: adapterFailure, ..."tier" in next ? { tier: next.tier } : {} };
-        const hop = buildFallbackRecord({
-          storyId: request.runOptions.storyId,
-          priorAgent: currentAgent,
-          newAgent: next.agent,
-          hop: hopsSoFar,
-          failure: adapterFailure,
-          costUsd: result.estimatedCostUsd ?? 0
-        });
-        fallbacks.push(hop);
-        this._emitter.emit("onSwapAttempt", hop);
-        logger?.info("agent-manager", "Agent swap triggered", {
-          storyId: request.runOptions.storyId,
-          fromAgent: currentAgent,
-          toAgent: next.agent,
-          hop: hopsSoFar
-        });
-        _agentChain.push(next.agent);
-        currentAgent = next.agent;
-      }
-    } finally {
-      this._dispatchEvents.emitOperationCompleted({
-        kind: "operation-completed",
-        operation: "run-with-fallback",
-        agentChain: _agentChain,
-        hopCount: hopsSoFar,
-        fallbackTriggered: fallbacks.length > 0,
-        totalElapsedMs: Date.now() - _opStartMs,
-        totalCostUsd: _totalCostUsd,
-        finalStatus: _finalStatus,
-        storyId: request.runOptions.storyId,
-        stage: request.runOptions.pipelineStage ?? "run",
-        timestamp: Date.now(),
-        ...request.runOptions.callId !== undefined ? { callId: request.runOptions.callId } : {},
-        ...request.runOptions.scopeId !== undefined ? { scopeId: request.runOptions.scopeId } : {}
-      });
-    }
+    return runWithFallback({
+      request,
+      primaryAgentOverride,
+      config: this._config,
+      budget: this._budget,
+      runHop: this._runHop,
+      dispatchEvents: this._dispatchEvents,
+      logger: this._loggerOverride ?? getSafeLogger(),
+      getDefault: () => this.getDefault(),
+      isUnavailable: (agent) => this.isUnavailable(agent),
+      markUnavailable: (agent, failure) => this.markUnavailable(agent, failure),
+      nextCandidate: (current, hops, exclude) => this.nextCandidate(current, hops, exclude),
+      resolveExhaustion: (options) => this._resolveExhaustion(options),
+      emitSwapAttempt: (fallback) => this._emitter.emit("onSwapAttempt", fallback)
+    });
   }
   async completeWithFallback(prompt, options, primaryAgentOverride) {
     const logger = this._loggerOverride ?? getSafeLogger();
@@ -30359,6 +30519,7 @@ class AgentManager {
     let currentTier;
     let hopsSoFar = this._budget.spent(options.storyId);
     let staleRetryAttempts = 0;
+    let rateLimitRetry = 0;
     const maxStaleRetries = resolveIdleWatchdogSettings(this._config.agent?.idleWatchdog).maxRetryAttempts;
     const _opStartMs = Date.now();
     const _agentChain = [primaryAgent];
@@ -30437,12 +30598,50 @@ class AgentManager {
             hopsSoFar,
             failure: result.adapterFailure
           });
+          const outcome = await this._resolveExhaustion({
+            failure: result.adapterFailure,
+            hopsSoFar,
+            attempt: rateLimitRetry,
+            swapWasPossible: dec.reason === "hop-cap-reached",
+            agent: currentAgent,
+            site: "complete",
+            storyId: options.storyId,
+            stage: options.pipelineStage ?? "run",
+            signal: options.signal
+          });
+          if (outcome === "cancelled") {
+            _finalStatus = "cancelled";
+            return { result, fallbacks, ...currentTier !== undefined ? { finalTier: currentTier } : {} };
+          }
+          if (outcome === "retry") {
+            rateLimitRetry += 1;
+            continue;
+          }
           _finalStatus = hopsSoFar > 0 ? "exhausted" : "error";
           return { result, fallbacks, ...currentTier !== undefined ? { finalTier: currentTier } : {} };
         }
         this.markUnavailable(currentAgent, result.adapterFailure);
-        const next = this.nextCandidate(primaryAgent, hopsSoFar);
+        const next = this.nextCandidate(primaryAgent, hopsSoFar, currentAgent);
         if (!next) {
+          const outcome = await this._resolveExhaustion({
+            failure: result.adapterFailure,
+            hopsSoFar,
+            attempt: rateLimitRetry,
+            swapWasPossible: true,
+            agent: currentAgent,
+            site: "complete",
+            storyId: options.storyId,
+            stage: options.pipelineStage ?? "run",
+            signal: options.signal
+          });
+          if (outcome === "cancelled") {
+            _finalStatus = "cancelled";
+            return { result, fallbacks, ...currentTier !== undefined ? { finalTier: currentTier } : {} };
+          }
+          if (outcome === "retry") {
+            rateLimitRetry += 1;
+            continue;
+          }
           _finalStatus = "exhausted";
           return { result, fallbacks, ...currentTier !== undefined ? { finalTier: currentTier } : {} };
         }
@@ -30610,6 +30809,14 @@ class AgentManager {
   async completeAs(agentName, prompt, options) {
     return (await this.completeAsWithFallback(agentName, prompt, options)).result;
   }
+  _resolveExhaustion(options) {
+    return resolveManagerExhaustion({
+      ...options,
+      retryStrategy: this._retryStrategy,
+      sleep: _agentManagerDeps.sleep,
+      onExhausted: (hops) => this._emitter.emit("onSwapExhausted", { storyId: options.storyId, hops })
+    });
+  }
   close() {
     this._emitter.removeAllListeners();
   }
@@ -30630,12 +30837,16 @@ var init_manager = __esm(() => {
   init_idle_watchdog();
   init_bun_deps();
   init_complete_exception_classifier();
+  init_cooldown_store();
   init_manager_dispatch();
+  init_manager_exhaustion();
+  init_manager_run_fallback();
   init_registry2();
   init_default_strategy();
-  init_hop_retry_policy();
+  init_swap_decision();
   _agentManagerDeps = {
-    sleep: (ms, signal) => cancellableDelay(ms, signal)
+    sleep: (ms, signal) => cancellableDelay(ms, signal),
+    now: () => Date.now()
   };
 });
 
@@ -48637,7 +48848,7 @@ function turnResultToAgentResult(r) {
     success: !r.adapterFailure,
     exitCode: r.adapterFailure ? 1 : 0,
     output: r.output,
-    rateLimited: false,
+    rateLimited: r.adapterFailure?.outcome === "fail-rate-limit",
     durationMs: 0,
     estimatedCostUsd: r.estimatedCostUsd ?? 0,
     exactCostUsd: r.exactCostUsd,
@@ -49068,6 +49279,15 @@ function recordAgentFallbacks(ctx, fallbacks) {
   }
   store.set(ctx.storyId, [...fallbacks]);
 }
+function recordAdapterFailure(ctx, failure) {
+  if (!ctx.storyId)
+    return;
+  if (failure) {
+    ctx.runtime.lastAdapterFailure.set(ctx.storyId, failure);
+    return;
+  }
+  ctx.runtime.lastAdapterFailure.delete(ctx.storyId);
+}
 var MAX_COMPLETE_RETRY_ATTEMPTS = 20, correlationSequence = 0;
 var init_call_resolvers = __esm(() => {
   init_retry();
@@ -49417,7 +49637,7 @@ async function callOp(ctx, op, input) {
     }
     return sendWithParseRetry(initialPrompt, bodyCtx);
   };
-  const executeHop = _callOpDeps.buildHopCallback({
+  const executeHop2 = _callOpDeps.buildHopCallback({
     ...hopCtx,
     hopBody: effectiveHopBody,
     hopBodyInput: input
@@ -49425,12 +49645,13 @@ async function callOp(ctx, op, input) {
   const rawOutcome = await ctx.runtime.agentManager.runWithFallback({
     runOptions,
     signal: abortSignal,
-    executeHop,
+    executeHop: executeHop2,
     noFallback: runOp.noFallback,
     bundle: ctx.contextBundle
   }, dispatchAgent);
   const outcome = normalizeRunOutcome(rawOutcome);
   recordAgentFallbacks(ctx, outcome.fallbacks);
+  recordAdapterFailure(ctx, outcome.result.adapterFailure);
   if (abortSignal?.aborted) {
     throw new NaxError(`callOp[${op.name}]: aborted`, "CALL_OP_ABORTED", { stage: op.stage, storyId: ctx.storyId });
   }
@@ -60907,7 +61128,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.82.0-canary.4",
+    version: "0.82.0-canary.5",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -60975,7 +61196,7 @@ var init_package = __esm(() => {
       "spec:lint": "bun run scripts/spec-lint.ts"
     },
     dependencies: {
-      "@nathapp/nax-ai": "0.1.9",
+      "@nathapp/nax-ai": "0.1.10",
       "@types/react": "^19.2.14",
       chalk: "^5.6.2",
       commander: "^13.1.0",
@@ -61028,8 +61249,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("a125d17a"))
-        return "a125d17a";
+      if (/^[0-9a-f]{6,10}$/.test("363f5424"))
+        return "363f5424";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -62971,6 +63192,7 @@ function createRuntime(config2, workdir, opts) {
   const rectificationOscillations = new Map;
   const reviewFindingRecurrences = new Map;
   const agentFallbacks = new Map;
+  const lastAdapterFailure = new Map;
   const runtimeCrashRetries = new Map;
   const storyFixHistory = createStoryFixHistory();
   const mutationSummaries = new Map;
@@ -63002,6 +63224,7 @@ function createRuntime(config2, workdir, opts) {
     rectificationOscillations,
     reviewFindingRecurrences,
     agentFallbacks,
+    lastAdapterFailure,
     runtimeCrashRetries,
     storyFixHistory,
     mutationSummaries,
@@ -85345,6 +85568,30 @@ var init_execution_helpers = __esm(() => {
   init_errors();
 });
 
+// src/execution/post-run-notifications.ts
+async function sendPostRunNotification(ctx, notification) {
+  if (!ctx.interaction)
+    return;
+  try {
+    await ctx.interaction.send({
+      id: `${notification.idPrefix}-${ctx.story.id}-${Date.now()}`,
+      type: "notify",
+      featureName: ctx.featureDir ? ctx.featureDir.split("/").pop() ?? "unknown" : "unknown",
+      storyId: ctx.story.id,
+      stage: "execution",
+      summary: notification.summary,
+      detail: notification.detail,
+      fallback: "continue",
+      createdAt: Date.now()
+    });
+  } catch (err) {
+    getLogger().warn("execution", notification.failureMessage, { storyId: ctx.story.id, error: errorMessage(err) });
+  }
+}
+var init_post_run_notifications = __esm(() => {
+  init_logger2();
+});
+
 // src/execution/post-run-review-summary.ts
 function applyReviewsFailedOpen(ctx, phaseOutputs) {
   const count = [phaseOutputs[semanticReviewOp.name], phaseOutputs[adversarialReviewOp.name]].filter((output) => output?.failOpen === true).length;
@@ -85504,10 +85751,12 @@ async function applyPostRunInspection(ctx, planResult, opts) {
   const { capturedTokenUsage, capturedResponse, capturedCostUsd } = opts;
   const isTdd = opts.tddMode !== null;
   const implementerOutput = planResult.phaseOutputs[implementerOp.name];
+  const lastFailure = ctx.runtime.lastAdapterFailure.get(ctx.story.id);
+  const providerUnavailable = lastFailure?.outcome === "fail-rate-limit" || lastFailure?.outcome === "fail-quota" || lastFailure?.outcome === "fail-service-down";
   const agentResult = {
     success: implementerOutput?.success ?? false,
     estimatedCostUsd: capturedCostUsd || planResult.phaseCosts[implementerOp.name] || 0,
-    rateLimited: false,
+    rateLimited: lastFailure?.outcome === "fail-rate-limit",
     output: capturedResponse,
     exitCode: implementerOutput?.success ? 0 : 1,
     durationMs: implementerOutput?.durationMs ?? planResult.durationMs,
@@ -85619,7 +85868,7 @@ async function applyPostRunInspection(ctx, planResult, opts) {
   if (Object.keys(tddIsolations).length > 0) {
     ctx.tddIsolations = tddIsolations;
   }
-  const needsHumanReview = failureCategory === "session-failure";
+  const needsHumanReview = failureCategory === "session-failure" && !providerUnavailable;
   const combinedOutput = (agentResult.output ?? "") + (agentResult.stderr ?? "");
   if (isTdd) {
     const { cleanupVerdict: cleanupVerdict2 } = await Promise.resolve().then(() => (init_verdict(), exports_verdict));
@@ -85629,14 +85878,30 @@ async function applyPostRunInspection(ctx, planResult, opts) {
   }
   const rectOut = planResult.phaseOutputs.rectification;
   ctx.rectifyAttempt = rectOut?.iterationCount ?? 0;
-  return { agentResult, selfVerificationFailed, pauseReason, failureCategory, needsHumanReview, combinedOutput };
+  return {
+    agentResult,
+    selfVerificationFailed,
+    pauseReason,
+    failureCategory,
+    needsHumanReview,
+    providerUnavailable,
+    combinedOutput
+  };
 }
 async function decideStageAction(ctx, planResult, inspection, opts) {
   const logger = getLogger();
   const isTdd = opts.tddMode !== null;
   const isLiteMode = opts.tddMode?.isLite ?? false;
   const shouldRollback = shouldRollbackTddFailure(opts.tddMode, inspection.failureCategory);
-  const { agentResult, selfVerificationFailed, pauseReason, failureCategory, needsHumanReview, combinedOutput } = inspection;
+  const {
+    agentResult,
+    selfVerificationFailed,
+    pauseReason,
+    failureCategory,
+    needsHumanReview,
+    providerUnavailable,
+    combinedOutput
+  } = inspection;
   if (isTdd && !planResult.success) {
     ctx.tddFailureCategory = failureCategory;
   }
@@ -85716,27 +85981,13 @@ Reason: ${breaker.reason}`,
   }
   if (pauseReason) {
     logger.warn("execution", "Plan run produced pauseReason", { storyId: ctx.story.id, pauseReason });
-    if (ctx.interaction) {
-      try {
-        await ctx.interaction.send({
-          id: `pause-${ctx.story.id}-${Date.now()}`,
-          type: "notify",
-          featureName: ctx.featureDir ? ctx.featureDir.split("/").pop() ?? "unknown" : "unknown",
-          storyId: ctx.story.id,
-          stage: "execution",
-          summary: `Execution paused: ${ctx.story.id}`,
-          detail: `Story: ${ctx.story.title}
+    await sendPostRunNotification(ctx, {
+      idPrefix: "pause",
+      summary: `Execution paused: ${ctx.story.id}`,
+      detail: `Story: ${ctx.story.title}
 Reason: ${pauseReason}`,
-          fallback: "continue",
-          createdAt: Date.now()
-        });
-      } catch (notifyErr) {
-        logger.warn("execution", "Failed to send pause notification", {
-          storyId: ctx.story.id,
-          error: String(notifyErr)
-        });
-      }
-    }
+      failureMessage: "Failed to send pause notification"
+    });
     return { action: "pause", reason: pauseReason };
   }
   if (isTdd && !planResult.success) {
@@ -85754,30 +86005,16 @@ Reason: ${pauseReason}`,
         });
       }
     }
-    if (needsHumanReview) {
+    if (needsHumanReview && !providerUnavailable) {
       logger.warn("execution", "Human review needed", { storyId: ctx.story.id, failureCategory });
-      if (ctx.interaction) {
-        try {
-          await ctx.interaction.send({
-            id: `human-review-${ctx.story.id}-${Date.now()}`,
-            type: "notify",
-            featureName: ctx.featureDir ? ctx.featureDir.split("/").pop() ?? "unknown" : "unknown",
-            storyId: ctx.story.id,
-            stage: "execution",
-            summary: `Human review needed: ${ctx.story.id}`,
-            detail: `Story: ${ctx.story.title}
+      await sendPostRunNotification(ctx, {
+        idPrefix: "human-review",
+        summary: `Human review needed: ${ctx.story.id}`,
+        detail: `Story: ${ctx.story.title}
 Reason: Human review needed
 Category: ${failureCategory ?? "unknown"}`,
-            fallback: "continue",
-            createdAt: Date.now()
-          });
-        } catch (notifyErr) {
-          logger.warn("execution", "Failed to send human review notification", {
-            storyId: ctx.story.id,
-            error: String(notifyErr)
-          });
-        }
-      }
+        failureMessage: "Failed to send human review notification"
+      });
       return { action: "pause", reason: `Human review needed: ${failureCategory ?? "unknown"}` };
     }
     return routeTddFailure(failureCategory, isLiteMode, ctx);
@@ -85815,9 +86052,6 @@ Category: ${failureCategory ?? "unknown"}`,
       stderrTail: stderrTail || undefined,
       outputTail: outputTail || undefined
     });
-    if (agentResult.rateLimited) {
-      logger.warn("execution", "Rate limited \u2014 will retry", { storyId: ctx.story.id });
-    }
     await cleanupSessionOnFailure(ctx);
     const failedPhaseNames = Object.keys(failedPhases);
     const reasonParts = [];
@@ -85852,6 +86086,7 @@ var init_post_run = __esm(() => {
   init_rollback();
   init_git();
   init_oscillation_breaker();
+  init_post_run_notifications();
   init_post_run_review_summary();
   init_recurrence_pause();
   init_tdd_failure_category();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.82.0-canary.4",
+  "version": "0.82.0-canary.5",
   "description": "AI Coding Agent Orchestrator — loops until done",
   "type": "module",
   "bin": {
@@ -68,7 +68,7 @@
     "spec:lint": "bun run scripts/spec-lint.ts"
   },
   "dependencies": {
-    "@nathapp/nax-ai": "0.1.9",
+    "@nathapp/nax-ai": "0.1.10",
     "@types/react": "^19.2.14",
     "chalk": "^5.6.2",
     "commander": "^13.1.0",