@rulvar/core 1.34.0 → 1.36.0

package/dist/index.d.ts

@@ -28,7 +28,7 @@ type WireError = {
 * 'agent' is carried by the AgentError value projection, not by a
 * RulvarError subclass.
 */
-type ErrorCode = "agent" | "config" | "non_serializable_value" | "script_rejected" | "journal_compat" | "invalid_resolution" | "journal_order_violation" | "plan_invariant" | "replay_plan_hash_mismatch" | "orchestrator_cap_config" | "journal_miss" | "budget_exhausted" | "admission_rejected" | "sandbox_limit" | "lease_held" | "knowledge_cas";
+type ErrorCode = "agent" | "config" | "non_serializable_value" | "script_rejected" | "journal_compat" | "invalid_resolution" | "journal_order_violation" | "plan_invariant" | "replay_plan_hash_mismatch" | "orchestrator_cap_config" | "journal_miss" | "budget_exhausted" | "fail_run" | "admission_rejected" | "sandbox_limit" | "lease_held" | "knowledge_cas";
 /** An alias for the registry type; both names are public. */
 type RulvarErrorCode = ErrorCode;
 /**
@@ -191,6 +191,23 @@ declare class BudgetExhaustedError extends RulvarError {
   });
 }
 /**
+* A declared fail-run policy engaged and closed the run as a failure
+* (v1.35.0 review P2-1): `budget.atCap: 'fail-run'` after the journaled
+* orchestrator cap decision, or `guards.fallback: 'fail-run'` after the
+* journaled guard verdict. The run outcome is 'error' with this code;
+* `data.source` names the policy ('orchestrator_budget_cap' or
+* 'plan_guards') and `data` carries the decision entry reference, so the
+* outcome is a pure roll forward of the journal on resume: no second
+* decision, no model call, no spend.
+*/
+declare class FailRunError extends RulvarError {
+  readonly code = "fail_run";
+  constructor(message: string, opts?: {
+    data?: Json;
+    cause?: unknown;
+  });
+}
+/**
 * A structural admission rejection (maxDepth, maxChildrenPerNode,
 * maxTotalSpawns) from the AdmissionController (M6-T06). The rejection verdict is embedded in
 * the carrying spawn-admission decision entry and replays identically;
@@ -893,6 +910,14 @@ interface LeasableStore extends JournalStore {
   acquire(runId: string, owner: string): Promise<Lease>;
   renew(l: Lease): Promise<void>;
   release(l: Lease): Promise<void>;
+  /**
+  * Optional TTL introspection (v1.35.0 review P2-4): the configured
+  * lease ttl in milliseconds. A store exposing it lets createWorker
+  * VERIFY at construction that the worker's renew cadence matches the
+  * store's expiry instead of trusting two config sources to agree;
+  * stores without it are accepted with the worker's own ttl.
+  */
+  readonly leaseTtlMs?: number;
 }
 //#endregion
 //#region src/l0/spi/transcript.d.ts
