@rulvar/core 1.55.0 → 1.57.0

package/dist/index.d.ts

@@ -1638,6 +1638,59 @@ interface KbProposal {
   note?: string;
 }
 //#endregion
+//#region src/l0/spi/quota.d.ts
+/**
+* The pre-dispatch estimate a reservation is admitted under. Token
+* estimates are heuristic (the engine uses its deterministic
+* four-characters-per-token prompt estimate plus the request's output
+* cap when one is set); reconcile() settles the difference against
+* actual usage inside the same accounting window.
+*/
+interface QuotaEstimate {
+  /** Wire calls this reservation admits; the engine always sends 1. */
+  requests: number;
+  /** Heuristic prompt estimate for the attempt. */
+  inputTokens: number;
+  /** The request's output token cap, when one is set. */
+  maxOutputTokens?: number;
+}
+/** One admission request, dimensioned for tenant/model/provider rules. */
+interface QuotaReservationRequest {
+  /**
+  * The adapter id (the left segment of ModelRef), matching the keys
+  * of `concurrency.perProvider`.
+  */
+  provider: string;
+  /** The serving model, re-reserved per failover target. */
+  model: string;
+  /** The engine's configured tenant; absent when the host set none. */
+  tenant?: string;
+  /** The run paying for the attempt; observability only. */
+  runId?: string;
+  estimate: QuotaEstimate;
+}
+/**
+* The admission verdict. `retryAfterMs` on a denial is the
+* provider-shaped hint the retry engine honors verbatim: the time
+* until the limiter expects capacity (0 = retry immediately, e.g. a
+* request whose estimate can never fit its cap, so exhaustion and
+* failover happen without waiting; absent = the caller's backoff
+* policy applies).
+*/
+type QuotaDecision = {
+  granted: true;
+  reservationId: string;
+} | {
+  granted: false;
+  retryAfterMs?: number;
+  reason?: string;
+};
+/** The shared rate/quota limiter seam; see the module contract above. */
+interface QuotaLimiter {
+  reserve(request: QuotaReservationRequest): Promise<QuotaDecision>;
+  reconcile(reservationId: string, usage: Usage): Promise<void>;
+}
+//#endregion
 //#region src/knowledge/decay.d.ts
 /**
 * The asymmetric TTL table:
@@ -2227,12 +2280,21 @@ declare function replayDisposition(entry: JournalEntry, fold: AbandonFold, optio
   registry?: DeriverRegistry;
   terminal?: JournalEntry;
   invalidated?: ReadonlySet<number>;
+  /**
+  * True when the loaded journal carries a run settle with runStatus
+  * 'ok' (the resume is a pure replay of a finished run): unstamped
+  * limit entries then replay instead of re-running live. Terminal
+  * settles other than ok keep the retry semantics.
+  */
+  runSettledOk?: boolean;
 }): ReplayDisposition;
 /**
 * Adapts the predicate to the matcher's disposition hook: two-phase
 * operations dispatch on their terminal, single-phase on themselves.
 */
