@rulvar/core 1.21.0 → 1.23.0

package/dist/index.d.ts

@@ -799,6 +799,18 @@ 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;
 };
 type RunFilter = {
   status?: string;
@@ -917,6 +929,15 @@ declare function sanitizeUsageDelta(delta: Usage): Usage;
 */
 declare function sanitizeUsage(usage: Usage): Usage;
 //#endregion
+//#region src/l0/terminal.d.ts
+/**
+* Neutralizes terminal control sequences and control characters in one
+* untrusted string, collapsing each remaining control run to a single
+* space so a value can never inject a newline, an escape sequence, or a
+* hidden byte into a rendered line. Visible text is preserved.
+*/
+declare function sanitizeTerminalText(text: string): string;
+//#endregion
 //#region src/vendor/standard-schema.d.ts
 // Vendored from @standard-schema/spec@1.1.0 (MIT, Copyright (c) 2024 Colin
 // McDonnell), file dist/index.d.ts, byte-identical below this header.
@@ -4301,7 +4322,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";
   /**
@@ -5076,7 +5104,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
@@ -6412,12 +6447,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;
 }
@@ -6435,6 +6489,7 @@ declare class EventBus {
   private readonly listeners;
   private seq;
   private ended;
+  private listenerErrorReported;
   constructor(options: {
     runId: string;
     spans: SpanRegistry;
@@ -6445,8 +6500,27 @@ 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 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, {
     type: T;
   }>) => void): () => void;
@@ -6517,6 +6591,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, 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, 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

@@ -646,6 +646,47 @@ function sanitizeUsage(usage) {
 	return out;
 }
 //#endregion
+//#region src/l0/terminal.ts
+/**
+* Terminal output hygiene (v1.21.0 review P2-1): the rendering-boundary
+* counterpart to maskSecrets. Any UNTRUSTED string a terminal renderer
+* interpolates into a line, provider error messages, tool names, model
+* ids, workflow and label metadata, and log text, can carry control
+* characters and escape sequences that rewrite the screen, recolor to
+* hide forged text, set the window title, drive the clipboard on some
+* terminals, or inject fresh newlines that forge CI log structure.
+* Secret masking does not address this: it targets credential SHAPES,
+* not control bytes.
+*
+* Every line-oriented renderer passes each dynamic value through
+* `sanitizeTerminalText` BEFORE interpolation, and adds its own SGR
+* styling only afterward, so the renderer's own colors survive while
+* nothing an adapter or tool emitted can reach the terminal as a control
+* sequence. The guarantee after sanitization: the result contains no
+* byte in `U+0000..U+001F`, `U+007F..U+009F` (C0, DEL, and the C1 range
+* including every 8-bit sequence introducer), and no ESC-initiated
+* CSI/OSC/DCS/SOS/PM/APC sequence.
+*
+* The patterns are built from escaped codepoints (never literal control
+* bytes in the source) and applied in order: string sequences first (so
+* their printable payload leaves with them), then CSI, then any
+* remaining control run collapses to one space. An unterminated or
+* partial sequence loses its introducer in the final pass, which
+* de-fangs it.
+*/
+const ESC_STRING_SEQUENCE = /* @__PURE__ */ new RegExp("(?:\\u001B[\\]PX^_]|[\\u009D\\u0090\\u0098\\u009E\\u009F])[\\s\\S]*?(?:\\u0007|\\u001B\\\\|\\u009C)", "gu");
+const ESC_CSI_SEQUENCE = /* @__PURE__ */ new RegExp("(?:\\u001B\\[|\\u009B)[\\u0030-\\u003F]*[\\u0020-\\u002F]*[\\u0040-\\u007E]", "gu");
+const CONTROL_RUN = /* @__PURE__ */ new RegExp("[\\u0000-\\u001F\\u007F-\\u009F]+", "gu");
+/**
+* Neutralizes terminal control sequences and control characters in one
+* untrusted string, collapsing each remaining control run to a single
+* space so a value can never inject a newline, an escape sequence, or a
+* hidden byte into a rendered line. Visible text is preserved.
+*/
+function sanitizeTerminalText(text) {
+	return text.replace(ESC_STRING_SEQUENCE, "").replace(ESC_CSI_SEQUENCE, "").replace(CONTROL_RUN, " ");
+}
+//#endregion
 //#region src/vendor/json-schema/deep-compare-strict.ts
 function deepCompareStrict(a, b) {
 	const typeofa = typeof a;
@@ -5414,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;
 /**
@@ -5457,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);
 			}
 		}
 	}
@@ -5703,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 = {
@@ -5884,7 +5939,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 = {
@@ -8201,7 +8256,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,
@@ -10323,6 +10378,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
@@ -10858,14 +10933,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,
@@ -10897,15 +10981,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);
@@ -11465,7 +11556,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;
@@ -11546,8 +11637,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({
@@ -11563,7 +11658,7 @@ function createCtx(internals, rootWorkflow) {
 				}
 			});
 			verdict = decision.verdict;
-			await internals.replayer.appendSinglePhase({
+			decisionEntrySeq = (await internals.replayer.appendSinglePhase({
 				scope: state.scope,
 				key: "",
 				kind: "decision",
@@ -11577,10 +11672,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) {
@@ -12111,7 +12224,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);
@@ -12155,15 +12268,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, {
@@ -12314,7 +12443,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",
@@ -12366,24 +12505,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
@@ -12686,12 +12828,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);
@@ -12713,13 +12870,15 @@ var EventBus = class {
 	maskEvents;
 	subscribers = /* @__PURE__ */ new Set();
 	listeners = /* @__PURE__ */ new Set();
-	seq = 0;
+	seq;
 	ended = false;
+	listenerErrorReported = false;
 	constructor(options) {
 		this.runId = options.runId;
 		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);
@@ -12733,10 +12892,41 @@ var EventBus = class {
 			...replayed === true ? { replayed: true } : {},
 			...safeBody
 		};
-		for (const listener of this.listeners) listener(event);
+		let listenerFailure;
+		let sawListenerFailure = false;
+		for (const listener of this.listeners) try {
+			listener(event);
+		} catch (thrown) {
+			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 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;
+		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))
+		}, spanId);
+	}
 	on(type, cb) {
 		const listener = (event) => {
 			if (event.type === type) cb(event);
@@ -12940,12 +13130,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;
@@ -13024,7 +13217,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,
@@ -13070,6 +13263,7 @@ function createEngine(options) {
 		const putMeta = (status) => 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 },
@@ -13257,6 +13451,7 @@ 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,
 				previewResolve
 			});
 		})();
@@ -13355,8 +13550,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",
@@ -13373,7 +13574,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;
@@ -13447,7 +13649,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");
@@ -13610,4 +13812,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, 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, 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.21.0",
+  "version": "1.23.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",