nexus-agents 3.15.0 → 4.0.0

package/dist/{chunk-OUE5RIYB.js → chunk-7LCLCIGM.js}

@@ -1,6 +1,6 @@
 import {
   generateSecurityPlan
-} from "./chunk-BWP3SQRB.js";
+} from "./chunk-FD3I5B4X.js";
 import {
   analyzeGitHubRepo
 } from "./chunk-HFOQKCD2.js";
@@ -22,10 +22,10 @@ import {
   DEFAULT_TASK_TTL_MS,
   DEFAULT_TOOL_RATE_LIMITS,
   clampTaskTtl
-} from "./chunk-PKJMR6LK.js";
+} from "./chunk-THTBIBCW.js";
 import {
   executeExpert
-} from "./chunk-IQJUVQXT.js";
+} from "./chunk-4Z2Z52C7.js";
 import {
   JobStatusSchema,
   abortJob,
@@ -46,24 +46,24 @@ import {
   simulationDeniedResult,
   toJobSummary,
   writeJobCancelled
-} from "./chunk-ACR53LYN.js";
+} from "./chunk-QJKXF2MY.js";
 import {
   allOf
 } from "./chunk-OQB3XC5O.js";
 import {
   normalizeTopicToCanonical,
   synthesizeResearch
-} from "./chunk-TXZVEYXX.js";
+} from "./chunk-BMEJLPAE.js";
 import {
   IssueTriage
-} from "./chunk-Z3EIIXYW.js";
+} from "./chunk-N7YLNXHT.js";
 import {
   resolveEnvMode,
   sanitizeInput
-} from "./chunk-4LD5TWZ5.js";
+} from "./chunk-5HPJB35V.js";
 import {
   withPrerequisite
-} from "./chunk-GFQI6SWN.js";
+} from "./chunk-WXCRNJNO.js";
 import {
   NOOP_NOTIFIER,
   RateLimiter,
@@ -87,18 +87,18 @@ import {
   withAuditTrail,
   withProgressHeartbeat,
   wrapToolWithTimeout
-} from "./chunk-AKFSWIMY.js";
+} from "./chunk-VOLQTAV4.js";
 import {
   createAuditTrail,
   createGraphAuditBridge,
   emitPipelinePolicyEvent
-} from "./chunk-4L7OIPPC.js";
+} from "./chunk-ADIMVMAB.js";
 import {
   EventTopics,
   createEvent,
   getGlobalEventBus,
   getGlobalRegistry
-} from "./chunk-SEIKS6JB.js";
+} from "./chunk-VKLMXCI2.js";
 import {
   IDENTIFIER_RE,
   LANG_VALUES,
@@ -131,31 +131,31 @@ import {
   parseRegistry,
   sourceExistsInRegistry,
   summarizeContextForPrompt
-} from "./chunk-6RMLXVDE.js";
+} from "./chunk-CNB4PA7Q.js";
 import {
   loadPapersRegistry,
   loadTechniquesRegistry
-} from "./chunk-I7GXJESU.js";
+} from "./chunk-UM376MEM.js";
 import {
   resolveInsideRoot
 } from "./chunk-NUBSJGQZ.js";
 import {
   getTokenEnvVars,
   resolveToken
-} from "./chunk-ALAWHZGZ.js";
+} from "./chunk-3OM2W7H7.js";
 import {
   DEFAULT_RELEVANCE_CONFIG,
   MemoryImportance,
   calculateTextJaccardSimilarity,
   getToolMemory
-} from "./chunk-3J7AZXDA.js";
+} from "./chunk-KVHA4AEF.js";
 import {
   STOPWORDS,
   truncateWithInfo
 } from "./chunk-6T3EPABN.js";
 import {
   createSessionMemory
-} from "./chunk-SR5LZ5ZU.js";
+} from "./chunk-JRU5G6VW.js";
 import {
   BUILT_IN_EXPERTS,
   BuiltInExpertTypeSchema,
@@ -173,25 +173,25 @@ import {
   getAvailableClis,
   sleep,
   withTimeout
-} from "./chunk-XFWFCNBH.js";
+} from "./chunk-AMEVOGE7.js";
 import {
   BaseAdapter,
   createStream,
   requireApiKey,
   validateApiKeyPresence
-} from "./chunk-PKFOCPWL.js";
+} from "./chunk-KLN7TJLT.js";
 import {
   DEFAULTS
-} from "./chunk-FMEZ3J4A.js";
+} from "./chunk-HNC2G7AS.js";
 import {
   getAvailabilityCache,
   getCliForModelId,
   resolveFallback
-} from "./chunk-WIHC4JQB.js";
+} from "./chunk-S645LGB6.js";
 import {
   generateHyphenId,
   generateUUID
-} from "./chunk-V5OV5KMM.js";
+} from "./chunk-FRTNZUUF.js";
 import {
   AGENT_ROUTER_TIMEOUTS,
   API_TIMEOUTS,
@@ -291,7 +291,7 @@ import {
   selectStrategyByManifest,
   toExpertTaskAnalysisResult,
   withStep
-} from "./chunk-SH3A7WBR.js";
+} from "./chunk-TN7HF2SQ.js";
 import {
   ensureLearningDir,
   getMetaOutcomesFile,
@@ -5215,6 +5215,13 @@ var MIN_EXPERTS_FOR_PATTERN = {
   // Single agent with execution feedback (arXiv:2304.05128)
 };
 
+// src/agents/collaboration/token-usage-summary.ts
+function summarizeTokenUsage(contributors) {
+  const totalTokensUsed = contributors.filter((m) => m.tokensMeasured !== false).reduce((sum, m) => sum + m.tokensUsed, 0);
+  const unmeasuredResults = contributors.filter((m) => m.tokensMeasured === false).length;
+  return unmeasuredResults > 0 ? { totalTokensUsed, unmeasuredResults } : { totalTokensUsed };
+}
+
 // src/agents/collaboration/session-helpers.ts
 function getSequentialAssignments(config, participants, results) {
   const assignments = [];
@@ -5371,7 +5378,9 @@ function buildAggregatedResult(input) {
       resultCount: results.length,
       conflictCount: 0,
       averageConfidence: 1,
-      totalTokensUsed: results.reduce((sum, r) => sum + r.metadata.tokensUsed, 0),
+      // #4743: shared with result-aggregator so the two cannot drift — they
+      // were duplicate expressions computing the same thing.
+      ...summarizeTokenUsage(results.map((r) => r.metadata)),
       aggregatedAt: endTime.toISOString()
     }
   };
@@ -9205,7 +9214,7 @@ var WaveScheduler = class {
       if (aborted) break;
       if (this.isTokenBudgetExhausted(totalTokensUsed)) {
         aborted = true;
-        abortReason = `Token budget exhausted: ${String(totalTokensUsed)}/${String(this.config.maxTotalTokens)}`;
+        abortReason = `Estimated token budget exhausted: ${String(totalTokensUsed)}/${String(this.config.maxTotalTokens)} (estimate excludes input and failed tasks)`;
         break;
       }
       const wave = taskWaves[waveIdx];
@@ -9240,9 +9249,13 @@ var WaveScheduler = class {
     if (this.config.maxTotalTokens <= 0 || totalTokensUsed < this.config.maxTotalTokens) {
       return false;
     }
-    this.logger.warn("Wave execution aborted: token budget exhausted", {
+    this.logger.warn("Wave execution aborted: estimated token budget exhausted", {
       totalTokensUsed,
-      maxTotalTokens: this.config.maxTotalTokens
+      maxTotalTokens: this.config.maxTotalTokens,
+      // #4761: say what the figure is. It sums output-char estimates, ignores
+      // input, and counts failed tasks as zero — so the real spend at the point
+      // of abort is HIGHER than the number that triggered it.
+      basis: "sum of outputChars/4 estimates; excludes input and failed tasks"
     });
     return true;
   }
@@ -9309,6 +9322,10 @@ var WaveScheduler = class {
         output: "",
         truncated: false,
         originalLength: 0,
+        // #4761: a task that ran and then threw did not cost nothing — this 0
+        // is "unknown", and it under-counts any budget summing it. There is no
+        // better number available: the executor threw instead of returning
+        // output, and it reports no usage.
         estimatedTokens: 0,
         durationMs,
         error: message
@@ -13838,7 +13855,7 @@ var ResultAggregator = class {
     return ok(void 0);
   }
   buildResult(results, output2, strategy, conflicts, qualityScore) {
-    const totalTokensUsed = results.reduce((s, r) => s + r.result.metadata.tokensUsed, 0);
+    const usage = summarizeTokenUsage(results.map((r) => r.result.metadata));
     const avgConfidence = results.reduce((s, r) => s + (r.confidence ?? 0.5), 0) / results.length;
     return {
       output: output2,
@@ -13849,7 +13866,7 @@ var ResultAggregator = class {
         resultCount: results.length,
         conflictCount: conflicts.length,
         averageConfidence: Math.round(avgConfidence * 100) / 100,
-        totalTokensUsed,
+        ...usage,
         aggregatedAt: getTimeProvider().nowIso()
       }
     };
@@ -14137,7 +14154,8 @@ function emitPhaseCompleted(eventBus, params) {
       iteration: params.iteration,
       phase: params.phase,
       durationMs: params.durationMs,
-      tokensUsed: params.tokensUsed
+      tokensUsed: params.tokensUsed,
+      ...params.tokensMeasured !== void 0 ? { tokensMeasured: params.tokensMeasured } : {}
     },
     { sessionId: params.sessionId }
   );
@@ -14272,23 +14290,25 @@ var TrinityCoordinator = class {
     const result = await ctx.agent.execute(task);
     const durationMs = time.now() - phaseStart;
     const tokensUsed = result.ok ? result.value.metadata.tokensUsed : 0;
+    const tokensMeasured = result.ok ? result.value.metadata.tokensMeasured : void 0;
     emitPhaseCompleted(this.eventBus, {
       iteration: 0,
       phase: "thinker",
       durationMs,
       tokensUsed,
+      // #4743: a failed phase emits this event with tokensUsed 0. Without the
+      // flag that 0 is indistinguishable from a phase that genuinely spent
+      // nothing — and this event is the only observable record of a failure.
+      tokensMeasured: result.ok ? result.value.metadata.tokensMeasured : false,
       sessionId: ctx.sessionId
     });
     if (!result.ok) return err(new AgentError("Thinker phase failed", { cause: result.error }));
     const output2 = String(result.value.output);
     ctx.history.push(
-      this.createPhaseResult(
-        "thinking",
-        "thinker",
-        output2,
-        phaseStart,
-        result.value.metadata.tokensUsed
-      )
+      this.createPhaseResult("thinking", "thinker", output2, phaseStart, {
+        tokensUsed,
+        ...tokensMeasured !== void 0 ? { tokensMeasured } : {}
+      })
     );
     return ok(parseThinkerOutput(output2));
   }
@@ -14316,16 +14336,26 @@ Previous Attempt Feedback:
     const result = await ctx.agent.execute(task);
     const durationMs = time.now() - phaseStart;
     const tokensUsed = result.ok ? result.value.metadata.tokensUsed : 0;
+    const tokensMeasured = result.ok ? result.value.metadata.tokensMeasured : void 0;
     emitPhaseCompleted(this.eventBus, {
       iteration,
       phase: "worker",
       durationMs,
       tokensUsed,
+      // #4743: a failed phase emits this event with tokensUsed 0. Without the
+      // flag that 0 is indistinguishable from a phase that genuinely spent
+      // nothing — and this event is the only observable record of a failure.
+      tokensMeasured: result.ok ? result.value.metadata.tokensMeasured : false,
       sessionId: ctx.sessionId
     });
     if (!result.ok) return err(new AgentError("Worker phase failed", { cause: result.error }));
     const output2 = String(result.value.output);
-    ctx.history.push(this.createPhaseResult("working", "worker", output2, phaseStart, tokensUsed));
+    ctx.history.push(
+      this.createPhaseResult("working", "worker", output2, phaseStart, {
+        tokensUsed,
+        ...tokensMeasured !== void 0 ? { tokensMeasured } : {}
+      })
+    );
     return ok(parseWorkerOutput(output2));
   }
   async runVerifier(ctx, thinker, worker, iteration) {
@@ -14348,22 +14378,37 @@ ${worker.implementation}`;
     const result = await ctx.agent.execute(task);
     const durationMs = time.now() - phaseStart;
     const tokensUsed = result.ok ? result.value.metadata.tokensUsed : 0;
+    const tokensMeasured = result.ok ? result.value.metadata.tokensMeasured : void 0;
     emitPhaseCompleted(this.eventBus, {
       iteration,
       phase: "verifier",
       durationMs,
       tokensUsed,
+      // #4743: a failed phase emits this event with tokensUsed 0. Without the
+      // flag that 0 is indistinguishable from a phase that genuinely spent
+      // nothing — and this event is the only observable record of a failure.
+      tokensMeasured: result.ok ? result.value.metadata.tokensMeasured : false,
       sessionId: ctx.sessionId
     });
     if (!result.ok) return err(new AgentError("Verifier phase failed", { cause: result.error }));
     const output2 = String(result.value.output);
     ctx.history.push(
-      this.createPhaseResult("verifying", "verifier", output2, phaseStart, tokensUsed)
+      this.createPhaseResult("verifying", "verifier", output2, phaseStart, {
+        tokensUsed,
+        ...tokensMeasured !== void 0 ? { tokensMeasured } : {}
+      })
     );
     return ok(parseVerifierOutput(output2));
   }
-  createPhaseResult(phase, role, output2, startTime, tokensUsed) {
-    return { phase, role, output: output2, durationMs: getTimeProvider().now() - startTime, tokensUsed };
+  createPhaseResult(phase, role, output2, startTime, usage) {
+    return {
+      phase,
+      role,
+      output: output2,
+      durationMs: getTimeProvider().now() - startTime,
+      tokensUsed: usage.tokensUsed,
+      ...usage.tokensMeasured !== void 0 ? { tokensMeasured: usage.tokensMeasured } : {}
+    };
   }
   isTimedOut(ctx) {
     return getTimeProvider().now() - ctx.startTime > this.config.timeoutMs;
@@ -17634,7 +17679,9 @@ var SicaVersionManager = class {
     const count = history.length;
     const successes = history.filter((e) => e.success).length;
     const avgDuration = history.reduce((s, e) => s + e.durationMs, 0) / count;
-    const avgTokens = history.reduce((s, e) => s + e.tokensUsed, 0) / count;
+    const measuredTokens = history.filter((e) => e.tokensMeasured !== false);
+    const avgTokens = measuredTokens.length > 0 ? measuredTokens.reduce((s, e) => s + e.tokensUsed, 0) / measuredTokens.length : 0;
+    const unmeasuredExecutions = count - measuredTokens.length;
     const qualityScores = history.filter((e) => e.qualityScore !== void 0);
     const avgQuality = qualityScores.length > 0 ? qualityScores.reduce((s, e) => s + (e.qualityScore ?? 0), 0) / qualityScores.length : void 0;
     entry.metrics = {
@@ -17644,6 +17691,7 @@ var SicaVersionManager = class {
       successRate: count > 0 ? successes / count : 0,
       avgDurationMs: avgDuration,
       avgTokensUsed: avgTokens,
+      ...unmeasuredExecutions > 0 && { unmeasuredExecutions },
       ...avgQuality !== void 0 && { avgQualityScore: avgQuality },
       lastUpdatedAt: new Date(getTimeProvider().now())
     };
@@ -17946,6 +17994,9 @@ var SicaAgent = class {
       return {
         durationMs,
         tokensUsed: 0,
+        // #4743: a failed execution produced no measurement; this 0 is unknown,
+        // not a measured zero, and averaging it in understates cost.
+        tokensMeasured: false,
         success: false,
         errorType: result.error.message
       };
@@ -17953,6 +18004,9 @@ var SicaAgent = class {
     return {
       durationMs,
       tokensUsed: result.value.metadata.tokensUsed,
+      ...result.value.metadata.tokensMeasured !== void 0 && {
+        tokensMeasured: result.value.metadata.tokensMeasured
+      },
       success: true,
       qualityScore: estimateQuality(result.value)
     };
@@ -22708,407 +22762,6 @@ function createStepExecutor(deps) {
   return new StepExecutor(deps);
 }
 
-// src/workflows/budget-circuit-breaker-types.ts
-import { z as z37 } from "zod";
-var BudgetCircuitBreakerConfigSchema = z37.object({
-  /** Warning threshold as percentage (0-1) of budget (default: 0.8) */
-  warningThreshold: z37.number().min(0).max(1).default(0.8),
-  /** Critical threshold as percentage (0-1) that opens circuit (default: 0.95) */
-  criticalThreshold: z37.number().min(0).max(1).default(0.95),
-  /** Time in ms to wait before allowing half-open probes (default: 5000) */
-  cooldownMs: z37.number().positive().default(5e3),
-  /** Number of successful low-usage probes to close circuit (default: 2) */
-  recoveryProbes: z37.number().int().positive().default(2),
-  /** Whether to enforce hard stops (default: true) */
-  hardStop: z37.boolean().default(true),
-  /** Reserve percentage for step completion (default: 0.1) */
-  stepReserve: z37.number().min(0).max(0.5).default(0.1)
-});
-var DEFAULT_BUDGET_CIRCUIT_CONFIG = {
-  warningThreshold: 0.8,
-  criticalThreshold: 0.95,
-  cooldownMs: 5e3,
-  recoveryProbes: 2,
-  hardStop: true,
-  stepReserve: 0.1
-};
-var BudgetCircuitError = class extends NexusError {
-  budgetErrorCode;
-  circuitState;
-  usage;
-  constructor(message, options) {
-    const baseOptions = {
-      code: ErrorCode.RATE_LIMIT_ERROR,
-      context: {
-        budgetErrorCode: options.budgetErrorCode,
-        circuitState: options.circuitState,
-        currentTokens: options.usage.currentTokens,
-        maxTokens: options.usage.maxTokens,
-        usagePercent: options.usage.usagePercent
-      }
-    };
-    if (options.cause !== void 0) {
-      baseOptions.cause = options.cause;
-    }
-    super(message, baseOptions);
-    this.name = "BudgetCircuitError";
-    this.budgetErrorCode = options.budgetErrorCode;
-    this.circuitState = options.circuitState;
-    this.usage = options.usage;
-  }
-};
-
-// src/workflows/budget-circuit-breaker.ts
-var BudgetCircuitBreaker = class {
-  constructor(maxTokens, config, logger59) {
-    this.maxTokens = maxTokens;
-    this.config = { ...DEFAULT_BUDGET_CIRCUIT_CONFIG, ...config };
-    this.lastStateChange = getTimeProvider().now();
-    this.logger = logger59 ?? createLogger({ component: "budget-circuit-breaker" });
-  }
-  maxTokens;
-  state = "closed";
-  lastStateChange;
-  violationCount = 0;
-  recoveryProbeCount = 0;
-  lastUsage = null;
-  currentTokens = 0;
-  listeners = /* @__PURE__ */ new Set();
-  logger;
-  config;
-  checkBudget(estimatedTokens) {
-    this.checkCooldown();
-    const usage = this.createUsageSnapshot();
-    const projectedUsage = this.calculateProjectedUsage(estimatedTokens);
-    if (this.state === "open") {
-      return this.createBlockedResult(usage, "Circuit is open - budget exceeded");
-    }
-    if (this.state === "half-open") {
-      return this.handleHalfOpenCheck(estimatedTokens, usage, projectedUsage);
-    }
-    return this.handleClosedCheck(estimatedTokens, usage, projectedUsage);
-  }
-  recordUsage(actualTokens) {
-    this.currentTokens += actualTokens;
-    this.lastUsage = this.createUsageSnapshot();
-    this.logger.debug("Budget usage recorded", {
-      actualTokens,
-      totalUsed: this.currentTokens,
-      maxTokens: this.maxTokens,
-      usagePercent: this.lastUsage.usagePercent
-    });
-    if (this.state === "closed" && this.lastUsage.usagePercent >= this.config.criticalThreshold) {
-      this.transitionTo("open", "Usage exceeded critical threshold after recording");
-    }
-  }
-  allocateForStep(stepId, remainingSteps) {
-    const available = Math.max(0, this.maxTokens - this.currentTokens);
-    const reserveForOthers = remainingSteps > 1 ? this.config.stepReserve * available : 0;
-    const allocatable = available - reserveForOthers;
-    const perStepAllocation = Math.floor(allocatable / Math.max(1, remainingSteps));
-    this.logger.debug("Step budget allocated", {
-      stepId,
-      remainingSteps,
-      available,
-      allocated: perStepAllocation,
-      reserveForOthers: Math.floor(reserveForOthers)
-    });
-    return {
-      stepId,
-      allocatedTokens: perStepAllocation,
-      remainingForOtherSteps: available - perStepAllocation,
-      remainingStepCount: remainingSteps - 1
-    };
-  }
-  getState() {
-    this.checkCooldown();
-    return this.state;
-  }
-  getSnapshot() {
-    this.checkCooldown();
-    return {
-      state: this.state,
-      lastStateChange: this.lastStateChange,
-      violationCount: this.violationCount,
-      recoveryProbeCount: this.recoveryProbeCount,
-      lastUsage: this.lastUsage,
-      config: this.config
-    };
-  }
-  reset() {
-    const previousState = this.state;
-    this.state = "closed";
-    this.violationCount = 0;
-    this.recoveryProbeCount = 0;
-    this.currentTokens = 0;
-    this.lastStateChange = getTimeProvider().now();
-    this.lastUsage = null;
-    if (previousState !== "closed") {
-      this.emitStateChange(previousState, "closed", "Manual reset");
-    }
-    this.logger.info("Budget circuit breaker reset");
-  }
-  forceOpen(reason) {
-    if (this.state !== "open") {
-      this.transitionTo("open", `Forced open: ${reason}`);
-    }
-  }
-  addStateChangeListener(listener) {
-    this.listeners.add(listener);
-  }
-  removeStateChangeListener(listener) {
-    this.listeners.delete(listener);
-  }
-  // -------------------------------------------------------------------------
-  // Private Methods - State Transitions
-  // -------------------------------------------------------------------------
-  checkCooldown() {
-    if (this.state !== "open") return;
-    const elapsed = getTimeProvider().now() - this.lastStateChange;
-    if (elapsed >= this.config.cooldownMs) {
-      this.transitionTo("half-open", "Cooldown elapsed");
-    }
-  }
-  transitionTo(newState, reason) {
-    const previousState = this.state;
-    this.state = newState;
-    this.lastStateChange = getTimeProvider().now();
-    if (newState === "closed") {
-      this.violationCount = 0;
-      this.recoveryProbeCount = 0;
-    } else if (newState === "half-open") {
-      this.recoveryProbeCount = 0;
-    }
-    this.emitStateChange(previousState, newState, reason);
-  }
-  emitStateChange(previousState, newState, reason) {
-    const event = {
-      previousState,
-      newState,
-      timestamp: this.lastStateChange,
-      reason,
-      usage: this.lastUsage ?? this.createUsageSnapshot()
-    };
-    this.logger.info("Budget circuit state changed", {
-      previousState,
-      newState,
-      reason,
-      usagePercent: event.usage.usagePercent
-    });
-    for (const listener of this.listeners) {
-      try {
-        listener(event);
-      } catch {
-      }
-    }
-  }
-  // -------------------------------------------------------------------------
-  // Private Methods - Budget Checks
-  // -------------------------------------------------------------------------
-  handleClosedCheck(estimatedTokens, usage, projectedUsage) {
-    if (projectedUsage >= this.config.criticalThreshold) {
-      this.violationCount++;
-      if (this.config.hardStop) {
-        this.transitionTo("open", "Projected usage exceeds critical threshold");
-        return this.createBlockedResult(usage, "Budget exceeded - circuit opened");
-      }
-    }
-    const warning = projectedUsage >= this.config.warningThreshold ? this.createWarningMessage(projectedUsage) : void 0;
-    return this.createAllowedResult(usage, estimatedTokens, warning);
-  }
-  handleHalfOpenCheck(estimatedTokens, usage, projectedUsage) {
-    if (projectedUsage < this.config.warningThreshold) {
-      this.recoveryProbeCount++;
-      if (this.recoveryProbeCount >= this.config.recoveryProbes) {
-        this.transitionTo("closed", "Recovery probes successful");
-      }
-      return this.createAllowedResult(usage, estimatedTokens, "Recovery probe allowed");
-    }
-    this.transitionTo("open", "Recovery probe failed - usage still high");
-    return this.createBlockedResult(usage, "Recovery probe failed");
-  }
-  calculateProjectedUsage(estimatedTokens) {
-    const projected = this.currentTokens + estimatedTokens;
-    return this.maxTokens > 0 ? projected / this.maxTokens : 0;
-  }
-  createUsageSnapshot() {
-    const usagePercent = this.maxTokens > 0 ? this.currentTokens / this.maxTokens : 0;
-    return {
-      currentTokens: this.currentTokens,
-      maxTokens: this.maxTokens,
-      usagePercent,
-      availableTokens: Math.max(0, this.maxTokens - this.currentTokens),
-      timestamp: getTimeProvider().now()
-    };
-  }
-  // -------------------------------------------------------------------------
-  // Private Methods - Result Creation
-  // -------------------------------------------------------------------------
-  createBlockedResult(usage, reason) {
-    return {
-      allowed: false,
-      reason,
-      usage,
-      circuitState: this.state
-    };
-  }
-  createAllowedResult(usage, estimatedTokens, warning) {
-    const result = {
-      allowed: true,
-      reason: "Within budget",
-      usage,
-      circuitState: this.state,
-      allocatedTokens: estimatedTokens
-    };
-    if (warning !== void 0) {
-      return { ...result, warning };
-    }
-    return result;
-  }
-  createWarningMessage(projectedUsage) {
-    const percentUsed = Math.round(projectedUsage * 100);
-    return `Budget warning: ${String(percentUsed)}% of budget will be used`;
-  }
-};
-function createBudgetCircuitBreaker(maxTokens, config, logger59) {
-  const mergedConfig = {
-    ...DEFAULT_BUDGET_CIRCUIT_CONFIG,
-    ...config
-  };
-  return new BudgetCircuitBreaker(maxTokens, mergedConfig, logger59);
-}
-
-// src/workflows/budget-enforcement.ts
-function applyBudgetEnforcement(step, contextManager, budgetEvents, config) {
-  if (contextManager === void 0) {
-    return;
-  }
-  const { budget, source } = resolveStepBudget(step, config);
-  const stats = contextManager.getStats();
-  const statsBefore = {
-    totalTokens: stats.totalTokens,
-    availableTokens: stats.availableTokens,
-    usagePercentage: stats.usagePercentage
-  };
-  const event = {
-    timestamp: getTimeProvider().now(),
-    stepId: step.id,
-    budget,
-    source,
-    statsBefore
-  };
-  budgetEvents.push(event);
-  config.logger.debug("Budget enforcement applied for step", {
-    stepId: step.id,
-    source,
-    budget,
-    currentUsage: Math.round(statsBefore.usagePercentage * 100)
-  });
-}
-function enforceBudgetForStep(options) {
-  const { step, contextManager, circuitBreaker, budgetEvents, config, estimatedTokens } = options;
-  if (contextManager === void 0) {
-    return ok(createSkippedResult());
-  }
-  const { budget, source } = resolveStepBudget(step, config);
-  const stats = contextManager.getStats();
-  const statsBefore = {
-    totalTokens: stats.totalTokens,
-    availableTokens: stats.availableTokens,
-    usagePercentage: stats.usagePercentage
-  };
-  const enforcementResult = circuitBreaker.checkBudget(estimatedTokens);
-  const event = {
-    timestamp: getTimeProvider().now(),
-    stepId: step.id,
-    budget,
-    source,
-    statsBefore,
-    enforcementResult,
-    blocked: !enforcementResult.allowed
-  };
-  budgetEvents.push(event);
-  logEnforcementResult(config.logger, step.id, enforcementResult, statsBefore.usagePercentage);
-  if (!enforcementResult.allowed) {
-    return err(
-      new BudgetCircuitError(enforcementResult.reason, {
-        budgetErrorCode: "BUDGET_EXCEEDED",
-        circuitState: enforcementResult.circuitState,
-        usage: enforcementResult.usage
-      })
-    );
-  }
-  return ok(enforcementResult);
-}
-function createWorkflowCircuitBreaker(contextManager, config) {
-  if (contextManager === void 0) {
-    return void 0;
-  }
-  const stats = contextManager.getStats();
-  const maxTokens = Math.round(stats.availableTokens + stats.totalTokens);
-  const cbConfig = config.circuitBreakerConfig;
-  return new BudgetCircuitBreaker(maxTokens, cbConfig, config.logger);
-}
-function resolveStepBudget(step, config) {
-  if (step.contextBudget !== void 0) {
-    const baseBudget = config.workflowDefaultBudget ?? config.engineDefaultBudget;
-    const mergedBudget = {
-      system: step.contextBudget.system ?? baseBudget.system,
-      task: step.contextBudget.task ?? baseBudget.task,
-      active: step.contextBudget.active ?? baseBudget.active,
-      reserved: step.contextBudget.reserved ?? baseBudget.reserved
-    };
-    return { budget: mergedBudget, source: "step" };
-  }
-  if (config.workflowDefaultBudget !== void 0) {
-    return { budget: config.workflowDefaultBudget, source: "workflow" };
-  }
-  return { budget: config.engineDefaultBudget, source: "engine" };
-}
-function copyBudgetEvents(events) {
-  return [...events];
-}
-function createSkippedResult() {
-  return {
-    allowed: true,
-    reason: "No context manager - enforcement skipped",
-    usage: {
-      currentTokens: 0,
-      maxTokens: 0,
-      usagePercent: 0,
-      availableTokens: 0,
-      timestamp: getTimeProvider().now()
-    },
-    circuitState: "closed"
-  };
-}
-function logEnforcementResult(logger59, stepId, result, currentUsagePercent) {
-  const usagePercent = Math.round(currentUsagePercent * 100);
-  if (!result.allowed) {
-    logger59.warn("Budget enforcement blocked step", {
-      stepId,
-      reason: result.reason,
-      circuitState: result.circuitState,
-      currentUsage: usagePercent,
-      budgetUsage: Math.round(result.usage.usagePercent * 100)
-    });
-    return;
-  }
-  if (result.warning !== void 0) {
-    logger59.warn("Budget enforcement warning", {
-      stepId,
-      warning: result.warning,
-      currentUsage: usagePercent
-    });
-    return;
-  }
-  logger59.debug("Budget enforcement passed for step", {
-    stepId,
-    currentUsage: usagePercent,
-    allocatedTokens: result.allocatedTokens
-  });
-}
-
 // src/workflows/workflow-engine-helpers.ts
 var DEFAULT_TIMEOUT_MS2 = 3e5;
 var DEFAULT_MAX_CONCURRENCY = 5;
@@ -23118,9 +22771,7 @@ var DEFAULT_RESOLVED_CONFIG = {
   maxConcurrency: DEFAULT_MAX_CONCURRENCY,
   templatePaths: [],
   contextManagerConfig: void 0,
-  defaultBudget: DEFAULT_BUDGET,
-  budgetCircuitBreakerConfig: void 0,
-  enableBudgetEnforcement: false
+  defaultBudget: DEFAULT_BUDGET
 };
 function resolveConfig2(config) {
   if (config === void 0) {
@@ -23143,19 +22794,6 @@ function createContextManagerForWorkflow(config, workflow, logger59) {
   const budget = workflow.defaultBudget ?? config.defaultBudget;
   return new ContextManager({ ...config.contextManagerConfig, budget, logger: logger59 });
 }
-function createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger59) {
-  const budgetConfig = {
-    engineDefaultBudget: config.defaultBudget,
-    logger: logger59
-  };
-  if (workflow.defaultBudget !== void 0) {
-    budgetConfig.workflowDefaultBudget = workflow.defaultBudget;
-  }
-  if (config.budgetCircuitBreakerConfig !== void 0) {
-    budgetConfig.circuitBreakerConfig = config.budgetCircuitBreakerConfig;
-  }
-  return createWorkflowCircuitBreaker(contextManager, budgetConfig);
-}
 function cleanupOldExecutions(executions) {
   if (executions.size < MAX_TRACKED_EXECUTIONS) return;
   const completed = [];
@@ -23186,7 +22824,6 @@ function initializeExecution(params) {
   const startTime = getTimeProvider().now();
   const resolvedInputs = applyInputDefaults(workflow, inputs);
   const contextManager = createContextManagerForWorkflow(config, workflow, logger59);
-  const budgetCircuitBreaker = config.enableBudgetEnforcement ? createBudgetCircuitBreakerForWorkflow(contextManager, workflow, config, logger59) : void 0;
   const context = {
     workflowId: workflow.name,
     executionId,
@@ -23194,9 +22831,7 @@ function initializeExecution(params) {
     stepResults: /* @__PURE__ */ new Map(),
     variables: /* @__PURE__ */ new Map(),
     abortController: new AbortController(),
-    contextManager,
-    budgetEvents: [],
-    budgetCircuitBreaker
+    contextManager
   };
   const execution = {
     executionId,
@@ -23214,48 +22849,7 @@ function initializeExecution(params) {
   }
   return { executionId, context, startTime, execution };
 }
-function enforceStepBudgets(options) {
-  const { steps, context, workflow, totalSteps, config, logger: logger59 } = options;
-  const budgetConfig = {
-    engineDefaultBudget: config.defaultBudget,
-    logger: logger59
-  };
-  if (workflow.defaultBudget !== void 0) {
-    budgetConfig.workflowDefaultBudget = workflow.defaultBudget;
-  }
-  if (config.budgetCircuitBreakerConfig !== void 0) {
-    budgetConfig.circuitBreakerConfig = config.budgetCircuitBreakerConfig;
-  }
-  for (const step of steps) {
-    if (context.budgetCircuitBreaker !== void 0) {
-      const remainingSteps = totalSteps - context.stepResults.size;
-      const allocation = context.budgetCircuitBreaker.allocateForStep(step.id, remainingSteps);
-      const result = enforceBudgetForStep({
-        step,
-        contextManager: context.contextManager,
-        circuitBreaker: context.budgetCircuitBreaker,
-        budgetEvents: context.budgetEvents,
-        config: budgetConfig,
-        estimatedTokens: allocation.allocatedTokens
-      });
-      if (!result.ok) {
-        return err(
-          new WorkflowError(`Budget exceeded for step '${step.id}': ${result.error.message}`, {
-            context: { stepId: step.id, circuitState: result.error.circuitState },
-            cause: result.error
-          })
-        );
-      }
-    } else {
-      applyBudgetEnforcement(step, context.contextManager, context.budgetEvents, budgetConfig);
-    }
-  }
-  return ok(void 0);
-}
-function recordPhaseUsage(results, context) {
-  if (context.budgetCircuitBreaker === void 0) {
-    return { recordedSteps: 0, unmeasuredSteps: 0, tokensRecorded: 0 };
-  }
+function recordPhaseUsage(results) {
   let unmeasuredSteps = 0;
   let recordedSteps = 0;
   let tokensRecorded = 0;
@@ -23264,7 +22858,6 @@ function recordPhaseUsage(results, context) {
       unmeasuredSteps += 1;
       continue;
     }
-    context.budgetCircuitBreaker.recordUsage(result.tokensUsed);
     recordedSteps += 1;
     tokensRecorded += result.tokensUsed;
   }
@@ -23360,16 +22953,9 @@ var WorkflowEngine = class {
     const exec2 = this.executions.get(executionId);
     return exec2 ? exec2.status : { state: "failed", error: "Execution not found" };
   }
-  getBudgetEvents(executionId) {
-    const exec2 = this.executions.get(executionId);
-    return exec2 ? copyBudgetEvents(exec2.context.budgetEvents) : [];
-  }
   getContextManager(executionId) {
     return this.executions.get(executionId)?.context.contextManager;
   }
-  getBudgetCircuitBreaker(executionId) {
-    return this.executions.get(executionId)?.context.budgetCircuitBreaker;
-  }
   cancel(executionId) {
     const exec2 = this.executions.get(executionId);
     if (!exec2) {
@@ -23472,15 +23058,6 @@ var WorkflowEngine = class {
         currentStep,
         progress: completedSteps / totalSteps
       });
-      const enforceResult = enforceStepBudgets({
-        steps: phase.steps,
-        context,
-        workflow,
-        totalSteps,
-        config: this.config,
-        logger: this.logger
-      });
-      if (!enforceResult.ok) return enforceResult;
       const options = {
         maxConcurrency: this.config.maxConcurrency,
         failFast: true,
@@ -23488,7 +23065,7 @@ var WorkflowEngine = class {
       };
       const phaseResult = await this.deps.executePhase(phase.steps, context, options);
       if (!phaseResult.ok) return phaseResult;
-      this.reportUsageCoverage(recordPhaseUsage(phaseResult.value, context), workflow.name);
+      this.reportUsageCoverage(recordPhaseUsage(phaseResult.value), workflow.name);
       for (const result of phaseResult.value) {
         context.stepResults.set(result.stepId, result);
         allResults.push(result);
@@ -23818,41 +23395,286 @@ async function createProductionWorkflowEngine(config) {
 }
 
 // src/workflows/self-evolving/sew-types.ts
-import { z as z38 } from "zod";
-var EvolutionConfigSchema = z38.object({
-  mutationRate: z38.number().min(0).max(1).default(0.3),
-  populationSize: z38.number().int().min(2).max(20).default(5),
-  generations: z38.number().int().min(1).max(100).default(10),
-  minExecutionsForEval: z38.number().int().min(1).default(5),
-  promotionThreshold: z38.number().min(0).max(1).default(0.7),
-  regressionThreshold: z38.number().min(0).max(1).default(0.1),
-  selectionPressure: z38.number().min(1).max(3).default(1.5),
-  crossoverRate: z38.number().min(0).max(1).default(0.3),
-  elitismCount: z38.number().int().min(0).default(1),
-  timeoutAdjustmentRange: z38.tuple([z38.number().min(0.1), z38.number().max(10)]).default([0.5, 2]),
-  retryAdjustmentRange: z38.tuple([z38.number().int(), z38.number().int()]).default([-2, 2])
+import { z as z37 } from "zod";
+var EvolutionConfigSchema = z37.object({
+  mutationRate: z37.number().min(0).max(1).default(0.3),
+  populationSize: z37.number().int().min(2).max(20).default(5),
+  generations: z37.number().int().min(1).max(100).default(10),
+  minExecutionsForEval: z37.number().int().min(1).default(5),
+  promotionThreshold: z37.number().min(0).max(1).default(0.7),
+  regressionThreshold: z37.number().min(0).max(1).default(0.1),
+  selectionPressure: z37.number().min(1).max(3).default(1.5),
+  crossoverRate: z37.number().min(0).max(1).default(0.3),
+  elitismCount: z37.number().int().min(0).default(1),
+  timeoutAdjustmentRange: z37.tuple([z37.number().min(0.1), z37.number().max(10)]).default([0.5, 2]),
+  retryAdjustmentRange: z37.tuple([z37.number().int(), z37.number().int()]).default([-2, 2])
 });
 
 // src/workflows/aflow/aflow-types.ts
-import { z as z39 } from "zod";
-var AFlowConfigSchema = z39.object({
-  maxIterations: z39.number().int().positive().default(100),
-  maxDepth: z39.number().int().positive().default(10),
-  explorationConstant: z39.number().positive().default(Math.SQRT2),
-  simulationsPerExpansion: z39.number().int().positive().default(5),
-  acceptanceThreshold: z39.number().min(0).max(1).default(0.7),
-  maxSteps: z39.number().int().positive().default(20),
-  minSteps: z39.number().int().positive().default(2),
-  evaluationTimeoutMs: z39.number().int().positive().default(SINGLE_LLM_EVAL_TIMEOUT_MS),
-  enableEarlyTermination: z39.boolean().default(true),
-  earlyTerminationThreshold: z39.number().min(0).max(1).default(0.9),
-  temperature: z39.number().positive().default(1),
-  seed: z39.number().int().nullable().default(null)
+import { z as z38 } from "zod";
+var AFlowConfigSchema = z38.object({
+  maxIterations: z38.number().int().positive().default(100),
+  maxDepth: z38.number().int().positive().default(10),
+  explorationConstant: z38.number().positive().default(Math.SQRT2),
+  simulationsPerExpansion: z38.number().int().positive().default(5),
+  acceptanceThreshold: z38.number().min(0).max(1).default(0.7),
+  maxSteps: z38.number().int().positive().default(20),
+  minSteps: z38.number().int().positive().default(2),
+  evaluationTimeoutMs: z38.number().int().positive().default(SINGLE_LLM_EVAL_TIMEOUT_MS),
+  enableEarlyTermination: z38.boolean().default(true),
+  earlyTerminationThreshold: z38.number().min(0).max(1).default(0.9),
+  temperature: z38.number().positive().default(1),
+  seed: z38.number().int().nullable().default(null)
 });
 
 // src/workflows/aflow/aflow-generator.ts
 var logger11 = createLogger({ component: "AFlow" });
 
+// src/workflows/budget-circuit-breaker-types.ts
+import { z as z39 } from "zod";
+var BudgetCircuitBreakerConfigSchema = z39.object({
+  /** Warning threshold as percentage (0-1) of budget (default: 0.8) */
+  warningThreshold: z39.number().min(0).max(1).default(0.8),
+  /** Critical threshold as percentage (0-1) that opens circuit (default: 0.95) */
+  criticalThreshold: z39.number().min(0).max(1).default(0.95),
+  /** Time in ms to wait before allowing half-open probes (default: 5000) */
+  cooldownMs: z39.number().positive().default(5e3),
+  /** Number of successful low-usage probes to close circuit (default: 2) */
+  recoveryProbes: z39.number().int().positive().default(2),
+  /** Whether to enforce hard stops (default: true) */
+  hardStop: z39.boolean().default(true),
+  /** Reserve percentage for step completion (default: 0.1) */
+  stepReserve: z39.number().min(0).max(0.5).default(0.1)
+});
+var DEFAULT_BUDGET_CIRCUIT_CONFIG = {
+  warningThreshold: 0.8,
+  criticalThreshold: 0.95,
+  cooldownMs: 5e3,
+  recoveryProbes: 2,
+  hardStop: true,
+  stepReserve: 0.1
+};
+
+// src/workflows/budget-circuit-breaker.ts
+var BudgetCircuitBreaker = class {
+  constructor(maxTokens, config, logger59) {
+    this.maxTokens = maxTokens;
+    this.config = { ...DEFAULT_BUDGET_CIRCUIT_CONFIG, ...config };
+    this.lastStateChange = getTimeProvider().now();
+    this.logger = logger59 ?? createLogger({ component: "budget-circuit-breaker" });
+  }
+  maxTokens;
+  state = "closed";
+  lastStateChange;
+  violationCount = 0;
+  recoveryProbeCount = 0;
+  lastUsage = null;
+  currentTokens = 0;
+  listeners = /* @__PURE__ */ new Set();
+  logger;
+  config;
+  checkBudget(estimatedTokens) {
+    this.checkCooldown();
+    const usage = this.createUsageSnapshot();
+    const projectedUsage = this.calculateProjectedUsage(estimatedTokens);
+    if (this.state === "open") {
+      return this.createBlockedResult(usage, "Circuit is open - budget exceeded");
+    }
+    if (this.state === "half-open") {
+      return this.handleHalfOpenCheck(estimatedTokens, usage, projectedUsage);
+    }
+    return this.handleClosedCheck(estimatedTokens, usage, projectedUsage);
+  }
+  recordUsage(actualTokens) {
+    this.currentTokens += actualTokens;
+    this.lastUsage = this.createUsageSnapshot();
+    this.logger.debug("Budget usage recorded", {
+      actualTokens,
+      totalUsed: this.currentTokens,
+      maxTokens: this.maxTokens,
+      usagePercent: this.lastUsage.usagePercent
+    });
+    if (this.state === "closed" && this.lastUsage.usagePercent >= this.config.criticalThreshold) {
+      this.transitionTo("open", "Usage exceeded critical threshold after recording");
+    }
+  }
+  allocateForStep(stepId, remainingSteps) {
+    const available = Math.max(0, this.maxTokens - this.currentTokens);
+    const reserveForOthers = remainingSteps > 1 ? this.config.stepReserve * available : 0;
+    const allocatable = available - reserveForOthers;
+    const perStepAllocation = Math.floor(allocatable / Math.max(1, remainingSteps));
+    this.logger.debug("Step budget allocated", {
+      stepId,
+      remainingSteps,
+      available,
+      allocated: perStepAllocation,
+      reserveForOthers: Math.floor(reserveForOthers)
+    });
+    return {
+      stepId,
+      allocatedTokens: perStepAllocation,
+      remainingForOtherSteps: available - perStepAllocation,
+      remainingStepCount: remainingSteps - 1
+    };
+  }
+  getState() {
+    this.checkCooldown();
+    return this.state;
+  }
+  getSnapshot() {
+    this.checkCooldown();
+    return {
+      state: this.state,
+      lastStateChange: this.lastStateChange,
+      violationCount: this.violationCount,
+      recoveryProbeCount: this.recoveryProbeCount,
+      lastUsage: this.lastUsage,
+      config: this.config
+    };
+  }
+  reset() {
+    const previousState = this.state;
+    this.state = "closed";
+    this.violationCount = 0;
+    this.recoveryProbeCount = 0;
+    this.currentTokens = 0;
+    this.lastStateChange = getTimeProvider().now();
+    this.lastUsage = null;
+    if (previousState !== "closed") {
+      this.emitStateChange(previousState, "closed", "Manual reset");
+    }
+    this.logger.info("Budget circuit breaker reset");
+  }
+  forceOpen(reason) {
+    if (this.state !== "open") {
+      this.transitionTo("open", `Forced open: ${reason}`);
+    }
+  }
+  addStateChangeListener(listener) {
+    this.listeners.add(listener);
+  }
+  removeStateChangeListener(listener) {
+    this.listeners.delete(listener);
+  }
+  // -------------------------------------------------------------------------
+  // Private Methods - State Transitions
+  // -------------------------------------------------------------------------
+  checkCooldown() {
+    if (this.state !== "open") return;
+    const elapsed = getTimeProvider().now() - this.lastStateChange;
+    if (elapsed >= this.config.cooldownMs) {
+      this.transitionTo("half-open", "Cooldown elapsed");
+    }
+  }
+  transitionTo(newState, reason) {
+    const previousState = this.state;
+    this.state = newState;
+    this.lastStateChange = getTimeProvider().now();
+    if (newState === "closed") {
+      this.violationCount = 0;
+      this.recoveryProbeCount = 0;
+    } else if (newState === "half-open") {
+      this.recoveryProbeCount = 0;
+    }
+    this.emitStateChange(previousState, newState, reason);
+  }
+  emitStateChange(previousState, newState, reason) {
+    const event = {
+      previousState,
+      newState,
+      timestamp: this.lastStateChange,
+      reason,
+      usage: this.lastUsage ?? this.createUsageSnapshot()
+    };
+    this.logger.info("Budget circuit state changed", {
+      previousState,
+      newState,
+      reason,
+      usagePercent: event.usage.usagePercent
+    });
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Private Methods - Budget Checks
+  // -------------------------------------------------------------------------
+  handleClosedCheck(estimatedTokens, usage, projectedUsage) {
+    if (projectedUsage >= this.config.criticalThreshold) {
+      this.violationCount++;
+      if (this.config.hardStop) {
+        this.transitionTo("open", "Projected usage exceeds critical threshold");
+        return this.createBlockedResult(usage, "Budget exceeded - circuit opened");
+      }
+    }
+    const warning = projectedUsage >= this.config.warningThreshold ? this.createWarningMessage(projectedUsage) : void 0;
+    return this.createAllowedResult(usage, estimatedTokens, warning);
+  }
+  handleHalfOpenCheck(estimatedTokens, usage, projectedUsage) {
+    if (projectedUsage < this.config.warningThreshold) {
+      this.recoveryProbeCount++;
+      if (this.recoveryProbeCount >= this.config.recoveryProbes) {
+        this.transitionTo("closed", "Recovery probes successful");
+      }
+      return this.createAllowedResult(usage, estimatedTokens, "Recovery probe allowed");
+    }
+    this.transitionTo("open", "Recovery probe failed - usage still high");
+    return this.createBlockedResult(usage, "Recovery probe failed");
+  }
+  calculateProjectedUsage(estimatedTokens) {
+    const projected = this.currentTokens + estimatedTokens;
+    return this.maxTokens > 0 ? projected / this.maxTokens : 0;
+  }
+  createUsageSnapshot() {
+    const usagePercent = this.maxTokens > 0 ? this.currentTokens / this.maxTokens : 0;
+    return {
+      currentTokens: this.currentTokens,
+      maxTokens: this.maxTokens,
+      usagePercent,
+      availableTokens: Math.max(0, this.maxTokens - this.currentTokens),
+      timestamp: getTimeProvider().now()
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Private Methods - Result Creation
+  // -------------------------------------------------------------------------
+  createBlockedResult(usage, reason) {
+    return {
+      allowed: false,
+      reason,
+      usage,
+      circuitState: this.state
+    };
+  }
+  createAllowedResult(usage, estimatedTokens, warning) {
+    const result = {
+      allowed: true,
+      reason: "Within budget",
+      usage,
+      circuitState: this.state,
+      allocatedTokens: estimatedTokens
+    };
+    if (warning !== void 0) {
+      return { ...result, warning };
+    }
+    return result;
+  }
+  createWarningMessage(projectedUsage) {
+    const percentUsed = Math.round(projectedUsage * 100);
+    return `Budget warning: ${String(percentUsed)}% of budget will be used`;
+  }
+};
+function createBudgetCircuitBreaker(maxTokens, config, logger59) {
+  const mergedConfig = {
+    ...DEFAULT_BUDGET_CIRCUIT_CONFIG,
+    ...config
+  };
+  return new BudgetCircuitBreaker(maxTokens, mergedConfig, logger59);
+}
+
 // src/workflows/latts-types.ts
 import { z as z40 } from "zod";
 var LattsConfigSchema = z40.object({
@@ -28422,7 +28244,7 @@ function execIdFields(executionId) {
 async function populateUnifiedContextOnState(state, options) {
   const taskCandidate = state["task"];
   if (typeof taskCandidate !== "string" || taskCandidate === "") return;
-  const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-HS2TOSPT.js");
+  const { getContextForTask: getContextForTask2, inferTaskCategory: inferTaskCategory2 } = await import("./context-retriever-SGJTQUCI.js");
   const category = inferTaskCategory2(taskCandidate);
   const executionId = options?.executionId;
   const execFields = execIdFields(executionId);
@@ -38196,6 +38018,9 @@ function observeExpertContextIfOk(result, expert, task, durationMs, logger59) {
     role: expert.role,
     modelId: expertModelId,
     tokensUsed: result.value.metadata.tokensUsed,
+    // #4743: provenance travels with the number, so a consumer can tell a
+    // measured zero from an unreported one.
+    ...result.value.metadata.tokensMeasured !== void 0 ? { tokensMeasured: result.value.metadata.tokensMeasured } : {},
     taskDescription: task.description,
     durationMs
   };
@@ -44102,7 +43927,7 @@ async function tryIssueTriage(task) {
   try {
     const issueMatch = task.match(/github\.com\/([^/]+\/[^/]+)\/issues\/(\d+)/);
     if (issueMatch === null) return null;
-    const { createIssueTriage } = await import("./issue-triage-NLIV37LO.js");
+    const { createIssueTriage } = await import("./issue-triage-B3KU37U3.js");
     const triage = createIssueTriage();
     const owner = issueMatch[1] ?? "";
     const num = issueMatch[2] ?? "";
@@ -44130,7 +43955,7 @@ var VALID_TEMPLATES = /* @__PURE__ */ new Set([
 ]);
 async function classifyWithLLM(task) {
   try {
-    const { executeExpert: executeExpert2 } = await import("./expert-bridge-S6SBBQGK.js");
+    const { executeExpert: executeExpert2 } = await import("./expert-bridge-UH44L5CN.js");
     const prompt = [
       "Classify this task into exactly one pipeline template.",
       "Templates: dev (implementation/bug fix/refactor), research (investigate/evaluate/compare),",
@@ -45857,7 +45682,7 @@ var memoryInitPromise = null;
 async function initPipelineMemory() {
   if (cachedMemory !== null) return cachedMemory;
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-OOOKYNUT.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-5GVHJR26.js");
     const { getLearningDir } = await import("./learning-persistence-EGY4VKKO.js");
     const mem = createSessionMemory2(getLearningDir());
     mem.startSession(`pipeline-${String(getTimeProvider().now())}`);
@@ -45919,7 +45744,7 @@ function recordRoutingExperience(category, success, durationMs, tokensUsed = 0,
     callRecord(routingMemoryCache);
     return;
   }
-  routingMemoryInitPromise ??= import("./routing-memory-NOXXAXQG.js").then(({ createRoutingMemory }) => {
+  routingMemoryInitPromise ??= import("./routing-memory-EIF5XALW.js").then(({ createRoutingMemory }) => {
     routingMemoryCache ??= createRoutingMemory();
     return routingMemoryCache;
   }).catch((error) => {
@@ -45953,7 +45778,7 @@ ${text}` : "";
 }
 async function getWeatherContext() {
   try {
-    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-HQCHYA6M.js");
+    const { generateWeatherReport: generateWeatherReport2 } = await import("./weather-report-FV6YYGT4.js");
     const report = generateWeatherReport2({ includeAdaptive: true });
     const mappings = "recommendedMappings" in report ? report.recommendedMappings : [];
     if (!Array.isArray(mappings) || mappings.length === 0) return "";
@@ -45971,7 +45796,7 @@ ${lines}
 }
 async function getMemoryContext(task) {
   try {
-    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-OOOKYNUT.js");
+    const { createSessionMemory: createSessionMemory2 } = await import("./session-memory-5GVHJR26.js");
     const { getLearningDir } = await import("./learning-persistence-EGY4VKKO.js");
     const memory = createSessionMemory2(getLearningDir(), { maxLearningsInContext: 10 });
     const learnings = memory.searchLearnings(task.slice(0, 200));
@@ -46090,7 +45915,7 @@ ${contextBlock}`;
       const strategy = config.votingStrategy ?? "higher_order";
       await postProgress(config, "Vote", `Running consensus with ${strategy} strategy...`);
       try {
-        const { executeVoting } = await import("./consensus-vote-CPZ6E5NS.js");
+        const { executeVoting } = await import("./consensus-vote-U3OPVEUE.js");
         const votingResult = await executeVoting(
           {
             proposal: buildVoteProposal(plan, research),
@@ -46529,7 +46354,7 @@ async function searchCodebaseForTask(task) {
 }
 async function queryResearchRegistry(task) {
   try {
-    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-QBW2J7OI.js");
+    const { synthesizeResearch: synthesizeResearch2 } = await import("./research-helpers-synthesize-4YBZF2LZ.js");
     const topic = task.split(/[.!?\n]/).filter((s) => s.trim().length > 10)[0]?.trim();
     if (topic === void 0) return null;
     const result = await synthesizeResearch2(topic.slice(0, 50));
@@ -46600,7 +46425,7 @@ function createScanStageWrapper() {
       try {
         const slug = ctx.task.match(/([a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+)/)?.[1];
         if (slug !== void 0) {
-          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-UHYMCN54.js");
+          const { generateSecurityPlan: generateSecurityPlan2 } = await import("./repo-security-plan-E2MTJPSC.js");
           const plan = await generateSecurityPlan2({ repo: slug, maxScanners: 10 });
           const recs = plan.recommendations.slice(0, 5).map((r) => `${r.priority}: ${r.displayName} (${r.category})`).join("; ");
           return output(PIPELINE_STATE_KEYS.FINDINGS, recs, getTimeProvider().now() - start, true);
@@ -49689,7 +49514,7 @@ var GitHubTaskTracker = class {
   cachedProvider = null;
   async getProvider() {
     if (this.cachedProvider !== null) return this.cachedProvider;
-    const { createScmProvider } = await import("./factory-MZGIHXPG.js");
+    const { createScmProvider } = await import("./factory-HYFTOF35.js");
     const result = await createScmProvider({ repo: this.config.repo ?? "" });
     if (!result.ok) throw new Error(`SCM provider error: ${result.error.message}`);
     this.cachedProvider = result.value;
@@ -50539,7 +50364,7 @@ async function probeSource(source, includeModelIds) {
   }
 }
 async function defaultSources(includeOpenRouter) {
-  const { createAllAdapters: createAllAdapters2 } = await import("./factory-SOAR6BIV.js");
+  const { createAllAdapters: createAllAdapters2 } = await import("./factory-GUDAJED7.js");
   const adapters = createAllAdapters2();
   return buildDefaultModelSources(adapters, { includeOpenRouter });
 }
@@ -54581,4 +54406,4 @@ export {
   shutdownFeedbackSubscriber,
   createEventBusBridge
 };
-//# sourceMappingURL=chunk-OUE5RIYB.js.map
+//# sourceMappingURL=chunk-7LCLCIGM.js.map