-declare function dispositionHook(fold: AbandonFold, registry: DeriverRegistry, invalidated?: ReadonlySet<number>): (op: JournalOperation) => ReplayDisposition;
+declare function dispositionHook(fold: AbandonFold, registry: DeriverRegistry, invalidated?: ReadonlySet<number>, options?: {
+  runSettledOk?: boolean;
+}): (op: JournalOperation) => ReplayDisposition;
 //#endregion
 //#region src/journal/resolution.d.ts
 type ResolutionAttempt = {
@@ -2667,6 +2729,127 @@ declare class KeyedLimiter {
   withSlot<T>(key: string, fn: () => Promise<T>, onQueued?: () => void, signal?: AbortSignal): Promise<T>;
 }
 //#endregion
+//#region src/model/quota.d.ts
+/** The fixed accounting window every PerMinute cap counts over. */
+declare const QUOTA_WINDOW_MS = 6e4;
+/**
+* One shared-quota rule. The dimension fields select which requests
+* the rule governs (an absent dimension matches every value); EVERY
+* matching rule must admit a request, and a grant consumes capacity
+* from each of them. The counters are rule-scoped: one rule matching
+* two models pools them under one cap; write one rule per model for
+* per-model buckets.
+*/
+interface QuotaRule {
+  /** Adapter id, as in `concurrency.perProvider` keys. */
+  provider?: string;
+  model?: string;
+  tenant?: string;
+  /** Wire attempts admitted per window; the exact, hard cap. */
+  requestsPerMinute?: number;
+  /**
+  * Input plus output tokens admitted per window: estimated at
+  * admission, reconciled to actual usage.
+  */
+  tokensPerMinute?: number;
+}
+/**
+* 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.
+*/
+declare function validateQuotaRules(rules: readonly QuotaRule[], site?: string): void;
+/** True when every dimension the rule pins matches the request. */
+declare function quotaRuleMatches(rule: QuotaRule, request: QuotaReservationRequest): boolean;
+/** The tokens a reservation is admitted under: input estimate plus the output cap. */
+declare function quotaEstimateTokens(request: QuotaReservationRequest): number;
+/** The tokens a settled attempt actually consumed. */
+declare function quotaActualTokens(usage: Usage): number;
+/** Current-window counters of one rule bucket. */
+interface QuotaCounters {
+  requests: number;
+  tokens: number;
+}
+/**
+* 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.
+*/
+declare function quotaRuleAdmission(rule: QuotaRule, counters: QuotaCounters, estimate: QuotaCounters, msUntilWindowEnd: number): {
+  admit: true;
+} | {
+  admit: false;
+  retryAfterMs: number;
+  reason: string;
+};
+/**
+* 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.
+*/
+declare function mergeQuotaDenial(current: {
+  retryAfterMs: number;
+  reason: string;
+} | undefined, next: {
+  retryAfterMs: number;
+  reason: string;
+}): {
+  retryAfterMs: number;
+  reason: string;
+};
+/** One rule's live counters, exposed by `snapshot()` for telemetry. */
+interface QuotaWindowSnapshot {
+  rule: QuotaRule;
+  windowStart: number;
+  requests: number;
+  tokens: number;
+}
+/** The in-process reference QuotaLimiter returned by memoryQuotaLimiter. */
+interface MemoryQuotaLimiter extends QuotaLimiter {
+  /** Current-window counters per rule; rolled-over windows read as zero. */
+  snapshot(): QuotaWindowSnapshot[];
+}
+/**
+* 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.
+*/
+declare function memoryQuotaLimiter(rules: readonly QuotaRule[], options?: {
+  now?: () => number;
+}): MemoryQuotaLimiter;
+/** createEngine quota config: the limiter plus its engine-scoped knobs. */
+interface EngineQuotaConfig {
+  limiter: QuotaLimiter;
+  /** Stamped on every reservation of this engine's runs. */
+  tenant?: string;
+  /**
+  * What a limiter infrastructure FAILURE (reserve throwing) means:
+  * 'deny' (default, fail closed) converts it into a retryable
+  * transport-class denial; 'allow' logs a warning and dispatches
+  * without a reservation. A limiter DENIAL is unaffected by this
+  * knob. reconcile failures only ever warn.
+  */
+  onLimiterError?: "deny" | "allow";
+}
+/** The resolved engine-side quota runtime threaded into every run. */
+interface EngineQuotaRuntime {
+  limiter: QuotaLimiter;
+  tenant?: string;
+  onLimiterError: "deny" | "allow";
+}
+/**
+* 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).
+*/
+declare function validateEngineQuotaConfig(config: EngineQuotaConfig | undefined, site?: string): void;
+//#endregion
 //#region src/model/floors.d.ts
 /** An explicit allowlist and denylist; deny wins over allow. */
 type ModelListConstraint = {
@@ -3773,6 +3956,24 @@ interface RunAgentOptions<S extends SchemaSpec = JsonSchema> {
   * key's queue without a slot (v1.34.0 review P2-4).
   */
   providerSlot?: <T>(key: string, fn: () => Promise<T>, signal?: AbortSignal) => Promise<T>;
+  /**
+  * The shared quota limiter hook (RV-215): consulted before EVERY
+  * live wire dispatch (initial attempts, transport retries, and
+  * 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.
+  */
+  quota?: {
+    reserve: (request: QuotaReservationRequest) => Promise<QuotaDecision>;
+    reconcile: (reservationId: string, usage: Usage) => Promise<void>; /** Limiter infrastructure failure policy; a denial is unaffected. */
+    onLimiterError: "deny" | "allow";
+  };
   /** The resolved toolset; absent = no tools declared. */
   tools?: ToolRuntime;
   /**
@@ -5201,6 +5402,18 @@ interface CreateEngineOptions {
     perRun?: number; /** Per-adapter-id caps; unlimited unless configured (Appendix A; M4-T07). */
     perProvider?: Record<string, number>;
   };
+  /**
+  * The shared quota limiter (RV-215): a QuotaLimiter implementation
+  * consulted before every live wire dispatch of every run, plus the
+  * engine's tenant dimension and the limiter failure policy. Engines
+  * and processes that share one limiter (or one limiter storage,
+  * e.g. SqliteQuotaLimiter in @rulvar/store-sqlite over one database
+  * file) enforce one global quota; a denial rides the provider-429
+  * retry and failover machinery without paying a wire call. Absent =
+  * no shared quota (Appendix A: an embeddable library must not
+  * surprise-throttle hosts).
+  */
+  quota?: EngineQuotaConfig;
   /** Versioned price table; wins over caps.pricing (M4-T06). */
   pricing?: PriceTable;
   /**
@@ -6889,6 +7102,13 @@ interface RunInternals {
   };
   /** Engine-scoped per-provider keyed limiter (M4-T07). */
   providerLimiter?: KeyedLimiter;
+  /**
+  * The shared quota limiter runtime (RV-215): the configured
+  * QuotaLimiter with the engine's tenant and failure policy
+  * resolved. Threaded into every live wire dispatch of every run;
+  * absent = no shared quota, byte-identical to before the feature.
+  */
+  quota?: EngineQuotaRuntime;
   /** The configured price table's version; pinned in decision entries (M4-T06). */
   pricingVersion?: string;
   /** budgetDefaults.flatReserveUsd; last resort of the reserve formula. */
@@ -8091,4 +8311,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, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, 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, ChildIdentityInput, ChildResultPage, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostAttributionFacts, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, 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, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, 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, EntryKind, EntryRef, EntryStatus, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishInfo, 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, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, 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, OrchestrateOptions, OrchestrateSynthesis, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, type PhaseRow, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PriceTable, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, QualityFloors, 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, 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, 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, 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, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, 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, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, reconcileRunMeta, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, 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, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, 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, ChildIdentityInput, ChildResultPage, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostAttributionFacts, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, 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, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, 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, EntryKind, EntryRef, EntryStatus, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishInfo, 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, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, 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, OrchestrateOptions, OrchestrateSynthesis, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, type PhaseRow, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PriceTable, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, 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, 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, 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, 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, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, 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, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -4340,11 +4340,13 @@ function buildAbandonFold(entries) {
 		return isCovered(entry);
 	} };
 }
