@rulvar/core 1.240.0 → 1.242.0

package/dist/index.d.ts

@@ -1122,6 +1122,16 @@ type JournalEntry = {
     cap?: number;
   };
   /**
+  * Terminal agent entries whose invocation was aborted by the host's
+  * finish rejection (RV3702): the declared finish contract rejected
+  * the candidate past its repair bound, so the span died by host
+  * hand with its wires fine. Stamped at settle from the typed abort
+  * reason; never on a defective (throwing) validator, whose abort
+  * carries its own reason, because a host defect is not a verdict on
+  * the candidate. Policy, never identity, exactly like usageByModel.
+  */
+  hostRejected?: boolean;
+  /**
   * Terminal escalated entries ONLY: the schema-validated
   * EscalationReport with runtime-filled costToDate and salvage; replay
   * synthesizes the byte-identical report from here (DEF-1).
@@ -2599,6 +2609,15 @@ type AgentEvents = {
   */
   retryCount?: number;
   /**
+  * Present and true when the invocation was aborted by the host's
+  * finish rejection (RV3702): the declared finish contract
+  * rejected the candidate past its repair bound. Journaled on the
+  * terminal agent entry (unlike retryCount), so a replayed
+  * agent:end carries it too and both surfaces of the RV3404 cut
+  * read the same count.
+  */
+  hostRejected?: boolean;
+  /**
   * The exploration guard counters (RV-210). Present live whenever
   * any exploration guard limit was configured for the invocation;
   * on replay present only when the guard abort journaled it in the
@@ -3826,6 +3845,8 @@ interface TerminalPatch {
     used: number;
     cap?: number;
   };
+  /** Terminal agent entries: the host finish rejection stamp (RV3702); see JournalEntry. */
+  hostRejected?: boolean;
   /** Terminal escalated entries: the validated EscalationReport. */
   escalation?: unknown;
   /**
@@ -6428,6 +6449,8 @@ interface BudgetAccountView {
   finalizeReserveUsd: number;
   /** The synthesis payload hold (cycle 76); zero when none is committed. */
   synthesisReserveUsd: number;
+  /** The repair round's verdict hold (RV3701); zero when none is committed. */
+  convergenceReserveUsd: number;
   parentScope?: string;
 }
 /**
@@ -6727,6 +6750,28 @@ declare class RunBudget {
   commitSynthesisReserve(scope: string, reserveUsd: number): void;
   /** The synthesis dispatch consumes its reserve; see commitSynthesisReserve. */
   releaseSynthesisReserve(scope: string): void;
+  /**
+  * Registers the repair round's verdict reserve (RV3701, the third
+  * comparison experiment's arc): absolute dollars held on the
+  * orchestrator account AND the run root for the verdict pass (the
+  * round's second judge invocation) that must follow a DISPATCHED
+  * claim repair round. The third comparison run
+  * proved the round's two invocation tail is only as convergent as
+  * the money left when the candidate materializes; with the verdict
+  * money held from the moment the round is admitted, the round's own
+  * repair turns (the layer-2b clamp prices output from a remainder
+  * this hold shrinks) and any concurrent admission (the hold joins
+  * the projected admission sum) cannot eat it, so a round the budget
+  * can only START is refused before any wire call instead of being
+  * paid for and left unjudgeable. Exactly the synthesis reserve
+  * mechanics: released to the invocation it was held FOR (the
+  * verdict pass dispatch), never joined to the severing check.
+  * Idempotent per account: registering again adjusts the root by the
+  * delta.
+  */
+  commitConvergenceReserve(scope: string, reserveUsd: number): void;
+  /** The verdict pass dispatch consumes its reserve; see commitConvergenceReserve. */
+  releaseConvergenceReserve(scope: string): void;
   /** The reserve is replaced by real spend when the spawn settles. */
   releaseReserve(reserveUsd: number, accountScope?: string): void;
   /**
@@ -10016,6 +10061,15 @@ interface OrchestrateAcceptance {
 /** How many rejected finishes are repaired by default: the plan's repair once. */
 declare const DEFAULT_FINISH_MAX_REPAIRS = 1;
 /**
+* Character cap of the HOST VALIDATION LESSONS prompt block (RV3603):
+* the bounded repair round's prompt folds the run's journaled finish
+* validation failures so the round does not relearn a lesson the run
+* already bought, and a pathological history must not flood the
+* composition context. Rows keep journal order; the tail is dropped
+* and the block names how many rows it dropped.
+*/
+declare const FINISH_LESSON_CAP_CHARS = 2e3;
+/**
 * Default maxTurns of the synthesize invocation (RV-211): the finish
 * call plus headroom for one validator repair exchange.
 */
@@ -10038,7 +10092,8 @@ declare const DEFAULT_CLAIM_JUDGE_MAX_TURNS = 3;
 * finish({ result }) call first passes the configured host validators;
 * a rejection returns the failure reasons to the model as the call's
 * error tool result and the turn continues (a repair turn: the model
-* fixes the result and calls finish again), bounded by maxRepairs. A
+* fixes the result and calls finish again), bounded by maxRepairs
+* within the composition invocation (RV3602). A
 * rejection past the bound fails the run with the typed FailRunError
 * (code 'fail_run', data.source 'orchestrator_finish_validation'),
 * BEFORE the acceptance settle, so acceptance never judges a finish the
