@nathapp/nax 0.82.0-canary.6 → 0.82.0-canary.7

package/dist/nax.js

@@ -22256,7 +22256,8 @@ var init_schemas_infra = __esm(() => {
   });
   FallbackTargetSchema = exports_external.union([
     exports_external.string().min(1),
-    exports_external.object({ agent: exports_external.string().min(1), tier: exports_external.string().min(1) })
+    exports_external.object({ agent: exports_external.string().min(1), tier: exports_external.string().min(1) }),
+    exports_external.object({ agent: exports_external.string().min(1), model: exports_external.string().min(1) })
   ]);
   AgentFallbackConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(false),
@@ -29993,36 +29994,76 @@ function resolveCooldownExpiry(failure, now) {
 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-auth": {
+      sameAgentRetry: "none",
+      swap: "immediate",
+      cooldown: "run",
+      cooldownScope: "agent",
+      terminalBackoff: false
+    },
+    "fail-quota": {
+      sameAgentRetry: "none",
+      swap: "immediate",
+      cooldown: "run",
+      cooldownScope: "agent",
+      terminalBackoff: false
+    },
     "fail-rate-limit": {
       sameAgentRetry: "none",
       swap: "immediate",
       cooldown: { ms: TRANSIENT_COOLDOWN_MS },
+      cooldownScope: "model",
       terminalBackoff: true
     },
     "fail-service-down": {
       sameAgentRetry: "adapter-error",
       swap: "immediate",
       cooldown: { ms: TRANSIENT_COOLDOWN_MS },
+      cooldownScope: "model",
       terminalBackoff: true
     },
     "fail-stale": {
       sameAgentRetry: "stale",
       swap: "immediate",
       cooldown: { ms: TRANSIENT_COOLDOWN_MS },
+      cooldownScope: "model",
       terminalBackoff: true
     },
-    "fail-timeout": { sameAgentRetry: "timeout", swap: "after-retry-lane", cooldown: "none", terminalBackoff: false },
+    "fail-timeout": {
+      sameAgentRetry: "timeout",
+      swap: "after-retry-lane",
+      cooldown: "none",
+      cooldownScope: "model",
+      terminalBackoff: false
+    },
     "fail-adapter-error": {
       sameAgentRetry: "adapter-error",
       swap: "quality-gated",
       cooldown: "none",
+      cooldownScope: "model",
+      terminalBackoff: false
+    },
+    "fail-quality": {
+      sameAgentRetry: "none",
+      swap: "quality-gated",
+      cooldown: "none",
+      cooldownScope: "model",
+      terminalBackoff: false
+    },
+    "fail-unknown": {
+      sameAgentRetry: "none",
+      swap: "quality-gated",
+      cooldown: "none",
+      cooldownScope: "model",
       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 }
+    "fail-aborted": {
+      sameAgentRetry: "none",
+      swap: "never",
+      cooldown: "none",
+      cooldownScope: "model",
+      terminalBackoff: false
+    }
   });
 });
 
