@rulvar/core 1.170.0 → 1.171.0

package/dist/index.d.ts

@@ -764,7 +764,13 @@ interface ProviderCallRecord {
   /** The invocation phase that paid the call. */
   role: InvocationRole;
   servedBy: ModelRef;
-  /** 1-based try number on the serving target; retries increment it. */
+  /**
+  * 1-based DISPATCHED try number on the serving target; transport
+  * retries increment it, a pre-wire quota denial never does (RV1601),
+  * so the recorded attempts of one (role, target) series are always
+  * dense from 1 and an attempt=2 row proves a prior dispatched try
+  * with its own record.
+  */
   attempt: number;
   /**
   * 'ok' = a terminal finish; 'error' = a wire failure after dispatch
@@ -4067,6 +4073,19 @@ interface EngineQuotaConfig {
   */
   reserveContinuations?: boolean;
   /**
+  * The denial retry budget (RV1601): how many pre-wire quota denials
+  * one dispatch tolerates per serving target before the denial takes
+  * the exhaustion path (failover when the chain names a rate-limit
+  * trigger, else the typed rate-limit terminal). Denials stopped
+  * consuming `RetryPolicy.attempts` in RV1601: that budget counts
+  * DISPATCHED tries only, so a busy window can no longer exhaust the
+  * transport budget before the wire ever opens (the eighteenth
+  * comparison benchmark measured 21 denials riding the transport
+  * namespaces). Each denied turn still waits the limiter's own
+  * `retryAfterMs` first. Default {@link DEFAULT_MAX_QUOTA_DENIALS}.
+  */
+  maxDenials?: number;
+  /**
   * The drift telemetry opt-in (the v1.71 experiment review, P0.5
   * resized): the SAME rule declaration `preflightEstimate` takes as
   * `quotaRules`, mirrored here so the engine can hold it against what
@@ -4086,6 +4105,14 @@ interface EngineQuotaConfig {
   */
   declaredRules?: readonly QuotaRule[];
 }