@@ -1667,7 +1692,13 @@ declare function applyClaimOps(claims: readonly ModelClaim[], ops: readonly Clai
 interface FileModelKnowledgeStoreOptions {
   /** Default './rulvar.models.json'. */
   path?: string;
-  /** Active claims per (model, taskClass); default 8. */
+  /**
+  * Active claims per (model, taskClass); default 8. A nonnegative
+  * integer (zero refuses every active claim), validated at
+  * construction: the enforcement compares `count > cap`, and every
+  * comparison with NaN is false, so an unvalidated NaN or Infinity
+  * silently disabled the cap (v1.35.0 review P2-5).
+  */
   activeClaimsCap?: number;
 }
 declare class FileModelKnowledgeStore implements ModelKnowledgeStore {
@@ -2556,9 +2587,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
@@ -2790,7 +2823,11 @@ interface EscalationOptions {
   deadlineMs?: number;
   /** Applied by the timeout resolution (by: 'timeout'); default accept. */
   defaultDecision?: EscalationDecision;
-  /** In-run minimum spend before scope_bigger; default 0 (M3-T09). */
+  /**
+  * In-run minimum spend before scope_bigger; default 0 (M3-T09). A
+  * finite number >= 0, validated before any LLM call: the gate
+  * compares spend against it, and a NaN would silently disable it.
+  */
   minSpendUsd?: number;
 }
 /** The model-facing request: the report minus the runtime-filled fields. */
@@ -2881,15 +2918,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 +2952,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 +3152,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 +4842,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[];
@@ -5226,6 +5279,18 @@ interface OrchestratorExtensionIO {
     */
     replayed?: boolean;
   }): void;
+  /**
+  * A deterministic run failure declared by the extension (v1.35.0 review P2-1):
+  * the first call stores the error and aborts the orchestrator loop;
+  * the orchestrate settle boundary rethrows it, so the run fails with
+  * the given typed error instead of asking the model to finish. Later
+  * calls do nothing. The intended producer is a journaled
+  * policy verdict (the PlanRunner guards fallback 'fail-run'): boot
+  * terminates again from the journal on resume, so the failure rolls
+  * forward without another decision or model call. Optional so
+  * IO implementations built before v1.36 keep compiling.
+  */
+  terminate?(error: Error): void;
 }
 /**
 * The extension contract. PlanRunner implements it in @rulvar/plan; the
@@ -5272,17 +5337,43 @@ interface OrchestratorExtension {
 */
 interface OrchestratorBudgetSpec {
   /**
-  * Absolute bound in USD. It never REPLACES the fraction bound:
+  * Absolute bound in USD: a finite number >= 0, validated before any
+  * journal entry or dispatch (a malformed value is a ConfigError). It
+  * never REPLACES the fraction bound:
   * effectiveCap = min(capUsd, (capFraction ?? 0.2) * ceiling), so an
   * explicit capUsd larger than the default fraction of the run ceiling
   * is still cut to that fraction (and a warn log says so). Pass
   * capFraction: 1.0 to make capUsd the sole bound.
   */
   capUsd?: number;
-  /** default 0.2; effectiveCap = min of the given bounds */
+  /**
+  * A fraction in (0, 1], default 0.2; effectiveCap = min of the given
+  * bounds. Zero does not lift the cap (it would make every turn
+  * unpayable): anything outside (0, 1] is a ConfigError before any
+  * journal entry or dispatch.
+  */
   capFraction?: number;
+  /**
+  * A finite number >= 0, validated before any journal entry or
+  * dispatch. The reserve is SUBTRACTED from the soft boundary, so a
+  * negative value would widen the cap instead of reserving.
+  */
   finalizeReserveUsd?: number;
+  /**
+  * A positive integer, validated before any journal entry or dispatch:
+  * the turn limit of the reserved final wake.
+  */
   finalizeTurns?: number;
+  /**
+  * The policy at the cap, validated as exactly one of the two literals
+  * even at a plain JS/JSON boundary. 'finish-with-partial' (default)
+  * runs the reserved finalizer and returns its partial result with run
+  * outcome 'ok'. 'fail-run' skips the finalizer entirely: the run
+  * fails with outcome 'error' carrying FailRunError (code 'fail_run',
+  * data.source 'orchestrator_budget_cap', data.capDecisionRef); resume
+  * rolls the same failure forward from the journaled cap decision
+  * without another model call.
+  */
   atCap?: "finish-with-partial" | "fail-run";
 }
 /** Options for orchestrate(engine, goal, o?). */