@@ -30033,43 +30074,81 @@ class CooldownStore {
   constructor(_now) {
     this._now = _now;
   }
-  mark(agent, failure) {
+  mark(agent, failure, tier, modelId) {
     const expiresAt = resolveCooldownExpiry(failure, this._now());
     if (expiresAt === null)
       return;
-    this._entries.set(agent, { failure, expiresAt });
+    const key = failurePolicyFor(failure.outcome).cooldownScope === "agent" ? agent : identityKey(agent, tier, modelId);
+    this._entries.set(key, { failure, expiresAt });
   }
-  isCooling(agent) {
-    return this._live(agent) !== undefined;
+  isCooling(agent, tier, modelId) {
+    return this._live(agent, tier, modelId) !== undefined;
   }
-  failureFor(agent) {
-    return this._live(agent)?.failure;
+  failureFor(agent, tier, modelId) {
+    return this._live(agent, tier, modelId)?.failure;
   }
   sweepTransient() {
-    for (const [agent, entry] of this._entries) {
+    for (const [key, entry] of this._entries) {
       if (entry.expiresAt !== "run")
-        this._entries.delete(agent);
+        this._entries.delete(key);
     }
   }
   clear() {
     this._entries.clear();
   }
-  _live(agent) {
-    const entry = this._entries.get(agent);
+  _live(agent, tier, modelId) {
+    const narrow = identityKey(agent, tier, modelId);
+    const own = this._at(narrow);
+    if (own || narrow === agent)
+      return own;
+    const agentWide = this._at(agent);
+    return agentWide && failurePolicyFor(agentWide.failure.outcome).cooldownScope === "agent" ? agentWide : undefined;
+  }
+  _at(key) {
+    const entry = this._entries.get(key);
     if (!entry)
       return;
     if (entry.expiresAt === "run")
       return entry;
     if (entry.expiresAt > this._now())
       return entry;
-    this._entries.delete(agent);
+    this._entries.delete(key);
     return;
   }
 }
+function identityKey(agent, tier, modelId) {
+  if (modelId)
+    return `${agent}::model::${modelId}`;
+  return tier ? `${agent}::${tier}` : agent;
+}
 var init_cooldown_store = __esm(() => {
   init_failure_policy();
 });
 
+// src/agents/fallback-model-identity.ts
+function resolveFallbackModelId(models, agent, tier, defaultAgent) {
+  if (!tier || !models)
+    return;
+  try {
+    const def = resolveModelForAgent(models, agent, tier, defaultAgent);
+    return `${def.provider}/${def.model}`;
+  } catch {
+    return;
+  }
+}
+function resolveFallbackDispatchTarget(models, defaultAgent, target) {
+  if (target.model === undefined || !models)
+    return target;
+  const aliased = MODEL_SHORTHAND_TIERS[target.model.toLowerCase()] ?? target.model;
+  const membership = resolveTierMembership(models, target.agent, aliased, defaultAgent);
+  if (membership.isTier)
+    return { agent: target.agent, tier: aliased };
+  return target;
+}
+var init_fallback_model_identity = __esm(() => {
+  init_config();
+});
+
 // src/agents/hop-budget.ts
 function resolveStartAgent(source, primary, fallbackEnabled, storyId, logger) {
   if (!fallbackEnabled || !source.isUnavailable(primary))
@@ -30247,9 +30326,11 @@ function buildCompleteCallPreamble(input) {
     })
   };
 }
-function resolveHopCompleteOptions(options, currentAgent, primaryAgent, tier) {
+function resolveHopCompleteOptions(options, currentAgent, primaryAgent, tier, model) {
   if (currentAgent === primaryAgent)
     return options;
+  if (model !== undefined)
+    return { ...options, modelDef: resolveModel(model) };
   return { ...options, modelDef: options.modelDefFor?.(currentAgent, tier) ?? options.modelDef };
 }
 function resolveFinalDispatch(options, primaryAgent, fallbacks, finalTier) {
@@ -30324,7 +30405,7 @@ var init_manager_exhaustion = __esm(() => {
 
 // src/agents/retry/hop-retry-policy.ts
 function trySameAgentRetry(result, state, deps) {
-  const { staleRetryAttempts, timeoutRetryAttempts, adapterErrorRetries, currentRunOptions, tier } = state;
+  const { staleRetryAttempts, timeoutRetryAttempts, adapterErrorRetries, currentRunOptions, tier, model } = state;
   const { config: config2, requestRunOptions, signal } = deps;
   const outcome = result.adapterFailure?.outcome;
   const lane = outcome ? failurePolicyFor(outcome).sameAgentRetry : "none";
@@ -30335,7 +30416,12 @@ function trySameAgentRetry(result, state, deps) {
     return {
       outcome: "stale-retry",
       staleRetryAttempts: newAttempts,
-      kind: { kind: "stale-retry", attempt: newAttempts, ...tier !== undefined ? { tier } : {} },
+      kind: {
+        kind: "stale-retry",
+        attempt: newAttempts,
+        ...tier !== undefined ? { tier } : {},
+        ...model !== undefined ? { model } : {}
+      },
       fallbackRecord: {
         outcome: result.adapterFailure?.outcome ?? "fail-stale",
         category: result.adapterFailure?.category ?? "availability",
@@ -30352,7 +30438,12 @@ function trySameAgentRetry(result, state, deps) {
       return {
         outcome: "timeout-retry",
         timeoutRetryAttempts: newAttempts,
-        kind: { kind: "timeout-retry", attempt: newAttempts, ...tier !== undefined ? { tier } : {} },
+        kind: {
+          kind: "timeout-retry",
+          attempt: newAttempts,
+          ...tier !== undefined ? { tier } : {},
+          ...model !== undefined ? { model } : {}
+        },
         currentRunOptions: resolveTimeoutRetryOptions(currentRunOptions, timeoutConfig, config2.execution, requestRunOptions),
         fallbackRecord: {
           outcome: result.adapterFailure?.outcome ?? "fail-timeout",
@@ -30372,7 +30463,12 @@ function trySameAgentRetry(result, state, deps) {
       return {
         outcome: "adapter-error",
         adapterErrorRetries: newAttempts,
-        kind: { kind: "stale-retry", attempt: newAttempts, ...tier !== undefined ? { tier } : {} },
+        kind: {
+          kind: "stale-retry",
+          attempt: newAttempts,
+          ...tier !== undefined ? { tier } : {},
+          ...model !== undefined ? { model } : {}
+        },
         fallbackRecord: {
           outcome: result.adapterFailure?.outcome ?? "fail-adapter-error",
           category: result.adapterFailure?.category ?? "availability",
@@ -30447,10 +30543,14 @@ function decideSwap(failure, hopsSoFar, fallback) {
   return { swap: true };
 }
 function normaliseFallbackTarget(value) {
-  return typeof value === "string" ? { agent: value } : { agent: value.agent, tier: value.tier };
+  if (typeof value === "string")
+    return { agent: value };
+  if ("tier" in value)
+    return { agent: value.agent, tier: value.tier };
+  return { agent: value.agent, model: value.model };
 }
-function availableCandidates(map2, agent, isExcluded) {
-  return (map2?.[agent] ?? []).map(normaliseFallbackTarget).filter((candidate) => !isExcluded(candidate.agent));
+function availableCandidates(map2, agent, isExcluded, resolve9 = (target) => target) {
+  return (map2?.[agent] ?? []).map(normaliseFallbackTarget).map(resolve9).filter((candidate) => !isExcluded(candidate.agent, candidate.tier));
 }
 function credentialCandidates(map2, primary) {
   const candidates = new Set([primary]);
@@ -30484,7 +30584,11 @@ async function runWithFallback(input) {
   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 currentHopKind = {
+    kind: "primary",
+    ..."tier" in start && start.tier !== undefined ? { tier: start.tier } : {},
+    ..."model" in start && start.model !== undefined ? { model: start.model } : {}
+  };
   let hopsSoFar = budget.spent(storyId);
   let rateLimitRetry = 0;
   let staleRetryAttempts = 0;
@@ -30508,7 +30612,14 @@ async function runWithFallback(input) {
         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 });
+      const retry = trySameAgentRetry(result, {
+        staleRetryAttempts,
+        timeoutRetryAttempts,
+        adapterErrorRetries,
+        currentRunOptions,
+        tier: currentHopKind.tier,
+        model: currentHopKind.model
+      }, { config: config2, requestRunOptions: request.runOptions, signal: request.signal });
       if (retry) {
         ({ staleRetryAttempts, timeoutRetryAttempts, adapterErrorRetries, currentRunOptions } = applyRetry(retry, {
           staleRetryAttempts,
@@ -30556,8 +30667,9 @@ async function runWithFallback(input) {
         return { result, fallbacks, finalBundle: updatedBundle, finalPrompt, finalAgent: currentAgent };
       }
       const failure = result.adapterFailure ?? unknownFailure();
-      input.markUnavailable(currentAgent, failure);
-      const next = input.nextCandidate(primaryAgent, hopsSoFar, currentAgent);
+      const currentTier = currentHopKind.tier;
+      input.markUnavailable(currentAgent, failure, currentTier);
+      const next = input.nextCandidate(primaryAgent, hopsSoFar, currentAgent, currentTier);
       if (!next) {
         const outcome = await input.resolveExhaustion({
           failure,
@@ -30580,7 +30692,12 @@ async function runWithFallback(input) {
       hopsSoFar = budget.spend(storyId, hopsSoFar);
       rateLimitRetry = 0;
       currentBundle = updatedBundle;
-      currentHopKind = { kind: "swap", failure, ...next.tier ? { tier: next.tier } : {} };
+      currentHopKind = {
+        kind: "swap",
+        failure,
+        ...next.tier ? { tier: next.tier } : {},
+        ...next.model ? { model: next.model } : {}
+      };
       const fallback = buildFallbackRecord({
         storyId,
         priorAgent: currentAgent,
@@ -30780,6 +30897,7 @@ class AgentManager {
   _dispatchEvents;
   _pidRegistry;
   _retryStrategy;
+  _models;
   events;
   constructor(config2, registry3, opts) {
     this._config = config2;
@@ -30792,6 +30910,7 @@ class AgentManager {
     this._runHop = opts?.runHop;
     this._dispatchEvents = opts?.dispatchEvents ?? new DispatchEventBus;
     this._retryStrategy = opts?.retryStrategy ?? defaultRetryStrategy;
+    this._models = opts?.models;
     this.events = {
       on: (event, listener) => {
         this._emitter.on(event, listener);
@@ -30818,12 +30937,12 @@ class AgentManager {
       return fromAgent;
     return "claude";
   }
-  isUnavailable(agent) {
-    return this._cooldowns.isCooling(agent);
+  isUnavailable(agent, tier) {
+    return this._cooldowns.isCooling(agent, tier, resolveFallbackModelId(this._models, agent, tier, this.getDefault()));
   }
-  markUnavailable(agent, reason) {
-    this._cooldowns.mark(agent, reason);
-    this._emitter.emit("onAgentUnavailable", { agent, failure: reason });
+  markUnavailable(agent, reason, tier) {
+    this._cooldowns.mark(agent, reason, tier, resolveFallbackModelId(this._models, agent, tier, this.getDefault()));
+    this._emitter.emit("onAgentUnavailable", { agent, tier, failure: reason });
   }
   reset() {
     this._cooldowns.clear();
@@ -30855,16 +30974,18 @@ class AgentManager {
       this._prunedFallback.add(name);
     }
   }
-  _isExcluded = (c) => this._prunedFallback.has(c) || this.isUnavailable(c);
+  _isExcluded = (c, t) => this._prunedFallback.has(c) || this.isUnavailable(c, t);
+  _resolveTarget = (t) => resolveFallbackDispatchTarget(this._models, this.getDefault(), t);
   resolveFallbackChain(agent, _failure) {
-    return availableCandidates(this._config.agent?.fallback?.map, agent, this._isExcluded);
+    return availableCandidates(this._config.agent?.fallback?.map, agent, this._isExcluded, this._resolveTarget);
   }
   shouldSwap(failure, hopsSoFar) {
     return decideSwap(failure, hopsSoFar, this._config.agent?.fallback).swap;
   }
-  nextCandidate(current, _hopsSoFar, exclude) {
-    const excluded = (candidate) => candidate === exclude || this._isExcluded(candidate);
-    return availableCandidates(this._config.agent?.fallback?.map, current, excluded)[0] ?? null;
+  nextCandidate(current, _hopsSoFar, exclude, excludeTier) {
+    const excluded = (c, t) => c === exclude && t === excludeTier || this._isExcluded(c, t);
+    const map2 = this._config.agent?.fallback?.map;
+    return availableCandidates(map2, current, excluded, this._resolveTarget)[0] ?? null;
   }
   async runWithFallback(request, primaryAgentOverride) {
     return runWithFallback({
@@ -30876,9 +30997,9 @@ class AgentManager {
       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),
+      isUnavailable: (agent, tier) => this.isUnavailable(agent, tier),
+      markUnavailable: (agent, failure, tier) => this.markUnavailable(agent, failure, tier),
+      nextCandidate: (current, hops, exclude, excludeTier) => this.nextCandidate(current, hops, exclude, excludeTier),
       resolveExhaustion: (options) => this._resolveExhaustion(options),
       emitSwapAttempt: (fallback) => this._emitter.emit("onSwapAttempt", fallback)
     });
@@ -30889,6 +31010,7 @@ class AgentManager {
     const primaryAgent = primaryAgentOverride ?? this.getDefault();
     let currentAgent = primaryAgent;
     let currentTier;
+    let currentModel;
     let hopsSoFar = this._budget.spent(options.storyId);
     let staleRetryAttempts = 0;
     let rateLimitRetry = 0;
@@ -30899,7 +31021,7 @@ class AgentManager {
     let _totalCostUsd = 0;
     try {
       while (true) {
-        const hopOptions = resolveHopCompleteOptions(options, currentAgent, primaryAgent, currentTier);
+        const hopOptions = resolveHopCompleteOptions(options, currentAgent, primaryAgent, currentTier, currentModel);
         const adapter = this._resolveRegistry().getAgent(currentAgent);
         if (!adapter) {
           _finalStatus = "error";
@@ -30994,8 +31116,8 @@ class AgentManager {
           _finalStatus = hopsSoFar > 0 ? "exhausted" : "error";
           return { result, fallbacks, ...currentTier !== undefined ? { finalTier: currentTier } : {} };
         }
-        this.markUnavailable(currentAgent, result.adapterFailure);
-        const next = this.nextCandidate(primaryAgent, hopsSoFar, currentAgent);
+        this.markUnavailable(currentAgent, result.adapterFailure, currentTier);
+        const next = this.nextCandidate(primaryAgent, hopsSoFar, currentAgent, currentTier);
         if (!next) {
           const outcome = await this._resolveExhaustion({
             failure: result.adapterFailure,
@@ -31037,7 +31159,7 @@ class AgentManager {
           hop: hopsSoFar
         });
         _agentChain.push(next.agent);
-        [currentAgent, currentTier] = [next.agent, next.tier];
+        [currentAgent, currentTier, currentModel] = [next.agent, next.tier, next.model];
       }
     } finally {
       this._dispatchEvents.emitOperationCompleted({
@@ -31218,6 +31340,7 @@ var init_manager = __esm(() => {
   init_bun_deps();
   init_complete_exception_classifier();
   init_cooldown_store();
+  init_fallback_model_identity();
   init_manager_dispatch();
   init_manager_exhaustion();
   init_manager_run_fallback();
@@ -45070,6 +45193,292 @@ function computePollutionMetrics(manifests) {
   };
 }
 
+// src/runtime/cost-aggregator.ts
+import { mkdirSync as mkdirSync2 } from "fs";
+import { join as join22 } from "path";
+function totalSpendUsd(snap) {
+  return snap.totalCostUsd + snap.totalErrorCostUsd;
+}
+function storySpendUsd(costAggregator, storyId, fallbackUsd) {
+  const snap = costAggregator?.byStory()[storyId];
+  if (snap === undefined)
+    return { cost: fallbackUsd, errorCostUsd: 0 };
+  return { cost: totalSpendUsd(snap), errorCostUsd: snap.totalErrorCostUsd };
+}
+function makeCorrelationId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function createNoOpCostAggregator() {
+  return {
+    record() {},
+    recordError() {},
+    recordOperationSummary() {},
+    snapshot() {
+      return EMPTY_SNAPSHOT;
+    },
+    byAgent() {
+      return {};
+    },
+    byStage() {
+      return {};
+    },
+    byStory() {
+      return {};
+    },
+    byCall() {
+      return {};
+    },
+    byScope() {
+      return {};
+    },
+    openScope(scopeId) {
+      return {
+        scopeId: scopeId ?? makeCorrelationId(),
+        snapshot: () => EMPTY_SNAPSHOT,
+        close: () => {}
+      };
+    },
+    async drain() {}
+  };
+}
+function emptySnap() {
+  return {
+    totalCostUsd: 0,
+    totalEstimatedCostUsd: 0,
+    totalExactCostUsd: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCacheWriteTokens: 0,
+    tokenUsageCount: 0,
+    callCount: 0,
+    errorCount: 0,
+    totalErrorCostUsd: 0
+  };
+}
+function accumulate(snap, e) {
+  const tokens = e.tokens;
+  return {
+    totalCostUsd: snap.totalCostUsd + e.costUsd,
+    totalEstimatedCostUsd: snap.totalEstimatedCostUsd + e.estimatedCostUsd,
+    totalExactCostUsd: snap.totalExactCostUsd + e.exactCostUsd,
+    totalInputTokens: snap.totalInputTokens + (tokens?.input ?? 0),
+    totalOutputTokens: snap.totalOutputTokens + (tokens?.output ?? 0),
+    totalCacheReadTokens: (snap.totalCacheReadTokens ?? 0) + (tokens?.cacheRead ?? 0),
+    totalCacheWriteTokens: (snap.totalCacheWriteTokens ?? 0) + (tokens?.cacheWrite ?? 0),
+    tokenUsageCount: (snap.tokenUsageCount ?? 0) + (tokens ? 1 : 0),
+    callCount: snap.callCount + 1,
+    errorCount: snap.errorCount,
+    totalErrorCostUsd: snap.totalErrorCostUsd
+  };
+}
+function accumulateError(snap, e) {
+  return {
+    ...snap,
+    errorCount: snap.errorCount + 1,
+    totalErrorCostUsd: snap.totalErrorCostUsd + (e?.costUsd ?? 0)
+  };
+}
+
+class CostAggregator {
+  _runId;
+  _drainDir;
+  _events = [];
+  _errors = [];
+  _draining = false;
+  _inFlightEvents = [];
+  _inFlightErrors = [];
+  _openScopes = new Set;
+  constructor(_runId, _drainDir) {
+    this._runId = _runId;
+    this._drainDir = _drainDir;
+  }
+  record(event) {
+    if (this._draining) {
+      this._inFlightEvents.push(event);
+      return;
+    }
+    this._events.push(event);
+  }
+  recordError(event) {
+    if (this._draining) {
+      this._inFlightErrors.push(event);
+      return;
+    }
+    this._errors.push(event);
+  }
+  recordOperationSummary(_event) {}
+  snapshot() {
+    const allEvents = [...this._events, ...this._inFlightEvents];
+    const allErrors = [...this._errors, ...this._inFlightErrors];
+    const eventReduced = allEvents.reduce(accumulate, emptySnap());
+    return allErrors.reduce((snap, e) => accumulateError(snap, e), eventReduced);
+  }
+  byAgent() {
+    const m = {};
+    for (const e of this._events)
+      m[e.agentName] = accumulate(m[e.agentName] ?? emptySnap(), e);
+    for (const e of this._inFlightEvents)
+      m[e.agentName] = accumulate(m[e.agentName] ?? emptySnap(), e);
+    for (const e of this._errors)
+      m[e.agentName] = accumulateError(m[e.agentName] ?? emptySnap(), e);
+    for (const e of this._inFlightErrors)
+      m[e.agentName] = accumulateError(m[e.agentName] ?? emptySnap(), e);
+    return m;
+  }
+  byStage() {
+    const m = {};
+    for (const e of this._events) {
+      const k = e.stage ?? "unknown";
+      m[k] = accumulate(m[k] ?? emptySnap(), e);
+    }
+    for (const e of this._inFlightEvents) {
+      const k = e.stage ?? "unknown";
+      m[k] = accumulate(m[k] ?? emptySnap(), e);
+    }
+    for (const e of this._errors) {
+      const k = e.stage ?? "unknown";
+      m[k] = accumulateError(m[k] ?? emptySnap(), e);
+    }
+    for (const e of this._inFlightErrors) {
+      const k = e.stage ?? "unknown";
+      m[k] = accumulateError(m[k] ?? emptySnap(), e);
+    }
+    return m;
+  }
+  byStory() {
+    const m = {};
+    for (const e of this._events) {
+      const k = e.storyId ?? "unknown";
+      m[k] = accumulate(m[k] ?? emptySnap(), e);
+    }
+    for (const e of this._inFlightEvents) {
+      const k = e.storyId ?? "unknown";
+      m[k] = accumulate(m[k] ?? emptySnap(), e);
+    }
+    for (const e of this._errors) {
+      const k = e.storyId ?? "unknown";
+      m[k] = accumulateError(m[k] ?? emptySnap(), e);
+    }
+    for (const e of this._inFlightErrors) {
+      const k = e.storyId ?? "unknown";
+      m[k] = accumulateError(m[k] ?? emptySnap(), e);
+    }
+    return m;
+  }
+  byCall() {
+    const m = {};
+    for (const e of [...this._events, ...this._inFlightEvents]) {
+      if (e.callId === undefined)
+        continue;
+      m[e.callId] = accumulate(m[e.callId] ?? emptySnap(), e);
+    }
+    for (const e of [...this._errors, ...this._inFlightErrors]) {
+      if (e.callId === undefined)
+        continue;
+      m[e.callId] = accumulateError(m[e.callId] ?? emptySnap(), e);
+    }
+    return m;
+  }
+  byScope() {
+    const m = {};
+    for (const e of [...this._events, ...this._inFlightEvents]) {
+      if (e.scopeId === undefined)
+        continue;
+      m[e.scopeId] = accumulate(m[e.scopeId] ?? emptySnap(), e);
+    }
+    for (const e of [...this._errors, ...this._inFlightErrors]) {
+      if (e.scopeId === undefined)
+        continue;
+      m[e.scopeId] = accumulateError(m[e.scopeId] ?? emptySnap(), e);
+    }
+    return m;
+  }
+  openScope(scopeId) {
+    const id = scopeId ?? _costAggDeps.newCorrelationId();
+    this._openScopes.add(id);
+    let closed = false;
+    return {
+      scopeId: id,
+      snapshot: () => {
+        const matching = [...this._events, ...this._inFlightEvents].filter((e) => e.scopeId === id);
+        const matchingErrors = [...this._errors, ...this._inFlightErrors].filter((e) => e.scopeId === id);
+        const eventSnapshot = matching.reduce(accumulate, emptySnap());
+        return matchingErrors.reduce((snap, e) => accumulateError(snap, e), eventSnapshot);
+      },
+      close: () => {
+        if (closed)
+          return;
+        closed = true;
+        this._openScopes.delete(id);
+      }
+    };
+  }
+  async drain() {
+    const openScopeCount = this._openScopes.size;
+    if (openScopeCount > 0) {
+      _costAggDeps.getSafeLogger()?.warn("cost-aggregator", "drain called with open scopes", { openScopeCount });
+    }
+    this._draining = true;
+    try {
+      let committed = [...this._events.splice(0), ...this._errors.splice(0)];
+      if (committed.length === 0 && this._inFlightEvents.length === 0 && this._inFlightErrors.length === 0) {
+        return;
+      }
+      mkdirSync2(this._drainDir, { recursive: true });
+      const path5 = join22(this._drainDir, `${this._runId}.jsonl`);
+      let first = true;
+      let pass = 0;
+      while (first || this._inFlightEvents.length > 0 || this._inFlightErrors.length > 0) {
+        if (++pass > MAX_DRAIN_PASSES) {
+          _costAggDeps.getSafeLogger()?.warn("cost-aggregator", "drain exceeded max passes \u2014 late events keep arriving", {
+            pass,
+            inFlightEvents: this._inFlightEvents.length,
+            inFlightErrors: this._inFlightErrors.length
+          });
+          break;
+        }
+        first = false;
+        const late = [...this._inFlightEvents.splice(0), ...this._inFlightErrors.splice(0)];
+        committed = [...committed, ...late].sort((a, b) => a.ts - b.ts);
+        await _costAggDeps.write(path5, `${committed.map((e) => JSON.stringify(e)).join(`
+`)}
+`);
+      }
+      const committedEvents = committed.filter((e) => !(("kind" in e) && e.kind === "error"));
+      const committedErrors = committed.filter((e) => ("kind" in e) && e.kind === "error");
+      this._events.length = 0;
+      this._events.push(...committedEvents);
+      this._errors.length = 0;
+      this._errors.push(...committedErrors);
+    } finally {
+      this._draining = false;
+    }
+  }
+}
+var MAX_DRAIN_PASSES = 20, EMPTY_SNAPSHOT, _costAggDeps;
+var init_cost_aggregator = __esm(() => {
+  init_logger2();
+  EMPTY_SNAPSHOT = {
+    totalCostUsd: 0,
+    totalEstimatedCostUsd: 0,
+    totalExactCostUsd: 0,
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalCacheReadTokens: 0,
+    totalCacheWriteTokens: 0,
+    tokenUsageCount: 0,
+    callCount: 0,
+    errorCount: 0,
+    totalErrorCostUsd: 0
+  };
+  _costAggDeps = {
+    write: (path5, data) => Bun.write(path5, data),
+    getSafeLogger: () => getSafeLogger(),
+    newCorrelationId: makeCorrelationId
+  };
+});
+
 // src/utils/file-lock.ts
 import { readFile as readFile6, stat as stat4, unlink as unlink3, writeFile as writeFile5 } from "fs/promises";
 function unlinkQuiet(path5) {
@@ -45382,7 +45791,7 @@ async function collectStoryMetrics(ctx, storyStartTime) {
     attempts,
     finalTier,
     success: agentResult?.success || false,
-    cost: costSnapshot?.totalCostUsd ?? 0,
+    cost: costSnapshot !== undefined ? totalSpendUsd(costSnapshot) : 0,
     durationMs: agentResult?.durationMs || 0,
     firstPassSuccess,
     startedAt: storyStartTime,
@@ -45393,7 +45802,8 @@ async function collectStoryMetrics(ctx, storyStartTime) {
     reviewsFailedOpen: ctx.reviewsFailedOpen ?? 0,
     ...tokens !== undefined ? { tokens, tokenAttribution: "direct" } : {},
     ...contextMetrics !== undefined && { context: contextMetrics },
-    ...fallbackHops.length > 0 && { fallback: { hops: fallbackHops } }
+    ...fallbackHops.length > 0 && { fallback: { hops: fallbackHops } },
+    ...costSnapshot?.totalErrorCostUsd > 0 ? { errorCostUsd: costSnapshot.totalErrorCostUsd } : {}
   };
 }
 function collectBatchMetrics(ctx, storyStartTime) {
@@ -45401,9 +45811,8 @@ function collectBatchMetrics(ctx, storyStartTime) {
   const routing = ctx.routing;
   const agentResult = ctx.agentResult;
   const batchSnapshot = ctx.runtime.costAggregator.byStory()[ctx.story.id];
-  const batchTotal = batchSnapshot?.totalCostUsd ?? 0;
+  const errorCostPerStory = (batchSnapshot?.totalErrorCostUsd ?? 0) / stories.length;
   const totalDuration = agentResult?.durationMs || 0;
-  const costPerStory = batchTotal / stories.length;
   const durationPerStory = totalDuration / stories.length;
   const tokensPerStory = tokensFromSnapshot(batchSnapshot, stories.length);
   const batchAgentUsed = routing.agent ?? ctx.agentManager?.getDefault() ?? resolveDefaultAgent(ctx.config);
@@ -45425,7 +45834,8 @@ function collectBatchMetrics(ctx, storyStartTime) {
       attempts: 1,
       finalTier: routing.modelTier,
       success: true,
-      cost: costPerStory,
+      cost: (batchSnapshot !== undefined ? totalSpendUsd(batchSnapshot) : 0) / stories.length,
+      ...errorCostPerStory > 0 ? { errorCostUsd: errorCostPerStory } : {},
       durationMs: durationPerStory,
       firstPassSuccess: true,
       startedAt: storyStartTime,
@@ -45515,6 +45925,7 @@ var init_tracker = __esm(() => {
   init_schema();
   init_manifest_store();
   init_logger2();
+  init_cost_aggregator();
   init_json_file();
   init_path_file_lock();
 });
@@ -45807,7 +46218,7 @@ var init_static_rules_budget_notice = __esm(() => {
 
 // src/context/engine/providers/static-rules.ts
 import { createHash as createHash11 } from "crypto";
-import { join as join22, relative as relative11 } from "path";
+import { join as join23, relative as relative11 } from "path";
 function contentHash87(content) {
   return createHash11("sha256").update(content).digest("hex").slice(0, 8);
 }
@@ -46119,7 +46530,7 @@ ${section.content}`;
     const existingCandidates = [];
     for (const fileName of LEGACY_CANDIDATE_FILES) {
       try {
-        if (await _staticRulesDeps.fileExists(join22(rootDir, fileName))) {
+        if (await _staticRulesDeps.fileExists(join23(rootDir, fileName))) {
           existingCandidates.push(fileName);
         }
       } catch {}
@@ -46135,11 +46546,11 @@ ${section.content}`;
     for (const fileName of LEGACY_CANDIDATE_FILES) {
       legacySources.push({
         sourceId: fileName,
-        filePath: join22(rootDir, fileName),
+        filePath: join23(rootDir, fileName),
         heading: fileName
       });
     }
-    const rulesDir = join22(rootDir, LEGACY_RULES_DIR);
+    const rulesDir = join23(rootDir, LEGACY_RULES_DIR);
     const nestedRulePaths = _staticRulesDeps.globInDir(rulesDir);
     for (const filePath of nestedRulePaths) {
       const normalized = normalizePath2(filePath);
@@ -46202,7 +46613,7 @@ var init_static_rules = __esm(() => {
     fileExists: async (path6) => Bun.file(path6).exists(),
     globInDir: (dir) => {
       try {
-        return [...new Bun.Glob("**/*.md").scanSync({ cwd: dir, absolute: false })].sort().map((f) => join22(dir, f));
+        return [...new Bun.Glob("**/*.md").scanSync({ cwd: dir, absolute: false })].sort().map((f) => join23(dir, f));
       } catch {
         return [];
       }
@@ -46570,7 +46981,7 @@ var init_provider_weights_cache = __esm(() => {
 });
 
 // src/context/engine/providers/plugin-loader.ts
-import { isAbsolute as isAbsolute8, join as join23, resolve as resolve15 } from "path";
+import { isAbsolute as isAbsolute8, join as join24, resolve as resolve15 } from "path";
 function isInitialisable(p) {
   return typeof p.init === "function";
 }
@@ -46598,7 +47009,7 @@ function resolveModuleSpecifier(specifier, workdir) {
   }
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
     const resolvedWorkdir = resolve15(workdir);
-    const resolved = resolve15(join23(workdir, specifier));
+    const resolved = resolve15(join24(workdir, specifier));
     if (resolved !== resolvedWorkdir && !resolved.startsWith(`${resolvedWorkdir}/`)) {
       throw new Error(`Plugin module path escapes project workdir: "${specifier}" resolves to "${resolved}" (workdir: "${resolvedWorkdir}")`);
     }
@@ -46740,7 +47151,7 @@ var init_plugin_cache = __esm(() => {
 
 // src/context/engine/stage-assembler.ts
 import { readdir as readdir2 } from "fs/promises";
-import { isAbsolute as isAbsolute9, join as join24, resolve as resolve16 } from "path";
+import { isAbsolute as isAbsolute9, join as join25, resolve as resolve16 } from "path";
 function dedupeScratchDirs(dirs) {
   return [...new Set(dirs.filter((dir) => Boolean(dir)))];
 }
@@ -46751,7 +47162,7 @@ async function discoverSessionScratchDirsOnDisk(projectDir, featureName, storyId
   const logger = getLogger();
   let sessionsRoot;
   try {
-    sessionsRoot = join24(featureDir(projectDir, featureName), "sessions");
+    sessionsRoot = join25(featureDir(projectDir, featureName), "sessions");
   } catch (err) {
     logger.debug("context-v2", "discoverSessionScratchDirsOnDisk: invalid featureName \u2014 treating as no sessions", {
       storyId,
@@ -46769,7 +47180,7 @@ async function discoverSessionScratchDirsOnDisk(projectDir, featureName, storyId
   const cutoff = _stageAssemblerDeps.now() - ttlMs;
   const found = [];
   for (const entry of entries) {
-    const descriptorPath = join24(sessionsRoot, entry, "descriptor.json");
+    const descriptorPath = join25(sessionsRoot, entry, "descriptor.json");
     try {
       const parsed = await _stageAssemblerDeps.readDescriptor(descriptorPath);
       if (!parsed || parsed.storyId !== storyId || !parsed.scratchDir)
@@ -47148,7 +47559,7 @@ var init_feature_context_filter = __esm(() => {
 });
 
 // src/context/feature-resolver.ts
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 function disposeFeatureResolver(workdir) {
   if (workdir !== undefined) {
@@ -47200,7 +47611,7 @@ async function buildIndex(workdir) {
 }
 async function tryResolveFromActiveFeature(story, workdir, activeFeature) {
   const logger = getLogger();
-  const prdPath = join25(featureDir(workdir, activeFeature), "prd.json");
+  const prdPath = join26(featureDir(workdir, activeFeature), "prd.json");
   try {
     const raw = await _resolverDeps2.readFile(prdPath);
     const prd = JSON.parse(raw);
@@ -47252,7 +47663,7 @@ var init_feature_resolver = __esm(() => {
 
 // src/context/greenfield.ts
 import { readdir as readdir3 } from "fs/promises";
-import { join as join26, relative as relative13 } from "path";
+import { join as join27, relative as relative13 } from "path";
 async function gitLsFiles2(workdir) {
   try {
     const proc = _greenfieldDeps.spawn(["git", "ls-files"], {
@@ -47280,7 +47691,7 @@ async function* walkFiles(root) {
       for (const entry of entries) {
         if (entry.isSymbolicLink())
           continue;
-        const full = join26(dir, entry.name);
+        const full = join27(dir, entry.name);
         if (entry.isDirectory()) {
           if (IGNORE_DIRS.has(entry.name))
             continue;
@@ -47347,7 +47758,7 @@ var init_greenfield = __esm(() => {
 });
 
 // src/context/providers/feature-context.ts
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 function formatForInjection(content, featureId) {
   return `${INJECTION_HEADER}
 
@@ -47364,7 +47775,7 @@ class FeatureContextProvider {
     const featureId = await _featureContextDeps.resolveFeatureId(story, workdir, activeFeature);
     if (!featureId)
       return null;
-    const contextPath = join27(featureDir(workdir, featureId), "context.md");
+    const contextPath = join28(featureDir(workdir, featureId), "context.md");
     try {
       const exists = await _featureContextDeps.fileExists(contextPath);
       if (!exists)
@@ -47579,13 +47990,13 @@ __export(exports_loader, {
   _promptLoaderDeps: () => _promptLoaderDeps,
   loadOverride: () => loadOverride
 });
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 async function loadOverride(role, workdir, config2) {
   const overridePath = config2.prompts?.overrides?.[role];
   if (!overridePath) {
     return null;
   }
-  const absolutePath = join28(workdir, overridePath);
+  const absolutePath = join29(workdir, overridePath);
   if (!await _promptLoaderDeps.fileExists(absolutePath)) {
     return null;
   }
@@ -47884,7 +48295,7 @@ function composeSections(input) {
   const unslotted = [input.role, input.task].filter((s) => !!s.content.trim());
   return [...slotted, ...unslotted];
 }
-function join29(sections2) {
+function join30(sections2) {
   return sections2.map((s) => s.content).join(SECTION_SEP);
 }
 var init_compose2 = __esm(() => {
@@ -48186,11 +48597,11 @@ var init_generator_helpers = () => {};
 
 // src/acceptance/generator.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 function resolvePytestBin(packageDir) {
   if (packageDir) {
     for (const venvDir of [".venv", "venv", "env"]) {
-      const candidate = join30(packageDir, venvDir, "bin", "pytest");
+      const candidate = join31(packageDir, venvDir, "bin", "pytest");
       if (existsSync6(candidate))
         return candidate;
     }
@@ -48450,7 +48861,6 @@ var init_acceptance_refine = __esm(() => {
     kind: "complete",
     name: "acceptance-refine",
     stage: "acceptance",
-    jsonMode: true,
     config: acceptanceConfigSelector,
     retry: { preset: "transient-network", maxAttempts: 2, baseDelayMs: 0 },
     model: (_input, ctx) => ctx.config.acceptance.model,
@@ -49187,9 +49597,9 @@ var init_autofix_test_writer_strategy = __esm(() => {
 });
 
 // src/agents/exec-package-name.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 async function resolvePackageName(root) {
-  const pkgJson = Bun.file(join31(root, "package.json"));
+  const pkgJson = Bun.file(join32(root, "package.json"));
   if (await pkgJson.exists()) {
     try {
       const parsed = await pkgJson.json();
@@ -49197,14 +49607,14 @@ async function resolvePackageName(root) {
         return parsed.name;
     } catch {}
   }
-  const cargoToml = Bun.file(join31(root, "Cargo.toml"));
+  const cargoToml = Bun.file(join32(root, "Cargo.toml"));
   if (await cargoToml.exists()) {
     const content = await cargoToml.text();
     const match = content.match(/^\[package\][^[]*name\s*=\s*"([^"]+)"/ms);
     if (match?.[1] !== undefined && match[1].length > 0)
       return match[1];
   }
-  const pyproject = Bun.file(join31(root, "pyproject.toml"));
+  const pyproject = Bun.file(join32(root, "pyproject.toml"));
   if (await pyproject.exists()) {
     const content = await pyproject.text();
     const match = content.match(/^\[project\][^[]*name\s*=\s*"([^"]+)"/ms);
@@ -49338,6 +49748,9 @@ function turnResultToAgentResult(r) {
 function hopTier(hopKind, effectiveTier) {
   return "tier" in hopKind ? hopKind.tier ?? effectiveTier : effectiveTier;
 }
+function hopModelId(hopKind) {
+  return "model" in hopKind ? hopKind.model : undefined;
+}
 function buildHopCallback(ctx, sessionId, _initialOptions) {
   const {
     sessionManager,
@@ -49457,7 +49870,8 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
           sessionName,
           attempt: hopKind.attempt
         });
-        const modelDef = pinnedModelDef ?? resolveModelForAgent(config2.models, agentName, hopTier(hopKind, effectiveTier), defaultAgent);
+        const hopPin = hopModelId(hopKind);
+        const modelDef = pinnedModelDef ?? (hopPin ? resolveModel(hopPin) : resolveModelForAgent(config2.models, agentName, hopTier(hopKind, effectiveTier), defaultAgent));
         handle = await sessionManager.openSession(sessionName, {
           agentName,
           role: resolvedRunOptions.sessionRole ?? "implementer",
@@ -49465,7 +49879,7 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
           pipelineStage: stage,
           config: config2,
           modelDef,
-          ...pinnedModelDef !== undefined ? {} : { modelTier: hopTier(hopKind, effectiveTier) },
+          ...pinnedModelDef !== undefined || hopPin ? {} : { modelTier: hopTier(hopKind, effectiveTier) },
           timeoutSeconds: resolvedRunOptions.timeoutSeconds ?? config2.execution?.sessionTimeoutSeconds ?? DEFAULT_CONFIG.execution.sessionTimeoutSeconds,
           featureName,
           storyId: story.id,
@@ -49476,7 +49890,9 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
     } else {
       const pinned = hopKind.kind === "primary" && pinnedModelDef !== undefined;
       const tier = hopTier(hopKind, effectiveTier);
-      const modelDef = hopKind.kind === "primary" ? pinnedModelDef ?? resolveModelForAgent(config2.models, agentName, tier, defaultAgent) : resolveModelForAgent(config2.models, agentName, tier, defaultAgent);
+      const hopPin = hopModelId(hopKind);
+      const resolveForHop = () => hopPin ? resolveModel(hopPin) : resolveModelForAgent(config2.models, agentName, tier, defaultAgent);
+      const modelDef = hopKind.kind === "primary" ? pinnedModelDef ?? resolveForHop() : resolveForHop();
       handle = await sessionManager.openSession(sessionName, {
         agentName,
         role: resolvedRunOptions.sessionRole ?? "implementer",
@@ -49484,7 +49900,7 @@ function buildHopCallback(ctx, sessionId, _initialOptions) {
         pipelineStage: stage,
         config: config2,
         modelDef,
-        ...pinned ? {} : { modelTier: tier },
+        ...pinned || hopPin && !pinnedModelDef ? {} : { modelTier: tier },
         timeoutSeconds: resolvedRunOptions.timeoutSeconds ?? config2.execution?.sessionTimeoutSeconds ?? DEFAULT_CONFIG.execution.sessionTimeoutSeconds,
         featureName,
         storyId: story.id,
@@ -49585,14 +50001,14 @@ var init_build_hop_callback = __esm(() => {
 });
 
 // src/runtime/packages.ts
-import { isAbsolute as isAbsolute10, join as join32, relative as relative14 } from "path";
+import { isAbsolute as isAbsolute10, join as join33, relative as relative14 } from "path";
 function packageWorkdir(view) {
   const { packageDir, repoRoot } = view;
   if (!packageDir)
     return repoRoot;
   if (!repoRoot || isAbsolute10(packageDir))
     return packageDir;
-  return join32(repoRoot, packageDir);
+  return join33(repoRoot, packageDir);
 }
 function createPackageView(config2, packageDir, repoRoot, hasOverride) {
   const memo = new Map;
@@ -49880,7 +50296,7 @@ async function callOp(ctx, op, input) {
   const slicedConfig = ctx.packageView.select(selector);
   const buildCtx = { packageView: ctx.packageView, config: slicedConfig };
   const sections2 = composeSections(op.build(input, buildCtx));
-  const prompt = join29(sections2);
+  const prompt = join30(sections2);
   const timeoutMs = resolveTimeoutMs(op, input, buildCtx);
   const callId = ctx.callId ?? newCorrelationId();
   const abortSignal = ctx.signal ?? ctx.runtime.signal;
@@ -49899,7 +50315,6 @@ async function callOp(ctx, op, input) {
       modelDef: resolved.modelDef,
       modelDefFor: (agent, tier) => agent === dispatchAgent && tier === undefined ? resolved.modelDef : resolveModelForAgent(effectiveModels, agent, tier ?? effectiveTier, defaultAgent),
       ...resolved.modelTier !== undefined ? { modelTier: resolved.modelTier } : {},
-      jsonMode: completeOp.jsonMode ?? false,
       pipelineStage: op.stage,
       storyId: ctx.storyId,
       workdir: ctx.packageDir,
@@ -50838,7 +51253,6 @@ var init_classify_route = __esm(() => {
     kind: "complete",
     name: "classify-route",
     stage: "run",
-    jsonMode: true,
     config: routingConfigSelector,
     model: (_input, ctx) => ctx.config.routing.llm?.model ?? "balanced",
     retry: (_input, ctx) => ({
@@ -50875,7 +51289,6 @@ ${storyBody}`, overridable: false }
     kind: "complete",
     name: "classify-route-batch",
     stage: "run",
-    jsonMode: true,
     config: routingConfigSelector,
     model: (_input, ctx) => ctx.config.routing.llm?.model ?? "balanced",
     retry: (_input, ctx) => ({
@@ -51399,7 +51812,6 @@ var init_debate_judge = __esm(() => {
     kind: "complete",
     name: "debate-judge",
     stage: "review",
-    jsonMode: false,
     config: debateConfigSelector,
     model: (input) => ({ agent: input.resolverAgent, model: input.resolverModel }),
     timeoutMs: (input) => (input.timeoutSeconds ?? 600) * 1000,
@@ -51485,7 +51897,6 @@ var init_debate_propose = __esm(() => {
     kind: "complete",
     name: "debate-propose",
     stage: "review",
-    jsonMode: false,
     config: debateConfigSelector,
     model: (input) => {
       const debater = input.debaters[input.debaterIndex];
@@ -51513,7 +51924,6 @@ var init_debate_rebut = __esm(() => {
     kind: "complete",
     name: "debate-rebut",
     stage: "review",
-    jsonMode: false,
     config: debateConfigSelector,
     model: (input) => {
       const debater = input.debaters[input.debaterIndex];
@@ -51578,7 +51988,6 @@ var init_debate_synthesis = __esm(() => {
     kind: "complete",
     name: "debate-synthesis",
     stage: "review",
-    jsonMode: false,
     config: debateConfigSelector,
     model: (input) => ({ agent: input.resolverAgent, model: input.resolverModel }),
     timeoutMs: (input) => (input.timeoutSeconds ?? 600) * 1000,
@@ -51686,7 +52095,6 @@ var init_decompose2 = __esm(() => {
     kind: "complete",
     name: "decompose",
     stage: "plan",
-    jsonMode: false,
     config: decomposeConfigSelector,
     model: (_input, ctx) => ctx.config.plan.model,
     timeoutMs: (_input, ctx) => (ctx.config.plan.decomposeTimeoutSeconds ?? ctx.config.plan.timeoutSeconds ?? 600) * 1000,
@@ -52886,7 +53294,7 @@ __export(exports_command_resolver, {
   _commandResolverDeps: () => _commandResolverDeps,
   resolveQualityTestCommands: () => resolveQualityTestCommands
 });
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 async function resolveQualityTestCommands(config2, workdir, storyWorkdir) {
   const rawTestCommand = config2.review?.commands?.test ?? config2.quality?.commands?.test;
   const rawScopedTemplate = config2.quality?.commands?.testScoped;
@@ -52913,7 +53321,7 @@ var init_command_resolver = __esm(() => {
   _commandResolverDeps = {
     readPackageName: async (dir) => {
       try {
-        const content = await Bun.file(join33(dir, "package.json")).json();
+        const content = await Bun.file(join34(dir, "package.json")).json();
         return typeof content.name === "string" ? content.name : null;
       } catch {
         return null;
@@ -52929,7 +53337,7 @@ __export(exports_command_defaults, {
   clearCommandDefaultsCache: () => clearCommandDefaultsCache,
   resolveDefaultQualityCommands: () => resolveDefaultQualityCommands
 });
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 function clearCommandDefaultsCache() {
   memo.clear();
 }
@@ -52961,18 +53369,18 @@ async function compute(packageDir) {
 }
 async function pythonDefaults(packageDir) {
   const deps = _commandDefaultsDeps;
-  const pyproject = await deps.readText(join34(packageDir, "pyproject.toml"));
+  const pyproject = await deps.readText(join35(packageDir, "pyproject.toml"));
   let prefix = "";
-  if (await deps.fileExists(join34(packageDir, "uv.lock")) || pyproject.includes("[tool.uv]")) {
+  if (await deps.fileExists(join35(packageDir, "uv.lock")) || pyproject.includes("[tool.uv]")) {
     prefix = "uv run ";
-  } else if (await deps.fileExists(join34(packageDir, "poetry.lock")) || pyproject.includes("[tool.poetry]")) {
+  } else if (await deps.fileExists(join35(packageDir, "poetry.lock")) || pyproject.includes("[tool.poetry]")) {
     prefix = "poetry run ";
   }
   const result = { test: `${prefix}pytest` };
-  if (pyproject.includes("[tool.mypy]") || await deps.fileExists(join34(packageDir, "mypy.ini"))) {
+  if (pyproject.includes("[tool.mypy]") || await deps.fileExists(join35(packageDir, "mypy.ini"))) {
     result.typecheck = `${prefix}mypy .`;
   }
-  if (pyproject.includes("[tool.ruff]") || await deps.fileExists(join34(packageDir, "ruff.toml")) || await deps.fileExists(join34(packageDir, ".ruff.toml"))) {
+  if (pyproject.includes("[tool.ruff]") || await deps.fileExists(join35(packageDir, "ruff.toml")) || await deps.fileExists(join35(packageDir, ".ruff.toml"))) {
     result.lint = `${prefix}ruff check .`;
   }
   return result;
@@ -52980,7 +53388,7 @@ async function pythonDefaults(packageDir) {
 async function jsDefaults(packageDir) {
   const deps = _commandDefaultsDeps;
   const pm = await detectJsPackageManager(packageDir);
-  const pkg = await deps.readJson(join34(packageDir, "package.json"));
+  const pkg = await deps.readJson(join35(packageDir, "package.json"));
   const scripts = pkg?.scripts ?? {};
   const result = {};
   if (typeof scripts.test === "string" && scripts.test.trim().length > 0) {
@@ -52990,24 +53398,24 @@ async function jsDefaults(packageDir) {
   }
   if (typeof scripts.typecheck === "string") {
     result.typecheck = `${pm} run typecheck`;
-  } else if (await deps.fileExists(join34(packageDir, "tsconfig.json"))) {
+  } else if (await deps.fileExists(join35(packageDir, "tsconfig.json"))) {
     result.typecheck = `${pm === "bun" ? "bunx" : `${pm} exec`} tsc --noEmit`;
   }
-  if (await deps.fileExists(join34(packageDir, "biome.json"))) {
+  if (await deps.fileExists(join35(packageDir, "biome.json"))) {
     result.lint = `${pm === "bun" ? "bunx" : `${pm} exec`} biome check .`;
-  } else if (await deps.fileExists(join34(packageDir, ".eslintrc")) || await deps.fileExists(join34(packageDir, ".eslintrc.json")) || await deps.fileExists(join34(packageDir, ".eslintrc.js")) || await deps.fileExists(join34(packageDir, "eslint.config.js"))) {
+  } else if (await deps.fileExists(join35(packageDir, ".eslintrc")) || await deps.fileExists(join35(packageDir, ".eslintrc.json")) || await deps.fileExists(join35(packageDir, ".eslintrc.js")) || await deps.fileExists(join35(packageDir, "eslint.config.js"))) {
     result.lint = `${pm === "bun" ? "bunx" : `${pm} exec`} eslint .`;
   }
   return result;
 }
 async function detectJsPackageManager(packageDir) {
   const deps = _commandDefaultsDeps;
-  if (await deps.fileExists(join34(packageDir, "bun.lock")) || await deps.fileExists(join34(packageDir, "bun.lockb"))) {
+  if (await deps.fileExists(join35(packageDir, "bun.lock")) || await deps.fileExists(join35(packageDir, "bun.lockb"))) {
     return "bun";
   }
-  if (await deps.fileExists(join34(packageDir, "pnpm-lock.yaml")))
+  if (await deps.fileExists(join35(packageDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (await deps.fileExists(join34(packageDir, "yarn.lock")))
+  if (await deps.fileExists(join35(packageDir, "yarn.lock")))
     return "yarn";
   return "npm";
 }
@@ -53045,13 +53453,13 @@ __export(exports_runners, {
   verifyAssets: () => verifyAssets
 });
 import { existsSync as existsSync7 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 async function verifyAssets(workingDirectory, expectedFiles) {
   if (!expectedFiles || expectedFiles.length === 0)
     return { success: true, missingFiles: [] };
   const missingFiles = [];
   for (const file2 of expectedFiles) {
-    if (!existsSync7(join35(workingDirectory, file2)))
+    if (!existsSync7(join36(workingDirectory, file2)))
       missingFiles.push(file2);
   }
   if (missingFiles.length > 0) {
@@ -54972,16 +55380,16 @@ var init_classify2 = __esm(() => {
 });
 
 // src/verification/mutation/journal.ts
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function journalDir(repoRoot) {
-  return join36(repoRoot, JOURNAL_DIRNAME);
+  return join37(repoRoot, JOURNAL_DIRNAME);
 }
 function journalFileName(storyId) {
   const safe = storyId.replace(/[^A-Za-z0-9._-]/g, "_");
   return `${safe || "unknown"}.json`;
 }
 function journalPathFor(repoRoot, storyId) {
-  return join36(journalDir(repoRoot), journalFileName(storyId));
+  return join37(journalDir(repoRoot), journalFileName(storyId));
 }
 async function mayHaveJournal(candidateRoots) {
   const { stat: stat6 } = await import("fs/promises");
@@ -55028,7 +55436,7 @@ async function restoreInFlight(repoRoot) {
   for (const name of names) {
     if (!name.endsWith(".json"))
       continue;
-    const path8 = join36(dir, name);
+    const path8 = join37(dir, name);
     const entry = await readEntry(path8);
     if (!entry) {
       await unlink4(path8).catch(() => {});
@@ -55058,7 +55466,7 @@ var JOURNAL_DIRNAME;
 var init_journal = __esm(() => {
   init_realpath();
   init_apply();
-  JOURNAL_DIRNAME = join36(".nax", "mutation-journal");
+  JOURNAL_DIRNAME = join37(".nax", "mutation-journal");
 });
 
 // src/verification/mutation/operators.ts
@@ -55281,7 +55689,7 @@ var init_mutation = __esm(() => {
 });
 
 // src/operations/mutation-check.ts
-import { isAbsolute as isAbsolute11, join as join37 } from "path";
+import { isAbsolute as isAbsolute11, join as join38 } from "path";
 async function sweepLeftoverMutants(repoRoot, storyId) {
   const logger = getLogger();
   try {
@@ -55391,7 +55799,7 @@ var init_mutation_check = __esm(() => {
       const anchor = input.packagePrefix && input.repoRoot ? input.repoRoot : await deps.getGitRoot(input.workdir) ?? input.workdir;
       const scopeRoot = input.repoRoot ?? input.workdir;
       const absoluteChangedFiles = changedFiles2.map((f) => {
-        const path8 = isAbsolute11(f) ? f : join37(anchor, f);
+        const path8 = isAbsolute11(f) ? f : join38(anchor, f);
         return { path: path8, resolved: realOrRaw(path8) };
       }).filter(({ resolved }) => isInside(scopeRoot, resolved));
       const rawRangeMap = await deps.getChangedLineRanges(input.workdir, input.storyGitRef);
@@ -55898,7 +56306,7 @@ var init_plan_draft = __esm(() => {
 });
 
 // src/operations/plan-refine.ts
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 function hasToken(text, tokens) {
   const lower = text.toLowerCase();
   return tokens.some((token) => lower.includes(token));
@@ -55976,7 +56384,7 @@ async function normalizeStoryFiles(story, workdir, fileExists, upstreamProduced)
   for (const entry of contextFiles) {
     const filePath = typeof entry === "string" ? entry : entry.path;
     const factId = typeof entry === "string" ? undefined : entry.factId;
-    if (expected.has(filePath) || await fileExists(join38(workdir, filePath))) {
+    if (expected.has(filePath) || await fileExists(join39(workdir, filePath))) {
       kept.push(entry);
       continue;
     }
@@ -56739,14 +57147,14 @@ var init_typecheck_check = __esm(() => {
 });
 
 // src/operations/validate-mock-structure-files.ts
-import { isAbsolute as isAbsolute12, join as join39, relative as relative15 } from "path";
+import { isAbsolute as isAbsolute12, join as join40, relative as relative15 } from "path";
 function resolutionCandidates(file2, packageDir, repoRoot) {
   if (isAbsolute12(file2))
     return [file2];
-  const viaPackageDir = join39(packageDir, file2);
+  const viaPackageDir = join40(packageDir, file2);
   if (repoRoot === undefined)
     return [viaPackageDir];
-  const viaRepoRoot = join39(repoRoot, file2);
+  const viaRepoRoot = join40(repoRoot, file2);
   return viaRepoRoot === viaPackageDir ? [viaPackageDir] : [viaPackageDir, viaRepoRoot];
 }
 async function resolvePackageRelative(file2, opts) {
@@ -57661,20 +58069,67 @@ var init_operations = __esm(() => {
 });
 
 // src/findings/cycle-cost.ts
-function ledgerCostFor(ctx, callId) {
+function ledgerSpendFor(ctx, callId) {
   try {
-    return ctx.runtime.costAggregator.byCall()[callId]?.totalCostUsd ?? 0;
+    const snap = ctx.runtime.costAggregator.byCall()[callId];
+    if (snap === undefined)
+      return { costUsd: 0, errorCostUsd: 0 };
+    return { costUsd: totalSpendUsd(snap), errorCostUsd: snap.totalErrorCostUsd };
   } catch (err) {
     getSafeLogger()?.debug("findings.cycle", "cost ledger read failed; reporting 0 for this dispatch", {
       storyId: ctx.storyId,
       callId,
       error: errorMessage(err)
     });
-    return 0;
+    return { costUsd: 0, errorCostUsd: 0 };
   }
 }
 var init_cycle_cost = __esm(() => {
   init_logger2();
+  init_cost_aggregator();
+});
+
+// src/findings/cycle-dispatch.ts
+async function dispatchStrategy(strategy, ctx, findingsBefore, priorIterations, deps) {
+  const { dispatchCallId } = deps;
+  const relevantFindings = findingsBefore.filter((f) => strategy.appliesTo(f));
+  const input = strategy.buildInput(relevantFindings, priorIterations, ctx);
+  const fixCtx = {
+    ...ctx,
+    callId: dispatchCallId,
+    fixStrategy: { name: strategy.name, findingsBefore: findingsBefore.length },
+    ...strategy.sessionRole ? { sessionOverride: { role: strategy.sessionRole } } : {}
+  };
+  let output;
+  try {
+    output = await deps.callOp(fixCtx, strategy.fixOp, input);
+  } catch (err) {
+    const spend2 = ledgerSpendFor(fixCtx, dispatchCallId);
+    deps.logger?.warn("findings.cycle", "dispatch threw \u2014 spend recorded here, not on an iteration", {
+      ...deps.logCtx,
+      strategyName: strategy.name,
+      op: strategy.fixOp.name,
+      callId: dispatchCallId,
+      costUsd: spend2.costUsd,
+      errorCostUsd: spend2.errorCostUsd,
+      error: errorMessage(err)
+    });
+    throw err;
+  }
+  const extracted = await (strategy.extractApplied?.(output, input) ?? {});
+  const spend = ledgerSpendFor(fixCtx, dispatchCallId);
+  return {
+    strategyName: strategy.name,
+    op: strategy.fixOp.name,
+    targetFiles: extracted.targetFiles ?? [],
+    summary: extracted.summary ?? "",
+    ...extracted.unresolved ? { unresolved: extracted.unresolved } : {},
+    costUsd: extracted.costUsd !== undefined ? extracted.costUsd + spend.errorCostUsd : spend.costUsd,
+    ...spend.errorCostUsd > 0 ? { errorCostUsd: spend.errorCostUsd } : {}
+  };
+}
+var init_cycle_dispatch = __esm(() => {
+  init_cycle_cost();
 });
 
 // src/findings/types.ts
@@ -57708,6 +58163,7 @@ function recordIteration(cycle, input, ctx, logger) {
   const findingRecurrenceKeysBefore = input.findingsBefore.map(findingRecurrenceKey);
   const findingRecurrenceKeysAfter = input.findingsAfter.map(findingRecurrenceKey);
   const costUsd = input.fixesApplied.reduce((sum, fa) => sum + (fa.costUsd ?? 0), 0);
+  const errorCostUsd = input.fixesApplied.reduce((sum, fa) => sum + (fa.errorCostUsd ?? 0), 0);
   const seenTargetFiles = new Set;
   const fixTargetFiles = [];
   for (const fa of input.fixesApplied) {
@@ -57733,7 +58189,8 @@ function recordIteration(cycle, input, ctx, logger) {
     findingRecurrenceKeysBefore,
     findingRecurrenceKeysAfter,
     ...hasFixes ? { fixTargetFiles, fixSummaries } : {},
-    ...costUsd > 0 ? { costUsd } : {}
+    ...costUsd > 0 ? { costUsd } : {},
+    ...errorCostUsd > 0 ? { errorCostUsd } : {}
   };
   cycle.iterations.push(iteration);
   logger?.info("findings.cycle", "iteration completed", {
@@ -57750,7 +58207,8 @@ function recordIteration(cycle, input, ctx, logger) {
     findingRecurrenceKeysBefore,
     findingRecurrenceKeysAfter,
     ...hasFixes ? { fixTargetFiles, fixSummaries } : {},
-    ...costUsd > 0 ? { costUsd } : {}
+    ...costUsd > 0 ? { costUsd } : {},
+    ...errorCostUsd > 0 ? { errorCostUsd } : {}
   });
   return iteration;
 }
@@ -57942,25 +58400,12 @@ async function runFixCycle(cycle, ctx, cycleName, _deps = {}) {
     const findingsBefore = [...cycle.findings];
     const fixesApplied = [];
     for (const strategy of group) {
-      const relevantFindings = findingsBefore.filter((f) => strategy.appliesTo(f));
-      const input = strategy.buildInput(relevantFindings, cycle.iterations, ctx);
-      const dispatchCallId = newCorrelationId();
-      const fixCtx = {
-        ...ctx,
-        callId: dispatchCallId,
-        fixStrategy: { name: strategy.name, findingsBefore: findingsBefore.length },
-        ...strategy.sessionRole ? { sessionOverride: { role: strategy.sessionRole } } : {}
-      };
-      const output = await doCallOp(fixCtx, strategy.fixOp, input);
-      const extracted = await (strategy.extractApplied?.(output, input) ?? {});
-      fixesApplied.push({
-        strategyName: strategy.name,
-        op: strategy.fixOp.name,
-        targetFiles: extracted.targetFiles ?? [],
-        summary: extracted.summary ?? "",
-        ...extracted.unresolved ? { unresolved: extracted.unresolved } : {},
-        costUsd: extracted.costUsd ?? ledgerCostFor(fixCtx, dispatchCallId)
-      });
+      fixesApplied.push(await dispatchStrategy(strategy, ctx, findingsBefore, cycle.iterations, {
+        callOp: doCallOp,
+        dispatchCallId: newCorrelationId(),
+        logger,
+        logCtx
+      }));
     }
     const unresolvedFas = fixesApplied.filter((fa) => fa.unresolved);
     if (unresolvedFas.length > 0) {
@@ -58174,7 +58619,7 @@ var _cycleDeps;
 var init_cycle = __esm(() => {
   init_logger2();
   init_operations();
-  init_cycle_cost();
+  init_cycle_dispatch();
   init_cycle_iteration_log();
   init_cycle_retirement();
   init_types8();
@@ -59161,7 +59606,7 @@ var init_config_descriptions = __esm(() => {
 
 // src/cli/config-get.ts
 import { existsSync as existsSync8 } from "fs";
-import { join as join40 } from "path";
+import { join as join41 } from "path";
 async function loadConfigFile(path9) {
   if (!existsSync8(path9))
     return null;
@@ -59183,7 +59628,7 @@ async function loadProjectConfig() {
   const projectDir = findProjectDir();
   if (!projectDir)
     return null;
-  const projectPath = join40(projectDir, "config.json");
+  const projectPath = join41(projectDir, "config.json");
   return await loadConfigFile(projectPath);
 }
 var init_config_get = __esm(() => {
@@ -59193,11 +59638,11 @@ var init_config_get = __esm(() => {
 });
 
 // src/cli/config-profile.ts
-import { mkdirSync as mkdirSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join41 } from "path";
+import { mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join42 } from "path";
 async function profileListCommand(startDir) {
-  const globalProfilesDir = join41(globalConfigDir(), "profiles");
-  const projectProfilesDir = join41(projectConfigDir(startDir), "profiles");
+  const globalProfilesDir = join42(globalConfigDir(), "profiles");
+  const projectProfilesDir = join42(projectConfigDir(startDir), "profiles");
   const globalProfiles = scanProfileDir(globalProfilesDir);
   const projectProfiles = scanProfileDir(projectProfilesDir);
   const activeProfile = await resolveProfileName({}, _profileCLIDeps.env, startDir);
@@ -59260,7 +59705,7 @@ function maskProfileValue(value) {
   return value;
 }
 async function profileUseCommand(profileName, startDir) {
-  const configPath = join41(projectConfigDir(startDir), "config.json");
+  const configPath = join42(projectConfigDir(startDir), "config.json");
   const configFile = Bun.file(configPath);
   let existing = {};
   if (await configFile.exists()) {
@@ -59281,13 +59726,13 @@ async function profileCurrentCommand(startDir) {
 }
 async function profileCreateCommand(profileName, startDir) {
   validateProfileName(profileName);
-  const profilesDir = join41(projectConfigDir(startDir), "profiles");
-  const profilePath = join41(profilesDir, `${profileName}.json`);
+  const profilesDir = join42(projectConfigDir(startDir), "profiles");
+  const profilePath = join42(profilesDir, `${profileName}.json`);
   const profileFile = Bun.file(profilePath);
   if (await profileFile.exists()) {
     throw new Error(`Profile "${profileName}" already exists at ${profilePath}`);
   }
-  mkdirSync2(profilesDir, { recursive: true });
+  mkdirSync3(profilesDir, { recursive: true });
   await Bun.write(profilePath, "{}");
   return profilePath;
 }
@@ -59305,7 +59750,7 @@ var init_config_profile = __esm(() => {
 
 // src/cli/config-display.ts
 import { existsSync as existsSync9 } from "fs";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 async function configCommand(config2, options = {}) {
   const { explain = false, diff = false } = options;
   if (explain && diff) {
@@ -59363,7 +59808,7 @@ async function configCommand(config2, options = {}) {
 function determineConfigSources() {
   const globalPath = globalConfigPath();
   const projectDir = findProjectDir();
-  const projectPath = projectDir ? join42(projectDir, "config.json") : null;
+  const projectPath = projectDir ? join43(projectDir, "config.json") : null;
   return {
     global: fileExists(globalPath) ? globalPath : null,
     project: projectPath && fileExists(projectPath) ? projectPath : null
@@ -59918,7 +60363,7 @@ var init_context2 = __esm(() => {
 
 // src/cli/context-fragments.ts
 import { existsSync as existsSync11 } from "fs";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 function listDependentStoryIds(prd, startId) {
   const forward = new Map;
   for (const story of prd.userStories) {
@@ -60003,7 +60448,7 @@ function resolveProjectDir(dir) {
   return dir ?? process.cwd();
 }
 function featurePrdPath2(projectDir, featureId) {
-  return join43(featureDir(projectDir, featureId), "prd.json");
+  return join44(featureDir(projectDir, featureId), "prd.json");
 }
 async function fragmentsInspectCommand(options) {
   const projectDir = _contextFragmentsDeps.projectDirFor(resolveProjectDir(options.dir));
@@ -60621,7 +61066,7 @@ var init_acceptance2 = __esm(() => {
 
 // src/cli/features-acceptance.ts
 import { existsSync as existsSync12 } from "fs";
-import { join as join44, relative as relative16 } from "path";
+import { join as join45, relative as relative16 } from "path";
 async function resolveFeatureAcceptance(featureName, workdir) {
   let enabled = true;
   try {
@@ -60629,13 +61074,13 @@ async function resolveFeatureAcceptance(featureName, workdir) {
     if (!naxDir) {
       return { status: "no-prd", enabled, groups: [] };
     }
-    const repoRoot = join44(naxDir, "..");
+    const repoRoot = join45(naxDir, "..");
     const config2 = await loadConfig(workdir);
     enabled = config2.acceptance?.enabled ?? true;
     if (!enabled) {
       return { status: "disabled", enabled: false, groups: [] };
     }
-    const prdPath = join44(naxDir, "features", featureName, "prd.json");
+    const prdPath = join45(naxDir, "features", featureName, "prd.json");
     if (!existsSync12(prdPath)) {
       return { status: "no-prd", enabled, groups: [] };
     }
@@ -60694,7 +61139,7 @@ function validateFeatureName(feature) {
 
 // src/cli/features-resolve.ts
 import { existsSync as existsSync13, readdirSync as readdirSync3 } from "fs";
-import { join as join45, relative as relative17 } from "path";
+import { join as join46, relative as relative17 } from "path";
 async function resolveTestPatterns(workdir) {
   try {
     const config2 = await loadConfig(workdir);
@@ -60712,10 +61157,10 @@ async function isNonEmptyFile(absolutePath) {
 }
 async function searchSpecSource(naxDir, repoRoot, name) {
   const candidates = [
-    { abs: join45(naxDir, "features", name, "spec.md"), kind: "markdown" },
-    { abs: join45(naxDir, "specs", `${name}.md`), kind: "markdown" }
+    { abs: join46(naxDir, "features", name, "spec.md"), kind: "markdown" },
+    { abs: join46(naxDir, "specs", `${name}.md`), kind: "markdown" }
   ];
-  const docsSpecExact = join45(repoRoot, "docs", "specs", `SPEC-${name}.md`);
+  const docsSpecExact = join46(repoRoot, "docs", "specs", `SPEC-${name}.md`);
   candidates.push({ abs: docsSpecExact, kind: "markdown" });
   const checked = candidates.map((c) => relative17(repoRoot, c.abs));
   for (const { abs, kind } of candidates.slice(0, 2)) {
@@ -60729,11 +61174,11 @@ async function searchSpecSource(naxDir, repoRoot, name) {
   if (await isNonEmptyFile(docsSpecExact)) {
     return { source: { kind: "markdown", path: relative17(repoRoot, docsSpecExact) }, checked };
   }
-  const docsSpecsDir = join45(repoRoot, "docs", "specs");
+  const docsSpecsDir = join46(repoRoot, "docs", "specs");
   if (existsSync13(docsSpecsDir)) {
     const glob = new Bun.Glob(`*${name}*.md`);
     for (const match of glob.scanSync({ cwd: docsSpecsDir, absolute: false })) {
-      const abs = join45(docsSpecsDir, match);
+      const abs = join46(docsSpecsDir, match);
       if (await isNonEmptyFile(abs)) {
         const relPath = relative17(repoRoot, abs);
         if (!checked.includes(relPath))
@@ -60742,7 +61187,7 @@ async function searchSpecSource(naxDir, repoRoot, name) {
       }
     }
   }
-  const prdAbs = join45(naxDir, "features", name, "prd.json");
+  const prdAbs = join46(naxDir, "features", name, "prd.json");
   const prdRel = relative17(repoRoot, prdAbs);
   if (!checked.includes(prdRel))
     checked.push(prdRel);
@@ -60752,14 +61197,14 @@ async function searchSpecSource(naxDir, repoRoot, name) {
   return { source: null, checked };
 }
 function discoverCandidates(naxDir) {
-  const featuresDir2 = join45(naxDir, "features");
+  const featuresDir2 = join46(naxDir, "features");
   if (!existsSync13(featuresDir2))
     return [];
   return readdirSync3(featuresDir2, { withFileTypes: true }).filter((e) => {
     if (!e.isDirectory())
       return false;
-    const dir = join45(featuresDir2, e.name);
-    return existsSync13(join45(dir, "prd.json")) || existsSync13(join45(dir, "spec.md"));
+    const dir = join46(featuresDir2, e.name);
+    return existsSync13(join46(dir, "prd.json")) || existsSync13(join46(dir, "spec.md"));
   }).map((e) => e.name).sort();
 }
 async function resolveFeatureSpec(name, workdir) {
@@ -60770,9 +61215,9 @@ async function resolveFeatureSpec(name, workdir) {
       message: `not a nax repo: no .nax/config.json found from ${workdir}`
     };
   }
-  const repoRoot = join45(naxDir, "..");
+  const repoRoot = join46(naxDir, "..");
   if (name !== undefined && (name.startsWith("./") || name.startsWith("/") || name.endsWith(".md"))) {
-    const abs = name.startsWith("/") ? name : join45(workdir, name);
+    const abs = name.startsWith("/") ? name : join46(workdir, name);
     if (!existsSync13(abs)) {
       return {
         status: "missing",
@@ -60812,7 +61257,7 @@ async function resolveFeatureSpec(name, workdir) {
         message: `resolved spec: ${source2.path}`
       };
     }
-    const featureDir2 = join45(naxDir, "features", name);
+    const featureDir2 = join46(naxDir, "features", name);
     if (existsSync13(featureDir2)) {
       return {
         status: "missing",
@@ -60875,9 +61320,9 @@ var init_features_resolve = __esm(() => {
 
 // src/context/injector.ts
 import { existsSync as existsSync14 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 async function detectNode(workdir) {
-  const pkgPath = join46(workdir, "package.json");
+  const pkgPath = join47(workdir, "package.json");
   if (!existsSync14(pkgPath))
     return null;
   try {
@@ -60894,7 +61339,7 @@ async function detectNode(workdir) {
   }
 }
 async function detectGo(workdir) {
-  const goMod = join46(workdir, "go.mod");
+  const goMod = join47(workdir, "go.mod");
   if (!existsSync14(goMod))
     return null;
   try {
@@ -60918,7 +61363,7 @@ async function detectGo(workdir) {
   }
 }
 async function detectRust(workdir) {
-  const cargoPath = join46(workdir, "Cargo.toml");
+  const cargoPath = join47(workdir, "Cargo.toml");
   if (!existsSync14(cargoPath))
     return null;
   try {
@@ -60934,8 +61379,8 @@ async function detectRust(workdir) {
   }
 }
 async function detectPython(workdir) {
-  const pyproject = join46(workdir, "pyproject.toml");
-  const requirements = join46(workdir, "requirements.txt");
+  const pyproject = join47(workdir, "pyproject.toml");
+  const requirements = join47(workdir, "requirements.txt");
   if (!existsSync14(pyproject) && !existsSync14(requirements))
     return null;
   try {
@@ -60954,7 +61399,7 @@ async function detectPython(workdir) {
   }
 }
 async function detectPhp(workdir) {
-  const composerPath = join46(workdir, "composer.json");
+  const composerPath = join47(workdir, "composer.json");
   if (!existsSync14(composerPath))
     return null;
   try {
@@ -60967,7 +61412,7 @@ async function detectPhp(workdir) {
   }
 }
 async function detectRuby(workdir) {
-  const gemfile = join46(workdir, "Gemfile");
+  const gemfile = join47(workdir, "Gemfile");
   if (!existsSync14(gemfile))
     return null;
   try {
@@ -60979,9 +61424,9 @@ async function detectRuby(workdir) {
   }
 }
 async function detectJvm(workdir) {
-  const pom = join46(workdir, "pom.xml");
-  const gradle = join46(workdir, "build.gradle");
-  const gradleKts = join46(workdir, "build.gradle.kts");
+  const pom = join47(workdir, "pom.xml");
+  const gradle = join47(workdir, "build.gradle");
+  const gradleKts = join47(workdir, "build.gradle.kts");
   if (!existsSync14(pom) && !existsSync14(gradle) && !existsSync14(gradleKts))
     return null;
   try {
@@ -60989,7 +61434,7 @@ async function detectJvm(workdir) {
       const content2 = await Bun.file(pom).text();
       const nameMatch = content2.match(/<artifactId>([^<]+)<\/artifactId>/);
       const deps2 = [...content2.matchAll(/<artifactId>([^<]+)<\/artifactId>/g)].map((m) => m[1]).filter((d) => d !== nameMatch?.[1]).slice(0, 10);
-      const lang2 = existsSync14(join46(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
+      const lang2 = existsSync14(join47(workdir, "src/main/kotlin")) ? "Kotlin" : "Java";
       return { name: nameMatch?.[1], lang: lang2, dependencies: deps2 };
     }
     const gradleFile = existsSync14(gradleKts) ? gradleKts : gradle;
@@ -61243,7 +61688,7 @@ var init_windsurf = __esm(() => {
 
 // src/context/generator.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join47, relative as relative18 } from "path";
+import { join as join48, relative as relative18 } from "path";
 async function loadContextContent(options, config2) {
   if (!_generatorDeps.existsSync(options.contextPath)) {
     throw new Error(`Context file not found: ${options.contextPath}`);
@@ -61261,7 +61706,7 @@ async function generateFor(agent, options, config2) {
   try {
     const context = await loadContextContent(options, config2);
     const content = generator.generate(context);
-    const outputPath = join47(options.outputDir, generator.outputFile);
+    const outputPath = join48(options.outputDir, generator.outputFile);
     validateFilePath(outputPath, options.outputDir);
     if (!options.dryRun) {
       await _generatorDeps.writeFile(outputPath, content);
@@ -61279,7 +61724,7 @@ async function generateAll(options, config2, agentFilter) {
   for (const [agentKey, generator] of entries) {
     try {
       const content = generator.generate(context);
-      const outputPath = join47(options.outputDir, generator.outputFile);
+      const outputPath = join48(options.outputDir, generator.outputFile);
       validateFilePath(outputPath, options.outputDir);
       if (!options.dryRun) {
         await _generatorDeps.writeFile(outputPath, content);
@@ -61299,7 +61744,7 @@ async function discoverPackages(repoRoot) {
     const glob = new Bun.Glob(pattern);
     for await (const match of glob.scan({ cwd: repoRoot, dot: true })) {
       const pkgRelative = match.replace(/^\.nax\/mono\//, "").replace(/\/context\.md$/, "");
-      const pkgAbsolute = join47(repoRoot, pkgRelative);
+      const pkgAbsolute = join48(repoRoot, pkgRelative);
       if (!seen.has(pkgAbsolute)) {
         seen.add(pkgAbsolute);
         packages.push(pkgAbsolute);
@@ -61331,14 +61776,14 @@ async function discoverWorkspacePackages2(repoRoot) {
       }
     }
   }
-  const turboPath = join47(repoRoot, "turbo.json");
+  const turboPath = join48(repoRoot, "turbo.json");
   try {
     const turbo = JSON.parse(await _generatorDeps.readTextFile(turboPath));
     if (Array.isArray(turbo.packages)) {
       await resolveGlobs(turbo.packages);
     }
   } catch {}
-  const pkgPath = join47(repoRoot, "package.json");
+  const pkgPath = join48(repoRoot, "package.json");
   try {
     const pkg = JSON.parse(await _generatorDeps.readTextFile(pkgPath));
     const ws = pkg.workspaces;
@@ -61346,7 +61791,7 @@ async function discoverWorkspacePackages2(repoRoot) {
     if (patterns.length > 0)
       await resolveGlobs(patterns);
   } catch {}
-  const pnpmPath = join47(repoRoot, "pnpm-workspace.yaml");
+  const pnpmPath = join48(repoRoot, "pnpm-workspace.yaml");
   try {
     const raw = await _generatorDeps.readTextFile(pnpmPath);
     const lines = raw.split(`
@@ -61372,7 +61817,7 @@ async function discoverWorkspacePackages2(repoRoot) {
 async function generateForPackage(packageDir, config2, dryRun = false, repoRoot) {
   const resolvedRepoRoot = repoRoot ?? packageDir;
   const relativePkgPath = relative18(resolvedRepoRoot, packageDir);
-  const contextPath = join47(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
+  const contextPath = join48(resolvedRepoRoot, ".nax", "mono", relativePkgPath, "context.md");
   if (!_generatorDeps.existsSync(contextPath)) {
     return [
       {
@@ -61441,7 +61886,7 @@ var init_generator2 = __esm(() => {
 
 // src/cli/generate.ts
 import { existsSync as existsSync16 } from "fs";
-import { join as join48 } from "path";
+import { join as join49 } from "path";
 async function generateCommand(options) {
   const workdir = options.dir ?? process.cwd();
   const dryRun = options.dryRun ?? false;
@@ -61486,7 +61931,7 @@ async function generateCommand(options) {
     if (!isRelativeAndSafe(options.package)) {
       throw new NaxError(`generateCommand: package "${options.package}" is not a safe relative path (must be non-empty, relative, and free of ".." segments)`, "INVALID_PACKAGE_PATH", { stage: "generate", package: options.package });
     }
-    const packageDir = join48(workdir, options.package);
+    const packageDir = join49(workdir, options.package);
     if (dryRun) {
       console.log(source_default.yellow("\u26A0 Dry run \u2014 no files will be written"));
     }
@@ -61506,8 +61951,8 @@ async function generateCommand(options) {
       process.exit(1);
     return;
   }
-  const contextPath = options.context ? join48(workdir, options.context) : join48(workdir, ".nax/context.md");
-  const outputDir = options.output ? join48(workdir, options.output) : workdir;
+  const contextPath = options.context ? join49(workdir, options.context) : join49(workdir, ".nax/context.md");
+  const outputDir = options.output ? join49(workdir, options.output) : workdir;
   const autoInject = !options.noAutoInject;
   if (!existsSync16(contextPath)) {
     console.error(source_default.red(`\u2717 Context file not found: ${contextPath}`));
@@ -61621,11 +62066,11 @@ var init_generate = __esm(() => {
 });
 
 // src/utils/nax-project-root.ts
-import { dirname as dirname11, join as join49, resolve as resolve19 } from "path";
+import { dirname as dirname11, join as join50, resolve as resolve19 } from "path";
 async function findNaxProjectRoot(startDir) {
   let dir = resolve19(startDir);
   for (let depth = 0;depth < MAX_NAX_WALK_DEPTH; depth++) {
-    if (await _naxProjectRootDeps.exists(join49(dir, ".nax", "config.json"))) {
+    if (await _naxProjectRootDeps.exists(join50(dir, ".nax", "config.json"))) {
       return dir;
     }
     const parent = dirname11(dir);
@@ -61649,7 +62094,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@nathapp/nax",
-    version: "0.82.0-canary.6",
+    version: "0.82.0-canary.7",
     description: "AI Coding Agent Orchestrator \u2014 loops until done",
     type: "module",
     bin: {
@@ -61770,8 +62215,8 @@ var init_version = __esm(() => {
   NAX_VERSION = package_default.version;
   NAX_COMMIT = (() => {
     try {
-      if (/^[0-9a-f]{6,10}$/.test("4addbf38"))
-        return "4addbf38";
+      if (/^[0-9a-f]{6,10}$/.test("21dacecf"))
+        return "21dacecf";
     } catch {}
     try {
       const result = Bun.spawnSync(["git", "rev-parse", "--short", "HEAD"], {
@@ -61791,7 +62236,7 @@ var init_version = __esm(() => {
 
 // src/review/review-audit.ts
 import { mkdir as mkdir9 } from "fs/promises";
-import { join as join50 } from "path";
+import { join as join51 } from "path";
 function auditKey(reviewer, storyId) {
   return `${reviewer}:${storyId ?? "_feature"}`;
 }
@@ -61827,15 +62272,15 @@ function toPersistedEntry(entry, epochMs) {
 async function persistReviewAudit(entry) {
   let resolvedDir;
   if (entry.outputDir) {
-    resolvedDir = join50(entry.outputDir, "review-audit", entry.featureName ?? "_unknown");
+    resolvedDir = join51(entry.outputDir, "review-audit", entry.featureName ?? "_unknown");
   } else {
     const projectRoot = entry.projectDir ?? await _reviewAuditDeps.findNaxProjectRoot(entry.workdir);
-    resolvedDir = join50(projectRoot, ".nax", "review-audit", entry.featureName ?? "_unknown");
+    resolvedDir = join51(projectRoot, ".nax", "review-audit", entry.featureName ?? "_unknown");
   }
   await _reviewAuditDeps.mkdir(resolvedDir);
   const epochMs = _reviewAuditDeps.now();
   const filename = `${epochMs}-${entry.sessionName}.json`;
-  await _reviewAuditDeps.writeFile(join50(resolvedDir, filename), toPersistedEntry(entry, epochMs));
+  await _reviewAuditDeps.writeFile(join51(resolvedDir, filename), toPersistedEntry(entry, epochMs));
 }
 function createNoOpReviewAuditor() {
   return {
@@ -61954,283 +62399,6 @@ var init_agent_stream_events = __esm(() => {
   init_logger2();
 });
 
-// src/runtime/cost-aggregator.ts
-import { mkdirSync as mkdirSync3 } from "fs";
-import { join as join51 } from "path";
-function makeCorrelationId() {
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function createNoOpCostAggregator() {
-  return {
-    record() {},
-    recordError() {},
-    recordOperationSummary() {},
-    snapshot() {
-      return EMPTY_SNAPSHOT;
-    },
-    byAgent() {
-      return {};
-    },
-    byStage() {
-      return {};
-    },
-    byStory() {
-      return {};
-    },
-    byCall() {
-      return {};
-    },
-    byScope() {
-      return {};
-    },
-    openScope(scopeId) {
-      return {
-        scopeId: scopeId ?? makeCorrelationId(),
-        snapshot: () => EMPTY_SNAPSHOT,
-        close: () => {}
-      };
-    },
-    async drain() {}
-  };
-}
-function emptySnap() {
-  return {
-    totalCostUsd: 0,
-    totalEstimatedCostUsd: 0,
-    totalExactCostUsd: 0,
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    totalCacheReadTokens: 0,
-    totalCacheWriteTokens: 0,
-    tokenUsageCount: 0,
-    callCount: 0,
-    errorCount: 0,
-    totalErrorCostUsd: 0
-  };
-}
-function accumulate(snap, e) {
-  const tokens = e.tokens;
-  return {
-    totalCostUsd: snap.totalCostUsd + e.costUsd,
-    totalEstimatedCostUsd: snap.totalEstimatedCostUsd + e.estimatedCostUsd,
-    totalExactCostUsd: snap.totalExactCostUsd + e.exactCostUsd,
-    totalInputTokens: snap.totalInputTokens + (tokens?.input ?? 0),
-    totalOutputTokens: snap.totalOutputTokens + (tokens?.output ?? 0),
-    totalCacheReadTokens: (snap.totalCacheReadTokens ?? 0) + (tokens?.cacheRead ?? 0),
-    totalCacheWriteTokens: (snap.totalCacheWriteTokens ?? 0) + (tokens?.cacheWrite ?? 0),
-    tokenUsageCount: (snap.tokenUsageCount ?? 0) + (tokens ? 1 : 0),
-    callCount: snap.callCount + 1,
-    errorCount: snap.errorCount,
-    totalErrorCostUsd: snap.totalErrorCostUsd
-  };
-}
-function accumulateError(snap, e) {
-  return {
-    ...snap,
-    errorCount: snap.errorCount + 1,
-    totalErrorCostUsd: snap.totalErrorCostUsd + (e?.costUsd ?? 0)
-  };
-}
-
-class CostAggregator {
-  _runId;
-  _drainDir;
-  _events = [];
-  _errors = [];
-  _draining = false;
-  _inFlightEvents = [];
-  _inFlightErrors = [];
-  _openScopes = new Set;
-  constructor(_runId, _drainDir) {
-    this._runId = _runId;
-    this._drainDir = _drainDir;
-  }
-  record(event) {
-    if (this._draining) {
-      this._inFlightEvents.push(event);
-      return;
-    }
-    this._events.push(event);
-  }
-  recordError(event) {
-    if (this._draining) {
-      this._inFlightErrors.push(event);
-      return;
-    }
-    this._errors.push(event);
-  }
-  recordOperationSummary(_event) {}
-  snapshot() {
-    const allEvents = [...this._events, ...this._inFlightEvents];
-    const allErrors = [...this._errors, ...this._inFlightErrors];
-    const eventReduced = allEvents.reduce(accumulate, emptySnap());
-    return allErrors.reduce((snap, e) => accumulateError(snap, e), eventReduced);
-  }
-  byAgent() {
-    const m = {};
-    for (const e of this._events)
-      m[e.agentName] = accumulate(m[e.agentName] ?? emptySnap(), e);
-    for (const e of this._inFlightEvents)
-      m[e.agentName] = accumulate(m[e.agentName] ?? emptySnap(), e);
-    for (const e of this._errors)
-      m[e.agentName] = accumulateError(m[e.agentName] ?? emptySnap(), e);
-    for (const e of this._inFlightErrors)
-      m[e.agentName] = accumulateError(m[e.agentName] ?? emptySnap(), e);
-    return m;
-  }
-  byStage() {
-    const m = {};
-    for (const e of this._events) {
-      const k = e.stage ?? "unknown";
-      m[k] = accumulate(m[k] ?? emptySnap(), e);
-    }
-    for (const e of this._inFlightEvents) {
-      const k = e.stage ?? "unknown";
-      m[k] = accumulate(m[k] ?? emptySnap(), e);
-    }
-    for (const e of this._errors) {
-      const k = e.stage ?? "unknown";
-      m[k] = accumulateError(m[k] ?? emptySnap(), e);
-    }
-    for (const e of this._inFlightErrors) {
-      const k = e.stage ?? "unknown";
-      m[k] = accumulateError(m[k] ?? emptySnap(), e);
-    }
-    return m;
-  }
-  byStory() {
-    const m = {};
-    for (const e of this._events) {
-      const k = e.storyId ?? "unknown";
-      m[k] = accumulate(m[k] ?? emptySnap(), e);
-    }
-    for (const e of this._inFlightEvents) {
-      const k = e.storyId ?? "unknown";
-      m[k] = accumulate(m[k] ?? emptySnap(), e);
-    }
-    for (const e of this._errors) {
-      const k = e.storyId ?? "unknown";
-      m[k] = accumulateError(m[k] ?? emptySnap(), e);
-    }
-    for (const e of this._inFlightErrors) {
-      const k = e.storyId ?? "unknown";
-      m[k] = accumulateError(m[k] ?? emptySnap(), e);
-    }
-    return m;
-  }
-  byCall() {
-    const m = {};
-    for (const e of [...this._events, ...this._inFlightEvents]) {
-      if (e.callId === undefined)
-        continue;
-      m[e.callId] = accumulate(m[e.callId] ?? emptySnap(), e);
-    }
-    for (const e of [...this._errors, ...this._inFlightErrors]) {
-      if (e.callId === undefined)
-        continue;
-      m[e.callId] = accumulateError(m[e.callId] ?? emptySnap(), e);
-    }
-    return m;
-  }
-  byScope() {
-    const m = {};
-    for (const e of [...this._events, ...this._inFlightEvents]) {
-      if (e.scopeId === undefined)
-        continue;
-      m[e.scopeId] = accumulate(m[e.scopeId] ?? emptySnap(), e);
-    }
-    for (const e of [...this._errors, ...this._inFlightErrors]) {
-      if (e.scopeId === undefined)
-        continue;
-      m[e.scopeId] = accumulateError(m[e.scopeId] ?? emptySnap(), e);
-    }
-    return m;
-  }
-  openScope(scopeId) {
-    const id = scopeId ?? _costAggDeps.newCorrelationId();
-    this._openScopes.add(id);
-    let closed = false;
-    return {
-      scopeId: id,
-      snapshot: () => {
-        const matching = [...this._events, ...this._inFlightEvents].filter((e) => e.scopeId === id);
-        const matchingErrors = [...this._errors, ...this._inFlightErrors].filter((e) => e.scopeId === id);
-        const eventSnapshot = matching.reduce(accumulate, emptySnap());
-        return matchingErrors.reduce((snap, e) => accumulateError(snap, e), eventSnapshot);
-      },
-      close: () => {
-        if (closed)
-          return;
-        closed = true;
-        this._openScopes.delete(id);
-      }
-    };
-  }
-  async drain() {
-    const openScopeCount = this._openScopes.size;
-    if (openScopeCount > 0) {
-      _costAggDeps.getSafeLogger()?.warn("cost-aggregator", "drain called with open scopes", { openScopeCount });
-    }
-    this._draining = true;
-    try {
-      let committed = [...this._events.splice(0), ...this._errors.splice(0)];
-      if (committed.length === 0 && this._inFlightEvents.length === 0 && this._inFlightErrors.length === 0) {
-        return;
-      }
-      mkdirSync3(this._drainDir, { recursive: true });
-      const path11 = join51(this._drainDir, `${this._runId}.jsonl`);
-      let first = true;
-      let pass = 0;
-      while (first || this._inFlightEvents.length > 0 || this._inFlightErrors.length > 0) {
-        if (++pass > MAX_DRAIN_PASSES) {
-          _costAggDeps.getSafeLogger()?.warn("cost-aggregator", "drain exceeded max passes \u2014 late events keep arriving", {
-            pass,
-            inFlightEvents: this._inFlightEvents.length,
-            inFlightErrors: this._inFlightErrors.length
-          });
-          break;
-        }
-        first = false;
-        const late = [...this._inFlightEvents.splice(0), ...this._inFlightErrors.splice(0)];
-        committed = [...committed, ...late].sort((a, b) => a.ts - b.ts);
-        await _costAggDeps.write(path11, `${committed.map((e) => JSON.stringify(e)).join(`
-`)}
-`);
-      }
-      const committedEvents = committed.filter((e) => !(("kind" in e) && e.kind === "error"));
-      const committedErrors = committed.filter((e) => ("kind" in e) && e.kind === "error");
-      this._events.length = 0;
-      this._events.push(...committedEvents);
-      this._errors.length = 0;
-      this._errors.push(...committedErrors);
-    } finally {
-      this._draining = false;
-    }
-  }
-}
-var MAX_DRAIN_PASSES = 20, EMPTY_SNAPSHOT, _costAggDeps;
-var init_cost_aggregator = __esm(() => {
-  init_logger2();
-  EMPTY_SNAPSHOT = {
-    totalCostUsd: 0,
-    totalEstimatedCostUsd: 0,
-    totalExactCostUsd: 0,
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    totalCacheReadTokens: 0,
-    totalCacheWriteTokens: 0,
-    tokenUsageCount: 0,
-    callCount: 0,
-    errorCount: 0,
-    totalErrorCostUsd: 0
-  };
-  _costAggDeps = {
-    write: (path11, data) => Bun.write(path11, data),
-    getSafeLogger: () => getSafeLogger(),
-    newCorrelationId: makeCorrelationId
-  };
-});
-
 // src/runtime/middleware/agent-stream-logging.ts
 function attachAgentStreamLogging(bus, runId) {
   const activeCalls = new Map;
@@ -63653,6 +63821,8 @@ __export(exports_runtime, {
   projectOutputDir: () => projectOutputDir,
   readProjectIdentity: () => readProjectIdentity,
   resolveIdleWatchdogSettings: () => resolveIdleWatchdogSettings,
+  storySpendUsd: () => storySpendUsd,
+  totalSpendUsd: () => totalSpendUsd,
   writeProjectIdentity: () => writeProjectIdentity
 });
 import { basename as basename9, join as join53 } from "path";
@@ -63705,7 +63875,8 @@ function createRuntime(config2, workdir, opts) {
     runId,
     sendPrompt: (handle, prompt, sendOpts) => sessionManager.sendPrompt(handle, prompt, sendOpts),
     runHop: createSessionRunHop(sessionManager, () => agentManager),
-    dispatchEvents
+    dispatchEvents,
+    models: config2.models
   };
   if (opts?.agentManager instanceof AgentManager) {
     opts.agentManager.configureRuntime({ ...agentManagerOpts, pidRegistry });
@@ -66115,7 +66286,10 @@ class DebateRunner {
         resolverCallContext: { ...this.ctx, scopeId: resolverScope.scopeId }
       };
       const result = await runner(ctxWithScopes, prompt);
-      return { ...result, totalCostUsd: debaterScope.snapshot().totalCostUsd + resolverScope.snapshot().totalCostUsd };
+      return {
+        ...result,
+        totalCostUsd: totalSpendUsd(debaterScope.snapshot()) + totalSpendUsd(resolverScope.snapshot())
+      };
     } finally {
       debaterScope.close();
       resolverScope.close();
@@ -66153,7 +66327,7 @@ class DebateRunner {
         debaters: resolved.map((r) => r.debater.agent)
       });
       const concurrencyLimit = this.config?.debate?.maxConcurrentDebaters ?? 2;
-      const scopeTotal = () => prePhaseScope.snapshot().totalCostUsd + debaterScope.snapshot().totalCostUsd + resolverScope.snapshot().totalCostUsd + verifierScope.snapshot().totalCostUsd;
+      const scopeTotal = () => totalSpendUsd(prePhaseScope.snapshot()) + totalSpendUsd(debaterScope.snapshot()) + totalSpendUsd(resolverScope.snapshot()) + totalSpendUsd(verifierScope.snapshot());
       let taskContext = prompt;
       let preDebateManifestSection;
       if (config2.preDebatePhase) {
@@ -71238,7 +71412,8 @@ function collectFixCycleIteration(context, entry, data) {
       outcome,
       findingsBefore: numberValue(data.findingsBefore, 0),
       findingsAfter: numberValue(data.findingsAfter, 0),
-      costUsd: numberValue(data.costUsd, 0)
+      costUsd: numberValue(data.costUsd, 0),
+      errorCostUsd: numberValue(data.errorCostUsd, 0)
     }
   };
 }
@@ -76410,7 +76585,8 @@ async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = fa
     throw err;
   } finally {
     const snapshot = scope.snapshot();
-    phaseCosts[opName] = (phaseCosts[opName] ?? 0) + snapshot.totalCostUsd;
+    const phaseSpend = totalSpendUsd(snapshot);
+    phaseCosts[opName] = (phaseCosts[opName] ?? 0) + phaseSpend;
     scope.close();
     if (ctx.storyId) {
       const phaseDetails = buildPhaseDetails(opName, phaseOutputs[opName], isThreeSession, ctx.packageView.config, advIterationBefore, ctx.fixStrategy);
@@ -76420,7 +76596,8 @@ async function runPhase(ctx, slot, phaseCosts, phaseOutputs, isThreeSession = fa
         phase: opName,
         outcome,
         durationMs: Date.now() - phaseStartedAt,
-        costUsd: snapshot.totalCostUsd,
+        costUsd: phaseSpend,
+        ...snapshot.totalErrorCostUsd > 0 ? { errorCostUsd: snapshot.totalErrorCostUsd } : {},
         ...ctx.phaseTelemetry ? {
           tier: ctx.phaseTelemetry.tier,
           testStrategy: ctx.phaseTelemetry.testStrategy,
@@ -76525,6 +76702,7 @@ var init_run_phase = __esm(() => {
   init_operations();
   init_pipeline2();
   init_review2();
+  init_runtime2();
   init_git();
   init_resume_plan();
   init_non_blocking_fix();
@@ -78319,11 +78497,13 @@ async function handleNoTierAvailable(ctx, failureCategory) {
     if (ctx.featureDir) {
       await appendProgress(ctx.featureDir, ctx.story.id, "paused", `${ctx.story.title} \u2014 Execution stopped (needs human review)`);
     }
+    const spend2 = storySpendUsd(ctx.runtime?.costAggregator, ctx.story.id, ctx.totalCost);
     pipelineEventBus.emit({
       type: "story:paused",
       storyId: ctx.story.id,
       reason: pauseReason,
-      cost: ctx.runtime?.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+      cost: spend2.cost,
+      ...spend2.errorCostUsd > 0 ? { errorCostUsd: spend2.errorCostUsd } : {}
     });
     return { outcome: "paused", prdDirty: true, prd: pausedPrd };
   }
@@ -78336,13 +78516,15 @@ async function handleNoTierAvailable(ctx, failureCategory) {
   if (ctx.featureDir) {
     await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 Execution failed`);
   }
+  const spend = storySpendUsd(ctx.runtime?.costAggregator, ctx.story.id, ctx.totalCost);
   pipelineEventBus.emit({
     type: "story:failed",
     storyId: ctx.story.id,
     story: { id: ctx.story.id, title: ctx.story.title, status: ctx.story.status, attempts: ctx.story.attempts },
     reason: "Execution failed",
     countsTowardEscalation: true,
-    cost: ctx.runtime?.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+    cost: spend.cost,
+    ...spend.errorCostUsd > 0 ? { errorCostUsd: spend.errorCostUsd } : {}
   });
   return { outcome: "failed", prdDirty: true, prd: failedPrd };
 }
@@ -78362,11 +78544,13 @@ async function handleMaxAttemptsReached(ctx, failureCategory) {
     if (ctx.featureDir) {
       await appendProgress(ctx.featureDir, ctx.story.id, "paused", `${ctx.story.title} \u2014 Max attempts reached (needs human review)`);
     }
+    const spend2 = storySpendUsd(ctx.runtime?.costAggregator, ctx.story.id, ctx.totalCost);
     pipelineEventBus.emit({
       type: "story:paused",
       storyId: ctx.story.id,
       reason: pauseReason,
-      cost: ctx.runtime?.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+      cost: spend2.cost,
+      ...spend2.errorCostUsd > 0 ? { errorCostUsd: spend2.errorCostUsd } : {}
     });
     return { outcome: "paused", prdDirty: true, prd: pausedPrd };
   }
@@ -78380,13 +78564,15 @@ async function handleMaxAttemptsReached(ctx, failureCategory) {
   if (ctx.featureDir) {
     await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 Max attempts reached`);
   }
+  const spend = storySpendUsd(ctx.runtime?.costAggregator, ctx.story.id, ctx.totalCost);
   pipelineEventBus.emit({
     type: "story:failed",
     storyId: ctx.story.id,
     story: { id: ctx.story.id, title: ctx.story.title, status: ctx.story.status, attempts: ctx.story.attempts },
     reason: "Max attempts reached",
     countsTowardEscalation: true,
-    cost: ctx.runtime?.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+    cost: spend.cost,
+    ...spend.errorCostUsd > 0 ? { errorCostUsd: spend.errorCostUsd } : {}
   });
   return { outcome: "failed", prdDirty: true, prd: failedPrd };
 }
@@ -78394,6 +78580,7 @@ var init_tier_outcome = __esm(() => {
   init_logger2();
   init_pipeline2();
   init_prd();
+  init_runtime2();
   init_progress();
   init_quote_integrity();
   init_tier_escalation();
@@ -78536,6 +78723,7 @@ async function preIterationTierCheck(story, routing, config2, prd, prdPath, feat
     await appendProgress(featureDir2, story.id, "failed", `${story.title} \u2014 All tiers exhausted`);
   }
   const failedStory = failedPrd.userStories.find((s) => s.id === story.id) ?? story;
+  const spend = storySpendUsd(runtime?.costAggregator, story.id, totalCost);
   pipelineEventBus.emit({
     type: "story:failed",
     storyId: story.id,
@@ -78544,7 +78732,8 @@ async function preIterationTierCheck(story, routing, config2, prd, prdPath, feat
     countsTowardEscalation: true,
     feature,
     attempts: failedStory.attempts,
-    cost: runtime?.costAggregator.byStory()[story.id]?.totalCostUsd ?? totalCost
+    cost: spend.cost,
+    ...spend.errorCostUsd > 0 ? { errorCostUsd: spend.errorCostUsd } : {}
   });
   return { shouldSkipIteration: true, prdDirty: true, prd: failedPrd };
 }
@@ -78669,6 +78858,7 @@ var init_tier_escalation = __esm(() => {
   init_logger2();
   init_pipeline2();
   init_prd();
+  init_runtime2();
   init_escalation();
   init_progress();
   init_quote_integrity();
@@ -79873,6 +80063,7 @@ async function failStoryAfterMerge(ctx, prd, reason) {
   if (ctx.featureDir) {
     await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 ${reason}`);
   }
+  const spend = storySpendUsd(ctx.runtime.costAggregator, ctx.story.id, ctx.totalCost);
   pipelineEventBus.emit({
     type: "story:failed",
     storyId: ctx.story.id,
@@ -79881,7 +80072,8 @@ async function failStoryAfterMerge(ctx, prd, reason) {
     countsTowardEscalation: false,
     feature: ctx.feature,
     attempts: ctx.story.attempts,
-    cost: ctx.runtime.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+    cost: spend.cost,
+    ...spend.errorCostUsd > 0 ? { errorCostUsd: spend.errorCostUsd } : {}
   });
 }
 function filterOutputFiles(files) {
@@ -80014,11 +80206,13 @@ async function handlePipelineFailure(ctx, pipelineResult) {
       if (hasWorktree(ctx.workdir, ctx.story.id)) {
         await removeWorktreeDirectory(ctx.workdir, ctx.story.id);
       }
+      const spend = storySpendUsd(ctx.runtime.costAggregator, ctx.story.id, ctx.totalCost);
       pipelineEventBus.emit({
         type: "story:paused",
         storyId: ctx.story.id,
         reason: pipelineResult.reason || "Pipeline paused",
-        cost: ctx.runtime.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+        cost: spend.cost,
+        ...spend.errorCostUsd > 0 ? { errorCostUsd: spend.errorCostUsd } : {}
       });
       break;
     }
@@ -80031,7 +80225,7 @@ async function handlePipelineFailure(ctx, pipelineResult) {
       });
       prdDirty = true;
       break;
-    case "fail":
+    case "fail": {
       markStoryFailed(prd, ctx.story.id, pipelineResult.context.tddFailureCategory, pipelineResult.stoppedAtStage, ctx.statusWriter);
       await savePRD(prd, ctx.prdPath);
       prdDirty = true;
@@ -80046,6 +80240,7 @@ async function handlePipelineFailure(ctx, pipelineResult) {
       if (ctx.featureDir) {
         await appendProgress(ctx.featureDir, ctx.story.id, "failed", `${ctx.story.title} \u2014 ${pipelineResult.reason}`);
       }
+      const spend = storySpendUsd(ctx.runtime.costAggregator, ctx.story.id, ctx.totalCost);
       pipelineEventBus.emit({
         type: "story:failed",
         storyId: ctx.story.id,
@@ -80054,7 +80249,8 @@ async function handlePipelineFailure(ctx, pipelineResult) {
         countsTowardEscalation: true,
         feature: ctx.feature,
         attempts: ctx.story.attempts,
-        cost: ctx.runtime.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? ctx.totalCost
+        cost: spend.cost,
+        ...spend.errorCostUsd > 0 ? { errorCostUsd: spend.errorCostUsd } : {}
       });
       if (ctx.story.attempts !== undefined && ctx.story.attempts >= ctx.config.execution.rectification.maxAttemptsTotal) {
         await pipelineEventBus.emitAsync({
@@ -80066,6 +80262,7 @@ async function handlePipelineFailure(ctx, pipelineResult) {
         });
       }
       break;
+    }
     case "escalate": {
       const runtimeCrashResult = pipelineResult.context.tddFailureCategory === "runtime-crash" ? { status: "RUNTIME_CRASH", success: false } : undefined;
       const escalationResult = await _resultHandlerDeps.handleTierEscalation({
@@ -80106,6 +80303,7 @@ var init_pipeline_result_handler = __esm(() => {
   init_pipeline2();
   init_logger2();
   init_prd();
+  init_runtime2();
   init_bun_deps();
   init_git();
   init_worktree();
@@ -81127,7 +81325,7 @@ function isExecutionFailure(story) {
   return story != null && (story.status === "failed" || story.status === "regression-failed");
 }
 function synthesizeBackfillMetric(args) {
-  const { storyId, story, totalCostUsd, config: config2, defaultAgent, timestamp, fallbackHops, runtimeCrashes } = args;
+  const { storyId, story, totalCostUsd, errorCostUsd, config: config2, defaultAgent, timestamp, fallbackHops, runtimeCrashes } = args;
   if (story != null && isExecutionFailure(story)) {
     const tier = story.routing?.modelTier ?? "balanced";
     const agent = story.routing?.agent ?? defaultAgent;
@@ -81149,6 +81347,7 @@ function synthesizeBackfillMetric(args) {
       finalTier,
       success: false,
       cost: totalCostUsd,
+      ...errorCostUsd > 0 ? { errorCostUsd } : {},
       durationMs: 0,
       firstPassSuccess: false,
       startedAt: timestamp,
@@ -81167,6 +81366,7 @@ function synthesizeBackfillMetric(args) {
     finalTier: "balanced",
     success: story?.passes ?? false,
     cost: totalCostUsd,
+    ...errorCostUsd > 0 ? { errorCostUsd } : {},
     durationMs: 0,
     firstPassSuccess: story?.passes ?? false,
     startedAt: timestamp,
@@ -81210,7 +81410,9 @@ function applyBackfill(input) {
     stories
   });
   for (const storyId of domain2) {
-    const totalCostUsd = aggByStory[storyId]?.totalCostUsd ?? 0;
+    const snap = aggByStory[storyId];
+    const errorCostUsd = snap?.totalErrorCostUsd ?? 0;
+    const totalCostUsd = (snap?.totalCostUsd ?? 0) + errorCostUsd;
     const fallbackHops = toFallbackHops(agentFallbacks.get(storyId), storyId);
     const runtimeCrashes = runtimeCrashRetries.get(storyId) ?? 0;
     const story = storyById.get(storyId);
@@ -81223,6 +81425,7 @@ function applyBackfill(input) {
         storyId,
         story,
         totalCostUsd,
+        errorCostUsd,
         config: config2,
         defaultAgent,
         timestamp,
@@ -81233,7 +81436,11 @@ function applyBackfill(input) {
     }
     const existing = allStoryMetrics[existingIdx];
     if (totalCostUsd > (existing.cost ?? 0)) {
-      allStoryMetrics[existingIdx] = { ...existing, cost: totalCostUsd };
+      allStoryMetrics[existingIdx] = {
+        ...existing,
+        cost: totalCostUsd,
+        ...errorCostUsd > 0 ? { errorCostUsd } : {}
+      };
     }
   }
 }
@@ -82167,7 +82374,9 @@ async function handleRunCompletion(options) {
     });
   }
   const aggSnap = options.runtime.costAggregator.snapshot();
-  const reportedTotal = aggSnap.totalCostUsd;
+  const reportedTotal = totalSpendUsd(aggSnap);
+  const errorCostUsd = aggSnap.totalErrorCostUsd;
+  const errorCostField = errorCostUsd > 0 ? { errorCostUsd } : {};
   const aggByStage = options.runtime.costAggregator.byStage();
   const aggByStory = options.runtime.costAggregator.byStory();
   applyBackfill({
@@ -82200,6 +82409,7 @@ async function handleRunCompletion(options) {
     pausedStories: finalCounts.paused,
     durationMs,
     totalCost: reportedTotal,
+    ...errorCostField,
     ...fallbackAggregate && { fallback: fallbackAggregate }
   });
   await pipelineEventBus.drain();
@@ -82209,6 +82419,7 @@ async function handleRunCompletion(options) {
     startedAt,
     completedAt: runCompletedAt,
     totalCost: reportedTotal,
+    ...errorCostField,
     totalStories: allStoryMetrics.length,
     storiesCompleted,
     storiesFailed: finalCounts.failed,
@@ -82273,6 +82484,7 @@ async function handleRunCompletion(options) {
     storiesFailed: finalCounts.failed,
     storiesPending: finalCounts.pending,
     totalCost: reportedTotal,
+    ...errorCostField,
     ...contextCostUsd > 0 && { contextCostUsd },
     ...Object.keys(aggByStage).length > 0 && { costByStage: aggByStage },
     ...Object.keys(aggByStory).length > 0 && { costByStory: aggByStory },
@@ -82307,6 +82519,7 @@ var init_run_completion = __esm(() => {
   init_pipeline2();
   init_prd();
   init_project();
+  init_runtime2();
   init_session2();
   init_detect();
   init_verification();
@@ -88898,6 +89111,7 @@ var init_phase = __esm(() => {
   init_forge();
   init_logger2();
   init_pipeline2();
+  init_runtime2();
   init_config3();
   init_context3();
   init_machine();
@@ -88911,7 +89125,7 @@ var init_phase = __esm(() => {
     runFinishMachine,
     sendTelegramNotify,
     now: () => new Date().toISOString(),
-    snapshotCost: (runtime) => runtime.costAggregator.snapshot().totalCostUsd
+    snapshotCost: (runtime) => totalSpendUsd(runtime.costAggregator.snapshot())
   };
 });
 
@@ -89592,6 +89806,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime, projectKey) {
               status: "completed",
               runElapsedMs: ev.runElapsedMs,
               cost: ev.cost ?? 0,
+              ...ev.errorCostUsd !== undefined ? { errorCostUsd: ev.errorCostUsd } : {},
               tier: ev.modelTier ?? "balanced",
               testStrategy: ev.testStrategy ?? "test-after"
             });
@@ -89613,7 +89828,8 @@ function wireReporters(bus, pluginRegistry, runId, startTime, projectKey) {
               storyId: ev.storyId,
               status: "failed",
               runElapsedMs: Date.now() - startTime,
-              cost: 0,
+              cost: ev.cost ?? 0,
+              ...ev.errorCostUsd !== undefined ? { errorCostUsd: ev.errorCostUsd } : {},
               tier: "balanced",
               testStrategy: "test-after"
             });
@@ -89635,7 +89851,8 @@ function wireReporters(bus, pluginRegistry, runId, startTime, projectKey) {
               storyId: ev.storyId,
               status: "paused",
               runElapsedMs: Date.now() - startTime,
-              cost: 0,
+              cost: ev.cost ?? 0,
+              ...ev.errorCostUsd !== undefined ? { errorCostUsd: ev.errorCostUsd } : {},
               tier: "balanced",
               testStrategy: "test-after"
             });
@@ -89675,6 +89892,7 @@ function wireReporters(bus, pluginRegistry, runId, startTime, projectKey) {
               runId,
               totalDurationMs: Date.now() - startTime,
               totalCost: ev.totalCost ?? 0,
+              ...ev.errorCostUsd !== undefined ? { errorCostUsd: ev.errorCostUsd } : {},
               storySummary: {
                 completed: ev.passedStories,
                 failed: ev.failedStories,
@@ -89698,6 +89916,30 @@ var init_reporters = __esm(() => {
   init_logger2();
 });
 
+// src/execution/cost-guard.ts
+async function enforceCostLimit(ctx, totalCost2, costLimit, storyId) {
+  const enforcedCost = Math.max(totalCost2, totalSpendUsd(ctx.runtime.costAggregator.snapshot()));
+  if (enforcedCost < costLimit)
+    return { stop: false, enforcedCost };
+  const shouldProceed = ctx.interactionChain && isTriggerEnabled("cost-exceeded", ctx.config) ? await checkCostExceeded({ featureName: ctx.feature, cost: enforcedCost, limit: costLimit }, ctx.config, ctx.interactionChain) : false;
+  if (!shouldProceed) {
+    pipelineEventBus.emit({
+      type: "run:paused",
+      reason: `Cost limit reached: $${enforcedCost.toFixed(2)}`,
+      ...storyId !== undefined ? { storyId } : {},
+      cost: enforcedCost
+    });
+    return { stop: true, enforcedCost };
+  }
+  pipelineEventBus.emit({ type: "run:resumed", feature: ctx.feature });
+  return { stop: false, enforcedCost };
+}
+var init_cost_guard = __esm(() => {
+  init_runtime2();
+  init_triggers();
+  init_event_bus();
+});
+
 // src/execution/cost-warning.ts
 async function maybeSendCostWarning(ctx, enforcedCost, costLimit, warningSent) {
   if (warningSent || !ctx.interactionChain || !isTriggerEnabled("cost-warning", ctx.config))
@@ -90231,23 +90473,6 @@ async function closeStoryIfTerminal(ctx, storyId, iter) {
     await closeStorySessions(ctx.sessionManager, storyId, ctx.agentGetFn);
   ctx.agentManager?.resetTransientUnavailable?.();
 }
-async function enforceCostLimit(ctx, totalCost2, costLimit, storyId) {
-  const enforcedCost = Math.max(totalCost2, ctx.runtime.costAggregator.snapshot().totalCostUsd);
-  if (enforcedCost < costLimit)
-    return { stop: false, enforcedCost };
-  const shouldProceed = ctx.interactionChain && isTriggerEnabled("cost-exceeded", ctx.config) ? await checkCostExceeded({ featureName: ctx.feature, cost: enforcedCost, limit: costLimit }, ctx.config, ctx.interactionChain) : false;
-  if (!shouldProceed) {
-    pipelineEventBus.emit({
-      type: "run:paused",
-      reason: `Cost limit reached: $${enforcedCost.toFixed(2)}`,
-      ...storyId !== undefined ? { storyId } : {},
-      cost: enforcedCost
-    });
-    return { stop: true, enforcedCost };
-  }
-  pipelineEventBus.emit({ type: "run:resumed", feature: ctx.feature });
-  return { stop: false, enforcedCost };
-}
 async function executeUnified(ctx, initialPrd) {
   const logger = getSafeLogger();
   let prd = initialPrd;
@@ -90666,7 +90891,7 @@ async function executeUnified(ctx, initialPrd) {
         iter.prdDirty
       ];
       await closeStoryIfTerminal(ctx, selection.story.id, iter);
-      warningSent = await maybeSendCostWarning(ctx, Math.max(totalCost2, ctx.runtime.costAggregator.snapshot().totalCostUsd), costLimit, warningSent);
+      warningSent = await maybeSendCostWarning(ctx, Math.max(totalCost2, totalSpendUsd(ctx.runtime.costAggregator.snapshot())), costLimit, warningSent);
       if (iter.prdDirty) {
         prd = await loadPRD(ctx.prdPath);
         prdDirty = false;
@@ -90740,6 +90965,7 @@ function reconcileBatchOutcome(prd, batchResult) {
 var TERMINAL_ACTIONS, _prevRunUnsubscribers, _unifiedExecutorDeps;
 var init_unified_executor = __esm(() => {
   init_pipeline2();
+  init_runtime2();
   init_triggers();
   init_logger2();
   init_metrics();
@@ -90754,6 +90980,7 @@ var init_unified_executor = __esm(() => {
   init_routing();
   init_bun_deps();
   init_path_filters();
+  init_cost_guard();
   init_cost_warning();
   init_crash_recovery();
   init_deferred_review();
@@ -91442,6 +91669,7 @@ var init_completion = __esm(() => {
   init_logger2();
   init_metrics();
   init_prd();
+  init_runtime2();
   init_git();
   init_verification();
   init_event_bus();
@@ -91452,7 +91680,8 @@ var init_completion = __esm(() => {
     async execute(ctx) {
       const logger = getLogger();
       const isBatch = ctx.stories.length > 1;
-      const sessionCost = ctx.runtime.costAggregator.byStory()[ctx.story.id]?.totalCostUsd ?? 0;
+      const sessionSpend = storySpendUsd(ctx.runtime.costAggregator, ctx.story.id, 0);
+      const sessionCost = sessionSpend.cost;
       const persistPrd2 = ctx.skipPrdPersistence !== true;
       const prdPath = ctx.prdPath ?? join104(ctx.featureDir ?? featureDir(ctx.workdir, "unknown"), "prd.json");
       const storyStartTime = ctx.storyStartTime || new Date().toISOString();
@@ -91497,6 +91726,7 @@ var init_completion = __esm(() => {
           markStoryPassed(ctx.prd, completedStory.id);
         }
         const costPerStory = sessionCost / ctx.stories.length;
+        const errorCostPerStory = sessionSpend.errorCostUsd / ctx.stories.length;
         logger.info("completion", "Story passed", {
           storyId: completedStory.id,
           cost: costPerStory
@@ -91518,6 +91748,7 @@ var init_completion = __esm(() => {
             passed: true,
             runElapsedMs: storyMetric?.durationMs ?? 0,
             cost: costPerStory,
+            ...errorCostPerStory > 0 ? { errorCostUsd: errorCostPerStory } : {},
             modelTier: ctx.routing?.modelTier,
             testStrategy: ctx.routing?.testStrategy
           });
@@ -93886,6 +94117,7 @@ async function displayLastRunMetrics(workdir) {
     storiesCompleted: lastRun.storiesCompleted,
     storiesFailed: lastRun.storiesFailed,
     totalCost: lastRun.totalCost,
+    ...lastRun.errorCostUsd !== undefined ? { errorCostUsd: lastRun.errorCostUsd } : {},
     avgCostPerStory: reportedLastRun?.avgCostPerStory ?? 0
   });
   const sortedStories = [...lastRun.stories].sort((a, b) => b.cost - a.cost);