@rulvar/core 1.5.2 → 1.6.0

package/README.md

@@ -1,6 +1,6 @@
 # @rulvar/core
 
-The rulvar engine in one dependency-light package: the L0 contracts and
+The Rulvar engine in one dependency-light package: the L0 contracts and
 SPI interfaces, the journal kernel behind the never-pay-twice invariant,
 the model router with the capability and price registry, the agent
 runtime, the tool system and MCP bus, the `ctx` primitives and run
@@ -10,7 +10,7 @@ adapters plug in from their own packages. Key exports: `createEngine`,
 `defineWorkflow`, `tool`, `mcp`, `orchestrate`, `InMemoryStore`,
 `JsonlFileStore`.
 
-Part of [rulvar](https://rulvar.com), an embeddable TypeScript engine
+Part of [Rulvar](https://rulvar.com), an embeddable TypeScript engine
 for durable, budget-bounded multi-agent LLM workflows, where a completed
 LLM call is never paid for twice. Full documentation:
 [docs.rulvar.com](https://docs.rulvar.com).

package/dist/index.d.ts

@@ -1029,6 +1029,25 @@ declare function validateSchemaSpec<S extends SchemaSpec>(spec: S, value: unknow
 //#endregion
 //#region src/l0/spi/provider.d.ts
 /**
+* One long-context price tier. When the full prompt (canonical
+* inputTokens, cache included) is strictly above `aboveInputTokens`, the
+* ENTIRE request is re-priced with these multipliers, not only the tokens
+* past the threshold (how providers state their long-context rules).
+* `inputMultiplier` scales every input-side rate: input, cache read, and
+* cache write.
+* `outputMultiplier` scales the output rate. Provider pricing pages state
+* multipliers for "input" without saying whether cache rates scale;
+* scaling them with input is the conservative reading for budget
+* enforcement (it never underestimates spend). With several tiers, the
+* highest threshold below the prompt size wins, independent of array
+* order.
+*/
+interface PricingTier {
+  aboveInputTokens: number;
+  inputMultiplier: number;
+  outputMultiplier: number;
+}
+/**
 * Per-model pricing in USD per million tokens. The registry's
 * versioned price table wins over adapter-
 * reported caps.pricing, which is a fallback only.
@@ -1041,6 +1060,8 @@ interface Pricing {
   cacheWriteUsdPerMTok?: number;
   /** 1h write premium rate where the provider distinguishes. */
   cacheWrite1hUsdPerMTok?: number;
+  /** Long-context tiers; a row without them is one linear price. */
+  tiers?: PricingTier[];
 }
 /** Capability facts the router consumes for tier selection and scrubbing. */
 type ModelCaps = {
@@ -2740,6 +2761,15 @@ interface RuntimeEventSink {
 interface BudgetHooks {
   /** Layer 2: before every turn; throws BudgetExhaustedError to block dispatch. */
   beforeTurn(): void;
+  /**
+  * Layer 2b, the pre-dispatch output bound: the output tokens the
+  * remaining budget still affords from `servedBy` for a prompt of
+  * `estimatedInputTokens`. The dispatch clamps the request's
+  * maxOutputTokens to it and denies the turn entirely when not even one
+  * output token fits. Undefined = unbounded (no ceiling, no price row,
+  * or free output).
+  */
+  maxAffordableOutputTokens?: (servedBy: ModelRef, estimatedInputTokens: number) => number | undefined;
   /** Live usage accounting; layer 3 may respond by aborting `signal`. */
   onUsage(usage: Usage, servedBy: ModelRef): void;
   /** Layer 3: the ceiling AbortSignal. */
@@ -3292,15 +3322,20 @@ declare const DEFAULT_FLAT_RESERVE_USD = .5;
 /** The run-root account scope. */
 declare const ROOT_ACCOUNT = "run";
 /**
-* The admission reserve for a spawn: opts.estCost, else profile.estCost, else
-* price(countTokens(input) + caps.maxOutputTokens), else the engine flat
-* default.
+* The admission reserve for a spawn: opts.estCost, else profile.estCost,
+* else price(countTokens(input) + one turn's worth of output), else the
+* engine flat default. The output term is caps.maxOutputTokens clamped to
+* limits.maxOutputTokensPerTurn when the spawn carries one, so a host can
+* bound reserves without hand-written estimates. The priced path uses the
+* SAME price function as settlement (priceUsdOf), so long-context tiers
+* apply to estimates too.
 */
 declare function admissionReserveUsd(options: {
   estCost?: number;
   profileEstCost?: number;
   inputTokens?: number;
   caps?: ModelCaps;
+  maxOutputTokensPerTurn?: number;
   flatReserveUsd?: number;
 }): number;
 /** Read-only projection of one account. */
@@ -3324,6 +3359,7 @@ declare class RunBudget {
   private readonly lifetimeSpawnCap;
   private readonly events?;
   private readonly priceUsd?;
+  private readonly pricingOf?;
   private readonly accounts;
   private usageInternal;
   private agentsSpawnedInternal;
@@ -3334,7 +3370,8 @@ declare class RunBudget {
     ceilingUsd?: number;
     lifetimeSpawnCap?: number;
     events?: RuntimeEventSink;
-    priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined;
+    priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined; /** Raw price-row resolution for the layer-2b output bound. */
+    pricingOf?: (servedBy: ModelRef) => Pricing | undefined;
     /**
     * The resume ledger fold: spend is never
     * reset and never double-counted; replayed entries are already inside
@@ -3381,9 +3418,15 @@ declare class RunBudget {
   /** Spawn headroom under the engine lifetime cap (embedded in admission verdicts). */
   get spawnHeadroom(): number;
   /**
-  * Layer 1: admission before spawn. Blocks when spent + committedReserve
-  * has reached the ceiling on ANY account in the ancestor chain of
-  * `accountScope`, otherwise commits the reserve along the whole chain.
+  * Layer 1: PROJECTED admission before spawn. A spawn is admitted only
+  * when every account in the ancestor chain of `accountScope` still has
+  * admission headroom AND fits the PROPOSED reserve on top of spent +
+  * committedReserve + finalizeReserve (the finalize reserve is
+  * untouchable by admission, DEF-7). An exact fill is allowed; one
+  * dollar past the ceiling is not: a spawn is never admitted on the
+  * argument that the money it needs is merely not committed yet. The
+  * whole chain is checked before anything commits, so a rejection
+  * mutates no account, increments no counter, and journals nothing.
   * Also enforces the engine lifetime spawn cap.
   */
   admitSpawn(reserveUsd: number, accountScope?: string): void;
@@ -3416,6 +3459,17 @@ declare class RunBudget {
   /** Layer 2: the per-turn guard. A turn that would cross any ceiling in the chain is not dispatched. */
   beforeTurn(accountScope?: string): void;
   /**
+  * Layer 2b, the pre-dispatch output bound: the output tokens the
+  * remaining chain budget (min over capped ancestors of ceiling minus
+  * spend) still affords from `servedBy` for an estimated prompt, priced
+  * by the same function as settlement, long-context tiers included.
+  * Undefined when no account in the chain carries a USD ceiling, when
+  * the model has no price row (the once-per-model unpriced warning in
+  * onUsage covers that hole), or when output is free. Zero or negative
+  * means the turn cannot be dispatched within the budget.
+  */
+  maxAffordableOutputTokens(servedBy: ModelRef, estimatedInputTokens: number, accountScope?: string): number | undefined;
+  /**
   * Live accounting; spend propagates from `accountScope` to every
   * ancestor. Crossing a ceiling severs the crossing account's subtree
   * via its layer-3 AbortSignal (overshoot bounded by one turn per
@@ -4180,11 +4234,13 @@ type OnEscalation = (result: EscalatedResult<unknown>) => EscalationDecision | P
 /**
 * The mode (a) runner for human-authored closures. Determinism is enforced
 * by convention, lint, and the ctx shims, NOT by a VM: only the sequence
-* of keys must be stable. Dev mode (NODE_ENV !== 'production') patches
-* Date.now and Math.random for the duration of execute to emit one warning
-* per run pointing at ctx.now()/ctx.random(); the patch preserves behavior
-* and restores the prior functions on exit (nesting-safe by capturing the
-* prior value; concurrent runs may lose the warning, never correctness).
+* of keys must be stable. Dev mode (NODE_ENV !== 'production') detects
+* bare Date.now and Math.random and emits one warning per run pointing at
+* ctx.now()/ctx.random(). Detection is attributed by AsyncLocalStorage:
+* only code inside the workflow body's async context can trigger it, so
+* host code running concurrently, engine internals outside the body, and
+* other runs never produce a false warning, and nothing is ever restored,
+* so concurrent executes cannot race the patch state.
 */
 declare class InProcessRunner implements ScriptRunner {
   private readonly onEscalation?;
@@ -4209,13 +4265,29 @@ interface PriceTable {
 */
 declare function resolvePricing(ref: ModelRef, table: PriceTable | undefined, capsPricing: Pricing | undefined): Pricing | undefined;
 /**
-* Dollars from normalized usage against one pricing row (the adapter
-* normalized the usage; inputTokens is the
-* full prompt). Cache writes price at the 5m premium rate; the 1h rate
-* applies where a provider distinguishes it in usage, which the
+* Dollars from normalized usage against one pricing row. Under the Usage
+* invariant inputTokens is the FULL prompt including cache reads and
+* writes, so the input rate bills only the uncached remainder and cache
+* tokens bill at their own rates, never twice; a row that omits a cache
+* rate bills those tokens at the plain input rate rather than silently
+* for free. A row may carry long-context tiers: the highest threshold
+* strictly below the full prompt re-prices the ENTIRE request
+* (input-side rates scale by inputMultiplier, the output rate by
+* outputMultiplier). Cache writes price at the 5m premium rate; the 1h
+* rate applies where a provider distinguishes it in usage, which the
 * canonical Usage does not yet carry.
 */
 declare function priceUsdOf(pricing: Pricing, usage: Usage): number;
+/**
+* The output tokens `remainingUsd` still buys from one pricing row after
+* paying for an estimated prompt of `estimatedInputTokens`, priced with
+* the same tier rules as settlement (the tier is selected by the
+* estimated prompt). Floored to whole tokens; zero or negative means not
+* even one output token fits, so the turn must not be dispatched.
+* Undefined when the row prices output at zero (a free model needs no
+* output bound).
+*/
+declare function affordableOutputTokens(pricing: Pricing, remainingUsd: number, estimatedInputTokens: number): number | undefined;
 //#endregion
 //#region src/engine/engine.d.ts
 /**
@@ -4331,7 +4403,14 @@ interface CreateEngineOptions {
 interface RunOptions {
   /** Explicit id; otherwise the engine mints a ULID. */
   runId?: string;
-  /** Run ceiling B0; immutable after start. */
+  /**
+  * Run ceiling B0; immutable after start. Enforced by projected
+  * admission (a spawn whose reserve does not fit is denied before any
+  * dispatch), the per-turn guard with a budget-derived maxOutputTokens
+  * clamp, and live stream cuts on crossing; the residual
+  * provider-dependent overshoot is bounded by one in-flight turn per
+  * concurrent agent. Contract: https://docs.rulvar.com/guide/budgets.
+  */
   budgetUsd?: number;
   /** Run-level defaults merged over engine defaults. */
   limits?: UsageLimits;
@@ -5306,6 +5385,8 @@ interface RunInternals {
   dropped: DroppedItem[];
   cost: CostAttribution;
   priceUsd: (servedBy: ModelRef, usage: Usage) => number | undefined;
+  /** Raw price-row resolution (table wins, caps fallback); undefined = unpriced. */
+  pricingOf?: (servedBy: ModelRef) => Pricing | undefined;
   runSignal?: AbortSignal;
   /** The worktree lifecycle provider. */
   isolation?: IsolationProvider;
@@ -6100,4 +6181,4 @@ interface SandboxBridge {
 }
 declare function createSandboxBridge(ctx: Ctx<never>, options: SandboxBridgeOptions): SandboxBridge;
 //#endregion
-export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, AgentOpts, AgentProfile, AgentProfilePermissions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, BUDGET_ABORT_REASON, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildIdentityInput, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostReport, CreateEngineOptions, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DerivedKey, DeriverRegistry, DispositionRule, DispositionTable, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EntryKind, EntryRef, EntryStatus, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINISH_SCHEMA, FINISH_TOOL_NAME, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishInfo, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, INBOX_PROPOSAL_TTL_DAYS, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, InvocationRole, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_DEPTH_CEILING, MatchResult, McpConfig, MechanicalGateProfile, MechanicalGateVerdict, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateOptions, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PriceTable, PricedUsage, type Pricing, type ProviderAdapter, QualityFloors, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RandIdentityInput, RandPayload, RefEntryAppender, RefEntryClassification, RefusalInfo, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunBudget, RunEventSink, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStatus, RuntimeEventSink, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, Semaphore, SerializationHook, Settled, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StepIdentityInput, StructuredOutputTier, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, admissionReserveUsd, agentErrorFromWire, agentErrorToWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, scanJournalCompatibility, schemaHash, schemaHashOfSpec, selectStructuredOutputTier, shouldCompact, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateSchemaSpec, validateTerminationLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, AgentOpts, AgentProfile, AgentProfilePermissions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, BUDGET_ABORT_REASON, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildIdentityInput, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostReport, CreateEngineOptions, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DerivedKey, DeriverRegistry, DispositionRule, DispositionTable, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EntryKind, EntryRef, EntryStatus, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINISH_SCHEMA, FINISH_TOOL_NAME, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishInfo, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, INBOX_PROPOSAL_TTL_DAYS, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, InvocationRole, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_DEPTH_CEILING, MatchResult, McpConfig, MechanicalGateProfile, MechanicalGateVerdict, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateOptions, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PriceTable, PricedUsage, type Pricing, type PricingTier, type ProviderAdapter, QualityFloors, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RandIdentityInput, RandPayload, RefEntryAppender, RefEntryClassification, RefusalInfo, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunBudget, RunEventSink, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStatus, RuntimeEventSink, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, Semaphore, SerializationHook, Settled, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StepIdentityInput, StructuredOutputTier, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, scanJournalCompatibility, schemaHash, schemaHashOfSpec, selectStructuredOutputTier, shouldCompact, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateSchemaSpec, validateTerminationLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -6495,15 +6495,51 @@ function fallbackTriggerOf(outcome) {
 function resolvePricing(ref, table, capsPricing) {
 	return table?.models[ref] ?? capsPricing;
 }
-/**
-* Dollars from normalized usage against one pricing row (the adapter
-* normalized the usage; inputTokens is the
-* full prompt). Cache writes price at the 5m premium rate; the 1h rate
-* applies where a provider distinguishes it in usage, which the
+/** The tier a full prompt lands in: the highest threshold strictly below it. */
+function tierFor(pricing, inputTokens) {
+	let tier;
+	for (const candidate of pricing.tiers ?? []) if (inputTokens > candidate.aboveInputTokens && (tier === void 0 || candidate.aboveInputTokens > tier.aboveInputTokens)) tier = candidate;
+	return tier;
+}
+/**
+* Dollars from normalized usage against one pricing row. Under the Usage
+* invariant inputTokens is the FULL prompt including cache reads and
+* writes, so the input rate bills only the uncached remainder and cache
+* tokens bill at their own rates, never twice; a row that omits a cache
+* rate bills those tokens at the plain input rate rather than silently
+* for free. A row may carry long-context tiers: the highest threshold
+* strictly below the full prompt re-prices the ENTIRE request
+* (input-side rates scale by inputMultiplier, the output rate by
+* outputMultiplier). Cache writes price at the 5m premium rate; the 1h
+* rate applies where a provider distinguishes it in usage, which the
 * canonical Usage does not yet carry.
 */
 function priceUsdOf(pricing, usage) {
-	return usage.inputTokens / 1e6 * pricing.inputUsdPerMTok + usage.outputTokens / 1e6 * pricing.outputUsdPerMTok + usage.cacheReadTokens / 1e6 * (pricing.cacheReadUsdPerMTok ?? 0) + usage.cacheWriteTokens / 1e6 * (pricing.cacheWriteUsdPerMTok ?? 0);
+	const tier = tierFor(pricing, usage.inputTokens);
+	const inputMul = tier?.inputMultiplier ?? 1;
+	const outputMul = tier?.outputMultiplier ?? 1;
+	return Math.max(0, usage.inputTokens - usage.cacheReadTokens - usage.cacheWriteTokens) / 1e6 * pricing.inputUsdPerMTok * inputMul + usage.outputTokens / 1e6 * pricing.outputUsdPerMTok * outputMul + usage.cacheReadTokens / 1e6 * (pricing.cacheReadUsdPerMTok ?? pricing.inputUsdPerMTok) * inputMul + usage.cacheWriteTokens / 1e6 * (pricing.cacheWriteUsdPerMTok ?? pricing.inputUsdPerMTok) * inputMul;
+}
+/**
+* The output tokens `remainingUsd` still buys from one pricing row after
+* paying for an estimated prompt of `estimatedInputTokens`, priced with
+* the same tier rules as settlement (the tier is selected by the
+* estimated prompt). Floored to whole tokens; zero or negative means not
+* even one output token fits, so the turn must not be dispatched.
+* Undefined when the row prices output at zero (a free model needs no
+* output bound).
+*/
+function affordableOutputTokens(pricing, remainingUsd, estimatedInputTokens) {
+	const tier = tierFor(pricing, estimatedInputTokens);
+	const outputRate = pricing.outputUsdPerMTok * (tier?.outputMultiplier ?? 1);
+	if (outputRate <= 0) return;
+	const inputUsd = priceUsdOf(pricing, {
+		inputTokens: estimatedInputTokens,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0
+	});
+	return Math.floor((remainingUsd - inputUsd) / outputRate * 1e6);
 }
 //#endregion
 //#region src/model/profile-card.ts
@@ -7681,6 +7717,50 @@ function buildRequest(resolved, messages, limits, tools) {
 	return req;
 }
 /**
+* Cheap deterministic prompt-size estimate (about four serialized
+* characters per token) for the layer-2b output bound. Never used for
+* identity, accounting, or anything the journal records.
+*/
+function estimateInputTokens(messages) {
+	let chars = 0;
+	for (const msg of messages) chars += JSON.stringify(msg.parts).length;
+	return Math.ceil(chars / 4);
+}
+/**
+* Layer 2b at the wire boundary: clamps the outgoing request's
+* maxOutputTokens to what the remaining budget affords from the serving
+* model. The clamp uses the heuristic prompt estimate; the DENIAL does
+* not: a turn is refused (BudgetExhaustedError, never dispatched) only
+* when the remainder cannot buy even ONE output token at zero input,
+* which is exact. Denying on the estimate would kill turns the budget
+* still funds, including the DEF-7 forced finish paid from the released
+* finalize reserve; when the estimate says the prompt alone spends the
+* remainder, the turn dispatches with a one-token output floor and the
+* exact layers (2 and 3) settle the difference. A no-op without a hook
+* or when the hook reports no bound. The clamp touches only the wire
+* request, exactly like limits.maxOutputTokensPerTurn above it; identity
+* is computed at the ctx layer and never sees it.
+*/
+function applyOutputBudget(req, target, budget) {
+	const hook = budget?.maxAffordableOutputTokens;
+	if (hook === void 0) return req;
+	const affordable = hook(target.resolved.ref, estimateInputTokens(req.messages));
+	if (affordable === void 0) return req;
+	if (affordable < 1) {
+		const zeroInputAffordable = hook(target.resolved.ref, 0);
+		if (zeroInputAffordable !== void 0 && zeroInputAffordable < 1) throw new BudgetExhaustedError(`the remaining budget cannot afford one output token from ${target.resolved.ref}; the turn was not dispatched`);
+		return {
+			...req,
+			maxOutputTokens: 1
+		};
+	}
+	if (req.maxOutputTokens === void 0 || affordable < req.maxOutputTokens) return {
+		...req,
+		maxOutputTokens: affordable
+	};
+	return req;
+}
+/**
 * Builds the turn's canonical assistant message. Retained provider-raw
 * parts go at the HEAD: on both first-class providers the retained
 * blocks (thinking blocks, reasoning items) precede the turn's text and
@@ -8168,28 +8248,41 @@ async function runAgent(options) {
 		turns += 1;
 		const signals = [];
 		if (options.signal !== void 0) signals.push(options.signal);
-		const { outcome, target: servedTarget } = await dispatchPhase({
-			chain: loopChain,
-			cursor: loopCursor,
-			requestFor: (target) => {
-				let req = buildRequest(target.resolved, projectHistory(messages, providerOf(target.adapter)), limits, options.tools?.contracts);
-				if (options.schema !== void 0 && options.canonicalSchema !== void 0 && !separateExtract) req = applyStructuredOutputTier(req, rideTierFor(target), options.canonicalSchema);
-				return req;
-			},
-			streamOptionsFor: (target) => {
-				const streamTurnOptions = {
-					idleTimeoutMs: limits.streamIdleTimeoutMs,
-					signals,
-					onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
-				};
-				if (options.budget?.signal !== void 0) streamTurnOptions.budgetSignal = options.budget.signal;
-				if (options.stream === true) streamTurnOptions.onDelta = (delta) => events?.emit({
-					type: "agent:stream",
-					delta
-				});
-				return streamTurnOptions;
-			}
-		});
+		let loopDispatch;
+		try {
+			loopDispatch = await dispatchPhase({
+				chain: loopChain,
+				cursor: loopCursor,
+				requestFor: (target) => {
+					let req = buildRequest(target.resolved, projectHistory(messages, providerOf(target.adapter)), limits, options.tools?.contracts);
+					if (options.schema !== void 0 && options.canonicalSchema !== void 0 && !separateExtract) req = applyStructuredOutputTier(req, rideTierFor(target), options.canonicalSchema);
+					return applyOutputBudget(req, target, options.budget);
+				},
+				streamOptionsFor: (target) => {
+					const streamTurnOptions = {
+						idleTimeoutMs: limits.streamIdleTimeoutMs,
+						signals,
+						onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
+					};
+					if (options.budget?.signal !== void 0) streamTurnOptions.budgetSignal = options.budget.signal;
+					if (options.stream === true) streamTurnOptions.onDelta = (delta) => events?.emit({
+						type: "agent:stream",
+						delta
+					});
+					return streamTurnOptions;
+				}
+			});
+		} catch (thrown) {
+			if (!(thrown instanceof BudgetExhaustedError)) throw thrown;
+			status = "error";
+			agentError = {
+				kind: "budget",
+				retryable: false
+			};
+			errorMessage = thrown.message;
+			break;
+		}
+		const { outcome, target: servedTarget } = loopDispatch;
 		servedBy = servedTarget.resolved.ref;
 		usageApprox = usageApprox || outcome.usageApprox;
 		lastTurnUsage = {
@@ -8346,30 +8439,43 @@ async function runAgent(options) {
 					break;
 				}
 				turns += 1;
-				const { outcome: summary } = await dispatchPhase({
-					chain: [{
-						adapter: options.summarize.adapter,
-						resolved: options.summarize.resolved
-					}, ...options.summarize.fallbacks ?? []],
-					cursor: { index: 0 },
-					requestFor: (target) => {
-						let req = buildRequest(target.resolved, [...projectHistory(messages, providerOf(target.adapter)), summarizeInstruction()], limits, options.tools?.contracts);
-						if (req.tools !== void 0) req = {
-							...req,
-							toolChoice: "none"
-						};
-						return req;
-					},
-					streamOptionsFor: (target) => {
-						const summarizeStreamOptions = {
-							idleTimeoutMs: limits.streamIdleTimeoutMs,
-							signals: options.signal === void 0 ? [] : [options.signal],
-							onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
-						};
-						if (options.budget?.signal !== void 0) summarizeStreamOptions.budgetSignal = options.budget.signal;
-						return summarizeStreamOptions;
-					}
-				});
+				let summaryDispatch;
+				try {
+					summaryDispatch = await dispatchPhase({
+						chain: [{
+							adapter: options.summarize.adapter,
+							resolved: options.summarize.resolved
+						}, ...options.summarize.fallbacks ?? []],
+						cursor: { index: 0 },
+						requestFor: (target) => {
+							let req = buildRequest(target.resolved, [...projectHistory(messages, providerOf(target.adapter)), summarizeInstruction()], limits, options.tools?.contracts);
+							if (req.tools !== void 0) req = {
+								...req,
+								toolChoice: "none"
+							};
+							return applyOutputBudget(req, target, options.budget);
+						},
+						streamOptionsFor: (target) => {
+							const summarizeStreamOptions = {
+								idleTimeoutMs: limits.streamIdleTimeoutMs,
+								signals: options.signal === void 0 ? [] : [options.signal],
+								onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
+							};
+							if (options.budget?.signal !== void 0) summarizeStreamOptions.budgetSignal = options.budget.signal;
+							return summarizeStreamOptions;
+						}
+					});
+				} catch (thrown) {
+					if (!(thrown instanceof BudgetExhaustedError)) throw thrown;
+					status = "error";
+					agentError = {
+						kind: "budget",
+						retryable: false
+					};
+					errorMessage = thrown.message;
+					break;
+				}
+				const { outcome: summary } = summaryDispatch;
 				usageApprox = usageApprox || summary.usageApprox;
 				if (summary.aborted === "budget") {
 					status = "cancelled";
@@ -8473,66 +8579,80 @@ async function runAgent(options) {
 		}
 		if (proceed) {
 			turns += 1;
-			const { outcome, target: finalizeTarget } = await dispatchPhase({
-				chain: [{
-					adapter: options.finalize.adapter,
-					resolved: options.finalize.resolved
-				}, ...options.finalize.fallbacks ?? []],
-				cursor: { index: 0 },
-				requestFor: (target) => ({
-					...buildRequest(target.resolved, projectHistory(messages, providerOf(target.adapter)), limits, options.tools?.contracts),
-					toolChoice: "none"
-				}),
-				streamOptionsFor: (target) => {
-					const finalizeStreamOptions = {
-						idleTimeoutMs: limits.streamIdleTimeoutMs,
-						signals: options.signal === void 0 ? [] : [options.signal],
-						onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
-					};
-					if (options.budget?.signal !== void 0) finalizeStreamOptions.budgetSignal = options.budget.signal;
-					if (options.stream === true) finalizeStreamOptions.onDelta = (delta) => events?.emit({
-						type: "agent:stream",
-						delta
-					});
-					return finalizeStreamOptions;
-				}
-			});
-			usageApprox = usageApprox || outcome.usageApprox;
-			messages.push(assistantMsg(outcome.turn, liftRetainedParts(outcome.providerMetadata, finalizeTarget.adapter)));
-			if (invariantViolation !== void 0) {
+			let finalizeDispatch;
+			try {
+				finalizeDispatch = await dispatchPhase({
+					chain: [{
+						adapter: options.finalize.adapter,
+						resolved: options.finalize.resolved
+					}, ...options.finalize.fallbacks ?? []],
+					cursor: { index: 0 },
+					requestFor: (target) => applyOutputBudget({
+						...buildRequest(target.resolved, projectHistory(messages, providerOf(target.adapter)), limits, options.tools?.contracts),
+						toolChoice: "none"
+					}, target, options.budget),
+					streamOptionsFor: (target) => {
+						const finalizeStreamOptions = {
+							idleTimeoutMs: limits.streamIdleTimeoutMs,
+							signals: options.signal === void 0 ? [] : [options.signal],
+							onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
+						};
+						if (options.budget?.signal !== void 0) finalizeStreamOptions.budgetSignal = options.budget.signal;
+						if (options.stream === true) finalizeStreamOptions.onDelta = (delta) => events?.emit({
+							type: "agent:stream",
+							delta
+						});
+						return finalizeStreamOptions;
+					}
+				});
+			} catch (thrown) {
+				if (!(thrown instanceof BudgetExhaustedError)) throw thrown;
 				status = "error";
 				agentError = {
-					kind: "transport",
+					kind: "budget",
 					retryable: false
 				};
-				errorMessage = invariantViolation;
-			} else if (outcome.aborted !== void 0 || outcome.wireError !== void 0) {
-				status = outcome.aborted === "external" ? "cancelled" : "error";
-				if (outcome.wireError !== void 0) {
-					agentError = classifyWireError(outcome.wireError);
-					errorMessage = outcome.wireError.message;
-				} else if (outcome.aborted === "budget") {
-					status = "cancelled";
+				errorMessage = thrown.message;
+			}
+			if (finalizeDispatch !== void 0) {
+				const { outcome, target: finalizeTarget } = finalizeDispatch;
+				usageApprox = usageApprox || outcome.usageApprox;
+				messages.push(assistantMsg(outcome.turn, liftRetainedParts(outcome.providerMetadata, finalizeTarget.adapter)));
+				if (invariantViolation !== void 0) {
+					status = "error";
 					agentError = {
-						kind: "budget",
+						kind: "transport",
 						retryable: false
 					};
-				} else if (outcome.aborted === "idle") {
+					errorMessage = invariantViolation;
+				} else if (outcome.aborted !== void 0 || outcome.wireError !== void 0) {
+					status = outcome.aborted === "external" ? "cancelled" : "error";
+					if (outcome.wireError !== void 0) {
+						agentError = classifyWireError(outcome.wireError);
+						errorMessage = outcome.wireError.message;
+					} else if (outcome.aborted === "budget") {
+						status = "cancelled";
+						agentError = {
+							kind: "budget",
+							retryable: false
+						};
+					} else if (outcome.aborted === "idle") {
+						status = "error";
+						agentError = {
+							kind: "transport",
+							retryable: true
+						};
+						errorMessage = `stream idle for ${limits.streamIdleTimeoutMs}ms`;
+					}
+				} else if (outcome.finish?.reason === "refusal" || outcome.finish?.reason === "context-window-exceeded") {
 					status = "error";
 					agentError = {
-						kind: "transport",
-						retryable: true
+						kind: "terminal",
+						retryable: false
 					};
-					errorMessage = `stream idle for ${limits.streamIdleTimeoutMs}ms`;
-				}
-			} else if (outcome.finish?.reason === "refusal" || outcome.finish?.reason === "context-window-exceeded") {
-				status = "error";
-				agentError = {
-					kind: "terminal",
-					retryable: false
-				};
-				if (outcome.finish.reason === "refusal") errorMessage = `model refusal (${outcome.finish.refusal.provider})`;
-			} else if (options.schema === void 0) output = outcome.turn.text;
+					if (outcome.finish.reason === "refusal") errorMessage = `model refusal (${outcome.finish.refusal.provider})`;
+				} else if (options.schema === void 0) output = outcome.turn.text;
+			}
 		}
 	}
 	if (status === "ok" && !finishedViaTool && separateExtract && options.extract !== void 0 && options.schema !== void 0) {
@@ -8570,28 +8690,42 @@ async function runAgent(options) {
 				break;
 			}
 			turns += 1;
-			const { outcome, target: extractTarget } = await dispatchPhase({
-				chain: extractChain,
-				cursor: extractCursor,
-				requestFor: (target) => {
-					const targetTier = extractTierFor(target);
-					let req = buildRequest(target.resolved, projectHistory(extractMessages, providerOf(target.adapter)), limits, options.tools?.contracts);
-					if (req.tools !== void 0 && targetTier !== "forced-tool") req = {
-						...req,
-						toolChoice: "none"
-					};
-					return applyStructuredOutputTier(req, targetTier, options.canonicalSchema ?? {});
-				},
-				streamOptionsFor: (target) => {
-					const extractStreamOptions = {
-						idleTimeoutMs: limits.streamIdleTimeoutMs,
-						signals: options.signal === void 0 ? [] : [options.signal],
-						onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
-					};
-					if (options.budget?.signal !== void 0) extractStreamOptions.budgetSignal = options.budget.signal;
-					return extractStreamOptions;
-				}
-			});
+			let extractDispatch;
+			try {
+				extractDispatch = await dispatchPhase({
+					chain: extractChain,
+					cursor: extractCursor,
+					requestFor: (target) => {
+						const targetTier = extractTierFor(target);
+						let req = buildRequest(target.resolved, projectHistory(extractMessages, providerOf(target.adapter)), limits, options.tools?.contracts);
+						if (req.tools !== void 0 && targetTier !== "forced-tool") req = {
+							...req,
+							toolChoice: "none"
+						};
+						req = applyStructuredOutputTier(req, targetTier, options.canonicalSchema ?? {});
+						return applyOutputBudget(req, target, options.budget);
+					},
+					streamOptionsFor: (target) => {
+						const extractStreamOptions = {
+							idleTimeoutMs: limits.streamIdleTimeoutMs,
+							signals: options.signal === void 0 ? [] : [options.signal],
+							onUsage: (delta) => options.budget?.onUsage(delta, target.resolved.ref)
+						};
+						if (options.budget?.signal !== void 0) extractStreamOptions.budgetSignal = options.budget.signal;
+						return extractStreamOptions;
+					}
+				});
+			} catch (thrown) {
+				if (!(thrown instanceof BudgetExhaustedError)) throw thrown;
+				status = "error";
+				agentError = {
+					kind: "budget",
+					retryable: false
+				};
+				errorMessage = thrown.message;
+				break;
+			}
+			const { outcome, target: extractTarget } = extractDispatch;
 			usageApprox = usageApprox || outcome.usageApprox;
 			if (invariantViolation !== void 0) {
 				status = "error";
@@ -8674,10 +8808,16 @@ async function runAgent(options) {
 //#region src/engine/budget.ts
 /**
 * Three-layer budget (M1-T09, hierarchical sub-accounts M6-T06;
-* invariant I4). Layer 1: admission before spawn (spent + committedReserve
-* >= ceiling blocks on ANY account in the ancestor chain). Layer 2: the
-* per-turn guard against the spawn's own chain. Layer 3: the AbortSignal
-* ceiling severing live streams, with partial usage written usageApprox.
+* invariant I4). Layer 1: PROJECTED admission before spawn: a spawn is
+* admitted only when spent + committedReserve + finalizeReserve + the
+* PROPOSED reserve fits the ceiling of EVERY account in the ancestor
+* chain (exact fill allowed), checked atomically before any commit.
+* Layer 2: the per-turn guard against the spawn's own chain, plus the
+* pre-dispatch output bound (layer 2b): every turn's maxOutputTokens is
+* clamped to what the remaining chain budget affords from the serving
+* model, and a turn that cannot afford one output token is denied before
+* dispatch. Layer 3: the AbortSignal ceiling severing live streams, with
+* partial usage written usageApprox.
 * B0 is immutable after start: no API tops it up.
 *
 * The account tree: the run root plus one
@@ -8702,15 +8842,27 @@ const ZERO_USAGE = {
 	cacheWriteTokens: 0
 };
 /**
-* The admission reserve for a spawn: opts.estCost, else profile.estCost, else
-* price(countTokens(input) + caps.maxOutputTokens), else the engine flat
-* default.
+* The admission reserve for a spawn: opts.estCost, else profile.estCost,
+* else price(countTokens(input) + one turn's worth of output), else the
+* engine flat default. The output term is caps.maxOutputTokens clamped to
+* limits.maxOutputTokensPerTurn when the spawn carries one, so a host can
+* bound reserves without hand-written estimates. The priced path uses the
+* SAME price function as settlement (priceUsdOf), so long-context tiers
+* apply to estimates too.
 */
 function admissionReserveUsd(options) {
 	if (options.estCost !== void 0) return options.estCost;
 	if (options.profileEstCost !== void 0) return options.profileEstCost;
 	const pricing = options.caps?.pricing;
-	if (options.inputTokens !== void 0 && pricing !== void 0 && options.caps !== void 0) return options.inputTokens / 1e6 * pricing.inputUsdPerMTok + options.caps.maxOutputTokens / 1e6 * pricing.outputUsdPerMTok;
+	if (options.inputTokens !== void 0 && pricing !== void 0 && options.caps !== void 0) {
+		const outputTokens = options.maxOutputTokensPerTurn === void 0 ? options.caps.maxOutputTokens : Math.min(options.caps.maxOutputTokens, options.maxOutputTokensPerTurn);
+		return priceUsdOf(pricing, {
+			inputTokens: options.inputTokens,
+			outputTokens,
+			cacheReadTokens: 0,
+			cacheWriteTokens: 0
+		});
+	}
 	return options.flatReserveUsd ?? .5;
 }
 /**
@@ -8725,6 +8877,7 @@ var RunBudget = class {
 	lifetimeSpawnCap;
 	events;
 	priceUsd;
+	pricingOf;
 	accounts = /* @__PURE__ */ new Map();
 	usageInternal = { ...ZERO_USAGE };
 	agentsSpawnedInternal = 0;
@@ -8736,6 +8889,7 @@ var RunBudget = class {
 		this.lifetimeSpawnCap = options.lifetimeSpawnCap ?? 500;
 		if (options.events !== void 0) this.events = options.events;
 		if (options.priceUsd !== void 0) this.priceUsd = options.priceUsd;
+		if (options.pricingOf !== void 0) this.pricingOf = options.pricingOf;
 		const root = {
 			scope: "run",
 			spentUsd: 0,
@@ -8841,9 +8995,15 @@ var RunBudget = class {
 		return Math.max(0, this.lifetimeSpawnCap - this.agentsSpawnedInternal);
 	}
 	/**
-	* Layer 1: admission before spawn. Blocks when spent + committedReserve
-	* has reached the ceiling on ANY account in the ancestor chain of
-	* `accountScope`, otherwise commits the reserve along the whole chain.
+	* Layer 1: PROJECTED admission before spawn. A spawn is admitted only
+	* when every account in the ancestor chain of `accountScope` still has
+	* admission headroom AND fits the PROPOSED reserve on top of spent +
+	* committedReserve + finalizeReserve (the finalize reserve is
+	* untouchable by admission, DEF-7). An exact fill is allowed; one
+	* dollar past the ceiling is not: a spawn is never admitted on the
+	* argument that the money it needs is merely not committed yet. The
+	* whole chain is checked before anything commits, so a rejection
+	* mutates no account, increments no counter, and journals nothing.
 	* Also enforces the engine lifetime spawn cap.
 	*/
 	admitSpawn(reserveUsd, accountScope = "run") {
@@ -8852,14 +9012,19 @@ var RunBudget = class {
 			throw new BudgetExhaustedError(`engine lifetime spawn cap reached (${this.lifetimeSpawnCap} spawns per run; budgetDefaults.lifetimeSpawnCap)`, { data: { cap: this.lifetimeSpawnCap } });
 		}
 		const chain = this.chainOf(accountScope);
-		for (const account of chain) if (account.ceilingUsd !== void 0 && account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd >= account.ceilingUsd) {
-			if (account.scope === "run") this.exhaustedInternal = true;
-			throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserve ${account.committedReserveUsd.toFixed(4)} USD is at the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
-				account: account.scope,
-				spentUsd: account.spentUsd,
-				committedReserveUsd: account.committedReserveUsd,
-				ceilingUsd: account.ceilingUsd
-			} });
+		for (const account of chain) {
+			if (account.ceilingUsd === void 0) continue;
+			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd;
+			if (committed >= account.ceilingUsd || committed + reserveUsd > account.ceilingUsd) {
+				if (account.scope === "run") this.exhaustedInternal = true;
+				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
+					account: account.scope,
+					spentUsd: account.spentUsd,
+					committedReserveUsd: account.committedReserveUsd,
+					proposedReserveUsd: reserveUsd,
+					ceilingUsd: account.ceilingUsd
+				} });
+			}
 		}
 		this.agentsSpawnedInternal += 1;
 		for (const account of chain) account.committedReserveUsd += reserveUsd;
@@ -8921,6 +9086,28 @@ var RunBudget = class {
 		}
 	}
 	/**
+	* Layer 2b, the pre-dispatch output bound: the output tokens the
+	* remaining chain budget (min over capped ancestors of ceiling minus
+	* spend) still affords from `servedBy` for an estimated prompt, priced
+	* by the same function as settlement, long-context tiers included.
+	* Undefined when no account in the chain carries a USD ceiling, when
+	* the model has no price row (the once-per-model unpriced warning in
+	* onUsage covers that hole), or when output is free. Zero or negative
+	* means the turn cannot be dispatched within the budget.
+	*/
+	maxAffordableOutputTokens(servedBy, estimatedInputTokens, accountScope = "run") {
+		const pricing = this.pricingOf?.(servedBy);
+		if (pricing === void 0) return;
+		let remainingUsd;
+		for (const account of this.chainOf(accountScope)) {
+			if (account.ceilingUsd === void 0) continue;
+			const headroom = account.ceilingUsd - account.spentUsd;
+			remainingUsd = remainingUsd === void 0 ? headroom : Math.min(remainingUsd, headroom);
+		}
+		if (remainingUsd === void 0) return;
+		return affordableOutputTokens(pricing, Math.max(0, remainingUsd), estimatedInputTokens);
+	}
+	/**
 	* Live accounting; spend propagates from `accountScope` to every
 	* ancestor. Crossing a ceiling severs the crossing account's subtree
 	* via its layer-3 AbortSignal (overshoot bounded by one turn per
@@ -9193,13 +9380,16 @@ var AdmissionController = class {
 			},
 			statsBefore
 		};
-		const reserveUsd = spec.estCostUsd ?? this.flatReserveUsd;
-		const reserve = { reserveUsd };
+		let childCeilingUsd;
 		const parentRemainder = this.budget.remainderOf(spec.parentAccountScope);
 		if (parentRemainder !== void 0) {
 			const fractionCap = this.childBudgetFraction * parentRemainder;
-			reserve.childCeilingUsd = spec.budgetUsd === void 0 ? fractionCap : Math.min(spec.budgetUsd, fractionCap);
-		} else if (spec.budgetUsd !== void 0) reserve.childCeilingUsd = spec.budgetUsd;
+			childCeilingUsd = spec.budgetUsd === void 0 ? fractionCap : Math.min(spec.budgetUsd, fractionCap);
+		} else if (spec.budgetUsd !== void 0) childCeilingUsd = spec.budgetUsd;
+		let reserveUsd = spec.estCostUsd ?? this.flatReserveUsd;
+		if (childCeilingUsd !== void 0) reserveUsd = Math.min(reserveUsd, childCeilingUsd);
+		const reserve = { reserveUsd };
+		if (childCeilingUsd !== void 0) reserve.childCeilingUsd = childCeilingUsd;
 		if (this.budget.spawnHeadroom <= 0) return {
 			verdict: {
 				kind: "reject",
@@ -10172,6 +10362,7 @@ function createCtx(internals, rootWorkflow) {
 		}
 		const adapter = adapterOf(loopResolved);
 		const caps = adapter.caps(loopResolved.model);
+		const limits = mergeUsageLimits(opts.limits, profile?.limits, internals.defaults.limits);
 		let inputTokens;
 		if (opts.estCost === void 0 && profile?.estCost === void 0 && adapter.countTokens) try {
 			inputTokens = await adapter.countTokens({
@@ -10191,8 +10382,9 @@ function createCtx(internals, rootWorkflow) {
 		if (opts.estCost !== void 0) reserveOptions.estCost = opts.estCost;
 		if (profile?.estCost !== void 0) reserveOptions.profileEstCost = profile.estCost;
 		if (inputTokens !== void 0) reserveOptions.inputTokens = inputTokens;
+		if (limits.maxOutputTokensPerTurn !== void 0) reserveOptions.maxOutputTokensPerTurn = limits.maxOutputTokensPerTurn;
 		if (internals.flatReserveUsd !== void 0) reserveOptions.flatReserveUsd = internals.flatReserveUsd;
-		const reserve = admissionReserveUsd(reserveOptions);
+		const reserve = internals.pricingOf !== void 0 && internals.pricingOf(loopResolved.ref) === void 0 && opts.estCost === void 0 && profile?.estCost === void 0 ? 0 : admissionReserveUsd(reserveOptions);
 		const budgetAccount = state.budgetScope ?? "run";
 		internals.budget.admitSpawn(reserve, budgetAccount);
 		let acquired;
@@ -10222,7 +10414,6 @@ function createCtx(internals, rootWorkflow) {
 			running = await internals.replayer.appendRunning(runningInput);
 		}
 		opts[kOnRunning]?.(running.seq);
-		const limits = mergeUsageLimits(opts.limits, profile?.limits, internals.defaults.limits);
 		const agentSink = { emit: (body) => internals.events.emit(body, spanId) };
 		const ckptRef = checkpointRefFor(internals.runId, running.seq);
 		let checkpointWritten = false;
@@ -10338,6 +10529,7 @@ function createCtx(internals, rootWorkflow) {
 			},
 			budget: {
 				beforeTurn: () => internals.budget.beforeTurn(budgetAccount),
+				maxAffordableOutputTokens: (servedBy, estimatedInputTokens) => internals.budget.maxAffordableOutputTokens(servedBy, estimatedInputTokens, budgetAccount),
 				onUsage: (usage, servedBy) => internals.budget.onUsage(usage, servedBy, budgetAccount),
 				signal: budgetAccount === "run" ? internals.budget.signal : AbortSignal.any([internals.budget.signal, internals.budget.signalOf(budgetAccount)].filter((signal) => signal !== void 0))
 			},
@@ -11702,7 +11894,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			role: "orchestrate",
 			result: "full",
 			tools: [...buildOrchestratorTools(orchestratorRuntime, fullCardText), ...extension?.tools(io) ?? []],
-			...capState === void 0 ? {} : { estCost: capState.effectiveCapUsd },
+			...capState === void 0 ? {} : { estCost: capState.effectiveCapUsd - (orchestratorAccount === void 0 ? 0 : internals.budget.accountView(orchestratorAccount)?.finalizeReserveUsd ?? 0) },
 			...opts?.model === void 0 ? {} : { model: opts.model },
 			...opts?.limits === void 0 ? {} : { limits: opts.limits },
 			[kOnRunning]: (seq) => {
@@ -11904,13 +12096,75 @@ var EventBus = class {
 //#endregion
 //#region src/runner/inprocess.ts
 /**
+* ScriptRunner SPI and InProcessRunner (M1-T11).
+*
+* Script runner contract: https://docs.rulvar.com/guide/planner
+* Workflow (a closure value) runs in process only; CompiledWorkflow is the
+* only form admissible to the worker sandbox and first exists at M6
+* (compileScript in @rulvar/planner), so until then the engine accepts
+* only in-process Workflow values. The SPI's L0 listing refers
+* to its frozen-seam status; the declaration lives here with its types.
+*/
+const detection = new AsyncLocalStorage();
+let globalsPatched = false;
+/**
+* Stack line 0 names the Error, line 1 this helper, line 2 the patched
+* global, line 3 the caller whose provenance decides. Library code (a
+* provider SDK, any installed dependency, rulvar's own published dist)
+* lives under node_modules and is exempt: the guard exists for workflow
+* code, which imports from node_modules but does not live there.
+*/
+function libraryCaller() {
+	const caller = (/* @__PURE__ */ new Error()).stack?.split("\n")[3];
+	return caller !== void 0 && caller.includes("node_modules");
+}
+/**
+* Patches Date.now and Math.random ONCE per process and never restores:
+* outside a workflow's async context the store is absent and the patch is
+* a transparent passthrough. The previous per-execute patch/restore pair
+* could race under concurrent runs (one run's restore removed another's
+* patch, and the second restore re-installed a stale patched function
+* PERMANENTLY, which could then warn on host code outside any run: the
+* false RULVAR_BARE_DATE_NOW class the 1.5.2 review reproduced).
+*/
+function patchGlobalsOnce() {
+	if (globalsPatched) return;
+	globalsPatched = true;
+	const priorNow = Date.now;
+	const priorRandom = Math.random;
+	Date.now = function rulvarPatchedDateNow() {
+		const state = detection.getStore();
+		if (state !== void 0 && !state.warnedNow && !libraryCaller()) {
+			state.warnedNow = true;
+			process.emitWarning("bare Date.now() called inside a rulvar run; use ctx.now() so the value is journaled and stable on replay", {
+				code: "RULVAR_BARE_DATE_NOW",
+				type: "RulvarWarning"
+			});
+		}
+		return priorNow();
+	};
+	Math.random = function rulvarPatchedMathRandom() {
+		const state = detection.getStore();
+		if (state !== void 0 && !state.warnedRandom && !libraryCaller()) {
+			state.warnedRandom = true;
+			process.emitWarning("bare Math.random() called inside a rulvar run; use ctx.random() so the value is journaled and stable on replay", {
+				code: "RULVAR_BARE_MATH_RANDOM",
+				type: "RulvarWarning"
+			});
+		}
+		return priorRandom();
+	};
+}
+/**
 * The mode (a) runner for human-authored closures. Determinism is enforced
 * by convention, lint, and the ctx shims, NOT by a VM: only the sequence
-* of keys must be stable. Dev mode (NODE_ENV !== 'production') patches
-* Date.now and Math.random for the duration of execute to emit one warning
-* per run pointing at ctx.now()/ctx.random(); the patch preserves behavior
-* and restores the prior functions on exit (nesting-safe by capturing the
-* prior value; concurrent runs may lose the warning, never correctness).
+* of keys must be stable. Dev mode (NODE_ENV !== 'production') detects
+* bare Date.now and Math.random and emits one warning per run pointing at
+* ctx.now()/ctx.random(). Detection is attributed by AsyncLocalStorage:
+* only code inside the workflow body's async context can trigger it, so
+* host code running concurrently, engine internals outside the body, and
+* other runs never produce a false warning, and nothing is ever restored,
+* so concurrent executes cannot race the patch state.
 */
 var InProcessRunner = class {
 	onEscalation;
@@ -11923,47 +12177,14 @@ var InProcessRunner = class {
 	}
 	async execute(wf, ctx, args) {
 		if (wf.kind !== "workflow") throw new TypeError("InProcessRunner executes closure Workflow values only; CompiledWorkflow runs in the worker sandbox (@rulvar/planner, M6)");
-		const devMode = process.env.NODE_ENV !== "production";
-		let restore;
-		if (devMode) {
-			const priorNow = Date.now;
-			const priorRandom = Math.random;
-			let warnedNow = false;
-			let warnedRandom = false;
-			const libraryCaller = () => {
-				const caller = (/* @__PURE__ */ new Error()).stack?.split("\n")[3];
-				return caller !== void 0 && caller.includes("node_modules");
-			};
-			Date.now = function rulvarPatchedDateNow() {
-				if (!warnedNow && !libraryCaller()) {
-					warnedNow = true;
-					process.emitWarning("bare Date.now() called inside a rulvar run; use ctx.now() so the value is journaled and stable on replay", {
-						code: "RULVAR_BARE_DATE_NOW",
-						type: "RulvarWarning"
-					});
-				}
-				return priorNow();
-			};
-			Math.random = function rulvarPatchedMathRandom() {
-				if (!warnedRandom && !libraryCaller()) {
-					warnedRandom = true;
-					process.emitWarning("bare Math.random() called inside a rulvar run; use ctx.random() so the value is journaled and stable on replay", {
-						code: "RULVAR_BARE_MATH_RANDOM",
-						type: "RulvarWarning"
-					});
-				}
-				return priorRandom();
-			};
-			restore = () => {
-				Date.now = priorNow;
-				Math.random = priorRandom;
-			};
-		}
-		try {
-			return await wf.body(ctx, args);
-		} finally {
-			restore?.();
+		if (process.env.NODE_ENV !== "production") {
+			patchGlobalsOnce();
+			return detection.run({
+				warnedNow: false,
+				warnedRandom: false
+			}, () => wf.body(ctx, args));
 		}
+		return await wf.body(ctx, args);
 	}
 };
 //#endregion
@@ -12000,10 +12221,13 @@ function createEngine(options) {
 	const runner = new InProcessRunner(options.onEscalation === void 0 ? void 0 : { onEscalation: options.onEscalation });
 	const mintRunId = createCanonicalIdMinter();
 	const realNow = Date.now.bind(globalThis);
+	const pricingOf = (servedBy) => {
+		const { adapterId, model } = parseModelRef(servedBy);
+		return resolvePricing(servedBy, options.pricing, adapters.get(adapterId)?.caps(model).pricing);
+	};
 	const priceUsd = (servedBy, usage) => {
 		if (servedBy === void 0) return;
-		const { adapterId, model } = parseModelRef(servedBy);
-		const pricing = resolvePricing(servedBy, options.pricing, adapters.get(adapterId)?.caps(model).pricing);
+		const pricing = pricingOf(servedBy);
 		if (pricing === void 0) return;
 		return priceUsdOf(pricing, usage);
 	};
@@ -12029,6 +12253,7 @@ function createEngine(options) {
 			lifetimeSpawnCap: options.budgetDefaults?.lifetimeSpawnCap ?? 500,
 			events: { emit: (body) => bus.emit(body, rootSpanId) },
 			priceUsd,
+			pricingOf,
 			...budgetSeed === void 0 ? {} : { seed: budgetSeed }
 		});
 		const invalidated = new Set(resumeCtx?.invalidate ?? []);
@@ -12132,6 +12357,7 @@ function createEngine(options) {
 				}
 			},
 			priceUsd: (servedBy, usage) => priceUsd(servedBy, usage),
+			pricingOf,
 			runSignal: controller.signal,
 			...defaults.isolation === void 0 ? {} : { isolation: defaults.isolation },
 			...options.onEscalation === void 0 ? {} : { onEscalation: options.onEscalation },
@@ -12675,4 +12901,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DedupIndex, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EventBus, ExternalRegistry, FINISH_SCHEMA, FINISH_TOOL_NAME, FileModelKnowledgeStore, FileTranscriptStore, GitWorktreeProvider, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, PlanInvariantError, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, agentErrorFromWire, agentErrorToWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, scanJournalCompatibility, schemaHash, schemaHashOfSpec, selectStructuredOutputTier, shouldCompact, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateSchemaSpec, validateTerminationLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DedupIndex, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EventBus, ExternalRegistry, FINISH_SCHEMA, FINISH_TOOL_NAME, FileModelKnowledgeStore, FileTranscriptStore, GitWorktreeProvider, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, PlanInvariantError, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, scanJournalCompatibility, schemaHash, schemaHashOfSpec, selectStructuredOutputTier, shouldCompact, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateSchemaSpec, validateTerminationLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rulvar/core",
-  "version": "1.5.2",
-  "description": "rulvar core: L0 contracts, journal kernel, ctx primitives, agent runtime, model router, tool system, dynamic orchestrator, InMemory and JSONL stores, event stream.",
+  "version": "1.6.0",
+  "description": "Rulvar core: L0 contracts, journal kernel, ctx primitives, agent runtime, model router, tool system, dynamic orchestrator, InMemory and JSONL stores, event stream.",
   "type": "module",
   "license": "Apache-2.0",
   "engines": {