@rulvar/core 1.22.0 → 1.24.0

package/dist/index.d.ts

@@ -799,6 +799,38 @@ type RunMeta = {
   * resumed run to uncapped.
   */
   budgetUsd?: number;
+  /**
+  * Count of execution segments this run has STARTED (a fresh start
+  * writes 1; every resume writes prior + 1, durably, BEFORE the
+  * segment emits its first event). The engine derives each segment's
+  * WorkflowEvent seq and span-id base from it, which is what keeps
+  * `seq` strictly increasing and `spanId` unique per run across
+  * suspend/resume and process recreation, even after a crash-killed
+  * segment (v1.22.0 review P1-2). Stores must round-trip the field
+  * (the conformance kit checks); a store that drops it degrades a
+  * resumed run's telemetry counters to per-segment, never the journal.
+  */
+  segments?: number;
+  /**
+  * Whether the run started with defined args. Engine-recorded at
+  * genesis and preserved verbatim by every later segment (a resume
+  * never rewrites it from its own re-supplied args). Args themselves
+  * are not journaled; the host re-supplies them on resume, and this
+  * marker plus `argsHash` let a host refuse a resume whose args
+  * silently diverge from the original invocation (the v1.23.0 review:
+  * a CLI resume that forgot `--args` silently changed the logical run
+  * and paid again). Absent on runs started before v1.24.0. Stores must
+  * round-trip the field (the conformance kit checks).
+  */
+  argsProvided?: boolean;
+  /**
+  * sha256 hex over the JCS canonical serialization of the genesis args
+  * (`hashRunArgs`). Absent when the run started without args or when
+  * the args are not JCS-serializable (`argsProvided` still records
+  * presence). Never the raw args: nothing sensitive lands in meta.
+  * Stores must round-trip the field (the conformance kit checks).
+  */
+  argsHash?: string;
 };
 type RunFilter = {
   status?: string;
@@ -4310,7 +4342,14 @@ type AdaptiveEvents = {
   verdict: "admit" | "reuse_full" | "admit_graft";
   agentType: string;
   logicalTaskId: string;
-  spawnUnitsAfter: number;
+  /**
+  * Spawn-unit balance after the budget-layer debit. Present on
+  * budget-layer admissions (the orchestrator spawn tools and
+  * ctx.workflow children); absent on lineage-layer admissions
+  * (ctx.agent roots), whose spawn-unit debit rides the dispatch
+  * itself (v1.22.0 review P2-5).
+  */
+  spawnUnitsAfter?: number;
 } | {
   type: "spawn:rejected";
   /**
@@ -4778,6 +4817,17 @@ declare function hashWorkflowBody(wf: Workflow<never, never> | Workflow<unknown,
 declare function hashWorkflowSource(source: string): string;
 /** TranscriptStore ref of the persisted CompiledWorkflow source blob. */
 declare function workflowSourceRef(runId: string): string;
+/**
+* sha256 hex over the JCS canonical serialization of a run's args: the
+* value the engine records as `RunMeta.argsHash` at genesis, exposed so
+* hosts can verify re-supplied resume args against the recorded hash
+* (the v1.23.0 review: a resume that silently drops or changes args
+* changes the logical run and pays again). Returns undefined for
+* undefined args (a run started without args records none). Throws when
+* JCS cannot serialize the value (functions, cycles, non-finite
+* numbers); the engine then records `argsProvided` without a hash.
+*/
+declare function hashRunArgs(args: unknown): string | undefined;
 declare function createEngine(options: CreateEngineOptions): Engine;
 //#endregion
 //#region src/orchestrator/handles.d.ts
@@ -5085,7 +5135,14 @@ interface OrchestratorExtensionIO {
   /** Telemetry emission into the run event stream. */
   emit(event: {
     type: string;
-  } & Record<string, unknown>): void;
+  } & Record<string, unknown>, options?: {
+    /**
+    * Marks the event as the replay of a journal-recovered decision
+    * (the standard envelope flag), so extension surfaces can emit
+    * recovered admissions honestly (v1.22.0 review P2-5).
+    */
+    replayed?: boolean;
+  }): void;
 }
 /**
 * The extension contract. PlanRunner implements it in @rulvar/plan; the
@@ -6421,12 +6478,31 @@ declare function buildOrchestratorTools(runtime: OrchestratorRuntime, profileCar
 //#endregion
 //#region src/engine/events.d.ts
 /**
+* The distance between the telemetry counter bases of two consecutive
+* execution segments of one run: segment k of a run starts its event
+* `seq` and span counter at `k * EVENT_SEGMENT_STRIDE`. A single
+* segment would need over four billion events to reach the next base,
+* so `seq` stays strictly increasing and `spanId` unique across
+* suspend/resume and process recreation while remaining an ordinary
+* safe-integer number (v1.22.0 review P1-2). Informational for
+* consumers: treat `seq` as ordered and `spanId` as opaque, never
+* parse segment structure out of either.
+*/
+declare const EVENT_SEGMENT_STRIDE: number;
+/**
 * Spans form a tree per run; spanId values are engine-minted opaque
 * strings, unique per run, pure telemetry, never identity.
 */
 declare class SpanRegistry {
   private readonly parents;
   private counter;
+  constructor(options?: {
+    /**
+    * First counter value (default 0): the resumed-segment base that
+    * keeps span ids unique per run across segments.
+    */
+    first?: number;
+  });
   mint(parentSpanId?: string): string;
   parentOf(spanId: string): string | undefined;
 }