@@ -10067,7 +10122,14 @@ interface FinishValidationSpec {
   * How many rejected finishes are returned to the model for repair
   * before the run fails; a nonnegative integer, default
   * {@link DEFAULT_FINISH_MAX_REPAIRS}. Zero means the first rejected
-  * finish fails the run.
+  * finish fails the run. The bound belongs to one composition
+  * invocation (RV3602): with the bounded claim repair round armed
+  * (`claimConsistency.onFound: 'repair'`), the initial composition
+  * and the round each enter with the full bound, because the third
+  * comparison run's round inherited a spent run wide pool and its
+  * first regression was final by construction. At most two
+  * invocations exist, so the worst case is `maxRepairs + 1` judged
+  * finishes per invocation, twice.
   */
   maxRepairs?: number;
   /**
@@ -10717,10 +10779,15 @@ interface OrchestrateClaimConsistencyMeta {
   * is a clean verdict, a positive count is a disagreement that stayed
   * wherever the posture did not stop the run. The findings themselves
   * ride `claimContradictions` beside this meta on the acceptance
-  * envelope, but the meta travels ALONE onto RunOutcome, the
-  * journaled run settle, and the terminal envelope, and the
-  * 2026-08-12 comparison run settled ok/complete over a retained
-  * finding no terminal surface could count.
+  * envelope, and since RV3601 the engine lifts them onto RunOutcome,
+  * the journaled settle and `run:end` beside the meta, from the
+  * envelope or the typed error data alike: the 2026-08-12 comparison
+  * run settled ok/complete over a retained finding no terminal
+  * surface could count (this count is that fix, RV3304), then the
+  * 2026-08-13 run failed typed with the findings buried in error
+  * data while the outcome's top level read null. Only the compact
+  * terminal envelope still carries the meta alone, this count
+  * standing in for the details.
   */
   findings?: number;
   /**
@@ -11881,6 +11948,17 @@ declare function executeWorkflow<A, R>(internals: RunInternals, wf: Workflow<A,
 //#endregion
 //#region src/engine/cost-report.d.ts
 /**
+* The named fallback bucket of the attribution folds (RV3604): an
+* absent phase, an EMPTY phase and an empty agentType all fold under
+* 'unknown' instead of minting a '' key. The third comparison run's
+* report read `byPhase {"": 5.58}` for the whole run and a '' bucket
+* beside the named agent types: the empty string passed the `??`
+* fallback, and a '' key is unaddressable in every downstream table.
+* Both builders and both live accumulation sites apply this one rule,
+* so the live report and the journal fold cannot disagree on the key.
+*/
+declare function attributionBucket(value: string | undefined): string;
+/**
 * Folds the per-run attribution buckets into the normative CostReport.
 * Live attribution buckets never see abandoned subtrees, so a host
 * that tracked abandoned spend itself passes it as `abandoned`;
@@ -11991,8 +12069,15 @@ interface CostReport {
   };
   /** Keyed by canonical ModelRef 'adapterId:model'. */
   byModel: Record<string, number>;
-  /** ctx.phase names; phase is structural for this map. */
+  /**
+  * ctx.phase names; phase is structural for this map. Spend with no
+  * phase, or an EMPTY phase, folds under the named 'unknown' bucket
+  * (RV3604): a '' key is unaddressable in every downstream table,
+  * and the third comparison run's report read `byPhase {"": 5.58}`
+  * for the whole run.
+  */
   byPhase: Record<string, number>;
+  /** Spawn agentType names; absent and empty fold under 'unknown' (RV3604). */
   byAgentType: Record<string, number>;
   byRole: Record<InvocationRole, number>;
   /**
@@ -12177,7 +12262,20 @@ type RunOutcome<R> = {
   * and the error terminal carried null: the truth now rides every
   * terminal that has it, ok and failed alike.
   */
-  claimConsistencyMeta?: Record<string, unknown>; /** The synthesis-skip marker from the same envelope; same lift and posture (RV2203). */
+  claimConsistencyMeta?: Record<string, unknown>;
+  /**
+  * The judged contradictions themselves (RV3601), lifted from the
+  * same envelope or typed error data as the meta beside them. RV3304
+  * deliberately kept the details off this surface and let the meta's
+  * `findings` count stand in; the 2026-08-13 comparison run then
+  * failed typed with the findings buried in `error.data` while the
+  * outcome's top level read null beside a null meta, so the details
+  * now ride wherever the meta rides (this outcome, the journaled
+  * settle, `run:end`), the compact terminal envelope alone keeping
+  * the meta only. `[]` is the judge's claim of a clean document;
+  * absence means nothing was judged (RV1209).
+  */
+  claimContradictions?: Record<string, unknown>[]; /** The synthesis-skip marker from the same envelope; same lift and posture (RV2203). */
   synthesisSkipped?: boolean | string;
   /**
   * Whether the artifact THIS terminal carries was accepted by the
@@ -13568,6 +13666,35 @@ interface JournaledCriticalPath {
   /** Settled judge-side synthesize spans, counted; same condition. */
   judgeSpans?: number;
   /**
+  * First stamp to the FIRST settled composition-side span's end
+  * (RV3605): when a candidate deliverable first existed, readable
+  * from the archive. The third comparison run held a mechanically
+  * accepted candidate 25 minutes before it lost typed, and the only
+  * route to that fact was a span dig. Needs everything the wall
+  * needs (one segment) plus everything the split needs (every
+  * synthesize span labelled, or the milestone would count a judge as
+  * a candidate); absent otherwise, never guessed.
+  */
+  firstCandidateMs?: number;
+  /**
+  * First stamp to the LAST settled composition-side span's end; same
+  * conditions. Time to the accepted deliverable exactly when the
+  * terminal says `deliverableAccepted: true`; on a failed run it is
+  * when the last LOSING candidate settled, so pair it with the
+  * acceptance verdict and never read it as a win on an error
+  * terminal.
+  */
+  lastCandidateMs?: number;
+  /**
+  * Settled agent spans whose invocation was aborted by the host's
+  * finish rejection (RV3702): the journaled `hostRejected` stamps
+  * counted. Unconditional (the stamp is self contained: no label, no
+  * segment condition) and zero when none, exactly the live reading
+  * of the same run: the layer split (wires fine, document refused by
+  * host) stays readable years after the process exited.
+  */
+  hostRejectedSpans: number;
+  /**
   * The window itemization a journal CAN answer (RV3404); present
   * exactly when `postFanInMs` is.
   */
@@ -13852,6 +13979,28 @@ interface PinnedPricingSegment {
   pricingVersion?: string;
   /** The applied rows THIS settle pinned. */
   rows: AppliedPricingRow[];
+  /**
+  * sha256 over the canonical JSON of THIS pin's rows (RV3703): the
+  * version string is a label the table author chose, and the third
+  * experiment's arc found a price defect that a label cannot expose;
+  * the hash is the content. Two tables sharing a version string but
+  * disagreeing on rates are distinguishable, and two folds of one
+  * journal always derive the same hex. Computed at read time from
+  * the pinned bytes: the journal is unchanged and every existing pin
+  * gains it.
+  */
+  rowsHash: string;
+  /**
+  * The freshness range of THIS pin's dated rows (RV3703): the oldest
+  * and newest `ratesVerifiedAt` among rows carrying a parsable one,
+  * the machine-readable age of the table that priced the segment.
+  * Absent when no row is dated: freshness is then unattested, never
+  * guessed.
+  */
+  ratesVerifiedAt?: {
+    oldest: string;
+    newest: string;
+  };
 }
 /** What `journalPricingSnapshot` rebuilds from a pinned run settle. */
 interface JournalPricingSnapshot {
@@ -13859,6 +14008,16 @@ interface JournalPricingSnapshot {
   pricingVersion?: string;
   /** The last pin's rows: the union covering the whole settled journal. */
   rows: AppliedPricingRow[];
+  /** The last pin's content hash (RV3703); see PinnedPricingSegment.rowsHash. */
+  rowsHash: string;
+  /**
+  * The last pin's freshness range (RV3703); see the per-segment
+  * field. Absent when no row of the last pin is dated.
+  */
+  ratesVerifiedAt?: {
+    oldest: string;
+    newest: string;
+  };
   /**
   * The seq of the last pinning settle: rows at or past it belong to a
   * segment no pin covers yet, so a caller composing with a live table
@@ -14665,7 +14824,13 @@ interface PreflightOrchestratorSpec {
     * before the first wire, not the journal after the last. Pairings
     * orchestrate() refuses at intake (repair at the draft stage,
     * repair without a synthesis, carry at the final stage, RV3301)
-    * surface as error findings: the run would refuse to start.
+    * surface as error findings: the run would refuse to start. This
+    * static arithmetic has a runtime twin (RV3701): at the moment a
+    * round actually dispatches, the engine holds the money of the round's second judge pass
+    * (this same `judge.estCost` first, else the run's own observed
+    * post draft judge price) until that pass admits, so the
+    * declared estimate is not only judged before the run but enforced
+    * inside it.
     */
     onFound?: "report" | "carry" | "fail" | "repair";
     /**
@@ -14759,7 +14924,13 @@ interface PreflightInput {
     * the mandatory synthesis tail (RV2504): every granted repair can
     * write to the output allowance, so the tail
     * `synthesis-reserve-below-cap-composition` prices is one
-    * composition plus this many turns, whatever the turn reserve says.
+    * composition plus this many turns, whatever the turn reserve
+    * says. Since RV3602 the bound belongs to one composition
+    * invocation, so this tail is the price of EACH invocation: the
+    * armed claim repair round (RV3307) runs a second invocation with
+    * its own full bound, and the working room finding already prices
+    * that round at the declared synthesis reserve, the host's own
+    * estimate of exactly this tail.
     */
     maxRepairs?: number;
     /**
@@ -15480,6 +15651,14 @@ interface AgentInvocationRow {
   replayed: boolean;
   /** True when the span's agent:end never arrived. */
   open: boolean;
+  /**
+  * Present and true when the invocation was aborted by the host's
+  * finish rejection (RV3702): the declared finish contract rejected
+  * the candidate past its repair bound, so the span died by host
+  * hand with its wires fine. From the agent:end stamp; absent
+  * everywhere else.
+  */
+  hostRejected?: boolean;
   phases: PhaseRow[];
 }
 /** The reduced table plus the per-role aggregate across every span. */
@@ -15563,12 +15742,42 @@ interface CriticalPath {
   compositionSpans: number;
   /** Completed judge-side synthesize spans, counted (RV3404). */
   judgeSpans: number;
+  /**
+  * run:start to the FIRST completed composition-side synthesize
+  * span's end (RV3605): when a candidate deliverable first existed.
+  * The third comparison run held a mechanically accepted candidate
+  * from its 103rd journal seq onward and lost typed 25 minutes
+  * later; nothing on any surface said when the latent document
+  * materialized, and the judge had to dig spans by hand. Absent
+  * without a run:start or a completed composition span, and live
+  * fidelity like every wall figure here.
+  */
+  firstCandidateMs?: number;
+  /**
+  * run:start to the LAST completed composition-side span's end
+  * (RV3605). On a run whose terminal carries `deliverableAccepted:
+  * true` this is when the accepted composition settled, the time to
+  * accepted deliverable; on a failed run it is when the last LOSING
+  * candidate settled, so pair it with the acceptance verdict and
+  * never read it as a win on an error terminal (the comparison rule
+  * the third experiment wrote down).
+  */
+  lastCandidateMs?: number;
   /** postFanInMs / runWallMs when both are defined and the wall is > 0. */
   postFanInShare?: number;
   /** synthesisMs / runWallMs under the same conditions. */
   synthesisShare?: number;
   /** Settled non-coordination agent spans that anchored the fan-in. */
   workerSpans: number;
+  /**
+  * Settled spans whose invocation was aborted by the host's finish
+  * rejection (RV3702): the `hostRejected` stamps counted. The count
+  * is unconditional (the stamp is self contained, no labelling
+  * condition applies) and zero when none: on the third comparison
+  * run's shape it reads 1, the round's composition, telling the host
+  * rejection apart from a provider death at the cut level.
+  */
+  hostRejectedSpans: number;
   /** The RV710 decomposition of the window; present with postFanInMs. */
   postFanIn?: PostFanInBreakdown;
 }
@@ -15783,4 +15992,4 @@ interface SandboxBridge {
 declare const SANDBOX_AGENT_OPT_KEYS: readonly string[];
 declare function createSandboxBridge(ctx: Ctx<never>, options: SandboxBridgeOptions): SandboxBridge;
 //#endregion
-export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BillingComponent, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CachePolicy, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, ChildrenAtFailure, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DelimitedStatementOptions, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, JournaledChild, JournaledChildRoster, JournaledCriticalPath, JournaledPostFanIn, JournaledSynthesisCandidate, JournaledSynthesisCandidateReport, 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, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, OutputContractManifest, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RejectedFinishCandidate, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, SynthesisCandidateFailure, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TelemetryScope, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminalTelemetryScopes, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCalibrationExclusion, ToolCalibrationReport, ToolCalibrationRow, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, 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, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BillingComponent, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CachePolicy, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, ChildrenAtFailure, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DelimitedStatementOptions, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, JournaledChild, JournaledChildRoster, JournaledCriticalPath, JournaledPostFanIn, JournaledSynthesisCandidate, JournaledSynthesisCandidateReport, 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, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, OutputContractManifest, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RejectedFinishCandidate, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, SynthesisCandidateFailure, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TelemetryScope, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminalTelemetryScopes, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCalibrationExclusion, ToolCalibrationReport, ToolCalibrationRow, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, 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, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -7972,6 +7972,7 @@ var Replayer = class {
 			if (patch.evidence !== void 0) entry.evidence = patch.evidence;
 			if (patch.evidenceEntries !== void 0) entry.evidenceEntries = patch.evidenceEntries;
 			if (patch.toolBudget !== void 0) entry.toolBudget = patch.toolBudget;
+			if (patch.hostRejected !== void 0) entry.hostRejected = patch.hostRejected;
 			if (patch.artifacts !== void 0) entry.artifacts = toJournalValue(patch.artifacts, "terminal artifacts");
 			if (patch.escalation !== void 0) entry.escalation = toJournalValue(patch.escalation, "escalation report");
 			if (patch.memoizeOutcome !== void 0) entry.memoizeOutcome = patch.memoizeOutcome;
@@ -8936,6 +8937,7 @@ const TERMINAL_TELEMETRY_SCOPE = Object.freeze({
 	childrenAtFailure: "cumulative",
 	semanticPasses: "terminal",
 	claimConsistencyMeta: "terminal",
+	claimContradictions: "terminal",
 	synthesisSkipped: "terminal",
 	deliverableAccepted: "terminal",
 	resultAvailable: "terminal",
@@ -9310,6 +9312,7 @@ function reduceInvocationTable(events) {
 			row.usageApprox = event.usageApprox === true;
 			row.retryCount = event.retryCount ?? 0;
 			if (event.toolBudget !== void 0) row.toolBudget = event.toolBudget;
+			if (event.hostRejected === true) row.hostRejected = true;
 			totalCostUsd += event.costUsd;
 			break;
 		}
@@ -9330,6 +9333,20 @@ function reduceInvocationTable(events) {
 */
 const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
 /**
+* The live abort reason of a finish rejection (RV3702): the value
+* `orchestrate()` aborts a composition invocation's signal with when
+* the declared finish contract rejects its candidate past the repair
+* bound, and ONLY then; a defective (throwing) validator aborts with
+* its own distinct reason, because a host defect is not a verdict on
+* the candidate. The settle layer reads the reason back and stamps
+* `hostRejected` onto the terminal agent entry and the live
+* `agent:end` event, so both span surfaces can tell a host rejection
+* (wires fine, document refused) from a provider failure without a
+* journal dig; the third comparison run's reader had exactly that
+* span (two successful wires, span cancelled) and nothing to name it.
+*/
+const FINISH_REJECTION_ABORT_REASON = "rulvar:finish-validation";
+/**
 * Whether a synthesize span's label names a claim-consistency judge
 * invocation: the exact {@link CLAIM_JUDGE_LABEL}, or a suffixed
 * variant of it (the final pass dispatches under
@@ -9412,6 +9429,9 @@ function reduceCriticalPath(events) {
 	let finalJudgeMs = 0;
 	let compositionSpans = 0;
 	let judgeSpans = 0;
+	let hostRejectedSpans = 0;
+	let firstCompositionEnd;
+	let lastCompositionEnd;
 	const coordinationModel = [];
 	const coordinationTools = [];
 	const synthesisSpans = [];
@@ -9450,6 +9470,7 @@ function reduceCriticalPath(events) {
 			case "agent:end": {
 				const started = startBySpan.get(event.spanId);
 				if (started === void 0) break;
+				if (event.hostRejected === true) hostRejectedSpans += 1;
 				if (started.role === "synthesize") {
 					const wall = Math.max(0, at - started.at);
 					const stage = claimJudgeStageOf(started.label);
@@ -9463,6 +9484,8 @@ function reduceCriticalPath(events) {
 					} else {
 						finalCompositionMs += wall;
 						compositionSpans += 1;
+						firstCompositionEnd = firstCompositionEnd === void 0 ? at : firstCompositionEnd;
+						lastCompositionEnd = lastCompositionEnd === void 0 ? at : Math.max(lastCompositionEnd, at);
 					}
 					synthesisSpans.push({
 						from: started.at,
@@ -9486,9 +9509,12 @@ function reduceCriticalPath(events) {
 		finalJudgeMs,
 		compositionSpans,
 		judgeSpans,
-		workerSpans
+		workerSpans,
+		hostRejectedSpans
 	};
 	if (runStart !== void 0 && runEnd !== void 0) path.runWallMs = Math.max(0, runEnd - runStart);
+	if (runStart !== void 0 && firstCompositionEnd !== void 0) path.firstCandidateMs = Math.max(0, firstCompositionEnd - runStart);
+	if (runStart !== void 0 && lastCompositionEnd !== void 0) path.lastCandidateMs = Math.max(0, lastCompositionEnd - runStart);
 	if (runEnd !== void 0 && lastWorkerEnd !== void 0) {
 		path.postFanInMs = Math.max(0, runEnd - lastWorkerEnd);
 		const windowFrom = Math.min(lastWorkerEnd, runEnd);
@@ -9576,6 +9602,7 @@ function criticalPathFromJournal(entries) {
 	let lastWorkerEnd;
 	let workerSpans = 0;
 	let unclassifiedSpans = 0;
+	let hostRejectedSpans = 0;
 	let synthesisMs = 0;
 	let finalCompositionMs = 0;
 	let semanticJudgeMs = 0;
@@ -9583,6 +9610,8 @@ function criticalPathFromJournal(entries) {
 	let finalJudgeMs = 0;
 	let compositionSpans = 0;
 	let judgeSpans = 0;
+	let firstCompositionEnd;
+	let lastCompositionEnd;
 	let labelledSynthesis = false;
 	let unlabelledSynthesis = false;
 	const synthSpans = [];
@@ -9593,6 +9622,7 @@ function criticalPathFromJournal(entries) {
 		const last = endedAt ?? startedAt;
 		if (last !== void 0) runEnd = runEnd === void 0 ? last : Math.max(runEnd, last);
 		if (entry.kind !== "agent" || entry.status === "running" || entry.status === "suspended") continue;
+		if (entry.hostRejected === true) hostRejectedSpans += 1;
 		const role = entry.costAttribution?.role;
 		if (role === void 0) {
 			unclassifiedSpans += 1;
@@ -9626,6 +9656,8 @@ function criticalPathFromJournal(entries) {
 		} else {
 			finalCompositionMs += wall;
 			compositionSpans += 1;
+			firstCompositionEnd = firstCompositionEnd === void 0 ? endedAt : Math.min(firstCompositionEnd, endedAt);
+			lastCompositionEnd = lastCompositionEnd === void 0 ? endedAt : Math.max(lastCompositionEnd, endedAt);
 		}
 		synthSpans.push({
 			from: startedAt,
@@ -9638,7 +9670,8 @@ function criticalPathFromJournal(entries) {
 		workerSpans,
 		synthesisMs,
 		unclassifiedSpans,
-		segments
+		segments,
+		hostRejectedSpans
 	};
 	const splitLegible = labelledSynthesis && !unlabelledSynthesis;
 	if (splitLegible) {
@@ -9651,6 +9684,8 @@ function criticalPathFromJournal(entries) {
 	}
 	if (segments > 1 || runStart === void 0 || runEnd === void 0) return path;
 	path.runWallMs = Math.max(0, runEnd - runStart);
+	if (splitLegible && firstCompositionEnd !== void 0) path.firstCandidateMs = Math.max(0, firstCompositionEnd - runStart);
+	if (splitLegible && lastCompositionEnd !== void 0) path.lastCandidateMs = Math.max(0, lastCompositionEnd - runStart);
 	if (lastWorkerEnd !== void 0) {
 		path.postFanInMs = Math.max(0, runEnd - lastWorkerEnd);
 		const windowFrom = Math.min(lastWorkerEnd, runEnd);
@@ -14862,6 +14897,7 @@ var RunBudget = class {
 			committedReserveUsd: 0,
 			finalizeReserveUsd: 0,
 			synthesisReserveUsd: 0,
+			convergenceReserveUsd: 0,
 			controller: new AbortController()
 		};
 		if (options.ceilingUsd !== void 0) root.ceilingUsd = options.ceilingUsd;
@@ -14912,6 +14948,7 @@ var RunBudget = class {
 			committedReserveUsd: 0,
 			finalizeReserveUsd: options.finalizeReserveUsd ?? 0,
 			synthesisReserveUsd: 0,
+			convergenceReserveUsd: 0,
 			parentScope,
 			controller: new AbortController()
 		};
@@ -15012,7 +15049,8 @@ var RunBudget = class {
 			spentUsd: account.spentUsd,
 			committedReserveUsd: account.committedReserveUsd,
 			finalizeReserveUsd: account.finalizeReserveUsd,
-			synthesisReserveUsd: account.synthesisReserveUsd
+			synthesisReserveUsd: account.synthesisReserveUsd,
+			convergenceReserveUsd: account.convergenceReserveUsd
 		};
 		if (account.ceilingUsd !== void 0) view.ceilingUsd = account.ceilingUsd;
 		if (account.parentScope !== void 0) view.parentScope = account.parentScope;
@@ -15026,7 +15064,7 @@ var RunBudget = class {
 	remainderOf(scope) {
 		const account = this.accounts.get(scope);
 		if (account?.ceilingUsd === void 0) return;
-		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd);
+		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd - account.convergenceReserveUsd);
 	}
 	/**
 	* The tightest allowance headroom on the chain of `scope`: the minimum
@@ -15106,15 +15144,16 @@ var RunBudget = class {
 		}
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd + account.synthesisReserveUsd;
+			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd + account.synthesisReserveUsd + account.convergenceReserveUsd;
 			if (committed >= account.ceilingUsd || committed + reserveUsd > account.ceilingUsd) {
 				if (account.scope === "run") this.exhaustedInternal = true;
-				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD ` + (account.synthesisReserveUsd > 0 ? `plus the held synthesis reserve ${account.synthesisReserveUsd.toFixed(4)} USD ` : "") + `plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
+				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD ` + (account.synthesisReserveUsd > 0 ? `plus the held synthesis reserve ${account.synthesisReserveUsd.toFixed(4)} USD ` : "") + (account.convergenceReserveUsd > 0 ? `plus the held convergence reserve ${account.convergenceReserveUsd.toFixed(4)} USD ` : "") + `plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
 					account: account.scope,
 					spentUsd: account.spentUsd,
 					committedReserveUsd: account.committedReserveUsd,
 					finalizeReserveUsd: account.finalizeReserveUsd,
 					synthesisReserveUsd: account.synthesisReserveUsd,
+					convergenceReserveUsd: account.convergenceReserveUsd,
 					proposedReserveUsd: reserveUsd,
 					ceilingUsd: account.ceilingUsd
 				} });
@@ -15206,6 +15245,41 @@ var RunBudget = class {
 		account.synthesisReserveUsd = 0;
 		this.emitUpdate();
 	}
+	/**
+	* Registers the repair round's verdict reserve (RV3701, the third
+	* comparison experiment's arc): absolute dollars held on the
+	* orchestrator account AND the run root for the verdict pass (the
+	* round's second judge invocation) that must follow a DISPATCHED
+	* claim repair round. The third comparison run
+	* proved the round's two invocation tail is only as convergent as
+	* the money left when the candidate materializes; with the verdict
+	* money held from the moment the round is admitted, the round's own
+	* repair turns (the layer-2b clamp prices output from a remainder
+	* this hold shrinks) and any concurrent admission (the hold joins
+	* the projected admission sum) cannot eat it, so a round the budget
+	* can only START is refused before any wire call instead of being
+	* paid for and left unjudgeable. Exactly the synthesis reserve
+	* mechanics: released to the invocation it was held FOR (the
+	* verdict pass dispatch), never joined to the severing check.
+	* Idempotent per account: registering again adjusts the root by the
+	* delta.
+	*/
+	commitConvergenceReserve(scope, reserveUsd) {
+		const account = this.accounts.get(scope);
+		if (account === void 0) throw new ConfigError(`unknown budget account '${scope}' for the convergence reserve`);
+		const previous = account.convergenceReserveUsd;
+		account.convergenceReserveUsd = reserveUsd;
+		if (account.scope !== "run") this.root.convergenceReserveUsd = Math.max(0, this.root.convergenceReserveUsd + reserveUsd - previous);
+		this.emitUpdate();
+	}
+	/** The verdict pass dispatch consumes its reserve; see commitConvergenceReserve. */
+	releaseConvergenceReserve(scope) {
+		const account = this.accounts.get(scope);
+		if (account === void 0 || account.convergenceReserveUsd === 0) return;
+		if (account.scope !== "run") this.root.convergenceReserveUsd = Math.max(0, this.root.convergenceReserveUsd - account.convergenceReserveUsd);
+		account.convergenceReserveUsd = 0;
+		this.emitUpdate();
+	}
 	/** The reserve is replaced by real spend when the spawn settles. */
 	releaseReserve(reserveUsd, accountScope = "run") {
 		for (const account of this.chainOf(accountScope)) account.committedReserveUsd = Math.max(0, account.committedReserveUsd - reserveUsd);
@@ -15413,7 +15487,7 @@ var RunBudget = class {
 		let remaining;
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd;
+			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd - account.convergenceReserveUsd;
 			remaining = remaining === void 0 ? headroom : Math.min(remaining, headroom);
 		}
 		return remaining === void 0 ? void 0 : Math.max(0, remaining);
@@ -15634,6 +15708,28 @@ function isOrchestratorAccount(scope) {
 	return scope === "orchestrator" || scope.endsWith("/orchestrator");
 }
 /**
+* The named fallback bucket of the attribution folds (RV3604): an
+* absent phase, an EMPTY phase and an empty agentType all fold under
+* 'unknown' instead of minting a '' key. The third comparison run's
+* report read `byPhase {"": 5.58}` for the whole run and a '' bucket
+* beside the named agent types: the empty string passed the `??`
+* fallback, and a '' key is unaddressable in every downstream table.
+* Both builders and both live accumulation sites apply this one rule,
+* so the live report and the journal fold cannot disagree on the key.
+*/
+function attributionBucket(value) {
+	return value === void 0 || value === "" ? "unknown" : value;
+}
+/** {@link attributionBucket} over a whole live map, merging folded keys. */
+function foldBuckets(source) {
+	const folded = {};
+	for (const [key, usd] of source) {
+		const bucket = attributionBucket(key);
+		folded[bucket] = (folded[bucket] ?? 0) + usd;
+	}
+	return folded;
+}
+/**
 * Folds the per-run attribution buckets into the normative CostReport.
 * Live attribution buckets never see abandoned subtrees, so a host
 * that tracked abandoned spend itself passes it as `abandoned`;
@@ -15661,8 +15757,8 @@ function buildCostReport(attribution, totalUsd, abandoned = {
 		grossUsd: totalUsd + abandoned.usd,
 		abandoned,
 		byModel: Object.fromEntries(attribution.byModel),
-		byPhase: Object.fromEntries(attribution.byPhase),
-		byAgentType: Object.fromEntries(attribution.byAgentType),
+		byPhase: foldBuckets(attribution.byPhase),
+		byAgentType: foldBuckets(attribution.byAgentType),
 		byRole,
 		orchestrator: {
 			...orchestrator,
@@ -15727,9 +15823,9 @@ function costReportFromJournal(entries, priceUsd) {
 		totalUsd += priced.usd;
 		if (entry.usageApprox === true) usageApprox = true;
 		const facts = entry.costAttribution;
-		const phase = facts?.phase ?? "";
+		const phase = attributionBucket(facts?.phase);
 		byPhase[phase] = (byPhase[phase] ?? 0) + priced.usd;
-		const agentType = facts?.agentType ?? "unknown";
+		const agentType = attributionBucket(facts?.agentType);
 		byAgentType[agentType] = (byAgentType[agentType] ?? 0) + priced.usd;
 		const primaryRole = facts?.role ?? "loop";
 		for (const unit of priced.units) byRole[unit.role ?? primaryRole] += unit.usd;
@@ -16830,6 +16926,33 @@ function persistedTerminalEnvelope(input) {
 //#endregion
 //#region src/engine/pricing-snapshot.ts
 /**
+* The applied-pricing snapshot (RV407, the eighth-experiment review).
+* `invoiceFromJournal` and `costReportFromJournal` price at fold time
+* from the table the caller passes, so a live price-table update used
+* to silently re-price HISTORY: the same journal folded to different
+* invoices before and after the change. When `createEngine({ pricing })`
+* is configured, the settling segment now pins what it actually
+* applied: the resolved pricing row of every model the journal used
+* (table rows plus the caps-fallback rows of models the table misses),
+* and the table's version, additively inside the existing run-settle
+* decision value (the `outputHash` precedent; no journal shape change).
+* The gate is deliberate: caps-fallback pricing arrives ambiently from
+* adapters, and a setting the user never enabled must not change the
+* journal, so table-less runs settle byte for byte as before.
+* `journalPricingSnapshot` reads the pin back and
+* rebuilds a `priceUsd` from the pinned rows, so a repeated fold after
+* the live table changed reproduces the original numbers exactly.
+*
+* The snapshot governs REPORTING folds (the CLI invoice and inspect
+* cost views, and any host that opts in by passing the rebuilt
+* priceUsd; since RV611 those consumers pass `composedPriceUsd`, the
+* same pin-plus-current-table composition the engine's outcome mirror
+* applies, so a stored fold and the settled outcome can never
+* disagree). The engine's own live pricing, budget admission, and the
+* journaled spend debits are untouched: they were always priced at
+* write time and never re-priced by a fold.
+*/
+/**
 * A pinnable row: every present rate is a finite non-negative number.
 * The fold already treats a broken rate as unpriced (a NaN or negative
 * price never poisons the CostReport), so the pin mirrors exactly that
@@ -16867,6 +16990,42 @@ function snapshotJournalPricing(entries, pricingOf) {
 	}
 	return rows.length === 0 ? void 0 : rows;
 }
+/**
+* The pin's content hash (RV3703): sha256 over the canonical JSON of
+* the rows, so the derivation is byte-stable across folds, engines and
+* platforms; JCS fixes the key order, and the row order is the pin's
+* own (sorted at write, preserved at read).
+*/
+function rowsHashOf(rows) {
+	return createHash("sha256").update(jcsSerialize(rows), "utf8").digest("hex");
+}
+/**
+* The freshness range of a pin's dated rows (RV3703): oldest and
+* newest parsable `ratesVerifiedAt`, original strings preserved.
+* Undefined when no row carries a parsable date.
+*/
+function ratesVerifiedRangeOf(rows) {
+	let oldest;
+	let newest;
+	for (const row of rows) {
+		const raw = row.rates.ratesVerifiedAt;
+		if (raw === void 0) continue;
+		const at = Date.parse(raw);
+		if (!Number.isFinite(at)) continue;
+		if (oldest === void 0 || at < oldest.at) oldest = {
+			at,
+			raw
+		};
+		if (newest === void 0 || at > newest.at) newest = {
+			at,
+			raw
+		};
+	}
+	return oldest === void 0 || newest === void 0 ? void 0 : {
+		oldest: oldest.raw,
+		newest: newest.raw
+	};
+}
 function pinnedRows(value) {
 	const candidate = value?.pricing;
 	if (!Array.isArray(candidate) || candidate.length === 0) return;
@@ -16918,16 +17077,24 @@ function journalPricingSnapshot(entries) {
 		const rates = ratesFor(servedBy, seq);
 		return rates === void 0 ? void 0 : priceUsdOf(rates, usage);
 	};
+	const lastRange = ratesVerifiedRangeOf(last.rows);
 	return {
 		...last.pricingVersion === void 0 ? {} : { pricingVersion: last.pricingVersion },
 		rows: last.rows,
+		rowsHash: rowsHashOf(last.rows),
+		...lastRange === void 0 ? {} : { ratesVerifiedAt: lastRange },
 		pinnedThroughSeq,
-		segments: pins.map((pin, index) => ({
-			fromSeq: index === 0 ? 0 : pins[index - 1]?.seq ?? 0,
-			settleSeq: pin.seq,
-			...pin.pricingVersion === void 0 ? {} : { pricingVersion: pin.pricingVersion },
-			rows: pin.rows
-		})),
+		segments: pins.map((pin, index) => {
+			const range = ratesVerifiedRangeOf(pin.rows);
+			return {
+				fromSeq: index === 0 ? 0 : pins[index - 1]?.seq ?? 0,
+				settleSeq: pin.seq,
+				...pin.pricingVersion === void 0 ? {} : { pricingVersion: pin.pricingVersion },
+				rows: pin.rows,
+				rowsHash: rowsHashOf(pin.rows),
+				...range === void 0 ? {} : { ratesVerifiedAt: range }
+			};
+		}),
 		priceUsd,
 		composedPriceUsd: (current) => (servedBy, usage, seq) => seq !== void 0 && seq < pinnedThroughSeq ? priceUsd(servedBy, usage, seq) ?? current(servedBy, usage) : current(servedBy, usage)
 	};
@@ -18775,6 +18942,7 @@ function createCtx(internals, rootWorkflow) {
 				costBasis: replayBasis,
 				entryRef: terminal?.seq ?? matched.running.seq,
 				...terminal?.usageApprox === true ? { usageApprox: true } : {},
+				...terminal?.hostRejected === true ? { hostRejected: true } : {},
 				...result.exploration === void 0 ? {} : { exploration: result.exploration },
 				...result.toolBudget === void 0 ? {} : { toolBudget: result.toolBudget }
 			}, spanId, true);
@@ -19503,6 +19671,8 @@ function createCtx(internals, rootWorkflow) {
 				}
 			};
 		}
+		const settleSignal = state.signal ?? internals.runSignal;
+		if (result.status !== "ok" && settleSignal?.aborted === true && settleSignal.reason === "rulvar:finish-validation") terminalPatch.hostRejected = true;
 		if (checkpointWritten) terminalPatch.checkpointRef = ckptRef;
 		const terminal = await internals.replayer.appendTerminal(running.seq, terminalPatch);
 		internals.events.emit({
@@ -19516,6 +19686,7 @@ function createCtx(internals, rootWorkflow) {
 			entryRef: terminal.seq,
 			...resultUsageApprox ? { usageApprox: true } : {},
 			...result.transportRetries !== void 0 && result.transportRetries > 0 ? { retryCount: result.transportRetries } : {},
+			...terminalPatch.hostRejected === true ? { hostRejected: true } : {},
 			...result.quotaDenials === void 0 ? {} : { quotaDenials: result.quotaDenials },
 			...result.exploration === void 0 ? {} : { exploration: result.exploration },
 			...result.toolBudget === void 0 ? {} : { toolBudget: result.toolBudget }
@@ -22592,6 +22763,15 @@ function selfTestFinishValidation(options) {
 /** How many rejected finishes are repaired by default: the plan's repair once. */
 const DEFAULT_FINISH_MAX_REPAIRS = 1;
 /**
+* Character cap of the HOST VALIDATION LESSONS prompt block (RV3603):
+* the bounded repair round's prompt folds the run's journaled finish
+* validation failures so the round does not relearn a lesson the run
+* already bought, and a pathological history must not flood the
+* composition context. Rows keep journal order; the tail is dropped
+* and the block names how many rows it dropped.
+*/
+const FINISH_LESSON_CAP_CHARS = 2e3;
+/**
 * Default maxTurns of the synthesize invocation (RV-211): the finish
 * call plus headroom for one validator repair exchange.
 */
@@ -24056,10 +24236,33 @@ function makeOrchestratorWorkflow(goal, opts) {
 			callId: decision.callId,
 			failed: decision.failed,
 			repairsUsed: decision.repairsUsed,
-			maxRepairs: decision.maxRepairs
+			maxRepairs: decision.maxRepairs,
+			...decision.candidateHash === void 0 ? {} : { candidateHash: decision.candidateHash },
+			...decision.candidateChars === void 0 ? {} : { candidateChars: decision.candidateChars }
 		} });
 		const validationDecisions = () => internals.replayer.snapshot().filter((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.value?.decisionType === "orchestrator_finish_validation").map((entry) => entry.value);
 		/**
+		* Where the CURRENT composition invocation's verdicts begin
+		* (RV3602): an index into validationDecisions(), captured from the
+		* journaled verdict count at each synthesis dispatch, so the
+		* mechanical repair pool belongs to one composition invocation.
+		* The third comparison run's initial composition spent the single
+		* run wide repair (default maxRepairs 1), so the bounded claim
+		* repair round (RV3307) entered with zero mechanical retries BY
+		* CONSTRUCTION and its first regression was final: the round was
+		* structurally doomed whenever the initial composition had used
+		* its retry. Cycle 73 scoped the pool to the contract generation;
+		* this scopes it to the invocation on the same doctrine, the pool
+		* spender must be the thing that gets the bound. Replay stable:
+		* a resume replays the identical decision prefix, so the captured
+		* index is identical. Validators bound to the coordination loop
+		* (no synthesis) keep the zero baseline: one loop, one invocation,
+		* the pre RV3602 pool byte for byte. Worst case stays bounded:
+		* at most two composition invocations exist (the initial and one
+		* RV3307 round), each granting at most maxRepairs repair turns.
+		*/
+		let validationInvocationStart = 0;
+		/**
 		* The contract generation membership test (cycle 73). Without a
 		* contract there are no generations and every decision is current
 		* (the pre 1.77 behavior, byte identical). With one, a decision
@@ -24076,6 +24279,40 @@ function makeOrchestratorWorkflow(goal, opts) {
 			return internals.replayer.snapshot().filter((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.value?.decisionType === "orchestrator_finish_validation_bundle").length <= 1;
 		};
 		/**
+		* The HOST VALIDATION LESSONS block (RV3603): the third comparison
+		* run's repair round regressed provenance, the exact class the
+		* initial composition's mechanical loop had fixed minutes earlier,
+		* because the round is a FRESH invocation with no memory of
+		* exchanges it never saw. The block folds the run's journaled
+		* finish validation failures (current contract generation only,
+		* deduplicated by validator and reasons, journal order) so the
+		* round keeps the lessons the run already paid for. Derived ONLY
+		* from journaled decisions: a resume re-derives identical bytes.
+		* Capped at {@link FINISH_LESSON_CAP_CHARS}; the dropped row count
+		* is named, never silent.
+		*/
+		const hostValidationLessons = () => {
+			const rows = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const decision of validationDecisions()) {
+				if (decision.failed.length === 0 || !contractGenerationCurrent(decision)) continue;
+				for (const failure of decision.failed) {
+					const key = JSON.stringify([failure.name, failure.reasons]);
+					if (seen.has(key)) continue;
+					seen.add(key);
+					rows.push({
+						validator: failure.name,
+						reasons: failure.reasons
+					});
+				}
+			}
+			if (rows.length === 0) return [];
+			let kept = rows.length;
+			while (kept > 1 && JSON.stringify(rows.slice(0, kept)).length > 2e3) kept -= 1;
+			const dropped = rows.length - kept;
+			return ["HOST VALIDATION LESSONS: earlier composition attempts in this run failed the declared finish contract exactly so; keep the repaired result clear of these failures while resolving the contradictions. " + JSON.stringify(rows.slice(0, kept)) + (dropped === 0 ? "" : ` (${String(dropped)} lesson row${dropped === 1 ? "" : "s"} truncated)`)];
+		};
+		/**
 		* The children snapshot (RV-202): spawn order, pure reads of the
 		* records the orchestrator already tracks, so validators can hold
 		* a finish result (or the RV510 draft pre-pass) against the
@@ -24225,7 +24462,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 						verdict = validator.validate(input);
 					} catch (thrown) {
 						validationTermination = new ConfigError(`finish validator '${validator.name}' threw instead of returning a verdict: ` + (thrown instanceof Error ? thrown.message : String(thrown)));
-						validationAbort.abort("rulvar:finish-validation");
+						validationAbort.abort("rulvar:finish-validation-defect");
 						return {
 							ok: false,
 							feedback: { error: `finish validator '${validator.name}' is defective; the run fails` }
@@ -24236,7 +24473,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 						reasons: verdict.reasons
 					});
 				}
-				const repairsUsed = known.filter((candidate) => candidate.verdict !== "accepted" && contractGenerationCurrent(candidate)).length;
+				const repairsUsed = known.filter((candidate, index) => index >= validationInvocationStart && candidate.verdict !== "accepted" && contractGenerationCurrent(candidate)).length;
 				const rejectedCandidate = failed.length > 0;
 				let candidateRef;
 				if (rejectedCandidate && validationSpec.retainRejectedCandidates === true) {
@@ -24288,7 +24525,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			if (decision.verdict === "rejected") {
 				if (contractGenerationCurrent(decision)) {
 					validationTermination = finishValidationError(decision);
-					validationAbort.abort("rulvar:finish-validation");
+					validationAbort.abort(FINISH_REJECTION_ABORT_REASON);
 				}
 				return {
 					ok: false,
@@ -24823,6 +25060,15 @@ function makeOrchestratorWorkflow(goal, opts) {
 		* not settle ok, because an empty list would claim the pool agreed.
 		*/
 		let claimFindingsFound;
+		/**
+		* The observed price of this run's own latest post draft claim
+		* judge pass (RV3701): the fallback sizing of the repair round's
+		* convergence hold when the host declared no `judge.estCost`. By
+		* the time the bounded round can dispatch, a post draft pass has
+		* always settled (the round's findings came from it), so the
+		* fallback is this run's own money, never an invented constant.
+		*/
+		let observedFinalJudgeCostUsd;
 		/** Set whenever the pass ran, findings or not (the RV1404 pairing). */
 		let claimConsistencyMeta;
 		/**
@@ -25107,6 +25353,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			try {
 				judged = await runtime.runInScope(judgeState, () => ctx.agent(judgePrompt, judgeOpts));
 				noteInternalSettle(judged);
+				if (stage !== "draft" && typeof judged.costUsd === "number") observedFinalJudgeCostUsd = judged.costUsd;
 			} catch (declined) {
 				if (!(declined instanceof BudgetExhaustedError)) throw declined;
 				claimConsistencyMeta = finishMeta({
@@ -25438,6 +25685,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...draftGaps === void 0 ? [] : ["DRAFT CONTRACT GAPS: the coordination draft failed exactly these declared validators; repair the named gaps and preserve the draft otherwise. " + JSON.stringify(draftGaps)],
 				...opts?.contradictions?.onFound !== "carry" || contradictionsFound === void 0 || contradictionsFound.length === 0 ? [] : ["CHILD CONTRADICTIONS: the settled children read these cited locations differently; resolve each one EXPLICITLY in the final result (say which reading holds and why it does) instead of silently picking one. " + JSON.stringify(contradictionsFound)],
 				...opts?.claimConsistency?.onFound !== "carry" && opts?.claimConsistency?.onFound !== "repair" || claimFindingsFound === void 0 || claimFindingsFound.length === 0 ? [] : ["CLAIM CONTRADICTIONS: the composed draft contradicts the settled child pool at these cited locations; resolve each one EXPLICITLY in the final result (say which reading holds and why) instead of keeping the inverted claim. " + JSON.stringify(claimFindingsFound)],
+				...opts?.claimConsistency?.onFound !== "carry" && opts?.claimConsistency?.onFound !== "repair" || claimFindingsFound === void 0 || claimFindingsFound.length === 0 ? [] : hostValidationLessons(),
 				...spec.policyFacts === true ? [(() => {
 					const byStatus = {};
 					let extensionsGranted = 0;
@@ -25563,6 +25811,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					}
 				}
 			};
+			validationInvocationStart = validationDecisions().length;
 			const synthesized = await runtime.runInScope(synthesisState, () => ctx.agent(prompt, synthesisOpts));
 			noteInternalSettle(synthesized);
 			synthesisSchemaRejectedExchanges = synthesized.schemaRejectedTerminalExchanges ?? 0;
@@ -26288,19 +26537,55 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const hashOfDocument = (value) => createHash("sha256").update(jcsSerialize(value ?? null), "utf8").digest("hex");
 				const preRepairHash = hashOfDocument(synthesizedFinal);
 				const carried = claimFindingsFound;
+				const convergenceHoldUsd = opts?.claimConsistency?.judge?.estCost ?? observedFinalJudgeCostUsd ?? 0;
+				const convergenceScope = orchestratorAccount ?? "run";
+				if (convergenceHoldUsd > 0) internals.budget.commitConvergenceReserve(convergenceScope, convergenceHoldUsd);
 				try {
 					synthesizedFinal = await runSynthesis(result.output);
 				} catch (thrown) {
 					await journalSynthesisAdmissionDecline(thrown);
+					const hostRejection = thrown instanceof FailRunError && typeof thrown.data === "object" && thrown.data !== null && !Array.isArray(thrown.data) && thrown.data.source === "orchestrator_finish_validation" ? thrown.data : void 0;
+					if (hostRejection !== void 0) throw new FailRunError(`the claim-consistency repair round dispatched and its repaired candidate failed host validation (${thrown instanceof Error ? thrown.message.slice(0, 300) : String(thrown)}); ${String(carried.length)} judged contradiction${carried.length === 1 ? "" : "s"} stand unconsumed and a gate armed to repair must not pass silently`, { data: {
+						source: "orchestrator_claim_consistency",
+						claimContradictions: carried,
+						claimConsistencyMeta,
+						repairsUsed: 1,
+						roundDispatched: true,
+						preRepairHash,
+						finishValidation: {
+							...hostRejection.callId === void 0 ? {} : { callId: hostRejection.callId },
+							...hostRejection.failed === void 0 ? {} : { failed: hostRejection.failed },
+							...hostRejection.repairsUsed === void 0 ? {} : { repairsUsed: hostRejection.repairsUsed },
+							...hostRejection.maxRepairs === void 0 ? {} : { maxRepairs: hostRejection.maxRepairs },
+							...hostRejection.candidateHash === void 0 ? {} : { candidateHash: hostRejection.candidateHash },
+							...hostRejection.candidateChars === void 0 ? {} : { candidateChars: hostRejection.candidateChars }
+						},
+						...acceptanceSnapshot
+					} });
 					throw new FailRunError(`the claim-consistency repair round could not dispatch (${thrown instanceof Error ? thrown.message.slice(0, 300) : String(thrown)}); ${String(carried.length)} judged contradiction${carried.length === 1 ? "" : "s"} stand unconsumed and a gate armed to repair must not pass silently`, { data: {
 						source: "orchestrator_claim_consistency",
 						claimContradictions: carried,
+						claimConsistencyMeta,
 						repairsUsed: 0,
+						roundDispatched: false,
 						preRepairHash,
 						...acceptanceSnapshot
 					} });
+				} finally {
+					if (convergenceHoldUsd > 0) internals.budget.releaseConvergenceReserve(convergenceScope);
+				}
+				try {
+					await runClaimConsistencyPass(synthesizedFinal, acceptanceSnapshot, "final");
+				} catch (thrown) {
+					if (thrown instanceof FailRunError && typeof thrown.data === "object" && thrown.data !== null && !Array.isArray(thrown.data) && thrown.data.source === "orchestrator_claim_consistency") throw new FailRunError(thrown.message, { data: {
+						...thrown.data,
+						...thrown.data.claimContradictions === void 0 ? { claimContradictions: carried } : {},
+						roundDispatched: true,
+						repairsUsed: 1,
+						preRepairHash
+					} });
+					throw thrown;
 				}
-				await runClaimConsistencyPass(synthesizedFinal, acceptanceSnapshot, "final");
 				if (claimFindingsFound !== void 0 && claimFindingsFound.length > 0) throw new FailRunError(`the claim-consistency judge still found ${String(claimFindingsFound.length)} contradiction${claimFindingsFound.length === 1 ? "" : "s"} after the bounded repair round: the repaired composition keeps contradicting the settled pool`, { data: {
 					source: "orchestrator_claim_consistency",
 					claimContradictions: claimFindingsFound,
@@ -28119,6 +28404,8 @@ function liftRunCompletion(candidate) {
 	}
 	const metaCandidate = candidate.claimConsistencyMeta;
 	if (typeof metaCandidate === "object" && metaCandidate !== null && !Array.isArray(metaCandidate)) lifted.claimConsistencyMeta = { ...metaCandidate };
+	const findingsCandidate = candidate.claimContradictions;
+	if (Array.isArray(findingsCandidate) && findingsCandidate.every((row) => typeof row === "object" && row !== null && !Array.isArray(row) && typeof row.reason === "string")) lifted.claimContradictions = findingsCandidate.map((row) => ({ ...row }));
 	const skippedCandidate = candidate.synthesisSkipped;
 	if (typeof skippedCandidate === "boolean" || typeof skippedCandidate === "string") lifted.synthesisSkipped = skippedCandidate;
 	const acceptedCandidate = candidate.deliverableAccepted;
@@ -28755,6 +29042,7 @@ function createEngine(options) {
 				if (lifted.acceptanceChildren !== void 0) outcomeFacts.acceptanceChildren = lifted.acceptanceChildren;
 				if (lifted.semanticPasses !== void 0) outcomeFacts.semanticPasses = lifted.semanticPasses;
 				if (lifted.claimConsistencyMeta !== void 0) outcomeFacts.claimConsistencyMeta = lifted.claimConsistencyMeta;
+				if (lifted.claimContradictions !== void 0) outcomeFacts.claimContradictions = lifted.claimContradictions;
 				if (lifted.synthesisSkipped !== void 0) outcomeFacts.synthesisSkipped = lifted.synthesisSkipped;
 				if (lifted.deliverableAccepted !== void 0) outcomeFacts.deliverableAccepted = lifted.deliverableAccepted;
 				if (lifted.resultAvailable !== void 0) outcomeFacts.resultAvailable = lifted.resultAvailable;
@@ -29444,4 +29732,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.240.0",
+  "version": "1.242.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",
@@ -46,6 +46,7 @@
     "build": "tsdown",
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",
+    "test": "pnpm -w exec vitest run --project @rulvar/core",
     "pack-check": "publint --pack pnpm && attw --pack . --profile esm-only"
   }
 }