+/**
+* The default {@link EngineQuotaConfig.maxDenials}: generous next to the
+* transport default of 3 tries because a denial is a WAIT, not a
+* failure signal, yet finite because nothing else bounds the pre-wire
+* loop (the per-agent timeout is checked between turns, not inside a
+* dispatch).
+*/
+declare const DEFAULT_MAX_QUOTA_DENIALS = 8;
 /** The resolved engine-side quota runtime threaded into every run. */
 interface EngineQuotaRuntime {
   limiter: QuotaLimiter;
@@ -4093,6 +4120,8 @@ interface EngineQuotaRuntime {
   onLimiterError: "deny" | "allow";
   /** Pre-wire continuation admission (RV1013); see {@link EngineQuotaConfig}. */
   reserveContinuations: boolean;
+  /** The per-target denial retry budget (RV1601); see {@link EngineQuotaConfig}. */
+  maxDenials: number;
   /** The declared rule mirror for drift telemetry; see {@link EngineQuotaConfig}. */
   declaredRules?: readonly QuotaRule[];
 }
@@ -4856,9 +4885,14 @@ interface AgentResult<T> {
   abortClass?: AbortClass;
   /**
   * Transport retries across the span's phase activations, present only
-  * when greater than zero. Live telemetry only: the ctx layer surfaces
-  * it as `agent:end` retryCount; it is never journaled, so a replayed
-  * result omits it (absent means "zero or unknown").
+  * when greater than zero. Counts retries of DISPATCHED attempts only
+  * (RV1601): a pre-wire quota denial never increments it, so this
+  * number can be read against the provider ledger without correction
+  * (the eighteenth comparison benchmark exported 21 denials under this
+  * name over an invoice with zero provider error rows). Live telemetry
+  * only: the ctx layer surfaces it as `agent:end` retryCount; it is
+  * never journaled, so a replayed result omits it (absent means "zero
+  * or unknown").
   */
   transportRetries?: number;
   /**
@@ -5166,12 +5200,14 @@ interface RunAgentOptions<S extends SchemaSpec = JsonSchema> {
   * failover takeovers alike, in every phase). A denial becomes a
   * synthetic rate-limit-class WireError the retry and failover
   * engine treats exactly like a provider 429, except no wire call
-  * was paid: retryAfterMs drives the interruptible backoff, attempts
-  * stay bounded by RetryPolicy, and exhaustion fails over (the
-  * takeover reserves under its own model). Granted reservations are
-  * reconciled with the attempt's actual usage after the outcome
-  * settles. Live-only by construction: replayed calls never reach
-  * this seam, and nothing here is journaled.
+  * was paid: retryAfterMs drives the interruptible backoff, denied
+  * turns stay bounded by their OWN `maxDenials` budget (RV1601;
+  * RetryPolicy.attempts counts dispatched tries only), and
+  * exhaustion of either budget fails over (the takeover reserves
+  * under its own model). Granted reservations are reconciled with
+  * the attempt's actual usage after the outcome settles. Live-only
+  * by construction: replayed calls never reach this seam, and
+  * nothing here is journaled.
   */
   quota?: {
     reserve: (request: QuotaReservationRequest) => Promise<QuotaDecision>;
@@ -5179,7 +5215,8 @@ interface RunAgentOptions<S extends SchemaSpec = JsonSchema> {
       requests?: number;
     }) => Promise<void>; /** Limiter infrastructure failure policy; a denial is unaffected. */
     onLimiterError: "deny" | "allow"; /** Pre-wire continuation admission (RV1013); default post-hoc. */
-    reserveContinuations?: boolean; /** Cancels an unused admission; absent = window age-out. */
+    reserveContinuations?: boolean; /** The per-target denial retry budget (RV1601); default 8. */
+    maxDenials?: number; /** Cancels an unused admission; absent = window age-out. */
     release?: (reservationId: string) => Promise<void>;
   };
   /** The resolved toolset; absent = no tools declared. */
@@ -12675,4 +12712,4 @@ interface SandboxBridge {
 declare const SANDBOX_AGENT_OPT_KEYS: readonly string[];
 declare function createSandboxBridge(ctx: Ctx<never>, options: SandboxBridgeOptions): SandboxBridge;
 //#endregion
-export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, 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, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, CitationTarget, type ClaimClass, ClaimContradictionFinding, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, 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, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSerializationContext, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, RefEntryAppender, RefEntryClassification, RefusalInfo, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, type ToolBudgetSummary, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, 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, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolContractHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, 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, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, CitationTarget, type ClaimClass, ClaimContradictionFinding, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, 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, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSerializationContext, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, RefEntryAppender, RefEntryClassification, RefusalInfo, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, type ToolBudgetSummary, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, 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, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolContractHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -9009,123 +9009,446 @@ function compareRates(seed, page) {
 	return findings;
 }
 //#endregion
-//#region src/model/failover.ts
-/** Normalizes the author-facing ModelChoice.fallbacks list. */
-function normalizeFallbacks(refs) {
-	return (refs ?? []).map((model) => ({ model }));
-}
+//#region src/model/quota.ts
 /**
-* Maps a retry class to its failover trigger once retries exhaust.
-* Overloaded (529) is transport-class for failover purposes; a
-* non-retryable error never fails over.
+* Quota rules and the in-process reference QuotaLimiter (RV-215).
+* The rule model is shared by every reference implementation
+* (memoryQuotaLimiter here, SqliteQuotaLimiter in
+* @rulvar/store-sqlite): fixed one-minute windows aligned to the
+* epoch, admission at reservation time, reconciliation to actual
+* usage inside the same window. The hard guarantee is on
+* `requestsPerMinute` (every wire attempt is exactly one request);
+* `tokensPerMinute` admits on the heuristic estimate and settles to
+* actual usage, so token windows are approximate at admission and
+* exact at settlement.
+*
+* Docs: https://docs.rulvar.com/guide/model-routing
 */
-function failoverTriggerOf(retryClass) {
-	if (retryClass === void 0) return;
-	return retryClass === "rate-limit" ? "rate-limit" : "transport";
+/**
+* Captured at module load, before the InProcessRunner's
+* nondeterminism guard can patch the global: the limiter's clock is
+* engine infrastructure on the live-only dispatch path and must never
+* be blamed on workflow code.
+*/
+const nativeNow = Date.now;
+/** The fixed accounting window every PerMinute cap counts over. */
+const QUOTA_WINDOW_MS = 6e4;
+/**
+* Validates a quota rule set as a typed ConfigError before any
+* limiter can admit under it: a non-array or empty set, a rule
+* without a cap, a malformed dimension, or a malformed cap all fail
+* loud at construction. Shared by every reference implementation.
+*/
+function validateQuotaRules(rules, site = "quota rules") {
+	const raw = rules;
+	if (!Array.isArray(raw)) throw new ConfigError(`${site} must be an array of QuotaRule objects`);
+	if (raw.length === 0) throw new ConfigError(`${site} must contain at least one rule`);
+	raw.forEach((entry, index) => {
+		const at = `${site}[${String(index)}]`;
+		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw new ConfigError(`${at} must be a QuotaRule object`);
+		const rule = entry;
+		for (const dimension of [
+			"provider",
+			"model",
+			"tenant"
+		]) {
+			const value = rule[dimension];
+			if (value !== void 0 && (typeof value !== "string" || value === "")) throw new ConfigError(`${at}.${dimension} must be a nonempty string when given`);
+		}
+		if (rule.requestsPerMinute === void 0 && rule.tokensPerMinute === void 0) throw new ConfigError(`${at} must set requestsPerMinute or tokensPerMinute (or both)`);
+		for (const cap of ["requestsPerMinute", "tokensPerMinute"]) if (rule[cap] !== void 0) requirePositiveInteger$2(rule[cap], `${at}.${cap}`);
+	});
 }
 /**
-* The next target index past `from` that serves `trigger`, or undefined
-* when the chain is exhausted. Index 0 is the primary; the chain never
-* moves backwards (sticky failover).
+* The canonical content key of one rule (RV608, promoted from the
+* store limiters): a fixed-field-order JSON of the rule, identical
+* across processes and hosts for identical rules. It is the bucket key
+* of both store references, the input of
+* `quotaRulesFingerprint`, and the CANONICAL ORDER every reference
+* limiter folds denials in, so equal rule sets produce byte-identical
+* refusal objects regardless of array permutation.
 */
-function nextFailover(targets, trigger, from) {
-	for (let index = from + 1; index < targets.length; index += 1) {
-		const on = targets[index]?.on;
-		if (on === void 0 || on.includes(trigger)) return index;
-	}
+function quotaRuleKey(rule) {
+	return JSON.stringify({
+		provider: rule.provider ?? null,
+		model: rule.model ?? null,
+		tenant: rule.tenant ?? null,
+		requestsPerMinute: rule.requestsPerMinute ?? null,
+		tokensPerMinute: rule.tokensPerMinute ?? null
+	});
 }
 /**
-* Classifies a terminal agent outcome for the degenerate fallback:
-* schema-mismatch errors are
-* 'schema-exhausted'; any other error is 'error'; limit terminals (the
-* no-progress abort included) are 'limit'; cancelled, escalated, and
-* skipped never trigger.
+* Validates a rule set and returns the immutable snapshot every
+* reference limiter admits under (RV608): a fresh array of fresh
+* objects carrying ONLY the known rule fields, each frozen, the array
+* frozen. The caller's array and objects stay untouched and unshared,
+* so ordinary JavaScript after the constructor (a pushed rule, a
+* reassigned cap) can no longer change a decision, a bucket key, or a
+* recorded fingerprint.
+*
+* A set containing two rules with the same canonical content key is
+* refused typed (RV704): the memory reference buckets by rule INDEX
+* (each copy counts independently, the full cap admits) while the
+* store references bucket by rule KEY (one shared bucket is debited
+* once per matching copy, half the cap admits), so the same duplicated
+* configuration admitted differently per storage. Refusing it at the
+* shared construction chokepoint is what keeps equal configurations
+* equal on every storage.
 */
-function fallbackTriggerOf(outcome) {
-	if (outcome.status === "error") return outcome.error?.kind === "schema-mismatch" ? "schema-exhausted" : "error";
-	if (outcome.status === "limit") return "limit";
+function snapshotQuotaRules(rules, site = "quota rules") {
+	validateQuotaRules(rules, site);
+	const firstIndexByKey = /* @__PURE__ */ new Map();
+	rules.forEach((rule, index) => {
+		const key = quotaRuleKey(rule);
+		const first = firstIndexByKey.get(key);
+		if (first !== void 0) throw new ConfigError(`${site}[${String(index)}] duplicates ${site}[${String(first)}] (rule key ${key}): identical rules occupy independent buckets in memory but share one key-debited bucket on keyed storage, so one configuration would admit differently per store; delete the duplicate`);
+		firstIndexByKey.set(key, index);
+	});
+	return Object.freeze(rules.map((rule) => Object.freeze({
+		...rule.provider === void 0 ? {} : { provider: rule.provider },
+		...rule.model === void 0 ? {} : { model: rule.model },
+		...rule.tenant === void 0 ? {} : { tenant: rule.tenant },
+		...rule.requestsPerMinute === void 0 ? {} : { requestsPerMinute: rule.requestsPerMinute },
+		...rule.tokensPerMinute === void 0 ? {} : { tokensPerMinute: rule.tokensPerMinute }
+	})));
 }
-//#endregion
-//#region src/model/projector.ts
-/** The provider family of an adapter: `provider` when set, else `id`. */
-function providerOf(adapter) {
-	return adapter.provider ?? adapter.id;
+/** True when every dimension the rule pins matches the request. */
+function quotaRuleMatches(rule, request) {
+	return (rule.provider === void 0 || rule.provider === request.provider) && (rule.model === void 0 || rule.model === request.model) && (rule.tenant === void 0 || rule.tenant === request.tenant);
+}
+/** The tokens a reservation is admitted under: input estimate plus the output cap. */
+function quotaEstimateTokens(request) {
+	return request.estimate.inputTokens + (request.estimate.maxOutputTokens ?? 0);
+}
+/** The tokens a settled attempt actually consumed. */
+function quotaActualTokens(usage) {
+	return usage.inputTokens + usage.outputTokens;
 }
 /**
-* Projects the canonical history into the target provider's view:
-* provider-raw parts of a DIFFERENT provider are omitted; everything
-* else (text, images, tool calls, tool results, compaction content)
-* passes through untouched. Messages whose parts all belong to another
-* provider vanish entirely rather than ride as empty messages.
+* The request-count settlement delta of one reservation (RV905): the
+* reservation admitted ONE wire request, and `actual.requests` names
+* how many the attempt actually made (an adapter absorbing
+* provider-side continuations dispatches several inside one reserved
+* call). Non-integer, non-positive, or absent actuals settle as the
+* single reserved request (delta 0); a settlement only ever ADDS, the
+* calls already happened. Shared by every reference limiter so the
+* three implementations cannot disagree about the arithmetic.
 */
-function projectHistory(messages, targetProvider) {
-	const projected = [];
-	for (const msg of messages) {
-		const parts = msg.parts.filter((part) => part.type !== "provider-raw" || part.provider === targetProvider);
-		if (parts.length === 0 && msg.parts.length > 0) continue;
-		projected.push(parts.length === msg.parts.length ? msg : {
-			...msg,
-			parts
-		});
-	}
-	return projected;
+function quotaActualRequestsDelta(actual) {
+	const requests = actual?.requests;
+	return typeof requests === "number" && Number.isInteger(requests) && requests > 1 ? requests - 1 : 0;
 }
 /**
-* Lifts the adapter-shipped retention payload of one finished turn into
-* provider-raw parts (the retention transport). Reads
-* providerMetadata[<adapter id>].retainedParts and tags each block with
-* the adapter's provider family. Returns [] when the adapter shipped
-* nothing.
+* One rule's admission verdict against its current-window counters,
+* the pure decision both reference implementations share. A denial
+* carries the window remainder as retryAfterMs, except when the
+* estimate alone can never fit the token cap: that denial says
+* retryAfterMs 0 (retry immediately), so the caller's bounded
+* attempts exhaust without waiting and failover gets its chance.
 */
-function liftRetainedParts(providerMetadata, adapter) {
-	const namespace = providerMetadata?.[adapter.id];
-	if (typeof namespace !== "object" || namespace === null) return [];
-	const retained = namespace.retainedParts;
-	if (!Array.isArray(retained)) return [];
-	const blocks = retained;
-	const provider = providerOf(adapter);
-	return blocks.map((block) => ({
-		type: "provider-raw",
-		provider,
-		block
-	}));
+function quotaRuleAdmission(rule, counters, estimate, msUntilWindowEnd) {
+	if (rule.requestsPerMinute !== void 0 && counters.requests + estimate.requests > rule.requestsPerMinute) return {
+		admit: false,
+		retryAfterMs: msUntilWindowEnd,
+		reason: `requestsPerMinute ${String(rule.requestsPerMinute)} exhausted`
+	};
+	if (rule.tokensPerMinute !== void 0) {
+		if (estimate.tokens > rule.tokensPerMinute) return {
+			admit: false,
+			retryAfterMs: 0,
+			reason: `the estimate of ${String(estimate.tokens)} tokens can never fit tokensPerMinute ${String(rule.tokensPerMinute)}`
+		};
+		if (counters.tokens + estimate.tokens > rule.tokensPerMinute) return {
+			admit: false,
+			retryAfterMs: msUntilWindowEnd,
+			reason: `tokensPerMinute ${String(rule.tokensPerMinute)} exhausted`
+		};
+	}
+	return { admit: true };
 }
-//#endregion
-//#region src/model/retry.ts
 /**
-* Transport RetryPolicy (M4-T05): retries live UNDER the journal. A
-* retried-then-successful call is exactly one journal entry with one
-* usage total, transport retries never count as lineage attempts
-* (DEF-3), the provider-supplied retryAfterMs replaces the computed
-* delay, and task-class failures never retry by construction (a
-* non-retryable WireError has no retry class).
-*
-* Full contract: https://docs.rulvar.com/guide/model-routing; the
-* Appendix A defaults were committed at the M4 entry gate.
+* Folds one more failing rule into the decision the caller returns:
+* the wait is the LONGEST failing horizon (every matching rule must
+* admit), and the FIRST failing rule names the denial.
 */
+function mergeQuotaDenial(current, next) {
+	if (current === void 0) return {
+		retryAfterMs: next.retryAfterMs,
+		reason: next.reason
+	};
+	return next.retryAfterMs > current.retryAfterMs ? {
+		retryAfterMs: next.retryAfterMs,
+		reason: current.reason
+	} : current;
+}
 /**
-* Captured at module load, before the InProcessRunner's nondeterminism
-* guard can patch the global: the engine's own jitter is journal
-* invisible and must never be blamed on workflow code.
+* The in-process reference QuotaLimiter: fixed epoch-aligned
+* one-minute windows over the shared rule model. Coordinates every
+* engine that shares THIS instance inside one process; processes
+* coordinate through a shared-storage implementation of the same SPI
+* (SqliteQuotaLimiter in @rulvar/store-sqlite) instead.
 */
-const nativeRandom = Math.random;
-/** Appendix A committed defaults (M4 entry gate, PR #26). */
-const DEFAULT_RETRY_POLICY = {
-	attempts: 3,
-	backoff: {
-		initialMs: 500,
-		factor: 2,
-		maxMs: 8e3,
-		jitter: true
-	},
-	retryOn: [
-		"transport",
-		"rate-limit",
-		"overloaded"
-	]
-};
-/**
-* Classifies a WireError for the retry engine. Task-class failures are
+function memoryQuotaLimiter(rules, options = {}) {
+	const frozen = snapshotQuotaRules(rules, "memoryQuotaLimiter rules");
+	const ordered = frozen.map((rule, index) => ({
+		rule,
+		index,
+		key: quotaRuleKey(rule)
+	})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+	const now = options.now ?? (() => nativeNow());
+	const buckets = /* @__PURE__ */ new Map();
+	const reservations = /* @__PURE__ */ new Map();
+	let nextReservation = 0;
+	const windowStartAt = (at) => at - at % QUOTA_WINDOW_MS;
+	const bucketFor = (ruleIndex, windowStart) => {
+		let bucket = buckets.get(ruleIndex);
+		if (bucket === void 0 || bucket.windowStart !== windowStart) {
+			bucket = {
+				windowStart,
+				requests: 0,
+				tokens: 0
+			};
+			buckets.set(ruleIndex, bucket);
+		}
+		return bucket;
+	};
+	const prune = (windowStart) => {
+		for (const [id, reservation] of reservations) if (reservation.windowStart < windowStart) reservations.delete(id);
+	};
+	return {
+		reserve(request) {
+			const at = now();
+			const windowStart = windowStartAt(at);
+			prune(windowStart);
+			const estimateTokens = quotaEstimateTokens(request);
+			const msUntilWindowEnd = windowStart + QUOTA_WINDOW_MS - at;
+			const matched = [];
+			let denial;
+			for (const { rule, index } of ordered) {
+				if (!quotaRuleMatches(rule, request)) continue;
+				matched.push(index);
+				const verdict = quotaRuleAdmission(rule, bucketFor(index, windowStart), {
+					requests: request.estimate.requests,
+					tokens: estimateTokens
+				}, msUntilWindowEnd);
+				if (!verdict.admit) denial = mergeQuotaDenial(denial, verdict);
+			}
+			if (denial !== void 0) return Promise.resolve({
+				granted: false,
+				...denial
+			});
+			for (const index of matched) {
+				const bucket = bucketFor(index, windowStart);
+				bucket.requests += request.estimate.requests;
+				bucket.tokens += estimateTokens;
+			}
+			nextReservation += 1;
+			const reservationId = `mq-${String(nextReservation)}`;
+			reservations.set(reservationId, {
+				windowStart,
+				estimateTokens,
+				requests: request.estimate.requests,
+				ruleIndexes: matched
+			});
+			return Promise.resolve({
+				granted: true,
+				reservationId
+			});
+		},
+		reconcile(reservationId, usage, actual) {
+			const reservation = reservations.get(reservationId);
+			if (reservation === void 0) return Promise.resolve();
+			reservations.delete(reservationId);
+			const windowStart = windowStartAt(now());
+			if (reservation.windowStart !== windowStart) return Promise.resolve();
+			const delta = quotaActualTokens(usage) - reservation.estimateTokens;
+			const requestsDelta = quotaActualRequestsDelta(actual);
+			for (const index of reservation.ruleIndexes) {
+				const bucket = buckets.get(index);
+				if (bucket !== void 0 && bucket.windowStart === windowStart) {
+					bucket.tokens = Math.max(0, bucket.tokens + delta);
+					bucket.requests += requestsDelta;
+				}
+			}
+			return Promise.resolve();
+		},
+		release(reservationId) {
+			const reservation = reservations.get(reservationId);
+			if (reservation === void 0) return Promise.resolve();
+			reservations.delete(reservationId);
+			const windowStart = windowStartAt(now());
+			if (reservation.windowStart !== windowStart) return Promise.resolve();
+			for (const index of reservation.ruleIndexes) {
+				const bucket = buckets.get(index);
+				if (bucket !== void 0 && bucket.windowStart === windowStart) {
+					bucket.requests = Math.max(0, bucket.requests - reservation.requests);
+					bucket.tokens = Math.max(0, bucket.tokens - reservation.estimateTokens);
+				}
+			}
+			return Promise.resolve();
+		},
+		snapshot() {
+			const windowStart = windowStartAt(now());
+			return frozen.map((rule, index) => {
+				const bucket = buckets.get(index);
+				const current = bucket !== void 0 && bucket.windowStart === windowStart;
+				return {
+					rule,
+					windowStart,
+					requests: current ? bucket.requests : 0,
+					tokens: current ? bucket.tokens : 0
+				};
+			});
+		}
+	};
+}
+/**
+* The default {@link EngineQuotaConfig.maxDenials}: generous next to the
+* transport default of 3 tries because a denial is a WAIT, not a
+* failure signal, yet finite because nothing else bounds the pre-wire
+* loop (the per-agent timeout is checked between turns, not inside a
+* dispatch).
+*/
+const DEFAULT_MAX_QUOTA_DENIALS = 8;
+/**
+* Validates createEngine's quota config as a typed ConfigError before
+* any run could dispatch under a malformed limiter (the intake
+* discipline every engine option follows).
+*/
+function validateEngineQuotaConfig(config, site = "createEngine quota") {
+	if (config === void 0) return;
+	const raw = config;
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new ConfigError(`${site} must be an object with a limiter`);
+	const candidate = raw;
+	const limiter = candidate.limiter;
+	if (typeof limiter !== "object" || limiter === null || typeof limiter.reserve !== "function" || typeof limiter.reconcile !== "function") throw new ConfigError(`${site}.limiter must implement QuotaLimiter (reserve and reconcile functions)`);
+	if (candidate.tenant !== void 0 && (typeof candidate.tenant !== "string" || candidate.tenant === "")) throw new ConfigError(`${site}.tenant must be a nonempty string when given`);
+	if (candidate.onLimiterError !== void 0 && candidate.onLimiterError !== "deny" && candidate.onLimiterError !== "allow") throw new ConfigError(`${site}.onLimiterError must be 'deny' or 'allow' when given`);
+	const reserveContinuations = candidate.reserveContinuations;
+	if (reserveContinuations !== void 0 && typeof reserveContinuations !== "boolean") throw new ConfigError(`${site}.reserveContinuations must be a boolean when given`);
+	const maxDenials = candidate.maxDenials;
+	if (maxDenials !== void 0 && (typeof maxDenials !== "number" || !Number.isInteger(maxDenials) || maxDenials < 1)) throw new ConfigError(`${site}.maxDenials must be a positive integer when given`);
+	const declared = candidate.declaredRules;
+	if (declared !== void 0) validateQuotaRules(declared, `${site}.declaredRules`);
+}
+//#endregion
+//#region src/model/failover.ts
+/** Normalizes the author-facing ModelChoice.fallbacks list. */
+function normalizeFallbacks(refs) {
+	return (refs ?? []).map((model) => ({ model }));
+}
+/**
+* Maps a retry class to its failover trigger once retries exhaust.
+* Overloaded (529) is transport-class for failover purposes; a
+* non-retryable error never fails over.
+*/
+function failoverTriggerOf(retryClass) {
+	if (retryClass === void 0) return;
+	return retryClass === "rate-limit" ? "rate-limit" : "transport";
+}
+/**
+* The next target index past `from` that serves `trigger`, or undefined
+* when the chain is exhausted. Index 0 is the primary; the chain never
+* moves backwards (sticky failover).
+*/
+function nextFailover(targets, trigger, from) {
+	for (let index = from + 1; index < targets.length; index += 1) {
+		const on = targets[index]?.on;
+		if (on === void 0 || on.includes(trigger)) return index;
+	}
+}
+/**
+* Classifies a terminal agent outcome for the degenerate fallback:
+* schema-mismatch errors are
+* 'schema-exhausted'; any other error is 'error'; limit terminals (the
+* no-progress abort included) are 'limit'; cancelled, escalated, and
+* skipped never trigger.
+*/
+function fallbackTriggerOf(outcome) {
+	if (outcome.status === "error") return outcome.error?.kind === "schema-mismatch" ? "schema-exhausted" : "error";
+	if (outcome.status === "limit") return "limit";
+}
+//#endregion
+//#region src/model/projector.ts
+/** The provider family of an adapter: `provider` when set, else `id`. */
+function providerOf(adapter) {
+	return adapter.provider ?? adapter.id;
+}
+/**
+* Projects the canonical history into the target provider's view:
+* provider-raw parts of a DIFFERENT provider are omitted; everything
+* else (text, images, tool calls, tool results, compaction content)
+* passes through untouched. Messages whose parts all belong to another
+* provider vanish entirely rather than ride as empty messages.
+*/
+function projectHistory(messages, targetProvider) {
+	const projected = [];
+	for (const msg of messages) {
+		const parts = msg.parts.filter((part) => part.type !== "provider-raw" || part.provider === targetProvider);
+		if (parts.length === 0 && msg.parts.length > 0) continue;
+		projected.push(parts.length === msg.parts.length ? msg : {
+			...msg,
+			parts
+		});
+	}
+	return projected;
+}
+/**
+* Lifts the adapter-shipped retention payload of one finished turn into
+* provider-raw parts (the retention transport). Reads
+* providerMetadata[<adapter id>].retainedParts and tags each block with
+* the adapter's provider family. Returns [] when the adapter shipped
+* nothing.
+*/
+function liftRetainedParts(providerMetadata, adapter) {
+	const namespace = providerMetadata?.[adapter.id];
+	if (typeof namespace !== "object" || namespace === null) return [];
+	const retained = namespace.retainedParts;
+	if (!Array.isArray(retained)) return [];
+	const blocks = retained;
+	const provider = providerOf(adapter);
+	return blocks.map((block) => ({
+		type: "provider-raw",
+		provider,
+		block
+	}));
+}
+//#endregion
+//#region src/model/retry.ts
+/**
+* Transport RetryPolicy (M4-T05): retries live UNDER the journal. A
+* retried-then-successful call is exactly one journal entry with one
+* usage total, transport retries never count as lineage attempts
+* (DEF-3), the provider-supplied retryAfterMs replaces the computed
+* delay, and task-class failures never retry by construction (a
+* non-retryable WireError has no retry class).
+*
+* Full contract: https://docs.rulvar.com/guide/model-routing; the
+* Appendix A defaults were committed at the M4 entry gate.
+*/
+/**
+* Captured at module load, before the InProcessRunner's nondeterminism
+* guard can patch the global: the engine's own jitter is journal
+* invisible and must never be blamed on workflow code.
+*/
+const nativeRandom = Math.random;
+/** Appendix A committed defaults (M4 entry gate, PR #26). */
+const DEFAULT_RETRY_POLICY = {
+	attempts: 3,
+	backoff: {
+		initialMs: 500,
+		factor: 2,
+		maxMs: 8e3,
+		jitter: true
+	},
+	retryOn: [
+		"transport",
+		"rate-limit",
+		"overloaded"
+	]
+};
+/**
+* Classifies a WireError for the retry engine. Task-class failures are
 * never retryable by construction: adapters mark them retryable: false
 * and this returns undefined. The kind travels in WireError.data.kind;
 * anything retryable without a specific kind is transport.
@@ -11579,6 +11902,8 @@ async function runAgent(options) {
 		for (;;) {
 			const target = site.chain[site.cursor.index] ?? site.chain[0];
 			let tries = 0;
+			let denialTurns = 0;
+			const maxDenials = options.quota?.maxDenials ?? 8;
 			inner: for (;;) {
 				let reservationId;
 				const segmentReservations = [];
@@ -11819,14 +12144,16 @@ async function runAgent(options) {
 						reportedLimits: limited.reportedLimits
 					});
 				}
-				tries += 1;
+				if (outcome.quotaDenied === true) denialTurns += 1;
+				else tries += 1;
 				const retryClass = outcome.aborted === "idle" ? "transport" : outcome.wireError === void 0 ? void 0 : retryClassOf(outcome.wireError);
 				if (retryClass === void 0) return {
 					outcome,
 					target
 				};
 				usageApprox = usageApprox || outcome.usageApprox;
-				if (retryOn.includes(retryClass) && tries < retryPolicy.attempts) {
+				const retryBudgetLeft = outcome.quotaDenied === true ? denialTurns < maxDenials : tries < retryPolicy.attempts;
+				if (retryOn.includes(retryClass) && retryBudgetLeft) {
 					const abortedBefore = abortKind();
 					if (abortedBefore !== void 0) return {
 						outcome: abortedOutcome(abortedBefore),
@@ -11834,7 +12161,7 @@ async function runAgent(options) {
 					};
 					const retryAfter = (outcome.wireError?.data)?.retryAfterMs;
 					if (outcome.wireError !== void 0) {
-						transportRetries += 1;
+						if (outcome.quotaDenied !== true) transportRetries += 1;
 						events?.emit({
 							type: "agent:error",
 							agentType,
@@ -11843,7 +12170,7 @@ async function runAgent(options) {
 							willRetry: true
 						});
 					}
-					await backoffWait(retryDelayMs(retryPolicy, tries - 1, typeof retryAfter === "number" ? retryAfter : void 0, retryRandom));
+					await backoffWait(retryDelayMs(retryPolicy, outcome.quotaDenied === true ? denialTurns - 1 : tries - 1, typeof retryAfter === "number" ? retryAfter : void 0, retryRandom));
 					const abortedAfter = abortKind();
 					if (abortedAfter !== void 0) return {
 						outcome: abortedOutcome(abortedAfter),
@@ -14356,319 +14683,6 @@ function ladderRungChoice(ladder, index) {
 	};
 }
 //#endregion
-//#region src/model/quota.ts
-/**
-* Quota rules and the in-process reference QuotaLimiter (RV-215).
-* The rule model is shared by every reference implementation
-* (memoryQuotaLimiter here, SqliteQuotaLimiter in
-* @rulvar/store-sqlite): fixed one-minute windows aligned to the
-* epoch, admission at reservation time, reconciliation to actual
-* usage inside the same window. The hard guarantee is on
-* `requestsPerMinute` (every wire attempt is exactly one request);
-* `tokensPerMinute` admits on the heuristic estimate and settles to
-* actual usage, so token windows are approximate at admission and
-* exact at settlement.
-*
-* Docs: https://docs.rulvar.com/guide/model-routing
-*/
-/**
-* Captured at module load, before the InProcessRunner's
-* nondeterminism guard can patch the global: the limiter's clock is
-* engine infrastructure on the live-only dispatch path and must never
-* be blamed on workflow code.
-*/
-const nativeNow = Date.now;
-/** The fixed accounting window every PerMinute cap counts over. */
-const QUOTA_WINDOW_MS = 6e4;
-/**
-* Validates a quota rule set as a typed ConfigError before any
-* limiter can admit under it: a non-array or empty set, a rule
-* without a cap, a malformed dimension, or a malformed cap all fail
-* loud at construction. Shared by every reference implementation.
-*/
-function validateQuotaRules(rules, site = "quota rules") {
-	const raw = rules;
-	if (!Array.isArray(raw)) throw new ConfigError(`${site} must be an array of QuotaRule objects`);
-	if (raw.length === 0) throw new ConfigError(`${site} must contain at least one rule`);
-	raw.forEach((entry, index) => {
-		const at = `${site}[${String(index)}]`;
-		if (typeof entry !== "object" || entry === null || Array.isArray(entry)) throw new ConfigError(`${at} must be a QuotaRule object`);
-		const rule = entry;
-		for (const dimension of [
-			"provider",
-			"model",
-			"tenant"
-		]) {
-			const value = rule[dimension];
-			if (value !== void 0 && (typeof value !== "string" || value === "")) throw new ConfigError(`${at}.${dimension} must be a nonempty string when given`);
-		}
-		if (rule.requestsPerMinute === void 0 && rule.tokensPerMinute === void 0) throw new ConfigError(`${at} must set requestsPerMinute or tokensPerMinute (or both)`);
-		for (const cap of ["requestsPerMinute", "tokensPerMinute"]) if (rule[cap] !== void 0) requirePositiveInteger$2(rule[cap], `${at}.${cap}`);
-	});
-}
-/**
-* The canonical content key of one rule (RV608, promoted from the
-* store limiters): a fixed-field-order JSON of the rule, identical
-* across processes and hosts for identical rules. It is the bucket key
-* of both store references, the input of
-* `quotaRulesFingerprint`, and the CANONICAL ORDER every reference
-* limiter folds denials in, so equal rule sets produce byte-identical
-* refusal objects regardless of array permutation.
-*/
-function quotaRuleKey(rule) {
-	return JSON.stringify({
-		provider: rule.provider ?? null,
-		model: rule.model ?? null,
-		tenant: rule.tenant ?? null,
-		requestsPerMinute: rule.requestsPerMinute ?? null,
-		tokensPerMinute: rule.tokensPerMinute ?? null
-	});
-}
-/**
-* Validates a rule set and returns the immutable snapshot every
-* reference limiter admits under (RV608): a fresh array of fresh
-* objects carrying ONLY the known rule fields, each frozen, the array
-* frozen. The caller's array and objects stay untouched and unshared,
-* so ordinary JavaScript after the constructor (a pushed rule, a
-* reassigned cap) can no longer change a decision, a bucket key, or a
-* recorded fingerprint.
-*
-* A set containing two rules with the same canonical content key is
-* refused typed (RV704): the memory reference buckets by rule INDEX
-* (each copy counts independently, the full cap admits) while the
-* store references bucket by rule KEY (one shared bucket is debited
-* once per matching copy, half the cap admits), so the same duplicated
-* configuration admitted differently per storage. Refusing it at the
-* shared construction chokepoint is what keeps equal configurations
-* equal on every storage.
-*/
-function snapshotQuotaRules(rules, site = "quota rules") {
-	validateQuotaRules(rules, site);
-	const firstIndexByKey = /* @__PURE__ */ new Map();
-	rules.forEach((rule, index) => {
-		const key = quotaRuleKey(rule);
-		const first = firstIndexByKey.get(key);
-		if (first !== void 0) throw new ConfigError(`${site}[${String(index)}] duplicates ${site}[${String(first)}] (rule key ${key}): identical rules occupy independent buckets in memory but share one key-debited bucket on keyed storage, so one configuration would admit differently per store; delete the duplicate`);
-		firstIndexByKey.set(key, index);
-	});
-	return Object.freeze(rules.map((rule) => Object.freeze({
-		...rule.provider === void 0 ? {} : { provider: rule.provider },
-		...rule.model === void 0 ? {} : { model: rule.model },
-		...rule.tenant === void 0 ? {} : { tenant: rule.tenant },
-		...rule.requestsPerMinute === void 0 ? {} : { requestsPerMinute: rule.requestsPerMinute },
-		...rule.tokensPerMinute === void 0 ? {} : { tokensPerMinute: rule.tokensPerMinute }
-	})));
-}
-/** True when every dimension the rule pins matches the request. */
-function quotaRuleMatches(rule, request) {
-	return (rule.provider === void 0 || rule.provider === request.provider) && (rule.model === void 0 || rule.model === request.model) && (rule.tenant === void 0 || rule.tenant === request.tenant);
-}
-/** The tokens a reservation is admitted under: input estimate plus the output cap. */
-function quotaEstimateTokens(request) {
-	return request.estimate.inputTokens + (request.estimate.maxOutputTokens ?? 0);
-}
-/** The tokens a settled attempt actually consumed. */
-function quotaActualTokens(usage) {
-	return usage.inputTokens + usage.outputTokens;
-}
-/**
-* The request-count settlement delta of one reservation (RV905): the
-* reservation admitted ONE wire request, and `actual.requests` names
-* how many the attempt actually made (an adapter absorbing
-* provider-side continuations dispatches several inside one reserved
-* call). Non-integer, non-positive, or absent actuals settle as the
-* single reserved request (delta 0); a settlement only ever ADDS, the
-* calls already happened. Shared by every reference limiter so the
-* three implementations cannot disagree about the arithmetic.
-*/
-function quotaActualRequestsDelta(actual) {
-	const requests = actual?.requests;
-	return typeof requests === "number" && Number.isInteger(requests) && requests > 1 ? requests - 1 : 0;
-}
-/**
-* One rule's admission verdict against its current-window counters,
-* the pure decision both reference implementations share. A denial
-* carries the window remainder as retryAfterMs, except when the
-* estimate alone can never fit the token cap: that denial says
-* retryAfterMs 0 (retry immediately), so the caller's bounded
-* attempts exhaust without waiting and failover gets its chance.
-*/
-function quotaRuleAdmission(rule, counters, estimate, msUntilWindowEnd) {
-	if (rule.requestsPerMinute !== void 0 && counters.requests + estimate.requests > rule.requestsPerMinute) return {
-		admit: false,
-		retryAfterMs: msUntilWindowEnd,
-		reason: `requestsPerMinute ${String(rule.requestsPerMinute)} exhausted`
-	};
-	if (rule.tokensPerMinute !== void 0) {
-		if (estimate.tokens > rule.tokensPerMinute) return {
-			admit: false,
-			retryAfterMs: 0,
-			reason: `the estimate of ${String(estimate.tokens)} tokens can never fit tokensPerMinute ${String(rule.tokensPerMinute)}`
-		};
-		if (counters.tokens + estimate.tokens > rule.tokensPerMinute) return {
-			admit: false,
-			retryAfterMs: msUntilWindowEnd,
-			reason: `tokensPerMinute ${String(rule.tokensPerMinute)} exhausted`
-		};
-	}
-	return { admit: true };
-}
-/**
-* Folds one more failing rule into the decision the caller returns:
-* the wait is the LONGEST failing horizon (every matching rule must
-* admit), and the FIRST failing rule names the denial.
-*/
-function mergeQuotaDenial(current, next) {
-	if (current === void 0) return {
-		retryAfterMs: next.retryAfterMs,
-		reason: next.reason
-	};
-	return next.retryAfterMs > current.retryAfterMs ? {
-		retryAfterMs: next.retryAfterMs,
-		reason: current.reason
-	} : current;
-}
-/**
-* The in-process reference QuotaLimiter: fixed epoch-aligned
-* one-minute windows over the shared rule model. Coordinates every
-* engine that shares THIS instance inside one process; processes
-* coordinate through a shared-storage implementation of the same SPI
-* (SqliteQuotaLimiter in @rulvar/store-sqlite) instead.
-*/
-function memoryQuotaLimiter(rules, options = {}) {
-	const frozen = snapshotQuotaRules(rules, "memoryQuotaLimiter rules");
-	const ordered = frozen.map((rule, index) => ({
-		rule,
-		index,
-		key: quotaRuleKey(rule)
-	})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
-	const now = options.now ?? (() => nativeNow());
-	const buckets = /* @__PURE__ */ new Map();
-	const reservations = /* @__PURE__ */ new Map();
-	let nextReservation = 0;
-	const windowStartAt = (at) => at - at % QUOTA_WINDOW_MS;
-	const bucketFor = (ruleIndex, windowStart) => {
-		let bucket = buckets.get(ruleIndex);
-		if (bucket === void 0 || bucket.windowStart !== windowStart) {
-			bucket = {
-				windowStart,
-				requests: 0,
-				tokens: 0
-			};
-			buckets.set(ruleIndex, bucket);
-		}
-		return bucket;
-	};
-	const prune = (windowStart) => {
-		for (const [id, reservation] of reservations) if (reservation.windowStart < windowStart) reservations.delete(id);
-	};
-	return {
-		reserve(request) {
-			const at = now();
-			const windowStart = windowStartAt(at);
-			prune(windowStart);
-			const estimateTokens = quotaEstimateTokens(request);
-			const msUntilWindowEnd = windowStart + QUOTA_WINDOW_MS - at;
-			const matched = [];
-			let denial;
-			for (const { rule, index } of ordered) {
-				if (!quotaRuleMatches(rule, request)) continue;
-				matched.push(index);
-				const verdict = quotaRuleAdmission(rule, bucketFor(index, windowStart), {
-					requests: request.estimate.requests,
-					tokens: estimateTokens
-				}, msUntilWindowEnd);
-				if (!verdict.admit) denial = mergeQuotaDenial(denial, verdict);
-			}
-			if (denial !== void 0) return Promise.resolve({
-				granted: false,
-				...denial
-			});
-			for (const index of matched) {
-				const bucket = bucketFor(index, windowStart);
-				bucket.requests += request.estimate.requests;
-				bucket.tokens += estimateTokens;
-			}
-			nextReservation += 1;
-			const reservationId = `mq-${String(nextReservation)}`;
-			reservations.set(reservationId, {
-				windowStart,
-				estimateTokens,
-				requests: request.estimate.requests,
-				ruleIndexes: matched
-			});
-			return Promise.resolve({
-				granted: true,
-				reservationId
-			});
-		},
-		reconcile(reservationId, usage, actual) {
-			const reservation = reservations.get(reservationId);
-			if (reservation === void 0) return Promise.resolve();
-			reservations.delete(reservationId);
-			const windowStart = windowStartAt(now());
-			if (reservation.windowStart !== windowStart) return Promise.resolve();
-			const delta = quotaActualTokens(usage) - reservation.estimateTokens;
-			const requestsDelta = quotaActualRequestsDelta(actual);
-			for (const index of reservation.ruleIndexes) {
-				const bucket = buckets.get(index);
-				if (bucket !== void 0 && bucket.windowStart === windowStart) {
-					bucket.tokens = Math.max(0, bucket.tokens + delta);
-					bucket.requests += requestsDelta;
-				}
-			}
-			return Promise.resolve();
-		},
-		release(reservationId) {
-			const reservation = reservations.get(reservationId);
-			if (reservation === void 0) return Promise.resolve();
-			reservations.delete(reservationId);
-			const windowStart = windowStartAt(now());
-			if (reservation.windowStart !== windowStart) return Promise.resolve();
-			for (const index of reservation.ruleIndexes) {
-				const bucket = buckets.get(index);
-				if (bucket !== void 0 && bucket.windowStart === windowStart) {
-					bucket.requests = Math.max(0, bucket.requests - reservation.requests);
-					bucket.tokens = Math.max(0, bucket.tokens - reservation.estimateTokens);
-				}
-			}
-			return Promise.resolve();
-		},
-		snapshot() {
-			const windowStart = windowStartAt(now());
-			return frozen.map((rule, index) => {
-				const bucket = buckets.get(index);
-				const current = bucket !== void 0 && bucket.windowStart === windowStart;
-				return {
-					rule,
-					windowStart,
-					requests: current ? bucket.requests : 0,
-					tokens: current ? bucket.tokens : 0
-				};
-			});
-		}
-	};
-}
-/**
-* Validates createEngine's quota config as a typed ConfigError before
-* any run could dispatch under a malformed limiter (the intake
-* discipline every engine option follows).
-*/
-function validateEngineQuotaConfig(config, site = "createEngine quota") {
-	if (config === void 0) return;
-	const raw = config;
-	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new ConfigError(`${site} must be an object with a limiter`);
-	const candidate = raw;
-	const limiter = candidate.limiter;
-	if (typeof limiter !== "object" || limiter === null || typeof limiter.reserve !== "function" || typeof limiter.reconcile !== "function") throw new ConfigError(`${site}.limiter must implement QuotaLimiter (reserve and reconcile functions)`);
-	if (candidate.tenant !== void 0 && (typeof candidate.tenant !== "string" || candidate.tenant === "")) throw new ConfigError(`${site}.tenant must be a nonempty string when given`);
-	if (candidate.onLimiterError !== void 0 && candidate.onLimiterError !== "deny" && candidate.onLimiterError !== "allow") throw new ConfigError(`${site}.onLimiterError must be 'deny' or 'allow' when given`);
-	const reserveContinuations = candidate.reserveContinuations;
-	if (reserveContinuations !== void 0 && typeof reserveContinuations !== "boolean") throw new ConfigError(`${site}.reserveContinuations must be a boolean when given`);
-	const declared = candidate.declaredRules;
-	if (declared !== void 0) validateQuotaRules(declared, `${site}.declaredRules`);
-}
-//#endregion
 //#region src/runtime/usage-limits.ts
 /**
 * UsageLimits (M1-T06): normative limit vocabulary and the per-spawn merge.
@@ -16614,7 +16628,8 @@ function createCtx(internals, rootWorkflow) {
 				}),
 				reconcile: (reservationId, usage, actual) => quota.limiter.reconcile(reservationId, usage, actual),
 				onLimiterError: quota.onLimiterError,
-				reserveContinuations: quota.reserveContinuations
+				reserveContinuations: quota.reserveContinuations,
+				maxDenials: quota.maxDenials
 			};
 			const limiterRelease = quota.limiter.release?.bind(quota.limiter);
 			if (limiterRelease !== void 0) runAgentOptions.quota.release = limiterRelease;
@@ -24105,6 +24120,7 @@ function createEngine(options) {
 		...options.quota.tenant === void 0 ? {} : { tenant: options.quota.tenant },
 		onLimiterError: options.quota.onLimiterError ?? "deny",
 		reserveContinuations: options.quota.reserveContinuations ?? false,
+		maxDenials: options.quota.maxDenials ?? 8,
 		...options.quota.declaredRules === void 0 ? {} : { declaredRules: options.quota.declaredRules }
 	};
 	const knowledgeStore = options.stores?.modelKnowledge;
@@ -25130,4 +25146,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_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, 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, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolContractHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, 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_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, 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, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reduceAuditTrail, reduceCriticalPath, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolContractHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.170.0",
+  "version": "1.171.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",