@@ -6455,14 +6531,25 @@ declare class EventBus {
     * identity by construction, so masking cannot perturb replay.
     */
     maskEvents?: boolean;
+    /**
+    * First seq value (default 0): the resumed-segment base that keeps
+    * seq strictly increasing per run across segments (v1.22.0 review
+    * P1-2).
+    */
+    firstSeq?: number;
   });
   emit(body: WorkflowEventBody, spanId: string, replayed?: boolean): WorkflowEvent;
   /**
   * A throwing on() listener is isolated (its work is best-effort
   * telemetry), and the failure surfaces ONCE as a warn log on this bus
-  * rather than propagating into the run. The guard is set before the
-  * warn is delivered, so a listener that also throws on the warn cannot
-  * re-arm the report or recurse.
+  * rather than propagating into the run. The warn goes through emit()
+  * itself, AFTER the triggering event's fan-out completed: it is
+  * masked exactly like every other event (a secret-shaped fragment of
+  * the listener's error message never reaches observers raw), its seq
+  * is stamped at delivery, and every surface sees [event, warn] in
+  * that order. The guard is set before the recursive emit, so a
+  * listener that also throws on the warn cannot re-arm the report or
+  * recurse (v1.22.0 review P2-1).
   */
   private reportListenerError;
   on<T extends WorkflowEvent["type"]>(type: T, cb: (event: Extract<WorkflowEvent, {
@@ -6535,6 +6622,14 @@ interface SandboxBridge {
   /** Releases the activity token and rejects outstanding thunks. */
   close(): void;
 }
+/**
+* The sanctioned JSON subset of AgentOpts a sandbox script may pass:
+* the planner-dialect allowlist. Exported as the single source both for
+* the runtime validator below and for the planner API card, so the two
+* can never drift (v1.22.0 review P2-4: the hand-maintained card had
+* silently fallen three options behind).
+*/
+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, 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, 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 ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateOptions, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PhaseTarget, PipelineCollected, PipelineOpts, PlanInvariantError, PriceTable, PricedUsage, type Pricing, type PricingTier, type ProviderAdapter, QualityFloors, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_PROFILES, RandIdentityInput, RandPayload, RefEntryAppender, RefEntryClassification, RefusalInfo, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunBudget, RunEventSink, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStatus, RuntimeEventSink, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, Semaphore, SerializationHook, Settled, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StepIdentityInput, StructuredOutputTier, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, 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, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, 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, validateSchemaSpec, validateTerminationLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, AgentOpts, AgentProfile, AgentProfilePermissions, AgentResult, AgentResultMeta, AgentStatus, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, BUDGET_ABORT_REASON, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, 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 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, hashRunArgs, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, 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, validateSchemaSpec, validateTerminationLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -5455,6 +5455,20 @@ var JournalMatcher = class {
 * Full contract: https://docs.rulvar.com/guide/journal; architecture
 * overview: https://docs.rulvar.com/guide/architecture.
 */
+/**
+* The ordinal-space map key: one composite per (scope, hashVersion, key).
+* `U+0000` separators built from escape sequences (never literal control
+* bytes in source), because scopes and keys are free-form strings and a
+* printable separator could alias two different pairs. Prior seeding and
+* mint() MUST both go through this helper: v1.22.0 shipped with two
+* hand-built variants whose separators differed (an invisible literal
+* NUL against a space), so resume seeding filled a bucket mint() never
+* read and every identical live operation after a resume re-minted
+* ordinal 0, duplicating the identity triple (v1.22.0 review P1-1).
+*/
+function ordinalMapKey(scope, hashVersion, key) {
+	return `${scope}\u0000${String(hashVersion)}\u0000${key}`;
+}
 /** Large-value soft warn threshold (committed for M2). */
 const LARGE_VALUE_WARN_BYTES = 262144;
 /**
@@ -5498,9 +5512,9 @@ var Replayer = class {
 			this.entries.push(entry);
 			if (entry.seq >= this.seq) this.seq = entry.seq + 1;
 			if (entry.ref === void 0 && entry.kind !== "resolution" && entry.kind !== "abandon" && entry.hashVersion === 2) {
-				const ordinalKey = `${entry.scope} ${entry.hashVersion} ${entry.key}`;
-				const next = (this.ordinals.get(ordinalKey) ?? 0) + 1;
-				if (entry.ordinal + 1 > next - 1) this.ordinals.set(ordinalKey, entry.ordinal + 1);
+				const ordinalKey = ordinalMapKey(entry.scope, entry.hashVersion, entry.key);
+				const current = this.ordinals.get(ordinalKey) ?? 0;
+				if (entry.ordinal + 1 > current) this.ordinals.set(ordinalKey, entry.ordinal + 1);
 			}
 		}
 	}
@@ -5744,7 +5758,7 @@ var Replayer = class {
 		await this.queue;
 	}
 	mint(scope, key, kind, status) {
-		const ordinalKey = `${scope}2${key}`;
+		const ordinalKey = ordinalMapKey(scope, 2, key);
 		const ordinal = this.ordinals.get(ordinalKey) ?? 0;
 		this.ordinals.set(ordinalKey, ordinal + 1);
 		const entry = {
@@ -5762,6 +5776,11 @@ var Replayer = class {
 		return entry;
 	}
 	async persist(entry) {
+		if (this.strict) throw new JournalMissError(`replay-strict: refusing to append a '${entry.kind}' entry during a dry-run preview; a preview performs zero journal mutations`, { data: {
+			scope: entry.scope,
+			kind: entry.kind,
+			miss: "append"
+		} });
 		const shapeIssues = validateEntryShape(entry);
 		if (shapeIssues.length > 0) throw new ConfigError(`journal entry shape violation (kind '${entry.kind}'): ` + shapeIssues.map((i) => i.message).join("; "));
 		await this.store.append(this.runId, entry, this.lease);
@@ -5925,7 +5944,7 @@ var ExternalRegistry = class ExternalRegistry {
 	* until a resolution wins the first-closing-wins fold.
 	*/
 	async awaitExternal(scope, spanId, key, options) {
-		const scopeKey = `${scope}${key}`;
+		const scopeKey = `${scope}\u0000${key}`;
 		if (this.keysByScope.has(scopeKey)) throw new ConfigError(`duplicate awaitExternal key '${key}' in scope '${scope}'`);
 		this.keysByScope.add(scopeKey);
 		const identity = {
@@ -8242,7 +8261,7 @@ async function runAgent(options) {
 	const primaryRole = options.role ?? "loop";
 	const usageByPhaseModel = /* @__PURE__ */ new Map();
 	const addPhaseUsage = (role, ref, usage) => {
-		const key = `${role}${ref}`;
+		const key = `${role}\u0000${ref}`;
 		const prior = usageByPhaseModel.get(key);
 		usageByPhaseModel.set(key, {
 			role,
@@ -10364,6 +10383,26 @@ function runtimeOf(ctx) {
 	return runtime;
 }
 //#endregion
+//#region src/engine/spawn-events.ts
+function emitSpawnAdmitted(events, input) {
+	events.emit({
+		type: "spawn:admitted",
+		entryRef: input.entryRef,
+		verdict: input.verdict,
+		agentType: input.agentType,
+		logicalTaskId: input.logicalTaskId,
+		...input.spawnUnitsAfter === void 0 ? {} : { spawnUnitsAfter: input.spawnUnitsAfter }
+	}, input.spanId, input.replayed);
+}
+function emitSpawnRejected(events, input) {
+	events.emit({
+		type: "spawn:rejected",
+		...input.entryRef === void 0 ? {} : { entryRef: input.entryRef },
+		code: input.code,
+		agentType: input.agentType
+	}, input.spanId, input.replayed);
+}
+//#endregion
 //#region src/engine/ctx.ts
 /**
 * Ctx primitives (M1-T07) plus the parallel/pipeline composition semantics
@@ -10899,14 +10938,23 @@ function createCtx(internals, rootWorkflow) {
 				claimed.add(prior.seq);
 				const recorded = prior.value;
 				if (recorded.reject !== void 0) {
-					internals.events.emit({
-						type: "spawn:rejected",
+					emitSpawnRejected(internals.events, {
 						entryRef: prior.seq,
 						code: recorded.reject.code,
-						agentType
-					}, state.spanId, true);
+						agentType,
+						spanId: state.spanId,
+						replayed: true
+					});
 					throw new AdmissionRejectedError(`lineage admission rejected agent spawn (${recorded.reject.code}; recorded verdict)`, { data: { reason: recorded.reject } });
 				}
+				emitSpawnAdmitted(internals.events, {
+					entryRef: prior.seq,
+					verdict: "admit",
+					agentType,
+					logicalTaskId: recorded.lineage?.logicalTaskId ?? "unknown",
+					spanId: state.spanId,
+					replayed: true
+				});
 			} else {
 				const evaluated = admission.evaluateLineage({
 					name: agentType,
@@ -10938,15 +10986,22 @@ function createCtx(internals, rootWorkflow) {
 					value: decisionValue
 				});
 				if (evaluated.decision.kind === "reject") {
-					internals.events.emit({
-						type: "spawn:rejected",
+					emitSpawnRejected(internals.events, {
 						entryRef: decisionEntry.seq,
 						code: evaluated.decision.reason.code,
-						agentType
-					}, state.spanId);
+						agentType,
+						spanId: state.spanId
+					});
 					throw new AdmissionRejectedError(`lineage admission rejected agent spawn (${evaluated.decision.reason.code})`, { data: { reason: evaluated.decision.reason } });
 				}
 				admission.registerLineageAdmit(evaluated.decision.lineage.logicalTaskId);
+				emitSpawnAdmitted(internals.events, {
+					entryRef: decisionEntry.seq,
+					verdict: "admit",
+					agentType,
+					logicalTaskId: evaluated.decision.lineage.logicalTaskId,
+					spanId: state.spanId
+				});
 			}
 		}
 		const adapter = adapterOf(loopResolved);
@@ -11506,7 +11561,7 @@ function createCtx(internals, rootWorkflow) {
 	*/
 	const workflowOrdinals = /* @__PURE__ */ new Map();
 	const nextWorkflowOrdinal = (scope, name) => {
-		const counterKey = `${scope}${name}`;
+		const counterKey = `${scope}\u0000${name}`;
 		const ordinal = workflowOrdinals.get(counterKey) ?? 0;
 		workflowOrdinals.set(counterKey, ordinal + 1);
 		return ordinal;
@@ -11587,8 +11642,12 @@ function createCtx(internals, rootWorkflow) {
 			return value?.decisionType === "spawn-admission" && value.childScope === childScope;
 		});
 		let verdict;
+		let decisionEntrySeq;
+		let decisionReplayed = false;
 		if (prior !== void 0) {
 			verdict = prior.value.decision.verdict;
+			decisionEntrySeq = prior.seq;
+			decisionReplayed = true;
 			if (verdict.kind !== "reject") admission.recoverInFlight(budgetAccount, verdict);
 		} else {
 			const decision = admission.admit({
@@ -11604,7 +11663,7 @@ function createCtx(internals, rootWorkflow) {
 				}
 			});
 			verdict = decision.verdict;
-			await internals.replayer.appendSinglePhase({
+			decisionEntrySeq = (await internals.replayer.appendSinglePhase({
 				scope: state.scope,
 				key: "",
 				kind: "decision",
@@ -11618,10 +11677,28 @@ function createCtx(internals, rootWorkflow) {
 					parentAccountScope: budgetAccount,
 					decision
 				}
+			})).seq;
+		}
+		if (verdict.kind === "reject") {
+			emitSpawnRejected(internals.events, {
+				entryRef: decisionEntrySeq,
+				code: verdict.reason.code,
+				agentType: name,
+				spanId,
+				replayed: decisionReplayed ? true : void 0
 			});
+			throw rejectionError(verdict.reason, name);
 		}
-		if (verdict.kind === "reject") throw rejectionError(verdict.reason, name);
 		if (verdict.kind !== "admit") throw new ConfigError(`admission verdict '${verdict.kind}' has no producer before M7 (DEF-5)`);
+		emitSpawnAdmitted(internals.events, {
+			entryRef: decisionEntrySeq,
+			verdict: verdict.kind,
+			agentType: name,
+			logicalTaskId: verdict.lineage.logicalTaskId,
+			spawnUnitsAfter: verdict.spawnUnitsAfter,
+			spanId,
+			replayed: decisionReplayed ? true : void 0
+		});
 		const reserve = verdict.reserve;
 		const openOptions = { parentScope: budgetAccount };
 		if (reserve.childCeilingUsd !== void 0) {
@@ -12152,7 +12229,7 @@ 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) => internals.events.emit(event, callingState.spanId)
+			emit: (event, options) => internals.events.emit(event, callingState.spanId, options?.replayed)
 		};
 		const cancelByHandle = async (handle, _reason) => {
 			const record = records.get(handle);
@@ -12196,15 +12273,31 @@ function makeOrchestratorWorkflow(goal, opts) {
 				if (entry.kind !== "decision" || entry.scope !== callingState.scope) return false;
 				const value = entry.value;
 				return value?.decisionType === "spawn-admission" && (value.origin === "spawn_agent" || value.origin === "parallel_agents");
-			}).map((entry) => entry.value).sort((a, b) => a.spawnOrdinal - b.spawnOrdinal);
-			for (const value of admissions) {
+			}).map((entry) => ({
+				entrySeq: entry.seq,
+				value: entry.value
+			})).sort((a, b) => a.value.spawnOrdinal - b.value.spawnOrdinal);
+			for (const { entrySeq, value } of admissions) {
 				nextOrdinal = Math.max(nextOrdinal, value.spawnOrdinal + 1);
 				const decision = value.decision;
 				recoveredSpecByOrdinal.set(value.spawnOrdinal, value.spec);
+				const recoveredAgentType = value.spec?.agentType ?? "unknown";
 				if (decision.verdict.kind !== "admit") {
-					rejectedByOrdinal.set(value.spawnOrdinal, decision);
+					rejectedByOrdinal.set(value.spawnOrdinal, {
+						decision,
+						entrySeq
+					});
 					continue;
 				}
+				emitSpawnAdmitted(internals.events, {
+					entryRef: entrySeq,
+					verdict: decision.verdict.kind,
+					agentType: recoveredAgentType,
+					logicalTaskId: decision.verdict.lineage.logicalTaskId,
+					spawnUnitsAfter: decision.verdict.spawnUnitsAfter,
+					spanId: callingState.spanId,
+					replayed: true
+				});
 				admission.recoverChild(currentScope);
 				const childScope = value.childScope ?? value.orchestratorScope;
 				const record = await dispatchChild(value.spec, value.spawnOrdinal, {
@@ -12355,7 +12448,17 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const recovered = byOrdinal.get(spawnOrdinal);
 				if (recovered !== void 0 && specMatches) return { handle: recovered.handle };
 				const recoveredRejection = rejectedByOrdinal.get(spawnOrdinal);
-				if (recoveredRejection !== void 0 && specMatches) throw new AdmissionRejectedError(`admission rejected spawn ordinal ${String(spawnOrdinal)} (recovered verdict)`, { data: { decision: recoveredRejection } });
+				if (recoveredRejection !== void 0 && specMatches) {
+					const reason = recoveredRejection.decision.verdict;
+					emitSpawnRejected(internals.events, {
+						entryRef: recoveredRejection.entrySeq,
+						code: reason.reason?.code ?? "unknown",
+						agentType: params.agentType,
+						spanId: callingState.spanId,
+						replayed: true
+					});
+					throw new AdmissionRejectedError(`admission rejected spawn ordinal ${String(spawnOrdinal)} (recovered verdict)`, { data: { decision: recoveredRejection.decision } });
+				}
 				if (opts?.maxSpawns !== void 0 && spawnOrdinal >= opts.maxSpawns) {
 					internals.events.emit({
 						type: "spawn:rejected",
@@ -12407,24 +12510,27 @@ function makeOrchestratorWorkflow(goal, opts) {
 					value: admissionValue
 				});
 				if (decision.verdict.kind === "reject") {
-					rejectedByOrdinal.set(spawnOrdinal, decision);
-					internals.events.emit({
-						type: "spawn:rejected",
+					rejectedByOrdinal.set(spawnOrdinal, {
+						decision,
+						entrySeq: decisionEntry.seq
+					});
+					emitSpawnRejected(internals.events, {
 						entryRef: decisionEntry.seq,
 						code: decision.verdict.reason.code,
-						agentType: params.agentType
-					}, callingState.spanId);
+						agentType: params.agentType,
+						spanId: callingState.spanId
+					});
 					throw new AdmissionRejectedError(`admission rejected spawn_agent '${params.agentType}' (${decision.verdict.reason.code})`, { data: { reason: decision.verdict.reason } });
 				}
 				if (decision.verdict.kind !== "admit") throw new ConfigError(`admission verdict '${decision.verdict.kind}' has no producer before M7 (DEF-5)`);
-				internals.events.emit({
-					type: "spawn:admitted",
+				emitSpawnAdmitted(internals.events, {
 					entryRef: decisionEntry.seq,
 					verdict: decision.verdict.kind,
 					agentType: params.agentType,
 					logicalTaskId: decision.verdict.lineage.logicalTaskId,
-					spawnUnitsAfter: decision.verdict.spawnUnitsAfter
-				}, callingState.spanId);
+					spawnUnitsAfter: decision.verdict.spawnUnitsAfter,
+					spanId: callingState.spanId
+				});
 				return { handle: (await dispatchChild(params, spawnOrdinal, {
 					nodeId: decision.nodeId ?? "unknown",
 					logicalTaskId: decision.verdict.lineage.logicalTaskId
@@ -12727,12 +12833,27 @@ function orchestrate(engine, goal, opts, runOptions) {
 * Full contract: https://docs.rulvar.com/guide/observability.
 */
 /**
+* The distance between the telemetry counter bases of two consecutive
+* execution segments of one run: segment k of a run starts its event
+* `seq` and span counter at `k * EVENT_SEGMENT_STRIDE`. A single
+* segment would need over four billion events to reach the next base,
+* so `seq` stays strictly increasing and `spanId` unique across
+* suspend/resume and process recreation while remaining an ordinary
+* safe-integer number (v1.22.0 review P1-2). Informational for
+* consumers: treat `seq` as ordered and `spanId` as opaque, never
+* parse segment structure out of either.
+*/
+const EVENT_SEGMENT_STRIDE = 2 ** 32;
+/**
 * Spans form a tree per run; spanId values are engine-minted opaque
 * strings, unique per run, pure telemetry, never identity.
 */
 var SpanRegistry = class {
 	parents = /* @__PURE__ */ new Map();
-	counter = 0;
+	counter;
+	constructor(options) {
+		this.counter = options?.first ?? 0;
+	}
 	mint(parentSpanId) {
 		const spanId = `s${this.counter++}`;
 		if (parentSpanId !== void 0) this.parents.set(spanId, parentSpanId);
@@ -12754,7 +12875,7 @@ var EventBus = class {
 	maskEvents;
 	subscribers = /* @__PURE__ */ new Set();
 	listeners = /* @__PURE__ */ new Set();
-	seq = 0;
+	seq;
 	ended = false;
 	listenerErrorReported = false;
 	constructor(options) {
@@ -12762,6 +12883,7 @@ var EventBus = class {
 		this.spans = options.spans;
 		this.now = options.now ?? realNow;
 		this.maskEvents = options.maskEvents ?? true;
+		this.seq = options.firstSeq ?? 0;
 	}
 	emit(body, spanId, replayed) {
 		const parentSpanId = this.spans.parentOf(spanId);
@@ -12775,39 +12897,40 @@ var EventBus = class {
 			...replayed === true ? { replayed: true } : {},
 			...safeBody
 		};
+		let listenerFailure;
+		let sawListenerFailure = false;
 		for (const listener of this.listeners) try {
 			listener(event);
 		} catch (thrown) {
-			this.reportListenerError(thrown, spanId);
+			if (!sawListenerFailure) {
+				sawListenerFailure = true;
+				listenerFailure = thrown;
+			}
 		}
 		for (const subscriber of this.subscribers) subscriber.push(event);
+		if (sawListenerFailure) this.reportListenerError(listenerFailure, spanId);
 		return event;
 	}
 	/**
 	* A throwing on() listener is isolated (its work is best-effort
 	* telemetry), and the failure surfaces ONCE as a warn log on this bus
-	* rather than propagating into the run. The guard is set before the
-	* warn is delivered, so a listener that also throws on the warn cannot
-	* re-arm the report or recurse.
+	* rather than propagating into the run. The warn goes through emit()
+	* itself, AFTER the triggering event's fan-out completed: it is
+	* masked exactly like every other event (a secret-shaped fragment of
+	* the listener's error message never reaches observers raw), its seq
+	* is stamped at delivery, and every surface sees [event, warn] in
+	* that order. The guard is set before the recursive emit, so a
+	* listener that also throws on the warn cannot re-arm the report or
+	* recurse (v1.22.0 review P2-1).
 	*/
 	reportListenerError(thrown, spanId) {
 		if (this.listenerErrorReported) return;
 		this.listenerErrorReported = true;
-		const parentSpanId = this.spans.parentOf(spanId);
-		const warn = {
-			runId: this.runId,
-			seq: this.seq++,
-			ts: new Date(this.now()).toISOString(),
-			spanId,
-			...parentSpanId === void 0 ? {} : { parentSpanId },
+		this.emit({
 			type: "log",
 			level: "warn",
 			msg: "an event listener threw and was isolated so the run is unaffected: " + (thrown instanceof Error ? thrown.message : String(thrown))
-		};
-		for (const listener of this.listeners) try {
-			listener(warn);
-		} catch {}
-		for (const subscriber of this.subscribers) subscriber.push(warn);
+		}, spanId);
 	}
 	on(type, cb) {
 		const listener = (event) => {
@@ -12982,6 +13105,20 @@ function hashWorkflowSource(source) {
 function workflowSourceRef(runId) {
 	return `${runId}/workflow-source`;
 }
+/**
+* sha256 hex over the JCS canonical serialization of a run's args: the
+* value the engine records as `RunMeta.argsHash` at genesis, exposed so
+* hosts can verify re-supplied resume args against the recorded hash
+* (the v1.23.0 review: a resume that silently drops or changes args
+* changes the logical run and pays again). Returns undefined for
+* undefined args (a run started without args records none). Throws when
+* JCS cannot serialize the value (functions, cycles, non-finite
+* numbers); the engine then records `argsProvided` without a hash.
+*/
+function hashRunArgs(args) {
+	if (args === void 0) return;
+	return createHash("sha256").update(jcsSerialize(args), "utf8").digest("hex");
+}
 function createEngine(options) {
 	const adapters = buildAdapterRegistry(options.adapters);
 	const rawJournal = options.stores?.journal ?? new InMemoryStore();
@@ -13012,12 +13149,15 @@ function createEngine(options) {
 		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();
 		const registry = buildDeriverRegistry(options.extraDerivers);
-		const spans = new SpanRegistry();
+		const segmentsBefore = resumeCtx?.segmentsBefore ?? 0;
+		const telemetryBase = segmentsBefore * EVENT_SEGMENT_STRIDE;
+		const spans = new SpanRegistry({ first: telemetryBase });
 		const bus = new EventBus({
 			runId,
 			spans,
 			now: realNow,
-			maskEvents
+			maskEvents,
+			firstSeq: telemetryBase
 		});
 		const rootSpanId = spans.mint();
 		let budgetSeed;
@@ -13096,7 +13236,7 @@ function createEngine(options) {
 			...options.budgetDefaults?.flatReserveUsd === void 0 ? {} : { flatReserveUsd: options.budgetDefaults.flatReserveUsd },
 			...defaults.roleFloors === void 0 ? {} : { floors: defaults.roleFloors },
 			...knowledge === void 0 ? {} : { knowledge },
-			events: { emit: (body, spanId) => bus.emit(body, spanId ?? rootSpanId) },
+			events: { emit: (body, spanId, replayed) => bus.emit(body, spanId ?? rootSpanId, replayed) },
 			spans,
 			rootSpanId,
 			transcripts,
@@ -13139,13 +13279,27 @@ function createEngine(options) {
 			mintTranscriptRef: () => `${runId}/t${transcriptCounter++}`,
 			now: realNow
 		};
-		const putMeta = (status) => journal.putMeta({
+		const argsBinding = {};
+		if (resumeCtx === void 0) {
+			argsBinding.argsProvided = args !== void 0;
+			try {
+				const argsHash = hashRunArgs(args);
+				if (argsHash !== void 0) argsBinding.argsHash = argsHash;
+			} catch {}
+		} else {
+			if (resumeCtx.argsProvided !== void 0) argsBinding.argsProvided = resumeCtx.argsProvided;
+			if (resumeCtx.argsHash !== void 0) argsBinding.argsHash = resumeCtx.argsHash;
+		}
+		const putMeta = (status) => resumeCtx?.strict === true ? Promise.resolve() : journal.putMeta({
 			runId,
 			status,
+			segments: segmentsBefore + 1,
 			updatedAt: new Date(realNow()).toISOString(),
 			...opts?.name === void 0 ? {} : { name: opts.name },
 			...opts?.tags === void 0 ? {} : { tags: opts.tags },
 			...ceilingUsd === void 0 ? {} : { budgetUsd: ceilingUsd },
+			...argsBinding.argsProvided === void 0 ? {} : { argsProvided: argsBinding.argsProvided },
+			...argsBinding.argsHash === void 0 ? {} : { argsHash: argsBinding.argsHash },
 			workflowName: wf.name,
 			workflowHash: compiled === void 0 ? hashWorkflowBody(wf) : hashWorkflowSource(compiled.source),
 			...compiled === void 0 ? {} : { workflowSourceRef: workflowSourceRef(runId) }
@@ -13157,7 +13311,7 @@ function createEngine(options) {
 			let value;
 			let wireError;
 			let pending = [];
-			if (compiled !== void 0) await transcripts.put(workflowSourceRef(runId), new TextEncoder().encode(compiled.source));
+			if (compiled !== void 0 && resumeCtx?.strict !== true) await transcripts.put(workflowSourceRef(runId), new TextEncoder().encode(compiled.source));
 			await putMeta("running");
 			bus.emit({
 				type: "run:start",
@@ -13329,6 +13483,9 @@ function createEngine(options) {
 				invalidate: resumeOptions?.invalidate ?? [],
 				...resumeOptions?.lease === void 0 ? {} : { lease: resumeOptions.lease },
 				...typeof meta?.budgetUsd === "number" ? { budgetUsd: meta.budgetUsd } : {},
+				segmentsBefore: typeof meta?.segments === "number" && meta.segments > 0 ? Math.floor(meta.segments) : 1,
+				...typeof meta?.argsProvided === "boolean" ? { argsProvided: meta.argsProvided } : {},
+				...typeof meta?.argsHash === "string" ? { argsHash: meta.argsHash } : {},
 				previewResolve
 			});
 		})();
@@ -13427,8 +13584,14 @@ function createEngine(options) {
 *   exactly like an in-process one (the token is re-acquired BEFORE any
 *   response is posted, closing the wake latency gap).
 */
-/** The sanctioned JSON subset of AgentOpts a sandbox script may pass. */
-const SANDBOX_AGENT_OPT_KEYS = /* @__PURE__ */ new Set([
+/**
+* The sanctioned JSON subset of AgentOpts a sandbox script may pass:
+* the planner-dialect allowlist. Exported as the single source both for
+* the runtime validator below and for the planner API card, so the two
+* can never drift (v1.22.0 review P2-4: the hand-maintained card had
+* silently fallen three options behind).
+*/
+const SANDBOX_AGENT_OPT_KEYS = [
 	"agentType",
 	"model",
 	"effort",
@@ -13445,7 +13608,8 @@ const SANDBOX_AGENT_OPT_KEYS = /* @__PURE__ */ new Set([
 	"escalation",
 	"fallback",
 	"replay"
-]);
+];
+const SANDBOX_AGENT_OPT_KEY_SET = new Set(SANDBOX_AGENT_OPT_KEYS);
 function asRecord(value, what) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ConfigError(`sandbox call ${what} must be a JSON object`);
 	return value;
@@ -13519,7 +13683,7 @@ function createSandboxBridge(ctx, options) {
 					const record = asRecord(params, "agent params");
 					if (typeof record.prompt !== "string") throw new ConfigError("sandbox agent call requires a string prompt");
 					const rawOpts = record.opts === void 0 ? {} : asRecord(record.opts, "agent options");
-					for (const key of Object.keys(rawOpts)) if (!SANDBOX_AGENT_OPT_KEYS.has(key)) throw new ConfigError(`sandbox agent option '${key}' is outside the sanctioned dialect; allowed: ` + [...SANDBOX_AGENT_OPT_KEYS].sort().join(", "));
+					for (const key of Object.keys(rawOpts)) if (!SANDBOX_AGENT_OPT_KEY_SET.has(key)) throw new ConfigError(`sandbox agent option '${key}' is outside the sanctioned dialect; allowed: ` + [...SANDBOX_AGENT_OPT_KEYS].sort().join(", "));
 					if (rawOpts.tools !== void 0) {
 						const tools = rawOpts.tools;
 						if (!(Array.isArray(tools) && tools.every((v) => typeof v === "string"))) throw new ConfigError("sandbox agent tools must be registered profile NAMES");
@@ -13682,4 +13846,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_DEPTH, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DedupIndex, EMIT_RESULT_TOOL, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EventBus, ExternalRegistry, 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, 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, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, 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, 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, hashRunArgs, hashWorkflowBody, hashWorkflowSource, identityJcs, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lexShellCommand, liftRetainedParts, lineageWeightOf, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, mergeUsageLimits, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, parallelScope, parseModelRef, parseScopePath, phiInitialOf, pipelineScope, planNodeScope, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, readTerminationInit, registryKeyRing, remeasureQueue, replayDisposition, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, 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, validateSchemaSpec, validateTerminationLimits, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

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