-function applyRule(rule, op) {
+function applyRule(rule, op, runSettledOk) {
 	const terminal = op.terminal ?? op.running;
 	switch (rule) {
 		case "replay": return "replay";
-		case "memoize-limit": return terminal.memoizeOutcome ?? op.running.memoizeOutcome ?? false ? "replay" : "rerun";
+		case "memoize-limit":
+			if (terminal.memoizeOutcome ?? op.running.memoizeOutcome ?? false) return "replay";
+			return runSettledOk ? "replay" : "rerun";
 		case "memoize-task-error":
 			if (!(terminal.memoizeOutcome ?? op.running.memoizeOutcome ?? false) || terminal.error === void 0) return "rerun";
 			return classifyAgentError(agentErrorFromWireSafe(terminal)) === "task" ? "replay" : "rerun";
@@ -4381,17 +4383,18 @@ function replayDisposition(entry, fold, options) {
 	if (options?.invalidated?.has(entry.seq) === true) return "rerun";
 	const deriver = options?.registry?.get(entry.hashVersion) ?? deriverV2;
 	const status = (options?.terminal ?? entry).status;
-	return applyRule(deriver.dispositionTable[status], op);
+	return applyRule(deriver.dispositionTable[status], op, options?.runSettledOk ?? false);
 }
 /**
 * Adapts the predicate to the matcher's disposition hook: two-phase
 * operations dispatch on their terminal, single-phase on themselves.
 */
-function dispositionHook(fold, registry, invalidated) {
+function dispositionHook(fold, registry, invalidated, options) {
 	return (op) => replayDisposition(op.running, fold, {
 		registry,
 		...op.terminal === void 0 ? {} : { terminal: op.terminal },
-		...invalidated === void 0 ? {} : { invalidated }
+		...invalidated === void 0 ? {} : { invalidated },
+		...options?.runSettledOk === void 0 ? {} : { runSettledOk: options.runSettledOk }
 	});
 }
 //#endregion
@@ -7924,9 +7927,10 @@ var Semaphore = class {
 * ride RetryPolicy; hosts with known tier limits opt in per adapter id
 * via createEngine concurrency.perProvider.
 *
-* There is deliberately NO distributed cross-process limiter: two
-* processes sharing one API key coordinate nothing here (a
-* process-global limiter is an open question).
+* This keyed limiter bounds PARALLELISM inside one engine only. Two
+* processes sharing one API key coordinate through the QuotaLimiter
+* SPI instead (RV-215, createEngine `quota`): rate and volume live
+* there, in shared storage; in-flight slots live here.
 */
 var KeyedLimiter = class {
 	semaphores = /* @__PURE__ */ new Map();
@@ -8127,6 +8131,223 @@ function liftRetainedParts(providerMetadata, adapter) {
 	}));
 }
 //#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(rule[cap], `${at}.${cap}`);
+	});
+}
+/** 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;
+}
+/**
+* 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 = {}) {
+	validateQuotaRules(rules, "memoryQuotaLimiter rules");
+	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;
+			rules.forEach((rule, index) => {
+				if (!quotaRuleMatches(rule, request)) return;
+				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,
+				ruleIndexes: matched
+			});
+			return Promise.resolve({
+				granted: true,
+				reservationId
+			});
+		},
+		reconcile(reservationId, usage) {
+			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;
+			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);
+			}
+			return Promise.resolve();
+		},
+		snapshot() {
+			const windowStart = windowStartAt(now());
+			return rules.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`);
+}
+//#endregion
 //#region src/model/retry.ts
 /**
 * Transport RetryPolicy (M4-T05): retries live UNDER the journal. A
@@ -10311,12 +10532,74 @@ async function runAgent(options) {
 			const target = site.chain[site.cursor.index] ?? site.chain[0];
 			let tries = 0;
 			inner: for (;;) {
+				let reservationId;
+				const quotaDeniedOutcome = (denial) => ({
+					turn: {
+						text: "",
+						toolCalls: []
+					},
+					usage: ZERO_USAGE$1,
+					reported: ZERO_USAGE$1,
+					usageApprox: false,
+					quotaDenied: true,
+					wireError: {
+						code: denial.infrastructure === void 0 ? "rate-limit" : "quota-limiter",
+						message: denial.infrastructure ?? `the shared quota limiter denied ${target.resolved.ref}` + (denial.reason === void 0 ? "" : `: ${denial.reason}`),
+						retryable: true,
+						data: {
+							kind: denial.infrastructure === void 0 ? "rate-limit" : "transport",
+							source: "quota-limiter",
+							...denial.retryAfterMs === void 0 ? {} : { retryAfterMs: denial.retryAfterMs },
+							...denial.reason === void 0 ? {} : { reason: denial.reason }
+						}
+					}
+				});
+				const dispatchWithQuota = async (quota) => {
+					const req = site.requestFor(target);
+					let decision;
+					try {
+						decision = await quota.reserve({
+							provider: target.adapter.id,
+							model: target.resolved.model,
+							estimate: {
+								requests: 1,
+								inputTokens: estimateInputTokens(req.messages),
+								...req.maxOutputTokens === void 0 ? {} : { maxOutputTokens: req.maxOutputTokens }
+							}
+						});
+					} catch (thrown) {
+						const detail = thrown instanceof Error ? thrown.message : String(thrown);
+						if (quota.onLimiterError === "allow") {
+							events?.emit({
+								type: "log",
+								level: "warn",
+								msg: `the shared quota limiter failed; dispatching ${target.resolved.ref} without a reservation (onLimiterError 'allow'): ${detail}`
+							});
+							return streamTurn(target.adapter, req, site.streamOptionsFor(target));
+						}
+						return quotaDeniedOutcome({ infrastructure: `the shared quota limiter failed (onLimiterError 'deny'): ${detail}` });
+					}
+					if (!decision.granted) return quotaDeniedOutcome(decision);
+					reservationId = decision.reservationId;
+					return streamTurn(target.adapter, req, site.streamOptionsFor(target));
+				};
 				const dispatch = () => {
 					const aborted = abortKind();
-					return aborted === void 0 ? streamTurn(target.adapter, site.requestFor(target), site.streamOptionsFor(target)) : Promise.resolve(abortedOutcome(aborted));
+					if (aborted !== void 0) return Promise.resolve(abortedOutcome(aborted));
+					return options.quota === void 0 ? streamTurn(target.adapter, site.requestFor(target), site.streamOptionsFor(target)) : dispatchWithQuota(options.quota);
 				};
 				const outcome = await (options.providerSlot === void 0 ? dispatch() : options.providerSlot(target.adapter.id, dispatch, options.signal));
-				recordUsage(outcome.usage, outcome.reported, target.adapter.id, target.resolved.ref, site.role, outcome.usageViolation);
+				if (reservationId !== void 0 && options.quota !== void 0) try {
+					await options.quota.reconcile(reservationId, outcome.usage);
+				} catch (thrown) {
+					const detail = thrown instanceof Error ? thrown.message : String(thrown);
+					events?.emit({
+						type: "log",
+						level: "warn",
+						msg: `the shared quota limiter failed to reconcile a reservation: ${detail}`
+					});
+				}
+				if (outcome.quotaDenied !== true) recordUsage(outcome.usage, outcome.reported, target.adapter.id, target.resolved.ref, site.role, outcome.usageViolation);
 				tries += 1;
 				const retryClass = outcome.aborted === "idle" ? "transport" : outcome.wireError === void 0 ? void 0 : retryClassOf(outcome.wireError);
 				if (retryClass === void 0) return {
@@ -13251,6 +13534,18 @@ function createCtx(internals, rootWorkflow) {
 		if (profile?.compaction !== void 0) runAgentOptions.compaction = profile.compaction;
 		if (loopFallbacks.length > 0) runAgentOptions.fallbacks = loopFallbacks;
 		if (retryPolicy !== void 0) runAgentOptions.retry = { policy: retryPolicy };
+		if (internals.quota !== void 0) {
+			const quota = internals.quota;
+			runAgentOptions.quota = {
+				reserve: (request) => quota.limiter.reserve({
+					...request,
+					runId: internals.runId,
+					...quota.tenant === void 0 ? {} : { tenant: quota.tenant }
+				}),
+				reconcile: (reservationId, usage) => quota.limiter.reconcile(reservationId, usage),
+				onLimiterError: quota.onLimiterError
+			};
+		}
 		if (internals.providerLimiter !== void 0) {
 			const limiter = internals.providerLimiter;
 			runAgentOptions.providerSlot = (key, fn, signal) => limiter.withSlot(key, fn, () => internals.events.emit({
@@ -16322,6 +16617,12 @@ function createEngine(options) {
 		if (profile.compaction?.threshold !== void 0) requireFraction(profile.compaction.threshold, `createEngine defaults.profiles['${name}'].compaction.threshold`);
 	}
 	validateDeterminismConfig(options.determinism);
+	validateEngineQuotaConfig(options.quota);
+	const quotaRuntime = options.quota === void 0 ? void 0 : {
+		limiter: options.quota.limiter,
+		...options.quota.tenant === void 0 ? {} : { tenant: options.quota.tenant },
+		onLimiterError: options.quota.onLimiterError ?? "deny"
+	};
 	const knowledgeStore = options.stores?.modelKnowledge;
 	const knowledge = knowledgeStore === void 0 ? void 0 : { current: () => knowledgeStore.current() };
 	const runner = new InProcessRunner(options.onEscalation === void 0 ? void 0 : { onEscalation: options.onEscalation });
@@ -16386,8 +16687,9 @@ function createEngine(options) {
 			strict: resumeCtx?.strict ?? false
 		});
 		for (const seqToInvalidate of invalidated) replayer.invalidate(seqToInvalidate);
-		replayer.setDisposition(dispositionHook(replayer.fold.abandonFold, registry, replayer.invalidatedSeqs));
-		replayer.setAliasDisposition(dispositionHook({ isAbandoned: () => false }, registry, replayer.invalidatedSeqs));
+		const runSettledOk = resumeCtx !== void 0 && lastRunSettle(resumeCtx.priorEntries)?.runStatus === "ok";
+		replayer.setDisposition(dispositionHook(replayer.fold.abandonFold, registry, replayer.invalidatedSeqs, { runSettledOk }));
+		replayer.setAliasDisposition(dispositionHook({ isAbandoned: () => false }, registry, replayer.invalidatedSeqs, { runSettledOk }));
 		if (resumeCtx !== void 0) {
 			const prior = replayer.ledger();
 			budgetSeed = {
@@ -16428,6 +16730,7 @@ function createEngine(options) {
 			admission,
 			semaphore: new Semaphore(options.concurrency?.perRun ?? 12),
 			providerLimiter,
+			...quotaRuntime === void 0 ? {} : { quota: quotaRuntime },
 			...options.pricing === void 0 ? {} : { pricingVersion: options.pricing.pricingVersion },
 			...options.budgetDefaults?.flatReserveUsd === void 0 ? {} : { flatReserveUsd: options.budgetDefaults.flatReserveUsd },
 			...defaults.roleFloors === void 0 ? {} : { floors: defaults.roleFloors },
@@ -17102,4 +17405,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_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, 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, 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_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, 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, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, 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, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, reconcileRunMeta, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, 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_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_FINISH_MAX_REPAIRS, 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, 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_TOOL_NAME, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, 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_CHILD_RESULT_PAGE_CHARS, MAX_DEPTH_CEILING, 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, SpanRegistry, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, atCompactionThreshold, auditRun, auditRuns, 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, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidencePreservedValidator, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, identityJcs, implementationAgentProfile, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, 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, selectStructuredOutputTier, shouldCompact, snapshotUsage, spawnDepthOf, summarizeInstruction, summarizeOutput, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolContract, toolsetHash, ttlState, usageViolations, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateUsageLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

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