@@ -5290,13 +5381,19 @@ interface OrchestrateOptions {
   model?: ModelSpec;
   /** Registered profile names to advertise; default: every profile. */
   profiles?: string[];
-  /** Per-orchestrate spawn cap; the engine lifetime cap applies regardless. */
+  /**
+  * Per-orchestrate spawn cap: a nonnegative integer (zero admits no
+  * spawns), validated before any journal entry or dispatch. The engine
+  * lifetime cap applies regardless.
+  */
   maxSpawns?: number;
   /** The orchestrator's own budget sub-account (cap enforcement layers only in M6). */
   budget?: OrchestratorBudgetSpec;
   /**
-  * Deterministic digest render bound: each
-  * TaskDigest outputSummary is clamped to this many CHARACTERS (the
+  * Deterministic digest render bound: a nonnegative integer, validated
+  * before any journal entry or dispatch. Each TaskDigest outputSummary
+  * is truncated to AT MOST this many CHARACTERS, the truncation marker
+  * included (a budget below 3 keeps the bound with a bare slice; the
   * model-independent measure; OQ-04 closed at M10 entry). Default
   * WAKE_SUMMARY_RENDER_BUDGET_CHARS.
   */
@@ -5334,31 +5431,52 @@ 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
 //#region src/engine/external.d.ts
+/**
+* The rejection carrier of an aborted flavor B decision wait (v1.35.0
+* review P1): the parked `awaitDecision` observes the branch/run
+* AbortSignal, releases its held activity, removes its waiter, and
+* rejects with this class so cancel, host abort, the run deadline, and
+* failed sibling aborts all settle the run in bounded time.
+* Deliberately not a RulvarError: the abort is cancellation intent, not
+* a registry failure class; the suspension entry stays OPEN, so a later
+* resume parks the decision again and the durable deadline still applies.
+*/
+declare class EscalationDecisionAbortedError extends Error {
+  readonly entryRef: number;
+  constructor(message: string, entryRef: number);
+}
 /** The resolution value shape of a tool-approval suspension (M3-T03). */
 interface ApprovalDecision {
   decision: "allow" | "deny";
@@ -5459,6 +5577,13 @@ declare class ExternalRegistry {
     toolName: string;
     input: Json;
     deadlineAt: string;
+    /**
+    * The branch/run signal: an abort while parked releases the held
+    * activity, removes the waiter, and rejects with
+    * EscalationDecisionAbortedError (v1.35.0 review P1). The suspension
+    * entry stays open for resume.
+    */
+    signal?: AbortSignal;
     onPending?: (entry: JournalEntry, replayed: boolean) => void;
   }): Promise<{
     value: Json;
@@ -5523,7 +5648,8 @@ interface AgentProfile {
   /**
   * Per-profile compaction threshold; default 0.8 of the loop model's
   * contextWindow (M4-T03). Compaction is ON by
-  * default; history-processor plumbing stays engine-internal.
+  * default; history-processor plumbing stays engine-internal. The
+  * threshold is a fraction in (0, 1], validated at createEngine.
   */
   compaction?: {
     threshold?: number;
@@ -5962,8 +6088,12 @@ declare function compileVerifiedLayer(claims: readonly ModelClaim[], ladders: re
 /**
 * The deterministic card render. Pure: same filtered
 * claims and ladders give byte-identical text. The render budget is
-* 4096 chars; over it, the OLDEST-observed notes
-* withhold first behind an explicit marker.
+* 4096 chars by default; over it, the OLDEST-observed notes withhold
+* first behind an explicit marker, and the budget is a HARD upper bound
+* of the returned string: a card whose mandatory sections alone exceed
+* it is truncated with the shared marker (v1.35.0 review P2-5: a budget
+* of 32 used to return the full 136-char header form). budgetChars is a
+* nonnegative integer, validated as a ConfigError.
 */
 declare function modelKnowledgeCard(claims: readonly ModelClaim[], ladders: readonly DeclaredLadder[], options?: {
   budgetChars?: number;
@@ -6141,7 +6271,14 @@ interface GitWorktreeProviderOptions {
   * requests keep on dispose. Default false.
   */
   keepOnError?: boolean;
-  /** Pin cap shared by park/unpark and retainWorktree (default 4). */
+  /**
+  * Pin cap shared by park/unpark and retainWorktree (default 4). A
+  * nonnegative integer (zero retains nothing), validated at
+  * construction: the retention compares `pinned.size < cap`, and every
+  * comparison with NaN is false, so an unvalidated NaN performed the
+  * acquire effects and then dropped every tree as "cap reached"
+  * (v1.35.0 review P2-5).
+  */
   maxPinnedWorktrees?: number;
   /** Warning sink (cap overflow); defaults to process.emitWarning. */
   onWarn?: (msg: string) => void;
@@ -6754,4 +6891,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, 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, 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, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, type EvidenceRef, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, 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

@@ -206,6 +206,25 @@ var BudgetExhaustedError = class extends RulvarError {
 	}
 };
 /**
+* A declared fail-run policy engaged and closed the run as a failure
+* (v1.35.0 review P2-1): `budget.atCap: 'fail-run'` after the journaled
+* orchestrator cap decision, or `guards.fallback: 'fail-run'` after the
+* journaled guard verdict. The run outcome is 'error' with this code;
+* `data.source` names the policy ('orchestrator_budget_cap' or
+* 'plan_guards') and `data` carries the decision entry reference, so the
+* outcome is a pure roll forward of the journal on resume: no second
+* decision, no model call, no spend.
+*/
+var FailRunError = class extends RulvarError {
+	code = "fail_run";
+	constructor(message, opts) {
+		super(message, {
+			retryable: false,
+			...opts
+		});
+	}
+};
+/**
 * A structural admission rejection (maxDepth, maxChildrenPerNode,
 * maxTotalSpawns) from the AdmissionController (M6-T06). The rejection verdict is embedded in
 * the carrying spawn-admission decision entry and replays identically;
@@ -2179,6 +2198,51 @@ function modelEpochOf(inputs) {
 	return Object.keys(epoch).length === 0 ? void 0 : epoch;
 }
 //#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/knowledge/file-store.ts
 /**
 * FileModelKnowledgeStore (M10-T01): the default ModelKnowledgeStore, a
@@ -2245,6 +2309,7 @@ var FileModelKnowledgeStore = class {
 	queue = Promise.resolve();
 	constructor(options) {
 		this.path = resolve(options?.path ?? "./rulvar.models.json");
+		if (options?.activeClaimsCap !== void 0) requireNonNegativeInteger(options.activeClaimsCap, "FileModelKnowledgeStore activeClaimsCap");
 		this.activeClaimsCap = options?.activeClaimsCap;
 	}
 	read() {
@@ -2301,6 +2366,19 @@ var FileModelKnowledgeStore = class {
 		return result;
 	}
 };
+/**
+* Truncates `raw` to at most `budgetChars` characters. A string within
+* the budget returns unchanged; a longer one is cut to
+* `budgetChars - 3` characters plus the marker, and budgets below the
+* marker length fall back to a bare slice so the bound still holds.
+* The measure is deterministic characters (UTF-16 units): identical
+* live and on replay, no tokenizer dependence.
+*/
+function truncateToBudget(raw, budgetChars) {
+	if (raw.length <= budgetChars) return raw;
+	if (budgetChars < 3) return raw.slice(0, Math.max(0, budgetChars));
+	return `${raw.slice(0, budgetChars - 3)}...`;
+}
 //#endregion
 //#region src/model/floors.ts
 /**
@@ -2442,10 +2520,15 @@ function compileVerifiedLayer(claims, ladders) {
 /**
 * The deterministic card render. Pure: same filtered
 * claims and ladders give byte-identical text. The render budget is
-* 4096 chars; over it, the OLDEST-observed notes
-* withhold first behind an explicit marker.
+* 4096 chars by default; over it, the OLDEST-observed notes withhold
+* first behind an explicit marker, and the budget is a HARD upper bound
+* of the returned string: a card whose mandatory sections alone exceed
+* it is truncated with the shared marker (v1.35.0 review P2-5: a budget
+* of 32 used to return the full 136-char header form). budgetChars is a
+* nonnegative integer, validated as a ConfigError.
 */
 function modelKnowledgeCard(claims, ladders, options) {
+	if (options?.budgetChars !== void 0) requireNonNegativeInteger(options.budgetChars, "modelKnowledgeCard budgetChars");
 	const budget = options?.budgetChars ?? 4096;
 	const lines = ["Model knowledge card (tier-relative; advisory within declared ladders and hard floors)."];
 	const verified = compileVerifiedLayer(claims, ladders);
@@ -2494,7 +2577,7 @@ function modelKnowledgeCard(claims, ladders, options) {
 		shown -= 1;
 		text = render(shown);
 	}
-	return text;
+	return truncateToBudget(text, budget);
 }
 //#endregion
 //#region src/tools/presets.ts
@@ -3047,6 +3130,7 @@ var GitWorktreeProvider = class {
 	constructor(options) {
 		this.repoRoot = options?.repoRoot ?? process.cwd();
 		this.keepOnError = options?.keepOnError ?? false;
+		if (options?.maxPinnedWorktrees !== void 0) requireNonNegativeInteger(options.maxPinnedWorktrees, "GitWorktreeProvider maxPinnedWorktrees");
 		this.maxPinned = options?.maxPinnedWorktrees ?? 4;
 		this.onWarn = options?.onWarn ?? ((msg) => process.emitWarning(msg, {
 			code: "RULVAR_WORKTREE",
@@ -5836,6 +5920,24 @@ var Replayer = class {
 * Full contract: https://docs.rulvar.com/guide/durability
 */
 /**
+* The rejection carrier of an aborted flavor B decision wait (v1.35.0
+* review P1): the parked `awaitDecision` observes the branch/run
+* AbortSignal, releases its held activity, removes its waiter, and
+* rejects with this class so cancel, host abort, the run deadline, and
+* failed sibling aborts all settle the run in bounded time.
+* Deliberately not a RulvarError: the abort is cancellation intent, not
+* a registry failure class; the suspension entry stays OPEN, so a later
+* resume parks the decision again and the durable deadline still applies.
+*/
+var EscalationDecisionAbortedError = class extends Error {
+	entryRef;
+	constructor(message, entryRef) {
+		super(message);
+		this.name = "EscalationDecisionAbortedError";
+		this.entryRef = entryRef;
+	}
+};
+/**
 * Normalizes a resolution value into an ApprovalDecision. Anything that
 * is not an explicit allow is a deny: an approval never fails open.
 */
@@ -6112,8 +6214,33 @@ var ExternalRegistry = class ExternalRegistry {
 			},
 			deadlineAt: options.deadlineAt
 		});
-		return new Promise((resolve) => {
+		return new Promise((resolve, reject) => {
+			const signal = options.signal;
+			const abortError = () => {
+				const reason = signal?.reason;
+				const detail = reason instanceof Error ? reason.message : typeof reason === "string" ? reason : "aborted";
+				return new EscalationDecisionAbortedError(`flavor B escalation decision wait aborted (entry ${String(entry.seq)}): ${detail}`, entry.seq);
+			};
+			if (signal?.aborted === true) {
+				reject(abortError());
+				return;
+			}
 			const exitActivity = this.enter();
+			let settled = false;
+			let detachAbort;
+			/** Exactly one terminal: activity exits once, the listener detaches once. */
+			const settle = () => {
+				if (settled) return false;
+				settled = true;
+				exitActivity();
+				detachAbort?.();
+				return true;
+			};
+			const onAbort = () => {
+				if (!settle()) return;
+				this.waiters.delete(entry.seq);
+				if (!this.closedFlag) reject(abortError());
+			};
 			const waiter = {
 				kind: "decision",
 				key: ExternalRegistry.approvalKey(entry.seq),
@@ -6121,7 +6248,7 @@ var ExternalRegistry = class ExternalRegistry {
 				entryRef: entry.seq,
 				prompt: `decide escalation of '${options.toolName}'`,
 				resolve: (value) => {
-					exitActivity();
+					if (!settle()) return;
 					resolve({
 						value,
 						entryRef: entry.seq
@@ -6129,6 +6256,12 @@ var ExternalRegistry = class ExternalRegistry {
 				}
 			};
 			this.waiters.set(entry.seq, waiter);
+			if (signal !== void 0) {
+				signal.addEventListener("abort", onAbort, { once: true });
+				detachAbort = () => {
+					signal.removeEventListener("abort", onAbort);
+				};
+			}
 			options.onPending?.(entry, replayed);
 		});
 	}
@@ -6772,8 +6905,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;
@@ -6781,21 +6923,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 {
@@ -6805,7 +6976,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
@@ -6834,12 +7005,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
@@ -7066,13 +7239,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;
@@ -7128,7 +7294,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;
@@ -7517,6 +7683,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;
 /**
@@ -7539,6 +7714,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 {
@@ -8801,7 +8996,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);
@@ -9772,6 +9967,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 } });
@@ -9990,7 +10186,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;
@@ -10301,8 +10501,7 @@ const WAKE_SUMMARY_RENDER_BUDGET_CHARS = 400;
 * spawn ordinal; the LLM distillation upgrade is M7 territory).
 */
 function summarizeOutput(result) {
-	const raw = result.status === "ok" ? typeof result.output === "string" ? result.output : JSON.stringify(result.output ?? null) : result.errorMessage ?? `terminal status ${result.status}`;
-	return raw.length <= 400 ? raw : `${raw.slice(0, 400)}...`;
+	return truncateToBudget(result.status === "ok" ? typeof result.output === "string" ? result.output : JSON.stringify(result.output ?? null) : result.errorMessage ?? `terminal status ${result.status}`, 400);
 }
 /** Folds one settled child into its digest (spawn-ordinal ordering is the caller's). */
 function digestOf(record, result) {
@@ -10617,6 +10816,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
@@ -10882,6 +11120,8 @@ 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 (escalation.minSpendUsd !== void 0) requireNonNegativeNumber(escalation.minSpendUsd, "escalation.minSpendUsd");
 			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");
 		}
@@ -11010,6 +11250,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,
@@ -11413,12 +11655,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;
@@ -11430,56 +11672,13 @@ function createCtx(internals, rootWorkflow) {
 				type: "agent:queued",
 				agentType,
 				label: opts.label
-			}, spanId));
+			}, spanId), branchOrRunSignal);
 		} finally {
 			exitActivity?.();
 		}
 		internals.budget.releaseReserve(reserve, budgetAccount);
-		let flavorBDecision;
-		if (result.status === "escalated" && escalation?.flavor === "B" && result.escalationRequest !== void 0) {
-			if (internals.external === void 0) throw new ConfigError("flavor B escalation requires the engine run context");
-			const request = result.escalationRequest;
-			const deadlineMs = escalation.deadlineMs;
-			if (deadlineMs === void 0) throw new ConfigError("flavor 'B' escalation requires an explicit deadlineMs");
-			const defaultDecision = escalation.defaultDecision ?? { kind: "accept" };
-			let timer;
-			const decisionOutcome = await internals.external.awaitDecision({
-				scope: agentScope(state.scope, running.seq),
-				spanId: internals.spans.mint(spanId),
-				toolName: "escalate",
-				input: request,
-				deadlineAt: new Date(internals.now() + deadlineMs).toISOString(),
-				onPending: (entry, replayed) => {
-					internals.events.emit({
-						type: "approval:pending",
-						toolName: "escalate",
-						entryRef: entry.seq
-					}, spanId, replayed);
-					const registry = internals.external;
-					const dueAt = Date.parse(entry.deadlineAt ?? "") || internals.now();
-					timer = setTimeout(() => {
-						registry?.submitResolution(entry.seq, {
-							by: "timeout",
-							value: defaultDecision
-						}).catch(() => void 0);
-					}, Math.max(0, dueAt - internals.now()));
-					if (internals.onEscalation !== void 0) {
-						const preview = buildEscalationReport(request, result, void 0);
-						const previewResult = {
-							...result,
-							escalation: preview
-						};
-						Promise.resolve(internals.onEscalation(previewResult)).then((decision) => registry?.submitResolution(entry.seq, {
-							by: "external",
-							value: decision
-						})).catch(() => void 0);
-					}
-				}
-			});
-			if (timer !== void 0) clearTimeout(timer);
-			flavorBDecision = decisionOutcome.value;
-		}
-		if (acquired !== void 0) {
+		const collectAndDisposeWorktree = async () => {
+			if (acquired === void 0) return;
 			try {
 				const { files, patch } = await acquired.collect();
 				const patchRef = internals.mintTranscriptRef();
@@ -11499,7 +11698,62 @@ function createCtx(internals, rootWorkflow) {
 				}, spanId);
 			}
 			await acquired.dispose(result.status !== "ok" && result.status !== "escalated");
+		};
+		let flavorBDecision;
+		if (result.status === "escalated" && escalation?.flavor === "B" && result.escalationRequest !== void 0) {
+			if (internals.external === void 0) throw new ConfigError("flavor B escalation requires the engine run context");
+			const request = result.escalationRequest;
+			const deadlineMs = escalation.deadlineMs;
+			if (deadlineMs === void 0) throw new ConfigError("flavor 'B' escalation requires an explicit deadlineMs");
+			const defaultDecision = escalation.defaultDecision ?? { kind: "accept" };
+			let timer;
+			let decisionOutcome;
+			try {
+				decisionOutcome = await internals.external.awaitDecision({
+					scope: agentScope(state.scope, running.seq),
+					spanId: internals.spans.mint(spanId),
+					toolName: "escalate",
+					input: request,
+					deadlineAt: new Date(internals.now() + deadlineMs).toISOString(),
+					signal: branchOrRunSignal,
+					onPending: (entry, replayed) => {
+						internals.events.emit({
+							type: "approval:pending",
+							toolName: "escalate",
+							entryRef: entry.seq
+						}, spanId, replayed);
+						const registry = internals.external;
+						timer = setLongTimeout(() => {
+							registry?.submitResolution(entry.seq, {
+								by: "timeout",
+								value: defaultDecision
+							}).catch(() => void 0);
+						}, Date.parse(entry.deadlineAt ?? "") || internals.now(), () => internals.now());
+						if (internals.onEscalation !== void 0) {
+							const preview = buildEscalationReport(request, result, void 0);
+							const previewResult = {
+								...result,
+								escalation: preview
+							};
+							Promise.resolve(internals.onEscalation(previewResult)).then((decision) => registry?.submitResolution(entry.seq, {
+								by: "external",
+								value: decision
+							})).catch(() => void 0);
+						}
+					}
+				});
+			} catch (thrown) {
+				if (thrown instanceof EscalationDecisionAbortedError) {
+					await collectAndDisposeWorktree();
+					throw new AgentCallError(thrown.message, result, state.scope, running.seq);
+				}
+				throw thrown;
+			} finally {
+				if (timer !== void 0) timer.cancel();
+			}
+			flavorBDecision = decisionOutcome.value;
 		}
+		if (acquired !== void 0) await collectAndDisposeWorktree();
 		if (result.status === "escalated" && result.escalationRequest !== void 0) {
 			const patchRef = result.artifacts?.find((artifact) => artifact.kind === "patch")?.ref;
 			const report = buildEscalationReport(result.escalationRequest, result, patchRef);
@@ -12137,6 +12391,28 @@ async function executeWorkflow(internals, wf, args) {
 * written; escalated children simply settle into their digests.
 */
 const ORCHESTRATE_WORKFLOW_NAME = "rulvar-orchestrate";
+/**
+* The orchestrate intake gate (v1.35.0 review P2-2): every numeric
+* option and the atCap literal validate SYNCHRONOUSLY at workflow
+* construction, shared by both surfaces (the top level orchestrate() throws
+* before a run exists; ctx.orchestrate throws before any journal entry,
+* provider call, or child dispatch). A NaN here previously disabled the
+* spawn cap (`spawnOrdinal >= NaN` is false forever) and the digest
+* render bound, and a negative finalize reserve WIDENED the soft cap
+* boundary instead of reserving from it.
+*/
+function validateOrchestrateOptions(opts) {
+	if (opts === void 0) return;
+	if (opts.maxSpawns !== void 0) requireNonNegativeInteger(opts.maxSpawns, "orchestrate maxSpawns");
+	if (opts.renderBudgetChars !== void 0) requireNonNegativeInteger(opts.renderBudgetChars, "orchestrate renderBudgetChars");
+	const spec = opts.budget;
+	if (spec === void 0) return;
+	if (spec.capUsd !== void 0) requireNonNegativeNumber(spec.capUsd, "orchestrate budget.capUsd");
+	if (spec.capFraction !== void 0) requireFraction(spec.capFraction, "orchestrate budget.capFraction");
+	if (spec.finalizeReserveUsd !== void 0) requireNonNegativeNumber(spec.finalizeReserveUsd, "orchestrate budget.finalizeReserveUsd");
+	if (spec.finalizeTurns !== void 0) requirePositiveInteger(spec.finalizeTurns, "orchestrate budget.finalizeTurns");
+	if (spec.atCap !== void 0 && spec.atCap !== "finish-with-partial" && spec.atCap !== "fail-run") throw new ConfigError(`orchestrate budget.atCap must be 'finish-with-partial' or 'fail-run'; got ${String(spec.atCap)}`);
+}
 function orchestratorPrompt(goal, maxSpawns, extensionLines) {
 	return [
 		"You are the orchestrator of a multi-agent run.",
@@ -12191,6 +12467,7 @@ function filterProfiles(registered, names) {
 * orchestrator agent with the finish terminal tool.
 */
 function makeOrchestratorWorkflow(goal, opts) {
+	validateOrchestrateOptions(opts);
 	return defineWorkflow({ name: ORCHESTRATE_WORKFLOW_NAME }, async (ctx) => {
 		const runtime = runtimeOf(ctx);
 		const { internals } = runtime;
@@ -12216,7 +12493,6 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const runCeiling = internals.budget.accountView(callingState.budgetScope ?? "run")?.ceilingUsd;
 			const spec = opts?.budget;
 			const fraction = spec?.capFraction ?? .2;
-			if (fraction > 1) throw new OrchestratorCapConfigError(`capFraction ${String(fraction)} exceeds 1.0 (opting out of the cap is explicit only, up to 1.0 inclusive)`);
 			const fromFraction = runCeiling === void 0 ? void 0 : fraction * runCeiling;
 			const bounds = [spec?.capUsd, fromFraction].filter((bound) => bound !== void 0);
 			const priorReserveDecision = internals.replayer.snapshot().find((entry) => {
@@ -12399,6 +12675,15 @@ function makeOrchestratorWorkflow(goal, opts) {
 			byOrdinal.set(spawnOrdinal, record);
 			return record;
 		};
+		/**
+		* The declared fail-run terminal (v1.35.0 review P2-1): the first
+		* extension terminate() call stores its failure and aborts the
+		* orchestrator loop; the settle boundary rethrows it deterministically
+		* (boot terminates again from the journaled verdict on resume, so the
+		* same failure rolls forward without a model call).
+		*/
+		let extensionTermination;
+		const forcedFinishController = new AbortController();
 		const io = {
 			runId: internals.runId,
 			baseScope: callingState.scope,
@@ -12444,7 +12729,12 @@ function makeOrchestratorWorkflow(goal, opts) {
 			},
 			registerAlias: (donorScope, targetScope) => internals.replayer.registerAlias(donorScope, targetScope),
 			priceUsd: (servedBy, usage) => servedBy === void 0 ? void 0 : internals.priceUsd(servedBy, usage),
-			emit: (event, options) => internals.events.emit(event, callingState.spanId, options?.replayed)
+			emit: (event, options) => internals.events.emit(event, callingState.spanId, options?.replayed),
+			terminate: (error) => {
+				if (extensionTermination !== void 0) return;
+				extensionTermination = error;
+				forcedFinishController.abort("rulvar:extension-terminate");
+			}
 		};
 		const cancelByHandle = async (handle, _reason) => {
 			const record = records.get(handle);
@@ -12537,7 +12827,6 @@ function makeOrchestratorWorkflow(goal, opts) {
 			await runExtensionActivity();
 		};
 		let capDecisionRef = internals.replayer.snapshot().find((entry) => entry.kind === "decision" && entry.value?.decisionType === "orchestrator_budget_cap")?.seq;
-		const forcedFinishController = new AbortController();
 		let capInFlight = false;
 		/**
 		* The at-cap freeze: EXACTLY one decision entry
@@ -12619,11 +12908,11 @@ function makeOrchestratorWorkflow(goal, opts) {
 				completedDigests: undelivered.map((record) => {
 					const row = digestOf(record, record.settled);
 					const budgetChars = opts?.renderBudgetChars ?? 400;
-					if (row.outputSummary.length > budgetChars) return {
+					const outputSummary = truncateToBudget(row.outputSummary, budgetChars);
+					return outputSummary === row.outputSummary ? row : {
 						...row,
-						outputSummary: `${row.outputSummary.slice(0, budgetChars)}...`
+						outputSummary
 					};
-					return row;
 				}),
 				escalations
 			};
@@ -13015,9 +13304,32 @@ function makeOrchestratorWorkflow(goal, opts) {
 				completed: [...records.values()].filter((record) => record.settled !== void 0).sort((a, b) => a.spawnOrdinal - b.spawnOrdinal).map((record) => digestOf(record, record.settled))
 			};
 		};
-		if (capDecisionRef !== void 0) return await runForcedFinish();
+		/**
+		* The settle at the cap: the JOURNALED cap decision drives the policy
+		* branch (its `fallback` field froze budget.atCap when the cap
+		* tripped), so a crash between the decision and its effect rolls the
+		* SAME outcome forward on resume, immune to drift of the live options.
+		* 'finish-with-partial' runs the reserved finalizer;
+		* 'fail-run' skips it and fails the run typed (v1.35.0 review P2-1:
+		* the policy used to be journaled and then ignored).
+		*/
+		const settleCapOutcome = async () => {
+			const capValue = internals.replayer.snapshot().find((entry) => entry.seq === capDecisionRef)?.value;
+			if (capValue?.fallback === "fail-run") throw new FailRunError(`the orchestrator budget cap was reached (decision entry ${String(capDecisionRef ?? -1)}) and budget.atCap is 'fail-run': the reserved finalizer is skipped and the run fails instead of returning a partial result`, { data: {
+				source: "orchestrator_budget_cap",
+				capDecisionRef: capDecisionRef ?? -1,
+				spentUsd: capValue.spentUsd ?? 0,
+				capUsd: capValue.capUsd ?? 0
+			} });
+			return await runForcedFinish();
+		};
+		const bootTermination = extensionTermination;
+		if (bootTermination !== void 0) throw bootTermination;
+		if (capDecisionRef !== void 0) return await settleCapOutcome();
 		const result = await runtime.runInScope(orchestratorState, () => ctx.agent(orchestratorPrompt(goal, opts?.maxSpawns, extension?.promptLines?.()), agentOpts));
-		if (capDecisionRef !== void 0) return await runForcedFinish();
+		const liveTermination = extensionTermination;
+		if (liveTermination !== void 0) throw liveTermination;
+		if (capDecisionRef !== void 0) return await settleCapOutcome();
 		if (orchestratorAccount !== void 0) internals.cost.orchestrator.spentUsd = internals.budget.accountView(orchestratorAccount)?.spentUsd ?? 0;
 		if (result.status !== "ok") throw new ConfigError(`the orchestrator agent terminated with status '${result.status}'` + (result.errorMessage === void 0 ? "" : `: ${result.errorMessage}`));
 		return result.output;
@@ -13325,6 +13637,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");
@@ -13366,7 +13708,25 @@ 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.escalation?.minSpendUsd !== void 0) requireNonNegativeNumber(profile.escalation.minSpendUsd, `createEngine defaults.profiles['${name}'].escalation.minSpendUsd`);
+		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 });
@@ -13385,6 +13745,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();
@@ -13448,10 +13811,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,
@@ -13629,7 +13989,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);
 			}
@@ -14119,4 +14479,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, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_TOOL_NAME, FailRunError, 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.34.0",
+  "version": "1.36.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",