@rulvar/core 1.237.0 → 1.239.0

package/dist/index.d.ts

@@ -5764,10 +5764,13 @@ interface RunAgentOptions<S extends SchemaSpec = JsonSchema> {
   * before one existed; with the seam the crash window shrinks to the
   * single in-flight turn. Restored records (a checkpoint reboot)
   * never re-emit: they were journaled by the segment that minted
-  * them.
+  * them. A returned promise is AWAITED before the loop proceeds
+  * (RV3405, the awaited receipt posture): the caller decides the
+  * durability, the loop honors it; a void return keeps the RV2008
+  * fire and forget byte for byte.
   */
   billing?: {
-    onProviderCall: (record: ProviderCallRecord) => void;
+    onProviderCall: (record: ProviderCallRecord) => void | Promise<void>;
   };
   events?: RuntimeEventSink;
   transcript?: {
@@ -7663,6 +7666,20 @@ interface EngineDefaults {
   * identity, journals, or cassette keys.
   */
   cache?: CachePolicy;
+  /**
+  * The receipt posture of the incremental billing seam (RV3405).
+  * RV2008 journals every ProviderCallRecord the moment its wire call
+  * settles, but the append is fire and forget: the loop never blocks
+  * its dispatch path on journal IO, so the receipt most likely to
+  * lose the race with a crash is exactly the wire being paid for at
+  * the moment of death. `'awaited'` makes the loop await each receipt
+  * append before the turn proceeds (the RV601 intent before effect
+  * precedent), buying durable payment evidence for one journal IO
+  * await per wire call; a failed append still degrades loudly to the
+  * terminal lane (the RV2008 warning), never fails the run. Default
+  * `'async'`: byte identical to RV2008.
+  */
+  billingReceipts?: "async" | "awaited";
 }
 interface BudgetDefaults {
   /** Last resort of the admission reserve formula; default 0.50. */
@@ -8766,6 +8783,62 @@ declare function formatCharacterValidator(options?: {
   /** Single `Cf` characters to admit; everything else still rejects. */allow?: readonly string[];
   name?: string;
 }): FinishValidator;
+/**
+* Every declared literal must appear in the finish result at least
+* once (RV3308). The 2026-08-12 comparison run passed an exact twelve
+* heading contract and a citation floor while its "all publishable
+* packages" table silently dropped four of the seventeen names: shape
+* validators cannot see an enumerable universe, so the universe is
+* declared as literals and each one is held. Purely textual and
+* deterministic; fenced code counts, because tables and inline code
+* are legitimate places to name a package. Default name
+* 'required-mentions'.
+*/
+declare function requiredMentionsValidator(options: {
+  terms: readonly string[];
+  name?: string;
+}): FinishValidator;
+/**
+* One declaration for the shape a host both PROMPTS for and GATES on
+* (RV3308). The 2026-08-12 comparison run drifted exactly here: the
+* harness prompt named one heading while its finish contract named an
+* older one, the host accepted its own contract, and the common audit
+* refused the answer. A manifest is read twice, by
+* {@link manifestValidators} to build the gate and by
+* {@link renderContractRequirements} to build the prompt block, so
+* the two surfaces cannot disagree by construction.
+*/
+interface OutputContractManifest {
+  /** The exact heading lines, ordered and exclusive when present. */
+  sections?: readonly string[];
+  /** Literal strings the result must contain, each at least once. */
+  requiredMentions?: readonly string[];
+  /** Whitespace word bounds, either side optional. */
+  words?: {
+    min?: number;
+    max?: number;
+  };
+  /** Minimum citation occurrences over {@link DEFAULT_CITATION_PATTERN} or `citationPattern`. */
+  minCitations?: number;
+  /** Overrides the citation shape; only meaningful beside `minCitations`. */
+  citationPattern?: string;
+}
+/**
+* The manifest's gate half (RV3308): heading structure (ordered,
+* exclusive), word bounds, the citation floor, and the mention
+* universe, in that stable order, each through the existing named
+* validator. Everything is derived from the SAME object the prompt
+* block renders from.
+*/
+declare function manifestValidators(manifest: OutputContractManifest): FinishValidator[];
+/**
+* The manifest's prompt half (RV3308): a deterministic requirements
+* block enumerating the SAME headings, bounds, citation floor and
+* literals the validators hold, byte for byte, for the host to embed
+* in its question. Rendering is pure string assembly; nothing here
+* consults the result.
+*/
+declare function renderContractRequirements(manifest: OutputContractManifest): string;
 //#endregion
 //#region src/orchestrator/contradictions.d.ts
 /** One child's serialized output as the pass reads it. */
@@ -10406,7 +10479,16 @@ interface OrchestrateClaimConsistency {
   * under `stage: 'both'` the draft pass carries and the final pass
   * reports, and `stage: 'final'` with 'carry' is a ConfigError at
   * intake, because a posture that reads as a gate must not quietly
-  * behave as 'report'. 'fail' fails the run typed with
+  * behave as 'report'. 'repair' (RV3307) is the honest carry for the
+  * final pass: judged findings ride ONE more synthesis invocation
+  * (the same CLAIM CONTRADICTIONS block, over a prompt that now lies
+  * ahead again), the repaired document is judged again, and findings
+  * that survive the round fail the run typed, exactly like a dead or
+  * declined judge under this posture, because a gate armed to repair
+  * must not pass silently. It needs a pass that runs AFTER a
+  * synthesis, so `stage` must be 'final' or 'both' (a ConfigError
+  * beside the default 'draft', whose findings the ordinary carry
+  * already consumes). 'fail' fails the run typed with
   * `data.source` 'orchestrator_claim_consistency' BEFORE any
   * synthesis dispatch; the judge itself has already been paid, which
   * is the honest minimum for a semantic verdict. A judge that does
@@ -10414,7 +10496,7 @@ interface OrchestrateClaimConsistency {
   * run only under 'fail': a gate armed to stop the run must not pass
   * silently when its judge dies.
   */
-  onFound?: "report" | "carry" | "fail";
+  onFound?: "report" | "carry" | "fail" | "repair";
   /**
   * WHICH document the pass judges (RV2509), default `'draft'`, the
   * historical behavior byte for byte. The pass has always read the
@@ -11330,6 +11412,24 @@ interface EvidenceContract {
   /** Estimated non-evidence overhead calls; default 8. */
   overheadCalls?: number;
   /**
+  * A journal observed prior for the per-entry call estimate
+  * (RV3309): the figure `toolCalibrationFromJournal` folds from a
+  * prior run of the same profile (aggregate or a p90 over several),
+  * fractional on purpose. Preflight uses the HIGHER of the declared
+  * estimate and this prior when it computes the evidence call floor,
+  * never the lower, so a stale generous declaration still holds and
+  * an optimistic one stops hiding the observed reality: the
+  * 2026-08-12 comparison run observed 4.211 calls per entry where
+  * the default estimate says 3. When the prior raises the floor,
+  * preflight names it in an `evidence-estimate-below-observed`
+  * finding beside the usual floor arithmetic. `source` is echoed in
+  * that finding so a reader knows which journal spoke.
+  */
+  calibration?: {
+    callsPerEntry: number;
+    source?: string;
+  };
+  /**
   * What the floor does at the child's terminal settle (RV507). The
   * default 'warn' keeps the historical behavior: the contract is a
   * preflight signal only. 'refuse' turns an ok finish whose message
@@ -11690,7 +11790,8 @@ interface RunInternals {
     toolsets?: Record<string, ToolsOption>; /** Registered mechanical gate profiles (M7-T10). */
     gates?: Record<string, MechanicalGateProfile>; /** Engine-wide admission countTokens policy (RV1804); default 'allow'. */
     countTokens?: "allow" | "deny"; /** The engine-wide prompt-cache policy (RV2006); profile and call opts win. */
-    cache?: CachePolicy;
+    cache?: CachePolicy; /** The receipt posture of the billing seam (RV3405); default 'async'. */
+    billingReceipts?: "async" | "awaited";
   };
   /** Telemetry compat posture (RV1810). */
   telemetry?: {
@@ -13446,6 +13547,60 @@ interface JournaledCriticalPath {
   finalCompositionMs?: number;
   /** Synthesis that IS the claim judge; same all-or-nothing condition. */
   semanticJudgeMs?: number;
+  /**
+  * The stage split of `semanticJudgeMs` (RV3404), same all-or-nothing
+  * condition: the draft pass is the exact judge label and every
+  * suffixed variant is a post draft pass over the composed document
+  * (the final pass and the repair round's re-judge both dispatch
+  * `-final`, RV2509/RV3307). One classifier decides on both surfaces:
+  * {@link claimJudgeStageOf}.
+  */
+  draftJudgeMs?: number;
+  /** The post draft half of the split; same condition. */
+  finalJudgeMs?: number;
+  /**
+  * Settled synthesize spans counted by side, same condition (RV3404):
+  * `compositionSpans: 2` in an archived journal is the legible
+  * signature of the bounded repair round (RV3307), readable years
+  * after the process that paid for it exited.
+  */
+  compositionSpans?: number;
+  /** Settled judge-side synthesize spans, counted; same condition. */
+  judgeSpans?: number;
+  /**
+  * The window itemization a journal CAN answer (RV3404); present
+  * exactly when `postFanInMs` is.
+  */
+  postFanIn?: JournaledPostFanIn;
+}
+/**
+* The synthesis half of the RV710 decomposition, asked of a journal
+* (RV3404). The live breakdown also itemizes the coordinator's model
+* and tool time inside the window; a journal cannot: a terminal agent
+* entry spans the WHOLE invocation, and the coordinator's per turn
+* stamps died with the process that emitted them. So this block claims
+* exactly what the stamps prove: how much of the window settled
+* synthesize spans cover, the split of that cover when every span is
+* labelled, and how much of the window NO settled synthesize span
+* accounts for. `unaccountedMs` is a superset of the live `residueMs`
+* by construction (the coordinator's own tail time lives in it here),
+* which is why it refuses to share the name.
+*/
+interface JournaledPostFanIn {
+  /** Union of settled synthesize spans clipped to the window. */
+  synthesisCoveredMs: number;
+  /**
+  * The composition half of the covered spans, clipped; present under
+  * the same all-or-nothing labelling condition as the top level
+  * split, and equal to the live breakdown's reading of the same run.
+  */
+  finalCompositionMs?: number;
+  /** The judge half, clipped; same condition. */
+  semanticJudgeMs?: number;
+  /** `postFanInMs` minus `synthesisCoveredMs`, floored at zero. */
+  unaccountedMs: number;
+  /** `unaccountedMs / postFanInMs` when the window is positive. */
+  unaccountedShare?: number;
 }
 /**
 * Fold a run's critical path out of its journal.
@@ -13978,6 +14133,41 @@ interface InvoiceExport {
       responseId?: string;
     }>;
   };
+  /**
+  * The orphaned receipt lane (RV3405): incremental provider-call rows
+  * of agents whose TERMINAL entry does not cover them. The window is
+  * real: the loop journals a receipt as each wire settles (RV2008),
+  * the turn checkpoint lands later, and a crash between the two
+  * resumes from a checkpoint that never saw the paid wire, so the
+  * settled terminal's record set forgets the payment while the
+  * receipt lane remembers it. Real money, priced and summed apart
+  * from the settled totals exactly like `unsettled` (run_settle stays
+  * the billing boundary); this lane is why a provider statement
+  * billing that wire is explainable to the cent instead of reading as
+  * a foreign row. Coverage is decided by response id when either side
+  * carries one, else by the full (ordinal, servedBy, attempt,
+  * outcome) coordinate plus byte equal usage: after a resume the
+  * redispatched wire REUSES the ordinal, and reading the replacement
+  * as the orphan would silently absorb the double payment the resume
+  * honestly made. Present only when such rows exist; a journal
+  * without a mid turn crash never carries it.
+  */
+  orphanedReceipts?: {
+    usd: number;
+    wireRequests: number;
+    rows: Array<{
+      agentRef: number;
+      scope: string;
+      ordinal: number;
+      servedBy: ModelRef;
+      role: string;
+      attempt: number;
+      outcome: string;
+      usage: Usage;
+      usd?: number;
+      responseId?: string;
+    }>;
+  };
 }
 /**
 * The pure invoice fold. Pass the same entries and price table you
@@ -14160,6 +14350,23 @@ interface StatementReconciliation {
   * alone would have closed money against it.
   */
   monetarySettleable: boolean;
+  /**
+  * Statement rows explained by the invoice's receipt lanes (RV3405):
+  * per request export rows whose response id matches an `unsettled`
+  * or `orphanedReceipts` row of the invoice, i.e. OUR paid wires that
+  * the settled rows do not carry (a crash before settle, a terminal
+  * whose record set forgot the payment). Counted APART on purpose:
+  * their dollars never enter the totals, the coverage, `settleable`
+  * or `monetarySettleable`, because money the run did not settle must
+  * not close; they exist so the statement drift is explainable to the
+  * cent instead of reading as foreign rows. Present only when the
+  * caller passed the lanes and at least one row matched.
+  */
+  receiptMatchedRows?: number;
+  /** Statement side dollars over those rows, when the export claims any. */
+  receiptMatchedUsd?: number;
+  /** First matched receipt ids (at most 20). */
+  receiptIdSample?: string[];
 }
 /**
 * Reconciles the invoice against a normalized provider export. Pure and
@@ -14178,6 +14385,24 @@ interface StatementReconciliation {
 */
 declare function reconcileStatement(invoice: {
   rows: readonly InvoiceRow[];
+  /**
+  * The invoice's receipt lanes (RV3405), passed straight off the
+  * InvoiceExport when the caller wants statement rows for crashed
+  * or terminal forgotten wires EXPLAINED instead of counted
+  * foreign. Requests mode only (the join is by response id), and
+  * strictly opt in: a bare `{ rows }` invoice reads byte for byte
+  * as before.
+  */
+  unsettled?: {
+    rows: ReadonlyArray<{
+      responseId?: string;
+    }>;
+  };
+  orphanedReceipts?: {
+    rows: ReadonlyArray<{
+      responseId?: string;
+    }>;
+  };
 }, statement: ProviderStatement, options: ReconcileStatementOptions): StatementReconciliation;
 /**
 * Column mapping for {@link statementFromRows}: each field names the
@@ -14427,6 +14652,29 @@ interface PreflightOrchestratorSpec {
     judge?: {
       estCost?: number;
     };
+    /**
+    * Mirrors OrchestrateClaimConsistency.onFound (RV3402). Declaring
+    * `'repair'` prices the bounded post judge round (RV3307) into the
+    * static arithmetic: the working room adds one more judge pass and
+    * one more composition (priced at the declared
+    * `budget.synthesisReserveUsd`, the host's own estimate of one
+    * composition), and the tail spawn count adds the round's two
+    * invocations. The 2026-08-12 comparison shape motivates the
+    * polarity: a ceiling sized to the exact plan converts a triggered
+    * repair into the typed decline, and preflight should say so
+    * 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.
+    */
+    onFound?: "report" | "carry" | "fail" | "repair";
+    /**
+    * Mirrors OrchestrateClaimConsistency.stage (RV3402): `'both'`
+    * dispatches the judge twice at worst, and the working room and
+    * tail spawn arithmetic price passes, not declarations. Absent
+    * keeps the historical one pass reading byte for byte.
+    */
+    stage?: "draft" | "final" | "both";
   };
   /**
   * The `reserve-line-headroom` threshold in coordination turn floors
@@ -14448,6 +14696,18 @@ interface PreflightOrchestratorSpec {
   * configs are byte identical until a host opts in.
   */
   minCeilingHeadroomShare?: number;
+  /**
+  * What a breached headroom floor emits (RV3310). The default
+  * 'warning' keeps RV3208's behavior byte for byte: advisory, and a
+  * host that only throws on errors sails past it. 'error' makes the
+  * breach blocking for exactly such hosts: the 2026-08-12 comparison
+  * harness threw on error findings only, its 2 percent floor held
+  * against a 2.857 percent headroom, and the assurance answer to
+  * "this plan is too thin to survive drift" must be refusal before
+  * the first wire, not a line in a report nobody gates on.
+  * Meaningful only beside a positive `minCeilingHeadroomShare`.
+  */
+  ceilingHeadroomSeverity?: "warning" | "error";
 }
 /** The full input: engine surface, run surface, and the declared wave. */
 interface PreflightInput {
@@ -15283,6 +15543,26 @@ interface CriticalPath {
   * included, summed (RV1604).
   */
   semanticJudgeMs: number;
+  /**
+  * The stage split of `semanticJudgeMs` (RV3404): the draft pass
+  * dispatches under the exact {@link CLAIM_JUDGE_LABEL} and every
+  * suffixed variant is a post draft pass (today the final pass and
+  * the repair round's re-judge, both `-final`, RV2509/RV3307). Always
+  * the exact partition: `draftJudgeMs + finalJudgeMs` equals
+  * `semanticJudgeMs`.
+  */
+  draftJudgeMs: number;
+  /** The post draft half of the split; see `draftJudgeMs`. */
+  finalJudgeMs: number;
+  /**
+  * Completed composition-side synthesize spans, counted (RV3404): two
+  * compositions on one run is the legible signature of the bounded
+  * repair round (RV3307), and a count survives where milliseconds
+  * invite guessing.
+  */
+  compositionSpans: number;
+  /** Completed judge-side synthesize spans, counted (RV3404). */
+  judgeSpans: number;
   /** postFanInMs / runWallMs when both are defined and the wall is > 0. */
   postFanInShare?: number;
   /** synthesisMs / runWallMs under the same conditions. */
@@ -15379,6 +15659,40 @@ interface PostFanInBreakdown {
 */
 declare const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
 /**
+* 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
+* `claim-consistency-judge-final` since RV2509 so the two passes of
+* `stage: 'both'` stay separable). BOTH reducers must classify through
+* this one predicate (RV3302): the live fold compared the label for
+* exact equality while the journal fold accepted the suffix, and the
+* 2026-08-12 comparison run reported semanticJudgeMs 0 with the whole
+* 272923 ms window read as final composition on the live surface
+* while the journal fold correctly split 224864 against 48059.
+*/
+declare function isClaimJudgeLabel(label: string | undefined): boolean;
+/**
+* Which pass a claim-consistency judge label names (RV3404): the exact
+* {@link CLAIM_JUDGE_LABEL} is the draft pass, and every suffixed
+* variant is a post draft pass over the composed document (today the
+* final pass and the repair round's re-judge, both dispatching under
+* `-final`, RV2509/RV3307). `undefined` for every other label. One
+* classifier for both reducers, the RV3302 doctrine extended from the
+* judge predicate to the stage: the split must never read differently
+* off the live stream and off the journal of one run.
+*/
+declare function claimJudgeStageOf(label: string | undefined): "draft" | "final" | undefined;
+/**
+* Total length of the union of possibly overlapping intervals, exported
+* (RV3404) so the journal fold computes its window coverage through the
+* SAME arithmetic the live RV710 decomposition uses, never a sibling
+* implementation that can drift.
+*/
+declare function unionOfIntervalsMs(intervals: ReadonlyArray<{
+  from: number;
+  to: number;
+}>): number;
+/**
 * The label the final synthesis (composition) invocation dispatches
 * under (RV2901). The engine labelling its OWN dispatches is what lets
 * `criticalPathFromJournal` split the synthesize bucket offline: the
@@ -15469,4 +15783,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, 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, 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, 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, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, 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, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, 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, 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_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 };

package/dist/index.js

@@ -3158,11 +3158,17 @@ function requireTimerDelayMs(value, site) {
 * same shapes with the same wording.
 */
 function validateEvidenceContract(value, site) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ConfigError(`${site} must be { minEntries, estCallsPerEntry?, overheadCalls?, enforce? }; got ${typeof value}`);
-	const { minEntries, estCallsPerEntry, overheadCalls, enforce } = value;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new ConfigError(`${site} must be { minEntries, estCallsPerEntry?, overheadCalls?, calibration?, enforce? }; got ${typeof value}`);
+	const { minEntries, estCallsPerEntry, overheadCalls, calibration, enforce } = value;
 	requirePositiveInteger$2(minEntries, `${site}.minEntries`);
 	if (estCallsPerEntry !== void 0) requirePositiveInteger$2(estCallsPerEntry, `${site}.estCallsPerEntry`);
 	if (overheadCalls !== void 0) requireNonNegativeInteger(overheadCalls, `${site}.overheadCalls`);
+	if (calibration !== void 0) {
+		if (typeof calibration !== "object" || calibration === null || Array.isArray(calibration)) throw new ConfigError(`${site}.calibration must be { callsPerEntry, source? }; got ${typeof calibration}`);
+		const { callsPerEntry, source } = calibration;
+		if (typeof callsPerEntry !== "number" || !Number.isFinite(callsPerEntry) || callsPerEntry <= 0) throw new ConfigError(`${site}.calibration.callsPerEntry must be a positive finite number; got ` + JSON.stringify(callsPerEntry));
+		if (source !== void 0 && (typeof source !== "string" || source.length === 0)) throw new ConfigError(`${site}.calibration.source must be a non empty string when present; got ` + JSON.stringify(source));
+	}
 	if (enforce !== void 0 && enforce !== "warn" && enforce !== "refuse") throw new ConfigError(`${site}.enforce must be 'warn' or 'refuse'; got ${JSON.stringify(enforce)}`);
 }
 /**
@@ -9336,7 +9342,30 @@ const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
 * while the journal fold correctly split 224864 against 48059.
 */
 function isClaimJudgeLabel(label) {
-	return label === "claim-consistency-judge" || (label?.startsWith(`claim-consistency-judge-`) ?? false);
+	return claimJudgeStageOf(label) !== void 0;
+}
+/**
+* Which pass a claim-consistency judge label names (RV3404): the exact
+* {@link CLAIM_JUDGE_LABEL} is the draft pass, and every suffixed
+* variant is a post draft pass over the composed document (today the
+* final pass and the repair round's re-judge, both dispatching under
+* `-final`, RV2509/RV3307). `undefined` for every other label. One
+* classifier for both reducers, the RV3302 doctrine extended from the
+* judge predicate to the stage: the split must never read differently
+* off the live stream and off the journal of one run.
+*/
+function claimJudgeStageOf(label) {
+	if (label === "claim-consistency-judge") return "draft";
+	return label?.startsWith(`claim-consistency-judge-`) ?? false ? "final" : void 0;
+}
+/**
+* Total length of the union of possibly overlapping intervals, exported
+* (RV3404) so the journal fold computes its window coverage through the
+* SAME arithmetic the live RV710 decomposition uses, never a sibling
+* implementation that can drift.
+*/
+function unionOfIntervalsMs(intervals) {
+	return unionLength([...intervals]);
 }
 /**
 * The label the final synthesis (composition) invocation dispatches
@@ -9379,6 +9408,10 @@ function reduceCriticalPath(events) {
 	let synthesisMs = 0;
 	let finalCompositionMs = 0;
 	let semanticJudgeMs = 0;
+	let draftJudgeMs = 0;
+	let finalJudgeMs = 0;
+	let compositionSpans = 0;
+	let judgeSpans = 0;
 	const coordinationModel = [];
 	const coordinationTools = [];
 	const synthesisSpans = [];
@@ -9419,10 +9452,18 @@ function reduceCriticalPath(events) {
 				if (started === void 0) break;
 				if (started.role === "synthesize") {
 					const wall = Math.max(0, at - started.at);
-					const judge = isClaimJudgeLabel(started.label);
+					const stage = claimJudgeStageOf(started.label);
+					const judge = stage !== void 0;
 					synthesisMs += wall;
-					if (judge) semanticJudgeMs += wall;
-					else finalCompositionMs += wall;
+					if (judge) {
+						semanticJudgeMs += wall;
+						judgeSpans += 1;
+						if (stage === "draft") draftJudgeMs += wall;
+						else finalJudgeMs += wall;
+					} else {
+						finalCompositionMs += wall;
+						compositionSpans += 1;
+					}
 					synthesisSpans.push({
 						from: started.at,
 						to: at,
@@ -9441,6 +9482,10 @@ function reduceCriticalPath(events) {
 		synthesisMs,
 		finalCompositionMs,
 		semanticJudgeMs,
+		draftJudgeMs,
+		finalJudgeMs,
+		compositionSpans,
+		judgeSpans,
 		workerSpans
 	};
 	if (runStart !== void 0 && runEnd !== void 0) path.runWallMs = Math.max(0, runEnd - runStart);
@@ -9534,8 +9579,13 @@ function criticalPathFromJournal(entries) {
 	let synthesisMs = 0;
 	let finalCompositionMs = 0;
 	let semanticJudgeMs = 0;
+	let draftJudgeMs = 0;
+	let finalJudgeMs = 0;
+	let compositionSpans = 0;
+	let judgeSpans = 0;
 	let labelledSynthesis = false;
 	let unlabelledSynthesis = false;
+	const synthSpans = [];
 	for (const entry of ordered) {
 		const startedAt = parse$1(entry.startedAt);
 		const endedAt = parse$1(entry.endedAt);
@@ -9560,11 +9610,28 @@ function criticalPathFromJournal(entries) {
 		const label = entry.costAttribution?.label;
 		if (label === void 0) {
 			unlabelledSynthesis = true;
+			synthSpans.push({
+				from: startedAt,
+				to: endedAt
+			});
 			continue;
 		}
 		labelledSynthesis = true;
-		if (isClaimJudgeLabel(label)) semanticJudgeMs += wall;
-		else finalCompositionMs += wall;
+		const stage = claimJudgeStageOf(label);
+		if (stage !== void 0) {
+			semanticJudgeMs += wall;
+			judgeSpans += 1;
+			if (stage === "draft") draftJudgeMs += wall;
+			else finalJudgeMs += wall;
+		} else {
+			finalCompositionMs += wall;
+			compositionSpans += 1;
+		}
+		synthSpans.push({
+			from: startedAt,
+			to: endedAt,
+			judge: stage !== void 0
+		});
 	}
 	const segments = logicalRunTelemetry(ordered).segments;
 	const path = {
@@ -9573,13 +9640,49 @@ function criticalPathFromJournal(entries) {
 		unclassifiedSpans,
 		segments
 	};
-	if (labelledSynthesis && !unlabelledSynthesis) {
+	const splitLegible = labelledSynthesis && !unlabelledSynthesis;
+	if (splitLegible) {
 		path.finalCompositionMs = finalCompositionMs;
 		path.semanticJudgeMs = semanticJudgeMs;
+		path.draftJudgeMs = draftJudgeMs;
+		path.finalJudgeMs = finalJudgeMs;
+		path.compositionSpans = compositionSpans;
+		path.judgeSpans = judgeSpans;
 	}
 	if (segments > 1 || runStart === void 0 || runEnd === void 0) return path;
 	path.runWallMs = Math.max(0, runEnd - runStart);
-	if (lastWorkerEnd !== void 0) path.postFanInMs = Math.max(0, runEnd - lastWorkerEnd);
+	if (lastWorkerEnd !== void 0) {
+		path.postFanInMs = Math.max(0, runEnd - lastWorkerEnd);
+		const windowFrom = Math.min(lastWorkerEnd, runEnd);
+		const windowTo = runEnd;
+		const clipped = [];
+		for (const span of synthSpans) {
+			if (span.to < windowFrom || span.from > windowTo) continue;
+			clipped.push({
+				from: Math.max(span.from, windowFrom),
+				to: Math.min(span.to, windowTo),
+				...span.judge === void 0 ? {} : { judge: span.judge }
+			});
+		}
+		const synthesisCoveredMs = unionOfIntervalsMs(clipped);
+		const block = {
+			synthesisCoveredMs,
+			unaccountedMs: Math.max(0, path.postFanInMs - synthesisCoveredMs)
+		};
+		if (splitLegible) {
+			let judgeClippedMs = 0;
+			let compositionClippedMs = 0;
+			for (const span of clipped) {
+				const wall = span.to - span.from;
+				if (span.judge === true) judgeClippedMs += wall;
+				else compositionClippedMs += wall;
+			}
+			block.finalCompositionMs = compositionClippedMs;
+			block.semanticJudgeMs = judgeClippedMs;
+		}
+		if (path.postFanInMs > 0) block.unaccountedShare = block.unaccountedMs / path.postFanInMs;
+		path.postFanIn = block;
+	}
 	if (path.runWallMs > 0) {
 		if (path.postFanInMs !== void 0) path.postFanInShare = path.postFanInMs / path.runWallMs;
 		path.synthesisShare = synthesisMs / path.runWallMs;
@@ -13492,7 +13595,10 @@ async function runAgent(options) {
 					if (outcome.aborted !== void 0) record.aborted = outcome.aborted;
 					else if (outcome.wireError !== void 0) record.errorCode = outcome.wireError.code;
 					providerCalls.push(record);
-					options.billing?.onProviderCall(record);
+					{
+						const receipt = options.billing?.onProviderCall(record);
+						if (receipt !== void 0) await receipt;
+					}
 					addCallUsd(site.role, target.resolved.ref, accounted);
 					const limited = outcome.wireError?.data;
 					if (limited?.kind === "rate-limit" && typeof limited.reportedLimits === "object" && limited.reportedLimits !== null) rateLimitObservations.set(`${target.adapter.id}:${target.resolved.model}`, {
@@ -15818,6 +15924,20 @@ function sliceRemainder(slice, records) {
 	if (reasoning > 0) remainder.reasoningTokens = reasoning;
 	return USAGE_FIELDS.some((field) => remainder[field] > 0) || (remainder.reasoningTokens ?? 0) > 0 ? remainder : void 0;
 }
+/**
+* One export row's usage envelope (RV3311): every row carries the SAME
+* field set, `reasoningTokens` included (0 when the provider reported
+* none), and the object is detached from the journal entry it was read
+* from. The 2026-08-12 comparison run's invoice had 77 rows with the
+* field and one without, and a FinOps consumer folding the column had
+* to know that absence meant zero on exactly one row shape.
+*/
+function rowUsage(usage) {
+	return {
+		...usage,
+		reasoningTokens: usage.reasoningTokens ?? 0
+	};
+}
 /** One allocation pool per (entry, serving model) slice of the gross fold. */
 function allocationKey(entrySeq, servedBy) {
 	return `${String(entrySeq)} ${servedBy}`;
@@ -15933,7 +16053,7 @@ function invoiceFromJournal(entries, priceUsd, options) {
 				...record.responseId === void 0 ? {} : { responseId: record.responseId },
 				...record.wireResponseIds === void 0 ? {} : { wireResponseIds: record.wireResponseIds },
 				...record.wireRequests === void 0 ? {} : { wireRequests: record.wireRequests },
-				usage: record.usage,
+				usage: rowUsage(record.usage),
 				...record.usageApprox === true ? { usageApprox: true } : {},
 				...usageUnknown ? { usageUnknown: true } : {},
 				...usd === void 0 ? {} : { usd },
@@ -15951,7 +16071,7 @@ function invoiceFromJournal(entries, priceUsd, options) {
 					servedBy: slice.servedBy,
 					...slice.role === void 0 ? {} : { role: slice.role },
 					outcome: "unattributed",
-					usage: slice.usage,
+					usage: rowUsage(slice.usage),
 					...entry.usageApprox === true ? { usageApprox: true } : {},
 					...usd === void 0 ? {} : { usd },
 					allocatedUsd: 0,
@@ -15973,7 +16093,7 @@ function invoiceFromJournal(entries, priceUsd, options) {
 				servedBy: slice.servedBy,
 				...slice.role === void 0 ? {} : { role: slice.role },
 				outcome: "unattributed",
-				usage: remainder,
+				usage: rowUsage(remainder),
 				...entry.usageApprox === true ? { usageApprox: true } : {},
 				...usd === void 0 ? {} : { usd },
 				allocatedUsd: 0,
@@ -15984,16 +16104,40 @@ function invoiceFromJournal(entries, priceUsd, options) {
 		}
 	}
 	const unallocatedUsd = allocateRows(rows, entries, priceUsd, report.grossUsd);
-	const terminalRefs = new Set(entries.filter((entry) => entry.kind === "agent" && entry.status !== "running").map((entry) => entry.ref));
+	const terminalByRef = new Map(entries.filter((entry) => entry.kind === "agent" && entry.status !== "running").map((entry) => [entry.ref, entry]));
 	const runningBySeq = new Map(entries.filter((entry) => entry.kind === "agent" && entry.status === "running").map((entry) => [entry.seq, entry]));
 	const unsettledRows = [];
+	const orphanedRows = [];
 	for (const entry of entries) {
 		if (entry.kind !== "decision") continue;
 		const value = entry.value;
-		if (value?.decisionType !== "provider-call" || typeof value.agentRef !== "number" || terminalRefs.has(value.agentRef)) continue;
-		const running = runningBySeq.get(value.agentRef);
+		if (value?.decisionType !== "provider-call" || typeof value.agentRef !== "number") continue;
 		const record = value.record;
-		if (running === void 0 || record?.usage === void 0 || typeof record.ordinal !== "number" || typeof record.servedBy !== "string") continue;
+		if (record?.usage === void 0 || typeof record.ordinal !== "number" || typeof record.servedBy !== "string") continue;
+		const terminal = terminalByRef.get(value.agentRef);
+		if (terminal !== void 0) {
+			const receiptUsage = record.usage;
+			if ((terminal.providerCalls ?? []).some((call) => {
+				if (typeof record.responseId === "string" || call.responseId !== void 0) return call.responseId === record.responseId;
+				return call.ordinal === record.ordinal && call.servedBy === record.servedBy && call.attempt === (typeof record.attempt === "number" ? record.attempt : 1) && call.outcome === (typeof record.outcome === "string" ? record.outcome : "ok") && USAGE_FIELDS.every((field) => (call.usage[field] ?? 0) === (receiptUsage[field] ?? 0)) && (call.usage.reasoningTokens ?? 0) === (receiptUsage.reasoningTokens ?? 0);
+			})) continue;
+			const usd = rowUsd(priceUsd, record.servedBy, record.usage, entry.seq);
+			orphanedRows.push({
+				agentRef: value.agentRef,
+				scope: terminal.scope,
+				ordinal: record.ordinal,
+				servedBy: record.servedBy,
+				role: typeof record.role === "string" ? record.role : "loop",
+				attempt: typeof record.attempt === "number" ? record.attempt : 1,
+				outcome: typeof record.outcome === "string" ? record.outcome : "ok",
+				usage: rowUsage(record.usage),
+				...usd === void 0 ? {} : { usd },
+				...typeof record.responseId === "string" ? { responseId: record.responseId } : {}
+			});
+			continue;
+		}
+		const running = runningBySeq.get(value.agentRef);
+		if (running === void 0) continue;
 		const usd = rowUsd(priceUsd, record.servedBy, record.usage, entry.seq);
 		unsettledRows.push({
 			agentRef: value.agentRef,
@@ -16003,7 +16147,7 @@ function invoiceFromJournal(entries, priceUsd, options) {
 			role: typeof record.role === "string" ? record.role : "loop",
 			attempt: typeof record.attempt === "number" ? record.attempt : 1,
 			outcome: typeof record.outcome === "string" ? record.outcome : "ok",
-			usage: record.usage,
+			usage: rowUsage(record.usage),
 			...usd === void 0 ? {} : { usd },
 			...typeof record.responseId === "string" ? { responseId: record.responseId } : {}
 		});
@@ -16013,6 +16157,11 @@ function invoiceFromJournal(entries, priceUsd, options) {
 		wireRequests: unsettledRows.length,
 		rows: unsettledRows
 	};
+	const orphanedReceipts = orphanedRows.length === 0 ? void 0 : {
+		usd: orphanedRows.reduce((sum, row) => sum + (row.usd ?? 0), 0),
+		wireRequests: orphanedRows.length,
+		rows: orphanedRows
+	};
 	const usageApprox = report.usageApprox === true || report.abandoned.usageApprox === true;
 	const invoice = {
 		rows,
@@ -16026,6 +16175,7 @@ function invoiceFromJournal(entries, priceUsd, options) {
 		reconciliationFailures: rows.filter((row) => row.reconciliation !== "provider-id-present").length,
 		cardinality: cardinalityOf(rows),
 		...unsettled === void 0 ? {} : { unsettled },
+		...orphanedReceipts === void 0 ? {} : { orphanedReceipts },
 		...(() => {
 			const count = rows.filter((row) => row.usageUnknown === true).length;
 			return count === 0 ? {} : { usageUnknownRows: count };
@@ -16160,6 +16310,9 @@ function reconcileStatement(invoice, statement, options) {
 	const unmatchedIdSample = [];
 	let statementOnlyRows = 0;
 	const statementOnlyIdSample = [];
+	let receiptMatchedRows = 0;
+	let receiptMatchedUsd = 0;
+	const receiptIdSample = [];
 	let statementTotalUsd;
 	let statementComponents;
 	let matchedStatementRows = 0;
@@ -16257,7 +16410,15 @@ function reconcileStatement(invoice, statement, options) {
 				}
 			}
 		}
+		const receiptIds = /* @__PURE__ */ new Set();
+		for (const lane of [invoice.unsettled, invoice.orphanedReceipts]) for (const row of lane?.rows ?? []) if (typeof row.responseId === "string") receiptIds.add(row.responseId);
 		for (const row of statement.rows) if (!matchedStatement.has(row.responseId) && !partialSegmentIds.has(row.responseId)) {
+			if (receiptIds.has(row.responseId)) {
+				receiptMatchedRows += 1;
+				if (row.usd !== void 0) receiptMatchedUsd += row.usd;
+				if (receiptIdSample.length < SAMPLE_CAP) receiptIdSample.push(row.responseId);
+				continue;
+			}
 			statementOnlyRows += 1;
 			if (statementOnlyIdSample.length < SAMPLE_CAP) statementOnlyIdSample.push(row.responseId);
 		}
@@ -16406,7 +16567,12 @@ function reconcileStatement(invoice, statement, options) {
 		verdict,
 		dollarCoverage,
 		settleable,
-		monetarySettleable: settleable && dollarCoverage === "complete"
+		monetarySettleable: settleable && dollarCoverage === "complete",
+		...receiptMatchedRows === 0 ? {} : {
+			receiptMatchedRows,
+			receiptMatchedUsd,
+			receiptIdSample
+		}
 	};
 }
 /** A cell that is absent by export convention: missing, null, or ''. */
@@ -19031,7 +19197,7 @@ function createCtx(internals, rootWorkflow) {
 			if (cachePolicy !== void 0) runAgentOptions.cache = cachePolicy;
 		}
 		runAgentOptions.billing = { onProviderCall: (record) => {
-			internals.replayer.appendSinglePhase({
+			const append = internals.replayer.appendSinglePhase({
 				scope: state.scope,
 				key: `pc:${String(running.seq)}:${String(record.ordinal)}`,
 				kind: "decision",
@@ -19043,13 +19209,14 @@ function createCtx(internals, rootWorkflow) {
 					agentRef: running.seq,
 					record
 				}
-			}).catch((thrown) => {
+			}).then(() => void 0).catch((thrown) => {
 				internals.events.emit({
 					type: "log",
 					level: "warn",
 					msg: `incremental billing row failed to append; the terminal entry remains the canonical record (${thrown instanceof Error ? thrown.message : String(thrown)})`
 				}, spanId);
 			});
+			if (internals.defaults.billingReceipts === "awaited") return append;
 		} };
 		runAgentOptions.summarize = summarize;
 		if (profile?.compaction !== void 0) runAgentOptions.compaction = profile.compaction;
@@ -21466,6 +21633,93 @@ function formatCharacterValidator(options) {
 		}
 	};
 }
+/**
+* Every declared literal must appear in the finish result at least
+* once (RV3308). The 2026-08-12 comparison run passed an exact twelve
+* heading contract and a citation floor while its "all publishable
+* packages" table silently dropped four of the seventeen names: shape
+* validators cannot see an enumerable universe, so the universe is
+* declared as literals and each one is held. Purely textual and
+* deterministic; fenced code counts, because tables and inline code
+* are legitimate places to name a package. Default name
+* 'required-mentions'.
+*/
+function requiredMentionsValidator(options) {
+	const terms = requireNonEmptyStrings(options.terms, "requiredMentionsValidator terms");
+	const declared = /* @__PURE__ */ new Set();
+	for (const term of terms) {
+		if (declared.has(term)) throw new ConfigError(`requiredMentionsValidator terms carry a duplicate: '${term}'`);
+		declared.add(term);
+	}
+	return {
+		name: options.name ?? "required-mentions",
+		validate: (input) => {
+			const missing = terms.filter((term) => !input.text.includes(term));
+			if (missing.length === 0) return { ok: true };
+			return {
+				ok: false,
+				reasons: [`required mentions missing from the result: ${missing.slice(0, MAX_LISTED_CITATIONS).map((term) => `'${term}'`).join(", ")}${missing.length > MAX_LISTED_CITATIONS ? ` and ${String(missing.length - MAX_LISTED_CITATIONS)} more` : ""} (${String(missing.length)} of ${String(terms.length)} declared literals)`]
+			};
+		}
+	};
+}
+function requireManifest(manifest) {
+	if (manifest.sections === void 0 && manifest.requiredMentions === void 0 && manifest.words === void 0 && manifest.minCitations === void 0) throw new ConfigError("an OutputContractManifest must declare at least one of sections, requiredMentions, words, or minCitations: an empty manifest gates nothing and prompts for nothing");
+	if (manifest.citationPattern !== void 0 && manifest.minCitations === void 0) throw new ConfigError("OutputContractManifest.citationPattern is only meaningful beside minCitations");
+}
+/**
+* The manifest's gate half (RV3308): heading structure (ordered,
+* exclusive), word bounds, the citation floor, and the mention
+* universe, in that stable order, each through the existing named
+* validator. Everything is derived from the SAME object the prompt
+* block renders from.
+*/
+function manifestValidators(manifest) {
+	requireManifest(manifest);
+	const validators = [];
+	if (manifest.sections !== void 0) validators.push(headingStructureValidator({
+		sections: manifest.sections,
+		ordered: true,
+		exclusive: true
+	}));
+	if (manifest.words !== void 0) validators.push(wordCountValidator(manifest.words));
+	if (manifest.minCitations !== void 0) validators.push(minMatchesValidator({
+		pattern: manifest.citationPattern ?? "[\\w./-]+\\.\\w+:\\d+",
+		min: manifest.minCitations,
+		name: "citation-count"
+	}));
+	if (manifest.requiredMentions !== void 0) validators.push(requiredMentionsValidator({ terms: manifest.requiredMentions }));
+	return validators;
+}
+/**
+* The manifest's prompt half (RV3308): a deterministic requirements
+* block enumerating the SAME headings, bounds, citation floor and
+* literals the validators hold, byte for byte, for the host to embed
+* in its question. Rendering is pure string assembly; nothing here
+* consults the result.
+*/
+function renderContractRequirements(manifest) {
+	requireManifest(manifest);
+	const lines = ["The final document must satisfy every requirement below, verbatim."];
+	if (manifest.sections !== void 0) {
+		const sections = requireNonEmptyStrings(manifest.sections, "renderContractRequirements sections");
+		lines.push(`Exactly ${String(sections.length)} section headings, in this order and none besides:`);
+		for (const section of sections) lines.push(section);
+	}
+	if (manifest.words !== void 0) {
+		const { min, max } = manifest.words;
+		if (min !== void 0 && max !== void 0) lines.push(`Whitespace word count between ${String(min)} and ${String(max)}.`);
+		else if (min !== void 0) lines.push(`Whitespace word count at least ${String(min)}.`);
+		else if (max !== void 0) lines.push(`Whitespace word count at most ${String(max)}.`);
+	}
+	if (manifest.minCitations !== void 0) lines.push(`At least ${String(manifest.minCitations)} citations matching /${manifest.citationPattern ?? "[\\w./-]+\\.\\w+:\\d+"}/.`);
+	if (manifest.requiredMentions !== void 0) {
+		const terms = requireNonEmptyStrings(manifest.requiredMentions, "renderContractRequirements requiredMentions");
+		lines.push("Each of these literal strings must appear at least once:");
+		for (const term of terms) lines.push(term);
+	}
+	return lines.join("\n");
+}
 //#endregion
 //#region src/orchestrator/contradictions.ts
 /**
@@ -22607,7 +22861,11 @@ function validateOrchestrateOptions(opts) {
 		const consistency = opts.claimConsistency;
 		if (typeof consistency !== "object" || Array.isArray(consistency)) throw new ConfigError(`orchestrate claimConsistency must be an object; got ${JSON.stringify(opts.claimConsistency)}`);
 		const onFound = consistency.onFound ?? "report";
-		if (onFound !== "report" && onFound !== "carry" && onFound !== "fail") throw new ConfigError("orchestrate claimConsistency.onFound must be 'report', 'carry' or 'fail'; got " + JSON.stringify(consistency.onFound));
+		if (onFound !== "report" && onFound !== "carry" && onFound !== "fail" && onFound !== "repair") throw new ConfigError(`orchestrate claimConsistency.onFound must be 'report', 'carry', 'fail' or 'repair'; got ${JSON.stringify(consistency.onFound)}`);
+		if (onFound === "repair") {
+			if (opts.synthesis === void 0) throw new ConfigError("orchestrate claimConsistency.onFound 'repair' requires synthesis: the bounded repair round re-dispatches it with the judged findings carried");
+			if (opts.synthesis.mode === "incremental") throw new ConfigError("orchestrate claimConsistency.onFound 'repair' needs a 'single' synthesis: the deterministic 'incremental' reconciliation has no prompt for the findings to ride");
+		}
 		if (onFound === "carry") {
 			if (opts.synthesis === void 0) throw new ConfigError("orchestrate claimConsistency.onFound 'carry' requires synthesis: without the post-fan-in invocation there is no prompt to carry the findings into; use 'report' or 'fail'");
 			if (opts.synthesis.mode === "incremental") throw new ConfigError("orchestrate claimConsistency.onFound 'carry' needs a 'single' synthesis: the deterministic 'incremental' reconciliation has no prompt for the findings to ride");
@@ -22616,6 +22874,7 @@ function validateOrchestrateOptions(opts) {
 		if (stage !== "draft" && stage !== "final" && stage !== "both") throw new ConfigError("orchestrate claimConsistency.stage must be 'draft', 'final' or 'both'; got " + JSON.stringify(consistency.stage));
 		if (stage !== "draft" && opts.synthesis === void 0) throw new ConfigError(`orchestrate claimConsistency.stage '${stage}' requires synthesis: without the post-fan-in invocation the coordination draft IS the final artifact, and the default 'draft' already judges it`);
 		if (stage === "final" && onFound === "carry") throw new ConfigError("orchestrate claimConsistency.onFound 'carry' cannot pair with stage 'final': the final pass runs after the synthesis, so there is no prompt left to carry the findings into; use 'report' or 'fail', or keep a carried draft pass with stage 'both'");
+		if (stage === "draft" && onFound === "repair") throw new ConfigError("orchestrate claimConsistency.onFound 'repair' needs stage 'final' or 'both': the repair consumes the FINAL pass's findings, and the draft pass already has 'carry'");
 		if (consistency.pattern !== void 0) {
 			if (typeof consistency.pattern !== "string") throw new ConfigError(`orchestrate claimConsistency.pattern must be a string; got ${typeof consistency.pattern}`);
 			let probe;
@@ -24874,7 +25133,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					msg: "orchestrator claim consistency judge declined by admission",
 					data: { reason: declined.message.slice(0, 300) }
 				}, callingState.spanId);
-				if (onFound === "fail") throw new FailRunError("the claim-consistency judge could not be admitted within the orchestrator account, so the armed fail posture cannot pass the draft: " + declined.message.slice(0, 300), { data: {
+				if (onFound === "fail" || onFound === "repair") throw new FailRunError(`the claim-consistency judge could not be admitted within the orchestrator account, so the armed ${onFound} posture cannot pass the draft: ` + declined.message.slice(0, 300), { data: {
 					source: "orchestrator_claim_consistency",
 					claimConsistencyMeta,
 					...snapshot ?? {}
@@ -24895,7 +25154,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 						...judged.errorMessage === void 0 ? {} : { error: judged.errorMessage }
 					}
 				}, callingState.spanId);
-				if (onFound === "fail") throw new FailRunError(`the claim-consistency judge did not settle ok (status '${judged.status}'), so the armed fail posture cannot pass the draft`, { data: {
+				if (onFound === "fail" || onFound === "repair") throw new FailRunError(`the claim-consistency judge did not settle ok (status '${judged.status}'), so the armed ${onFound} posture cannot pass the draft`, { data: {
 					source: "orchestrator_claim_consistency",
 					judgeStatus: judged.status,
 					claimConsistencyMeta,
@@ -25063,7 +25322,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 						announceGaps(gapsEntry.seq, failed.map((row) => row.name));
 					}
 					const carryBlocked = opts?.contradictions?.onFound === "carry" && contradictionsFound !== void 0 && contradictionsFound.length > 0;
-					const claimCarryBlocked = opts?.claimConsistency?.onFound === "carry" && claimFindingsFound !== void 0 && claimFindingsFound.length > 0;
+					const claimCarryBlocked = (opts?.claimConsistency?.onFound === "carry" || opts?.claimConsistency?.onFound === "repair") && claimFindingsFound !== void 0 && claimFindingsFound.length > 0;
 					if (failed.length === 0 && (carryBlocked || claimCarryBlocked)) internals.events.emit({
 						type: "log",
 						level: "info",
@@ -25178,7 +25437,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...finishValidationPromptLines(validationSpec, synthSectionalFinish ? "draft-base" : void 0),
 				...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" || 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 ? [] : ["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)],
 				...spec.policyFacts === true ? [(() => {
 					const byStatus = {};
 					let extensionsGranted = 0;
@@ -26025,6 +26284,33 @@ function makeOrchestratorWorkflow(goal, opts) {
 		if (claimStage !== "draft") {
 			claimConsistencyDraftMeta = claimStage === "both" ? claimConsistencyMeta : void 0;
 			await runClaimConsistencyPass(synthesizedFinal, acceptanceSnapshot, "final");
+			if ((opts?.claimConsistency?.onFound ?? "report") === "repair" && claimFindingsFound !== void 0 && claimFindingsFound.length > 0) {
+				const hashOfDocument = (value) => createHash("sha256").update(jcsSerialize(value ?? null), "utf8").digest("hex");
+				const preRepairHash = hashOfDocument(synthesizedFinal);
+				const carried = claimFindingsFound;
+				try {
+					synthesizedFinal = await runSynthesis(result.output);
+				} catch (thrown) {
+					await journalSynthesisAdmissionDecline(thrown);
+					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,
+						repairsUsed: 0,
+						preRepairHash,
+						...acceptanceSnapshot
+					} });
+				}
+				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,
+					claimConsistencyMeta,
+					repairsUsed: 1,
+					preRepairHash,
+					repairedHash: hashOfDocument(synthesizedFinal),
+					...acceptanceSnapshot
+				} });
+			}
 		}
 		const envelopeSchemaRecovered = (result.schemaRecoveredTerminalExchanges ?? 0) + synthesisSchemaRecoveredExchanges;
 		const deliverable = deliverableVerdict(synthesizedFinal);
@@ -26290,6 +26576,36 @@ function preflightEstimate(input) {
 		if (input.orchestrator.estInputTokens !== void 0) requireNonNegativeInteger(input.orchestrator.estInputTokens, "preflight.orchestrator.estInputTokens");
 		if (input.orchestrator.acceptance?.minSpawnedChildren !== void 0) requirePositiveInteger$2(input.orchestrator.acceptance.minSpawnedChildren, "preflight.orchestrator.acceptance.minSpawnedChildren");
 		if (input.orchestrator.claimConsistency?.judge?.estCost !== void 0) requireNonNegativeNumber(input.orchestrator.claimConsistency.judge.estCost, "preflight.orchestrator.claimConsistency.judge.estCost");
+		{
+			const posture = input.orchestrator.claimConsistency;
+			if (posture?.onFound !== void 0 && ![
+				"report",
+				"carry",
+				"fail",
+				"repair"
+			].includes(posture.onFound)) throw new ConfigError(`preflight.orchestrator.claimConsistency.onFound must be 'report', 'carry', 'fail' or 'repair'; got ${JSON.stringify(posture.onFound)}`);
+			if (posture?.stage !== void 0 && ![
+				"draft",
+				"final",
+				"both"
+			].includes(posture.stage)) throw new ConfigError(`preflight.orchestrator.claimConsistency.stage must be 'draft', 'final' or 'both'; got ${JSON.stringify(posture.stage)}`);
+			const stage = posture?.stage ?? "draft";
+			if (posture?.onFound === "repair" && stage === "draft") say({
+				severity: "error",
+				code: "claim-posture-refused-at-intake",
+				message: "claimConsistency.onFound 'repair' needs stage 'final' or 'both' (at the draft stage the repair IS the carry, RV3307): the run would refuse to start"
+			});
+			if (posture?.onFound === "repair" && input.orchestrator.synthesis === void 0) say({
+				severity: "error",
+				code: "claim-posture-refused-at-intake",
+				message: "claimConsistency.onFound 'repair' requires a synthesis: the bounded round is one more composition, and without one there is nothing to repair with: the run would refuse to start"
+			});
+			if (posture?.onFound === "carry" && stage === "final") say({
+				severity: "error",
+				code: "claim-posture-refused-at-intake",
+				message: "claimConsistency.onFound 'carry' cannot pair with stage 'final' (RV3301): the final pass has no synthesis prompt left to ride, and the run would refuse to start; declare onFound 'repair' for the bounded post judge round"
+			});
+		}
 		const spec = input.orchestrator.budget;
 		const fraction = spec?.capFraction ?? .2;
 		const fromFraction = ceilingUsd === void 0 ? void 0 : fraction * ceilingUsd;
@@ -26530,9 +26846,20 @@ function preflightEstimate(input) {
 		if (positiveCallCap || limits.toolUnits !== void 0) anyCappedSpawn = true;
 		const evidenceContract = spec.evidenceContract ?? profile?.evidenceContract;
 		if (evidenceContract !== void 0 && executedToolCallCeiling !== null) {
-			const perEntry = evidenceContract.estCallsPerEntry ?? 3;
+			const declaredPerEntry = evidenceContract.estCallsPerEntry ?? 3;
+			const observed = evidenceContract.calibration?.callsPerEntry;
+			const perEntry = observed === void 0 ? declaredPerEntry : Math.max(declaredPerEntry, observed);
+			if (observed !== void 0 && observed > declaredPerEntry) {
+				const source = evidenceContract.calibration?.source === void 0 ? "" : ` (source: ${evidenceContract.calibration.source})`;
+				say({
+					severity: "info",
+					code: "evidence-estimate-below-observed",
+					message: `spawn '${label}' declares ${String(declaredPerEntry)} estimated calls per evidence entry, but the supplied calibration observed ${String(observed)}${source}: the evidence call floor uses the observed figure`,
+					spawn: label
+				});
+			}
 			const overhead = evidenceContract.overheadCalls ?? 8;
-			const floor = evidenceContract.minEntries * perEntry + overhead;
+			const floor = Math.ceil(evidenceContract.minEntries * perEntry) + overhead;
 			if (executedToolCallCeiling < floor) say({
 				severity: "warning",
 				code: "tool-cap-below-evidence-floor",
@@ -26842,30 +27169,38 @@ function preflightEstimate(input) {
 	const ceilingHeadroomUsd = ceilingUsd === void 0 || requiredMinimumCeilingUsd === void 0 ? void 0 : ceilingUsd - requiredMinimumCeilingUsd;
 	const ceilingHeadroomShare = ceilingHeadroomUsd === void 0 || ceilingUsd === void 0 || ceilingUsd <= 0 ? void 0 : ceilingHeadroomUsd / ceilingUsd;
 	const minCeilingHeadroomShare = input.orchestrator?.minCeilingHeadroomShare ?? 0;
+	const ceilingHeadroomSeverity = input.orchestrator?.ceilingHeadroomSeverity ?? "warning";
+	if (ceilingHeadroomSeverity !== "warning" && ceilingHeadroomSeverity !== "error") throw new ConfigError("preflight orchestrator.ceilingHeadroomSeverity must be 'warning' or 'error'; got " + JSON.stringify(input.orchestrator?.ceilingHeadroomSeverity));
 	if (ceilingHeadroomShare !== void 0 && minCeilingHeadroomShare > 0 && ceilingHeadroomShare < minCeilingHeadroomShare) say({
-		severity: "warning",
+		severity: ceilingHeadroomSeverity,
 		code: "ceiling-headroom-thin",
 		message: `the ceiling headroom is ${(ceilingHeadroomShare * 100).toFixed(2)} percent of the ceiling (${(ceilingHeadroomUsd ?? 0).toFixed(4)} USD over the required minimum ${(requiredMinimumCeilingUsd ?? 0).toFixed(4)} USD), below the declared ${(minCeilingHeadroomShare * 100).toFixed(2)} percent floor: a small pricing or context drift refuses the whole wave at admission; raise the ceiling or slim the wave`
 	});
+	const claimPosture = input.orchestrator?.claimConsistency;
+	const repairArmed = claimPosture?.onFound === "repair";
+	const worstJudgePasses = ((claimPosture?.stage ?? "draft") === "both" ? 2 : 1) + (repairArmed ? 1 : 0);
 	{
 		const judgeEstUsd = input.orchestrator?.claimConsistency?.judge?.estCost;
 		if (judgeEstUsd !== void 0 && effectiveCapUsd !== void 0 && synthesisHoldUsd > 0) {
 			const workingRoomUsd = effectiveCapUsd - synthesisHoldUsd;
-			if (workingRoomUsd < liveRootExposureTermUsd + judgeEstUsd) say({
+			const repairCompositionUsd = repairArmed ? synthesisHoldUsd : 0;
+			if (workingRoomUsd < liveRootExposureTermUsd + judgeEstUsd * worstJudgePasses + repairCompositionUsd) say({
 				severity: "warning",
 				code: "orchestrator-working-room",
-				message: `the orchestrator account's working room past the held synthesis reserve is ${workingRoomUsd.toFixed(4)} USD (cap ${effectiveCapUsd.toFixed(4)} minus the ${synthesisHoldUsd.toFixed(4)} USD hold), below one coordination turn floor (${liveRootExposureTermUsd.toFixed(4)} USD) plus the declared ${judgeEstUsd.toFixed(4)} USD claim-consistency judge estimate: the judge admission will be declined once the coordination loop has taken even one turn, and the pass degrades to its journaled declined verdict (RV2106); raise the cap, shrink the judge estimate, or shrink the synthesis reserve`
+				message: `the orchestrator account's working room past the held synthesis reserve is ${workingRoomUsd.toFixed(4)} USD (cap ${effectiveCapUsd.toFixed(4)} minus the ${synthesisHoldUsd.toFixed(4)} USD hold), below one coordination turn floor (${liveRootExposureTermUsd.toFixed(4)} USD) plus the declared ${judgeEstUsd.toFixed(4)} USD claim-consistency judge estimate` + (worstJudgePasses === 1 ? "" : ` across ${String(worstJudgePasses)} passes at worst (RV3402)`) + (repairArmed ? ` plus one repair round composition priced at the ${synthesisHoldUsd.toFixed(4)} USD reserve (RV3307)` : "") + ": the judge admission will be declined once the coordination loop has taken even one turn, and " + (claimPosture?.onFound === "fail" || claimPosture?.onFound === "repair" ? `under the armed '${claimPosture.onFound}' posture the declined judge stops the run typed (RV3307)` : "the pass degrades to its journaled declined verdict (RV2106)") + "; raise the cap, shrink the judge estimate, or shrink the synthesis reserve"
 			});
 		}
 	}
 	if (orchestrateWave && wave.length > 0 && admitted === wave.length) {
 		const lifetimeSpawnCap = input.engine?.budgetDefaults?.lifetimeSpawnCap ?? 500;
-		const judgeDeclared = input.orchestrator?.claimConsistency?.judge !== void 0;
+		const judgeDeclared = input.orchestrator?.claimConsistency !== void 0;
 		const synthesisDeclared = input.orchestrator?.synthesis !== void 0;
-		const plannedSpawns = wave.length + (judgeDeclared ? 1 : 0) + (synthesisDeclared ? 1 : 0);
+		const judgeSpawns = judgeDeclared ? worstJudgePasses : 0;
+		const repairSpawns = repairArmed && synthesisDeclared ? 1 : 0;
+		const plannedSpawns = wave.length + judgeSpawns + (synthesisDeclared ? 1 : 0) + repairSpawns;
 		const spawnHeadroom = lifetimeSpawnCap - plannedSpawns;
 		if (spawnHeadroom <= 0) {
-			const breakdown = `the admitted wave of ${String(wave.length)} agent invocations` + (judgeDeclared ? " plus the claim-consistency judge" : "") + (synthesisDeclared ? " plus the synthesis invocation" : "") + ` is ${String(plannedSpawns)} against budgetDefaults.lifetimeSpawnCap ` + String(lifetimeSpawnCap);
+			const breakdown = `the admitted wave of ${String(wave.length)} agent invocations` + (judgeDeclared ? judgeSpawns === 1 ? " plus the claim-consistency judge" : ` plus ${String(judgeSpawns)} claim-consistency judge passes at worst` : "") + (synthesisDeclared ? " plus the synthesis invocation" : "") + (repairSpawns === 0 ? "" : " plus the repair round composition") + ` is ${String(plannedSpawns)} against budgetDefaults.lifetimeSpawnCap ` + String(lifetimeSpawnCap);
 			say({
 				severity: "warning",
 				code: "tail-spawn-budget",
@@ -27945,6 +28280,7 @@ function createEngine(options) {
 		if (profile.countTokens !== void 0 && !["allow", "deny"].includes(profile.countTokens)) throw new ConfigError(`createEngine defaults.profiles['${name}'].countTokens must be 'allow' or 'deny'`);
 	}
 	if (options.defaults?.countTokens !== void 0 && !["allow", "deny"].includes(options.defaults.countTokens)) throw new ConfigError("createEngine defaults.countTokens must be 'allow' or 'deny'");
+	if (options.defaults?.billingReceipts !== void 0 && !["async", "awaited"].includes(options.defaults.billingReceipts)) throw new ConfigError("createEngine defaults.billingReceipts must be 'async' or 'awaited'");
 	if (options.telemetry?.quotaDeniedAgentError !== void 0 && typeof options.telemetry.quotaDeniedAgentError !== "boolean") throw new ConfigError("createEngine telemetry.quotaDeniedAgentError must be a boolean");
 	validateDeterminismConfig(options.determinism);
 	validateEngineQuotaConfig(options.quota);
@@ -28142,7 +28478,8 @@ function createEngine(options) {
 				...defaults.toolsets === void 0 ? {} : { toolsets: defaults.toolsets },
 				...defaults.gates === void 0 ? {} : { gates: defaults.gates },
 				...defaults.countTokens === void 0 ? {} : { countTokens: defaults.countTokens },
-				...defaults.cache === void 0 ? {} : { cache: defaults.cache }
+				...defaults.cache === void 0 ? {} : { cache: defaults.cache },
+				...defaults.billingReceipts === void 0 ? {} : { billingReceipts: defaults.billingReceipts }
 			},
 			...options.telemetry === void 0 ? {} : { telemetry: options.telemetry },
 			errorPolicy: wf.errorPolicy,
@@ -29107,4 +29444,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, 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, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, 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, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, 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, 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_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 };

package/package.json

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