@rulvar/core 1.33.0 → 1.35.0

package/dist/index.d.ts

@@ -2556,9 +2556,11 @@ declare class KeyedLimiter {
   pending(key: string): number;
   /**
   * Runs `fn` under the key's semaphore; keys without a configured cap
-  * run unlimited (no queueing, no overhead).
+  * run unlimited (no queueing, no overhead). An aborted `signal` frees
+  * a queued caller without a slot (the Semaphore contract), so run
+  * cancellation drains provider queues too (v1.34.0 review P2-4).
   */
-  withSlot<T>(key: string, fn: () => Promise<T>, onQueued?: () => void): Promise<T>;
+  withSlot<T>(key: string, fn: () => Promise<T>, onQueued?: () => void, signal?: AbortSignal): Promise<T>;
 }
 //#endregion
 //#region src/model/floors.d.ts
@@ -2881,15 +2883,6 @@ declare class NoProgressDetector {
 }
 //#endregion
 //#region src/runtime/usage-limits.d.ts
-/**
-* UsageLimits (M1-T06): normative limit vocabulary and the per-spawn merge.
-*
-* Full contract: https://docs.rulvar.com/guide/agents. Expiry of maxTurns, maxToolCalls,
-* or timeoutMs produces the terminal status 'limit' (paid partial work);
-* streamIdleTimeoutMs expiry is a retryable transport-class AgentError,
-* never 'limit'. The run-level deadline is RunOptions.deadlineAt, not a
-* UsageLimits field.
-*/
 interface UsageLimits {
   /** Default 32. */
   maxTurns?: number;
@@ -2924,6 +2917,19 @@ interface EffectiveUsageLimits {
 * defaults.limits.
 */
 declare function mergeUsageLimits(call?: UsageLimits, profile?: UsageLimits, engine?: UsageLimits): EffectiveUsageLimits;
+/**
+* Validates one UsageLimits layer at its intake boundary (v1.34.0
+* review P2-3): a malformed field (NaN, Infinity, a negative, a
+* fraction) is a typed ConfigError before the merge, before any journal
+* entry, and before any provider dispatch. `site` names the layer in the
+* error text (e.g. `RunOptions.limits`). Counts are positive integers
+* (maxToolCalls may be 0: a spawn that must not call tools).
+* streamIdleTimeoutMs is handed to setTimeout as-is, so it is bounded by
+* the Node timer maximum like RetryPolicy delays; timeoutMs is a
+* wall-clock comparison, so it has no upper bound. Every present field
+* is checked; absent fields keep their defaults.
+*/
+declare function validateUsageLimits(limits: UsageLimits, site: string): void;
 //#endregion
 //#region src/runtime/agent-loop.d.ts
 type AgentStatus = "ok" | "error" | "limit" | "cancelled" | "skipped" | "escalated";
@@ -3111,8 +3117,10 @@ interface RunAgentOptions<S extends SchemaSpec = JsonSchema> {
   /**
   * Per-provider keyed limiter hook (M4-T07): wraps every wire dispatch
   * under the serving adapter's key; absent = unlimited (Appendix A).
+  * `signal` is the agent-level abort: an aborted caller leaves the
+  * key's queue without a slot (v1.34.0 review P2-4).
   */
-  providerSlot?: <T>(key: string, fn: () => Promise<T>) => Promise<T>;
+  providerSlot?: <T>(key: string, fn: () => Promise<T>, signal?: AbortSignal) => Promise<T>;
   /** The resolved toolset; absent = no tools declared. */
   tools?: ToolRuntime;
   /**
@@ -4799,7 +4807,17 @@ interface RunOptions {
   budgetUsd?: number;
   /** Run-level defaults merged over engine defaults. */
   limits?: UsageLimits;
-  /** Run-level deadline (ISO 8601); crossing cancels the run. */
+  /**
+  * Run-level deadline: an ISO 8601 date-time with an explicit UTC
+  * designator or offset (e.g. `2026-07-21T10:00:00Z` or
+  * `2026-07-21T12:00:00+02:00`); crossing it cancels the run. Any
+  * other string is a typed ConfigError thrown synchronously by
+  * engine.run, before any journal entry or provider dispatch (v1.34.0
+  * review P2-1). A deadline already in the past cancels immediately:
+  * a crossed deadline is a valid deadline. Deadlines beyond the Node
+  * timer maximum are honored through sliced timers, never truncated
+  * (v1.34.0 review P2-2).
+  */
   deadlineAt?: string;
   name?: string;
   tags?: string[];
@@ -5334,27 +5352,34 @@ declare function makeOrchestratorWorkflow(goal: string, opts?: OrchestrateOption
 declare function orchestrate(engine: Engine, goal: string, opts?: OrchestrateOptions, runOptions?: RunOptions): RunHandle<unknown>;
 //#endregion
 //#region src/engine/scheduler.d.ts
-/**
-* Scheduler and concurrency (M1-T08): the per-run semaphore with a FIFO
-* queue (default 12 concurrent model calls). The engine lifetime spawn cap
-* is enforced by the budget layer at admission; parallel/pipeline
-* composition semantics live with ctx.
-* Per-provider concurrency keys land with M4.
-*/
 /** FIFO semaphore; default per-run width is 12. */
 declare const DEFAULT_PER_RUN_CONCURRENCY = 12;
 declare class Semaphore {
   private readonly limit;
   private active;
   private readonly waiters;
+  /**
+  * `limit` must be a positive integer: anything else (NaN included) is
+  * a typed ConfigError. Before this gate a NaN limit made
+  * `active < limit` permanently false, so the first acquire queued
+  * forever and the run could not settle, not even through cancel()
+  * (v1.34.0 review P2-4). Unlimited is expressed by not constructing a
+  * semaphore, never by a sentinel limit.
+  */
   constructor(limit: number);
   get pending(): number;
   /**
   * Acquires a slot, resolving in FIFO order. `onQueued` fires only when
   * the caller actually has to wait (feeds the agent:queued event).
-  */
-  acquire(onQueued?: () => void): Promise<() => void>;
-  withSlot<T>(fn: () => Promise<T>, onQueued?: () => void): Promise<T>;
+  * An aborted `signal` releases the caller from the queue without a
+  * slot: the returned release is a no-op, the remaining waiters keep
+  * their FIFO positions, and the caller proceeds to observe its own
+  * aborted signal (the model layers refuse dispatch under an aborted
+  * signal, so no provider call follows). Cancellation can therefore
+  * always drain a queued run (v1.34.0 review P2-4).
+  */
+  acquire(onQueued?: () => void, signal?: AbortSignal): Promise<() => void>;
+  withSlot<T>(fn: () => Promise<T>, onQueued?: () => void, signal?: AbortSignal): Promise<T>;
   private release;
 }
 //#endregion
@@ -6100,13 +6125,35 @@ interface McpConfig {
   risk?: Record<string, ToolRisk>;
 }
 /**
-* Imports MCP tools as a ToolSource. The client connects lazily on the
-* first tools() call; tools/list is fetched with cursor pagination until
-* exhaustion and cached per session; a listChanged notification
-* invalidates the cache, affecting subsequently spawned agents only (a
-* spawn's toolset snapshot is immutable by construction).
-*/
-declare function mcp(cfg: McpConfig): ToolSource;
+* The ToolSource returned by {@link mcp}: the frozen ToolSource seam
+* plus the lifecycle the seam deliberately leaves to the host.
+* `close()` releases everything the source created on first use: the
+* SDK client, its transport, and, for stdio, the spawned child
+* process, without which a one shot host process cannot exit
+* naturally after a run, because the child and its pipes keep the
+* event loop alive (v1.33.0 review P2). It is idempotent, resolves
+* even when the connection never succeeded, and resets the source, so
+* a later `tools()` call connects afresh. The engine never closes a
+* source, because one source may serve many runs: the host owns the
+* lifecycle and should close once its runs have settled (closing
+* while a run is in flight fails that run's MCP tool calls).
+*/
+interface McpToolSource extends ToolSource {
+  close(): Promise<void>;
+}
+/**
+* Imports MCP tools as a {@link McpToolSource}. The client connects
+* lazily on the first tools() call; tools/list is fetched with cursor
+* pagination until exhaustion and cached per session; a listChanged
+* notification invalidates the cache, affecting subsequently spawned
+* agents only (a spawn's toolset snapshot is immutable by
+* construction). The host owns the source's lifecycle: `close()`
+* releases the client, the transport, and the stdio child once the
+* runs using the source have settled; a one shot host should close in
+* a finally block, or its process never exits naturally (v1.33.0
+* review P2).
+*/
+declare function mcp(cfg: McpConfig): McpToolSource;
 //#endregion
 //#region src/tools/isolation.d.ts
 /** Appendix A: the shared pin cap (park/unpark and retainWorktree). */
@@ -6732,4 +6779,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, AgentOpts, AgentProfile, AgentProfilePermissions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, 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, ChildIdentityInput, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostAttributionFacts, CostReport, CreateEngineOptions, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DerivedKey, DeriverRegistry, DispositionRule, DispositionTable, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EntryKind, EntryRef, EntryStatus, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishInfo, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, INBOX_PROPOSAL_TTL_DAYS, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, InvocationRole, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_DEPTH_CEILING, MatchResult, McpConfig, MechanicalGateProfile, MechanicalGateVerdict, type 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, OrchestrateOptions, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PriceTable, PricedUsage, type Pricing, type PricingTier, type ProviderAdapter, QualityFloors, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RandIdentityInput, RandPayload, RefEntryAppender, RefEntryClassification, RefusalInfo, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunBudget, RunEventSink, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStatus, RuntimeEventSink, 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, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasMetaLookup, hashRunArgs, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, 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, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, AgentOpts, AgentProfile, AgentProfilePermissions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, BUDGET_ABORT_REASON, 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, ChildIdentityInput, type ClaimClass, type ClaimOp, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ConfigError, type CoreEvents, CostAttribution, CostAttributionFacts, CostReport, CreateEngineOptions, Ctx, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DebitResult, DeclaredLadder, DedupIndex, DedupNote, DerivedKey, DeriverRegistry, DispositionRule, DispositionTable, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EntryKind, EntryRef, EntryStatus, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, FinishInfo, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, INBOX_PROPOSAL_TTL_DAYS, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, InvocationRole, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_DEPTH_CEILING, MatchResult, McpConfig, 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, OrchestrateOptions, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PriceTable, PricedUsage, type Pricing, type PricingTier, type ProviderAdapter, QualityFloors, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RandIdentityInput, RandPayload, RefEntryAppender, RefEntryClassification, RefusalInfo, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunBudget, RunEventSink, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStatus, RuntimeEventSink, 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, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasMetaLookup, hashRunArgs, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, 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 };

package/dist/index.js

@@ -2893,11 +2893,16 @@ function errorText(result) {
 	return text === "" ? "MCP tool reported an error" : text;
 }
 /**
-* Imports MCP tools as a ToolSource. The client connects lazily on the
-* first tools() call; tools/list is fetched with cursor pagination until
-* exhaustion and cached per session; a listChanged notification
-* invalidates the cache, affecting subsequently spawned agents only (a
-* spawn's toolset snapshot is immutable by construction).
+* Imports MCP tools as a {@link McpToolSource}. The client connects
+* lazily on the first tools() call; tools/list is fetched with cursor
+* pagination until exhaustion and cached per session; a listChanged
+* notification invalidates the cache, affecting subsequently spawned
+* agents only (a spawn's toolset snapshot is immutable by
+* construction). The host owns the source's lifecycle: `close()`
+* releases the client, the transport, and the stdio child once the
+* runs using the source have settled; a one shot host should close in
+* a finally block, or its process never exits naturally (v1.33.0
+* review P2).
 */
 function mcp(cfg) {
 	validateConfig(cfg);
@@ -2908,19 +2913,24 @@ function mcp(cfg) {
 			name: "rulvar",
 			version: "1.0.0"
 		});
-		if (cfg.transport === "stdio") {
-			const transport = new StdioClientTransport({
-				command: cfg.command ?? "",
-				...cfg.args === void 0 ? {} : { args: cfg.args }
-			});
-			await client.connect(transport);
-		} else if (cfg.transport === "streamable-http") {
-			const transport = new StreamableHTTPClientTransport(new URL(cfg.url ?? ""));
-			await client.connect(transport);
-		} else {
-			const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-			await cfg.server.connect(serverTransport);
-			await client.connect(clientTransport);
+		try {
+			if (cfg.transport === "stdio") {
+				const transport = new StdioClientTransport({
+					command: cfg.command ?? "",
+					...cfg.args === void 0 ? {} : { args: cfg.args }
+				});
+				await client.connect(transport);
+			} else if (cfg.transport === "streamable-http") {
+				const transport = new StreamableHTTPClientTransport(new URL(cfg.url ?? ""));
+				await client.connect(transport);
+			} else {
+				const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+				await cfg.server.connect(serverTransport);
+				await client.connect(clientTransport);
+			}
+		} catch (error) {
+			await client.close().catch(() => void 0);
+			throw error;
 		}
 		client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
 			cache = void 0;
@@ -2980,6 +2990,19 @@ function mcp(cfg) {
 			const allowSet = cfg.allow === void 0 ? void 0 : new Set(cfg.allow);
 			cache = wireTools.filter((wire) => !denySet.has(wire.name) && (allowSet === void 0 || allowSet.has(wire.name))).map((wire) => toDef(client, wire));
 			return cache;
+		},
+		close: async () => {
+			const pending = clientPromise;
+			clientPromise = void 0;
+			cache = void 0;
+			if (pending === void 0) return;
+			let client;
+			try {
+				client = await pending;
+			} catch {
+				return;
+			}
+			await client.close();
 		}
 	};
 }
@@ -6735,6 +6758,51 @@ function tierWithinCaps(tier, caps) {
 	return TIER_ORDER[tier] <= TIER_ORDER[caps.structuredOutput];
 }
 //#endregion
+//#region src/l0/validate-numbers.ts
+/**
+* Shared numeric option validators (v1.34.0 review P2-3). Every public
+* numeric knob that shapes admission, limits, concurrency, or timers is
+* validated with these helpers at its intake boundary, so a malformed
+* value (NaN, Infinity, a negative, a fraction where an integer is
+* required) fails as a typed ConfigError before any journal entry,
+* worker, or provider dispatch. NaN needs dedicated handling because
+* every comparison with it is false: a hand-written range check in the
+* rejecting polarity (`value < min || value > max`) silently admits it.
+*/
+/**
+* The Node timer ceiling: setTimeout clamps any longer delay to 1 ms, so
+* a naive far-future timer fires immediately (v1.34.0 review P2-2).
+* Relative timer options are validated against this bound; absolute
+* deadlines use the sliced timer in long-timer.ts instead.
+*/
+const MAX_TIMER_DELAY_MS = 2147483647;
+function refuse(site, requirement, value) {
+	throw new ConfigError(`${site} must be ${requirement}; got ${String(value)}`);
+}
+/** An integer >= 1 (counts, caps, and depths). */
+function requirePositiveInteger(value, site) {
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 1) refuse(site, "a positive integer", value);
+}
+/** An integer >= 0 (caps where zero means "none allowed"). */
+function requireNonNegativeInteger(value, site) {
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 0) refuse(site, "a nonnegative integer", value);
+}
+/** A finite number >= 0 (USD amounts and reserves). */
+function requireNonNegativeNumber(value, site) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < 0) refuse(site, "a finite nonnegative number", value);
+}
+/** A finite fraction in (0, 1]. */
+function requireFraction(value, site) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > 1) refuse(site, "a fraction in (0, 1]", value);
+}
+/**
+* A relative delay handed to setTimeout as-is: an integer within the
+* Node timer maximum, mirroring validateRetryPolicy's bound.
+*/
+function requireTimerDelayMs(value, site) {
+	if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > 2147483647) refuse(site, "an integer between 1 and 2147483647 ms (the Node timer maximum)", value);
+}
+//#endregion
 //#region src/engine/scheduler.ts
 /**
 * Scheduler and concurrency (M1-T08): the per-run semaphore with a FIFO
@@ -6749,8 +6817,17 @@ var Semaphore = class {
 	limit;
 	active = 0;
 	waiters = [];
+	/**
+	* `limit` must be a positive integer: anything else (NaN included) is
+	* a typed ConfigError. Before this gate a NaN limit made
+	* `active < limit` permanently false, so the first acquire queued
+	* forever and the run could not settle, not even through cancel()
+	* (v1.34.0 review P2-4). Unlimited is expressed by not constructing a
+	* semaphore, never by a sentinel limit.
+	*/
 	constructor(limit) {
-		this.limit = Math.max(1, limit);
+		requirePositiveInteger(limit, "Semaphore limit");
+		this.limit = limit;
 	}
 	get pending() {
 		return this.waiters.length;
@@ -6758,21 +6835,50 @@ var Semaphore = class {
 	/**
 	* Acquires a slot, resolving in FIFO order. `onQueued` fires only when
 	* the caller actually has to wait (feeds the agent:queued event).
+	* An aborted `signal` releases the caller from the queue without a
+	* slot: the returned release is a no-op, the remaining waiters keep
+	* their FIFO positions, and the caller proceeds to observe its own
+	* aborted signal (the model layers refuse dispatch under an aborted
+	* signal, so no provider call follows). Cancellation can therefore
+	* always drain a queued run (v1.34.0 review P2-4).
 	*/
-	async acquire(onQueued) {
+	async acquire(onQueued, signal) {
 		if (this.active < this.limit) {
 			this.active += 1;
 			return () => this.release();
 		}
+		if (signal?.aborted === true) return () => void 0;
 		onQueued?.();
-		await new Promise((resolve) => {
-			this.waiters.push(resolve);
+		const waiter = {
+			resolve: () => void 0,
+			aborted: false
+		};
+		const wait = new Promise((resolve) => {
+			waiter.resolve = resolve;
 		});
+		this.waiters.push(waiter);
+		let onAbort;
+		if (signal !== void 0) {
+			onAbort = () => {
+				const index = this.waiters.indexOf(waiter);
+				if (index === -1) return;
+				this.waiters.splice(index, 1);
+				waiter.aborted = true;
+				waiter.resolve();
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		}
+		try {
+			await wait;
+		} finally {
+			if (signal !== void 0 && onAbort !== void 0) signal.removeEventListener("abort", onAbort);
+		}
+		if (waiter.aborted) return () => void 0;
 		this.active += 1;
 		return () => this.release();
 	}
-	async withSlot(fn, onQueued) {
-		const release = await this.acquire(onQueued);
+	async withSlot(fn, onQueued, signal) {
+		const release = await this.acquire(onQueued, signal);
 		try {
 			return await fn();
 		} finally {
@@ -6782,7 +6888,7 @@ var Semaphore = class {
 	release() {
 		this.active -= 1;
 		const next = this.waiters.shift();
-		if (next !== void 0) next();
+		if (next !== void 0) next.resolve();
 	}
 };
 //#endregion
@@ -6811,12 +6917,14 @@ var KeyedLimiter = class {
 	}
 	/**
 	* Runs `fn` under the key's semaphore; keys without a configured cap
-	* run unlimited (no queueing, no overhead).
+	* run unlimited (no queueing, no overhead). An aborted `signal` frees
+	* a queued caller without a slot (the Semaphore contract), so run
+	* cancellation drains provider queues too (v1.34.0 review P2-4).
 	*/
-	async withSlot(key, fn, onQueued) {
+	async withSlot(key, fn, onQueued, signal) {
 		const semaphore = this.semaphores.get(key);
 		if (semaphore === void 0) return fn();
-		return semaphore.withSlot(fn, onQueued);
+		return semaphore.withSlot(fn, onQueued, signal);
 	}
 };
 //#endregion
@@ -7043,13 +7151,6 @@ function retryClassOf(error) {
 	if (kind === "overloaded") return "overloaded";
 	return "transport";
 }
-/**
-* The largest delay a Node timer represents exactly (2^31 above that
-* a timer overflows and fires almost immediately); every returned
-* delay is clamped to it so a huge provider value can never turn
-* into an instant retry storm.
-*/
-const MAX_TIMER_DELAY_MS = 2147483647;
 /** Bounds a delay to a finite nonnegative integer a Node timer can honor. */
 function timerSafe(ms) {
 	if (!Number.isFinite(ms) || ms <= 0) return 0;
@@ -7105,7 +7206,7 @@ function validateRetryPolicy(policy, source = "retry") {
 	const backoff = candidate.backoff;
 	if (typeof backoff !== "object" || backoff === null || Array.isArray(backoff)) throw new ConfigError(`${source}: backoff must be an object with initialMs, factor, and maxMs; got ${renderConfigValue(backoff)}`);
 	const { initialMs, factor, maxMs, jitter } = backoff;
-	for (const [field, value] of [["backoff.initialMs", initialMs], ["backoff.maxMs", maxMs]]) if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > MAX_TIMER_DELAY_MS) fail(field, "must be an integer between 0 and 2147483647 ms (the Node timer maximum)", value);
+	for (const [field, value] of [["backoff.initialMs", initialMs], ["backoff.maxMs", maxMs]]) if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0 || value > 2147483647) fail(field, "must be an integer between 0 and 2147483647 ms (the Node timer maximum)", value);
 	if (typeof factor !== "number" || !Number.isFinite(factor) || factor <= 0) fail("backoff.factor", "must be a finite number above zero", factor);
 	if (jitter !== void 0 && typeof jitter !== "boolean") fail("backoff.jitter", "must be a boolean when given", jitter);
 	const retryOn = candidate.retryOn;
@@ -7494,6 +7595,15 @@ function ladderRungChoice(ladder, index) {
 }
 //#endregion
 //#region src/runtime/usage-limits.ts
+/**
+* UsageLimits (M1-T06): normative limit vocabulary and the per-spawn merge.
+*
+* Full contract: https://docs.rulvar.com/guide/agents. Expiry of maxTurns, maxToolCalls,
+* or timeoutMs produces the terminal status 'limit' (paid partial work);
+* streamIdleTimeoutMs expiry is a retryable transport-class AgentError,
+* never 'limit'. The run-level deadline is RunOptions.deadlineAt, not a
+* UsageLimits field.
+*/
 const DEFAULT_MAX_TURNS = 32;
 const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 12e4;
 /**
@@ -7516,6 +7626,26 @@ function mergeUsageLimits(call, profile, engine) {
 	if (noProgressTurns !== void 0) merged.noProgressTurns = noProgressTurns;
 	return merged;
 }
+/**
+* Validates one UsageLimits layer at its intake boundary (v1.34.0
+* review P2-3): a malformed field (NaN, Infinity, a negative, a
+* fraction) is a typed ConfigError before the merge, before any journal
+* entry, and before any provider dispatch. `site` names the layer in the
+* error text (e.g. `RunOptions.limits`). Counts are positive integers
+* (maxToolCalls may be 0: a spawn that must not call tools).
+* streamIdleTimeoutMs is handed to setTimeout as-is, so it is bounded by
+* the Node timer maximum like RetryPolicy delays; timeoutMs is a
+* wall-clock comparison, so it has no upper bound. Every present field
+* is checked; absent fields keep their defaults.
+*/
+function validateUsageLimits(limits, site) {
+	if (limits.maxTurns !== void 0) requirePositiveInteger(limits.maxTurns, `${site}.maxTurns`);
+	if (limits.maxToolCalls !== void 0) requireNonNegativeInteger(limits.maxToolCalls, `${site}.maxToolCalls`);
+	if (limits.maxOutputTokensPerTurn !== void 0) requirePositiveInteger(limits.maxOutputTokensPerTurn, `${site}.maxOutputTokensPerTurn`);
+	if (limits.timeoutMs !== void 0) requirePositiveInteger(limits.timeoutMs, `${site}.timeoutMs`);
+	if (limits.streamIdleTimeoutMs !== void 0) requireTimerDelayMs(limits.streamIdleTimeoutMs, `${site}.streamIdleTimeoutMs`);
+	if (limits.noProgressTurns !== void 0) requirePositiveInteger(limits.noProgressTurns, `${site}.noProgressTurns`);
+}
 //#endregion
 //#region src/runtime/model-retry.ts
 var ModelRetry = class extends Error {
@@ -8778,7 +8908,7 @@ async function runAgent(options) {
 					const aborted = abortKind();
 					return aborted === void 0 ? streamTurn(target.adapter, site.requestFor(target), site.streamOptionsFor(target)) : Promise.resolve(abortedOutcome(aborted));
 				};
-				const outcome = await (options.providerSlot === void 0 ? dispatch() : options.providerSlot(target.adapter.id, dispatch));
+				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);
 				tries += 1;
 				const retryClass = outcome.aborted === "idle" ? "transport" : outcome.wireError === void 0 ? void 0 : retryClassOf(outcome.wireError);
@@ -9749,6 +9879,7 @@ var RunBudget = class {
 	* Also enforces the engine lifetime spawn cap.
 	*/
 	admitSpawn(reserveUsd, accountScope = "run") {
+		requireNonNegativeNumber(reserveUsd, "the admission reserve (estCost or its fallbacks)");
 		if (this.agentsSpawnedInternal >= this.lifetimeSpawnCap) {
 			this.exhaustedInternal = true;
 			throw new BudgetExhaustedError(`engine lifetime spawn cap reached (${this.lifetimeSpawnCap} spawns per run; budgetDefaults.lifetimeSpawnCap)`, { data: { cap: this.lifetimeSpawnCap } });
@@ -9967,7 +10098,11 @@ var AdmissionController = class {
 	admittedTotal = 0;
 	constructor(options) {
 		const maxDepth = options.maxDepth ?? 1;
-		if (maxDepth < 1 || maxDepth > 4) throw new ConfigError(`maxDepth ${String(maxDepth)} is outside [1, ${String(4)}] (default 1, hard ceiling 4)`);
+		if (!Number.isInteger(maxDepth) || maxDepth < 1 || maxDepth > 4) throw new ConfigError(`maxDepth ${String(maxDepth)} is outside [1, ${String(4)}] (default 1, hard ceiling 4)`);
+		if (options.maxChildrenPerNode !== void 0) requirePositiveInteger(options.maxChildrenPerNode, "maxChildrenPerNode");
+		if (options.childBudgetFraction !== void 0) requireFraction(options.childBudgetFraction, "childBudgetFraction");
+		if (options.flatReserveUsd !== void 0) requireNonNegativeNumber(options.flatReserveUsd, "flatReserveUsd");
+		if (options.maxTotalSpawns !== void 0) requirePositiveInteger(options.maxTotalSpawns, "maxTotalSpawns");
 		this.budget = options.budget;
 		this.maxDepth = maxDepth;
 		this.maxChildrenPerNode = options.maxChildrenPerNode ?? 16;
@@ -10594,6 +10729,45 @@ function emitSpawnRejected(events, input) {
 	}, input.spanId, input.replayed);
 }
 //#endregion
+//#region src/l0/long-timer.ts
+/**
+* Sliced timers for absolute wall-clock deadlines (v1.34.0 review P2-2).
+*
+* Node clamps a setTimeout delay above 2147483647 ms (about 24.8 days)
+* to 1 ms, so a naive timer for a far-future deadline fires immediately.
+* setLongTimeout never hands Node more than one MAX_TIMER_DELAY_MS
+* slice, re-checks the wall clock when a slice fires, and re-arms until
+* the clock actually reaches the deadline: firing a slice is never taken
+* as proof the deadline arrived. A deadline already in the past fires on
+* the next macrotask (delay 0), matching the plain setTimeout behavior
+* the callers had for near deadlines.
+*/
+/**
+* Schedules `onDue` for the absolute wall-clock instant `dueAtMs` as
+* reported by `now` (default Date.now), slicing delays beyond the Node
+* timer maximum.
+*/
+function setLongTimeout(onDue, dueAtMs, now = Date.now) {
+	let handle;
+	let cancelled = false;
+	const arm = () => {
+		const remaining = Math.max(0, dueAtMs - now());
+		handle = setTimeout(() => {
+			if (cancelled) return;
+			if (now() >= dueAtMs) {
+				onDue();
+				return;
+			}
+			arm();
+		}, Math.min(remaining, MAX_TIMER_DELAY_MS));
+	};
+	arm();
+	return { cancel: () => {
+		cancelled = true;
+		if (handle !== void 0) clearTimeout(handle);
+	} };
+}
+//#endregion
 //#region src/engine/ctx.ts
 /**
 * Ctx primitives (M1-T07) plus the parallel/pipeline composition semantics
@@ -10859,6 +11033,7 @@ function createCtx(internals, rootWorkflow) {
 		const escalation = opts.escalation ?? profile?.escalation;
 		if (escalation !== void 0) {
 			if (escalation.flavor === "B" && escalation.deadlineMs === void 0) throw new ConfigError("flavor 'B' escalation requires an explicit deadlineMs: the suspension deadline has no engine default");
+			if (escalation.deadlineMs !== void 0) requirePositiveInteger(escalation.deadlineMs, "escalation.deadlineMs");
 			if (opts.result !== "full" && internals.onEscalation === void 0) throw new ConfigError("a spawn that opts into escalation from a plain value-form call needs an onEscalation hook (or use result: 'full')");
 			if (escalation.flavor === "B" && escalation.deadlineMs === void 0) throw new ConfigError("escalation flavor 'B' requires an explicit deadlineMs");
 		}
@@ -10987,6 +11162,8 @@ function createCtx(internals, rootWorkflow) {
 		}
 		const retryPolicy = opts.retry ?? profile?.retry ?? internals.defaults.retry;
 		if (retryPolicy !== void 0) validateRetryPolicy(retryPolicy, opts.retry !== void 0 ? "the agent retry option" : profile?.retry !== void 0 ? `the retry of profile '${String(opts.agentType)}'` : "engine defaults.retry");
+		if (opts.estCost !== void 0) requireNonNegativeNumber(opts.estCost, "the agent estCost option");
+		if (opts.limits !== void 0) validateUsageLimits(opts.limits, "the agent limits option");
 		const identityInput = {
 			kind: "agent",
 			agentType,
@@ -11390,12 +11567,12 @@ function createCtx(internals, rootWorkflow) {
 		if (retryPolicy !== void 0) runAgentOptions.retry = { policy: retryPolicy };
 		if (internals.providerLimiter !== void 0) {
 			const limiter = internals.providerLimiter;
-			runAgentOptions.providerSlot = (key, fn) => limiter.withSlot(key, fn, () => internals.events.emit({
+			runAgentOptions.providerSlot = (key, fn, signal) => limiter.withSlot(key, fn, () => internals.events.emit({
 				type: "agent:queued",
 				agentType,
 				label: opts.label,
 				providerKey: key
-			}, spanId));
+			}, spanId), signal);
 		}
 		if (opts.stream !== void 0) runAgentOptions.stream = opts.stream;
 		if (opts.label !== void 0) runAgentOptions.label = opts.label;
@@ -11407,7 +11584,7 @@ function createCtx(internals, rootWorkflow) {
 				type: "agent:queued",
 				agentType,
 				label: opts.label
-			}, spanId));
+			}, spanId), branchOrRunSignal);
 		} finally {
 			exitActivity?.();
 		}
@@ -11433,13 +11610,12 @@ function createCtx(internals, rootWorkflow) {
 						entryRef: entry.seq
 					}, spanId, replayed);
 					const registry = internals.external;
-					const dueAt = Date.parse(entry.deadlineAt ?? "") || internals.now();
-					timer = setTimeout(() => {
+					timer = setLongTimeout(() => {
 						registry?.submitResolution(entry.seq, {
 							by: "timeout",
 							value: defaultDecision
 						}).catch(() => void 0);
-					}, Math.max(0, dueAt - internals.now()));
+					}, Date.parse(entry.deadlineAt ?? "") || internals.now(), () => internals.now());
 					if (internals.onEscalation !== void 0) {
 						const preview = buildEscalationReport(request, result, void 0);
 						const previewResult = {
@@ -11453,7 +11629,7 @@ function createCtx(internals, rootWorkflow) {
 					}
 				}
 			});
-			if (timer !== void 0) clearTimeout(timer);
+			if (timer !== void 0) timer.cancel();
 			flavorBDecision = decisionOutcome.value;
 		}
 		if (acquired !== void 0) {
@@ -13302,6 +13478,36 @@ var InProcessRunner = class {
 * ctx is created per run. engine.resume lands with the journal
 * kernel in M2.
 */
+/**
+* The accepted RunOptions.deadlineAt grammar: an ISO 8601 calendar
+* date-time with minute precision at least, optional seconds and
+* fractional seconds, and a MANDATORY UTC designator or numeric offset.
+* Date.parse would accept far more (and would read an offset-less
+* date-time in the host's local zone, so the same string would mean a
+* different instant on different hosts); the grammar pins one meaning.
+*/
+const DEADLINE_AT_GRAMMAR = /^(\d{4})-(\d{2})-(\d{2})T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})$/;
+/**
+* Typed refusal of a malformed deadlineAt (v1.34.0 review P2-1). The
+* calendar day is range-checked explicitly: V8's Date.parse silently
+* ROLLS an impossible ISO day into the next month (2026-02-30 parses as
+* 2026-03-02), so the finite check alone would accept a date the host
+* never wrote and cancel the run at a different instant.
+*/
+function parseDeadlineAt(value) {
+	const parsed = Date.parse(value);
+	const match = DEADLINE_AT_GRAMMAR.exec(value);
+	const refuse = () => {
+		throw new ConfigError(`RunOptions.deadlineAt must be an ISO 8601 date-time with an explicit UTC designator or offset (e.g. 2026-07-21T10:00:00Z or 2026-07-21T12:00:00+02:00); got '${value}'`);
+	};
+	if (match === null || !Number.isFinite(parsed)) refuse();
+	const year = Number(match?.[1]);
+	const month = Number(match?.[2]);
+	const day = Number(match?.[3]);
+	const daysInMonth = new Date(Date.UTC(year, month, 0)).getUTCDate();
+	if (month < 1 || month > 12 || day < 1 || day > daysInMonth) refuse();
+	return parsed;
+}
 /** Content hash of an in-process workflow body (run-to-definition binding). */
 function hashWorkflowBody(wf) {
 	return createHash("sha256").update(wf.body.toString(), "utf8").digest("hex");
@@ -13343,7 +13549,24 @@ function createEngine(options) {
 	const maskEvents = options.redaction?.maskEvents ?? true;
 	const defaults = options.defaults ?? {};
 	if (defaults.retry !== void 0) validateRetryPolicy(defaults.retry, "createEngine defaults.retry");
-	for (const [name, profile] of Object.entries(defaults.profiles ?? {})) if (profile.retry !== void 0) validateRetryPolicy(profile.retry, `createEngine defaults.profiles['${name}'].retry`);
+	if (options.concurrency?.perRun !== void 0) requirePositiveInteger(options.concurrency.perRun, "createEngine concurrency.perRun");
+	for (const [adapterId, cap] of Object.entries(options.concurrency?.perProvider ?? {})) requirePositiveInteger(cap, `createEngine concurrency.perProvider['${adapterId}']`);
+	const budgetDefaults = options.budgetDefaults;
+	if (budgetDefaults?.flatReserveUsd !== void 0) requireNonNegativeNumber(budgetDefaults.flatReserveUsd, "createEngine budgetDefaults.flatReserveUsd");
+	if (budgetDefaults?.lifetimeSpawnCap !== void 0) requireNonNegativeInteger(budgetDefaults.lifetimeSpawnCap, "createEngine budgetDefaults.lifetimeSpawnCap");
+	if (budgetDefaults?.childBudgetFraction !== void 0) requireFraction(budgetDefaults.childBudgetFraction, "createEngine budgetDefaults.childBudgetFraction");
+	if (budgetDefaults?.maxDepth !== void 0) {
+		requirePositiveInteger(budgetDefaults.maxDepth, "createEngine budgetDefaults.maxDepth");
+		if (budgetDefaults.maxDepth > 4) throw new ConfigError(`createEngine budgetDefaults.maxDepth ${String(budgetDefaults.maxDepth)} is outside [1, ${String(4)}] (default 1, hard ceiling ${String(4)})`);
+	}
+	if (defaults.limits !== void 0) validateUsageLimits(defaults.limits, "createEngine defaults.limits");
+	for (const [name, profile] of Object.entries(defaults.profiles ?? {})) {
+		if (profile.retry !== void 0) validateRetryPolicy(profile.retry, `createEngine defaults.profiles['${name}'].retry`);
+		if (profile.limits !== void 0) validateUsageLimits(profile.limits, `createEngine defaults.profiles['${name}'].limits`);
+		if (profile.estCost !== void 0) requireNonNegativeNumber(profile.estCost, `createEngine defaults.profiles['${name}'].estCost`);
+		if (profile.escalation?.deadlineMs !== void 0) requirePositiveInteger(profile.escalation.deadlineMs, `createEngine defaults.profiles['${name}'].escalation.deadlineMs`);
+		if (profile.compaction?.threshold !== void 0) requireFraction(profile.compaction.threshold, `createEngine defaults.profiles['${name}'].compaction.threshold`);
+	}
 	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 });
@@ -13362,6 +13585,9 @@ function createEngine(options) {
 	const activeSegments = /* @__PURE__ */ new Set();
 	function run(wf, args, opts, resumeCtx) {
 		if (wf.kind !== "workflow" && wf.kind !== "compiled-workflow") throw new ConfigError("engine.run accepts in-process Workflow values or compileScript CompiledWorkflow values");
+		if (opts?.budgetUsd !== void 0) requireNonNegativeNumber(opts.budgetUsd, "RunOptions.budgetUsd");
+		if (opts?.limits !== void 0) validateUsageLimits(opts.limits, "RunOptions.limits");
+		const deadlineAtMs = opts?.deadlineAt === void 0 ? void 0 : parseDeadlineAt(opts.deadlineAt);
 		const compiled = wf.kind === "compiled-workflow" ? wf : void 0;
 		if (compiled !== void 0 && options.runners?.sandbox === void 0) throw new ConfigError("running a CompiledWorkflow requires a sandbox runner: pass createEngine({ runners: { sandbox: new WorkerSandboxRunner() } }) from @rulvar/planner ");
 		const runId = resumeCtx?.runId ?? opts?.runId ?? mintRunId();
@@ -13425,10 +13651,7 @@ function createEngine(options) {
 		if (opts?.signal !== void 0) if (opts.signal.aborted) requestCancel("host signal aborted");
 		else opts.signal.addEventListener("abort", () => requestCancel("host signal aborted"), { once: true });
 		let deadlineTimer;
-		if (opts?.deadlineAt !== void 0) {
-			const delay = Date.parse(opts.deadlineAt) - realNow();
-			deadlineTimer = setTimeout(() => requestCancel(`run deadline ${opts.deadlineAt} crossed`), Math.max(0, delay));
-		}
+		if (deadlineAtMs !== void 0) deadlineTimer = setLongTimeout(() => requestCancel(`run deadline ${opts?.deadlineAt ?? ""} crossed`), deadlineAtMs, realNow);
 		const budget = makeBudget();
 		const admission = new AdmissionController({
 			budget,
@@ -13606,7 +13829,7 @@ function createEngine(options) {
 					};
 				}
 			} finally {
-				if (deadlineTimer !== void 0) clearTimeout(deadlineTimer);
+				if (deadlineTimer !== void 0) deadlineTimer.cancel();
 				external.close();
 				await replayer.flush().catch(() => void 0);
 			}
@@ -14096,4 +14319,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DedupIndex, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FileModelKnowledgeStore, FileTranscriptStore, GitWorktreeProvider, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, PlanInvariantError, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, 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, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasMetaLookup, hashRunArgs, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, 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, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DedupIndex, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FileModelKnowledgeStore, FileTranscriptStore, GitWorktreeProvider, INBOX_PROPOSAL_TTL_DAYS, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_DEPTH_CEILING, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, PlanInvariantError, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, 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, atCompactionThreshold, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compilePermissionChain, compilePermissionPreset, compileVerifiedLayer, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, executeWorkflow, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, foldTermination, formatRePrompt, formatScopePath, hasMetaLookup, hashRunArgs, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, metaMatchesFilter, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readRunMeta, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, 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 };

package/package.json

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