@rulvar/core 1.231.0 → 1.233.0

package/dist/index.d.ts

@@ -1085,6 +1085,24 @@ type JournalEntry = {
     citation?: string;
   }>;
   /**
+  * Terminal agent entries: the durable subset of the tool-budget
+  * summary (RV3002): the loop's executed-call counter and the
+  * effective cap at the end, journaled at settle whenever the live
+  * result carried a summary. The counter has always been durable in
+  * the terminal checkpoint, but checkpoints are blobs and journal
+  * folds read entries only, so without this field observed
+  * calls-per-evidence-entry calibration cannot be a pure fold. Replay
+  * restores AgentResult.toolBudget from here unconditionally; entries
+  * without the field (every pre-existing journal) keep the RV509
+  * decision-conditional path byte for byte. Live-only summary fields
+  * (unitsUsed, noticesFired, limiter, and the rest) never journal.
+  * Policy, never identity, exactly like evidence.
+  */
+  toolBudget?: {
+    used: number;
+    cap?: number;
+  };
+  /**
   * Terminal escalated entries ONLY: the schema-validated
   * EscalationReport with runtime-filled costToDate and salvage; replay
   * synthesizes the byte-identical report from here (DEF-1).
@@ -2357,16 +2375,19 @@ interface ExplorationSummary {
 * visible BEFORE the terminal 'limit' a starved worker would settle
 * with. Attached to the full AgentResult and to the live `agent:end`
 * event whenever maxToolCalls, toolUnits, or toolBudgetExtension is
-* configured. The snapshot itself never journals, but since RV509 it
-* has a durable subset: an extension grant and the finalization-window
-* entry journal as decision entries the moment they fire, a
-* crash-resume restores them from the journal, and a replayed result
-* carries `used` (from the terminal checkpoint), the granted `cap`,
-* `extensionsGranted`, and `finalizationWindowEntered` whenever the
-* invocation journaled at least one such decision. Every other field
-* (unitsUsed/unitsMax, noticesFired, finalizationReserveUsed, limiter,
-* and the cap of a grant-free run) is live-only fidelity, exactly like
-* transportRetries, and stays absent on replay.
+* configured. The durable subset: since RV3002 the terminal entry
+* journals `used` and the effective `cap` at settle, so a replayed
+* result restores them unconditionally on new journals; an extension
+* grant and the finalization-window entry journal as decision entries
+* the moment they fire (RV509) and merge into the restored summary as
+* `extensionsGranted` and `finalizationWindowEntered`. A journal
+* written before the entry field shipped keeps the RV509 behavior byte
+* for byte: `used` from the terminal checkpoint plus the
+* decision-backed fields, present exactly when the invocation
+* journaled at least one decision. Every other field
+* (unitsUsed/unitsMax, noticesFired, finalizationReserveUsed, limiter)
+* is live-only fidelity, exactly like transportRetries, and stays
+* absent on replay.
 */
 interface ToolBudgetSummary {
   /** Executed tool calls (the loop's own counter). */
@@ -3732,6 +3753,11 @@ interface TerminalPatch {
     claim: string;
     citation?: string;
   }>;
+  /** Terminal agent entries: the durable tool-budget subset; see JournalEntry. */
+  toolBudget?: {
+    used: number;
+    cap?: number;
+  };
   /** Terminal escalated entries: the validated EscalationReport. */
   escalation?: unknown;
   /**
@@ -7854,6 +7880,19 @@ interface ResumeOptions {
   */
   args?: unknown;
   /**
+  * What an in-process body-hash mismatch does (RV3001). The default
+  * 'warn' keeps the historical design: the mismatch emits the loud
+  * `RULVAR_RESUME_HASH_MISMATCH` warning and the resume proceeds,
+  * because the journal decides replay versus live per content keys
+  * and reports orphans honestly. 'refuse' turns the same mismatch
+  * into a typed ConfigError BEFORE ownership, meta writes, or any
+  * append: the pin for hosts that treat an edited body as a
+  * different workflow. The vocabulary is
+  * {@link EvidenceContract.enforce}'s. Name mismatches and compiled
+  * source mismatches are hard errors regardless, exactly as before.
+  */
+  bodyHash?: "warn" | "refuse";
+  /**
   * Dry-run: replay-strict matching; the first would-be-live call throws
   * JournalMissError and the run settles with that typed error, zero live
   * calls performed.
@@ -7905,7 +7944,9 @@ interface Engine {
   * Rebinds a journal to a workflow definition and resumes. Requires wf
   * for in-process workflows;
   * a name mismatch is a typed ConfigError; a body-hash mismatch warns
-  * loudly and proceeds (the journal decides replay per content keys).
+  * loudly and proceeds (the journal decides replay per content keys),
+  * unless {@link ResumeOptions.bodyHash} is 'refuse', which makes it
+  * a typed ConfigError before any durable mutation (RV3001).
   * A compiled run resumes WITHOUT wf: the engine rehydrates the
   * persisted source pinned by workflowHash; supplying a compiled wf
   * whose source hash differs from the recorded one is a typed
@@ -8709,6 +8750,22 @@ interface ClaimPairOptions {
   * 40).
   */
   critical?: readonly string[];
+  /**
+  * The declared coverage target (RV2903), in (0, 1]: size the
+  * reported pairs to COVER at least this share of the citing
+  * sentences instead of taking the first `max` pairs blind. The
+  * ninth comparison run judged 43 of 115 citing sentences because
+  * its host guessed `max: 56`, and nothing sized the pass to a goal.
+  * Under a target the selection is coverage-first: every critical
+  * candidate, then ONE candidate per still-uncovered sentence in
+  * draft order until the target is met; pairs that only deepen an
+  * already covered sentence are skipped, because under a declared
+  * target the bounded budget buys coverage, not depth. `max` stays a
+  * hard ceiling, and `truncated` then means exactly that the ceiling
+  * cut selection the target still wanted. Unset = the exact
+  * historical first-`max` selection, byte for byte.
+  */
+  targetCoverageShare?: number;
 }
 /** What the fold produced, beside the pairs themselves. */
 interface ClaimPairsFold {
@@ -8727,6 +8784,13 @@ interface ClaimPairsFold {
   */
   coveredCitingSentences: number;
   /**
+  * Present when `targetCoverageShare` was declared (RV2903): the
+  * sentence count the target resolved to against THIS draft, so a
+  * consumer holds `coveredCitingSentences` against the goal the
+  * selection was sized for, not against a share it must re-derive.
+  */
+  targetCoveredSentences?: number;
+  /**
   * Present only when `critical` was given: the critical draft anchors
   * (verbatim, draft order, deduplicated) with no reported pair, capped
   * at {@link MAX_CRITICAL_UNCOVERED} entries.
@@ -10252,6 +10316,22 @@ interface OrchestrateClaimConsistency {
   /** Bound on each excerpt; default {@link DEFAULT_MAX_PAIR_EXCERPT_CHARS}. */
   maxExcerptChars?: number;
   /**
+  * The declared coverage target (RV2903), in (0, 1]: the pass sizes
+  * itself to COVER this share of the draft's citing sentences instead
+  * of judging the first `max` pairs blind. The ninth comparison run
+  * covered 43 of 115 citing sentences because its host guessed
+  * `max: 56` plus the default run-fact bound, and the honest
+  * 'partial' grade was the constant's echo, not a policy. Under a
+  * target the pairing selects coverage-first (criticals, then one
+  * pair per uncovered sentence until the target is met; `max` stays a
+  * hard ceiling), the run-fact pass judges EVERY matched candidate
+  * instead of the default bound, and an undeclared
+  * `minimumCoverageRatio` defaults to the target, so the RV1809
+  * floor machinery (the `lowCoverage` block, `onLowCoverage`, the
+  * strict CLI exit) enforces the same number that sized the pass.
+  */
+  coverageTarget?: number;
+  /**
   * Critical anchor declarations (RV1603): paths (a file, or a
   * directory matched as a prefix) or span anchors
   * (`src/exec.ts:250-300`). Pairs whose draft anchor matches sort
@@ -10353,6 +10433,12 @@ interface OrchestrateClaimConsistencyMeta {
   */
   coveredCitingSentences: number;
   /**
+  * Present when `coverageTarget` was declared (RV2903): the share the
+  * pass sized itself for, echoed so a persisted outcome says WHAT the
+  * coverage was held against, not only what it reached.
+  */
+  coverageTarget?: number;
+  /**
   * Present when `critical` was declared: the critical draft anchors
   * with no judged pair (capped at {@link MAX_CRITICAL_UNCOVERED});
   * `[]` means every declared claim the draft cited was judged.
@@ -10487,8 +10573,23 @@ interface OrchestrateSynthesis {
   * (harness-observed, not production evidence). Folded ONLY from
   * journal-replayed material; off by default, and the prompt stays
   * byte identical when unset.
-  */
-  runFacts?: boolean;
+  *
+  * The object form (RV3004) keeps the child line and adds opt-ins.
+  * `workflowSoFar: true` appends a RUN FACTS SO FAR line: the same
+  * counters folded over the settled children PLUS this
+  * orchestration's own settled internal spans as of this dispatch's
+  * composition (coordination turns, draft claim judges, judged
+  * contradiction passes, synthesis notes), so the number the model
+  * quotes sits next to the invoice instead of a third of it. The
+  * composing dispatch itself and anything still running are excluded
+  * by construction, the line says so, and dollars stay absent for
+  * the same replay reason as the child line. `runFacts: true` keeps
+  * today's prompt bytes exactly; the SO FAR line exists only under
+  * the object opt-in.
+  */
+  runFacts?: boolean | {
+    workflowSoFar?: boolean;
+  };
   /**
   * Admission estimate for the synthesize invocation, like
   * AgentOpts.estCost: under a tight orchestrator cap the default
@@ -13012,6 +13113,11 @@ interface JournaledChild {
     minEntries: number;
     met: boolean;
   };
+  /** The RV3002 durable tool-budget subset, when the terminal journaled it. */
+  toolBudget?: {
+    used: number;
+    cap?: number;
+  };
   /**
   * Present and true when the orchestration ABANDONED this child's
   * branch (RV2804): the work happened and the provider billed it, and
@@ -13177,6 +13283,156 @@ interface JournaledCriticalPath {
 */
 declare function criticalPathFromJournal(entries: readonly JournalEntry[]): JournaledCriticalPath;
 //#endregion
+//#region src/stores/synthesis-candidates.d.ts
+/** One failed validator on a journaled finish verdict, verbatim. */
+interface SynthesisCandidateFailure {
+  name: string;
+  reasons: readonly string[];
+}
+/** One finish candidate, folded from its journaled verdict (RV2902). */
+interface JournaledSynthesisCandidate {
+  /** The journaled verdict: 'accepted', 'repair', or 'rejected'. */
+  verdict: "accepted" | "repair" | "rejected";
+  /** The verdict decision's seq: the candidate's address in the run. */
+  verdictSeq: number;
+  /** The verdict decision's stamp, when the entry carried one. */
+  verdictAt?: string;
+  /** The finish call id the verdict was keyed by. */
+  callId?: string;
+  /** Repairs spent BEFORE this candidate, from the verdict itself. */
+  repairsUsed?: number;
+  maxRepairs?: number;
+  /** The contract generation the verdict was rendered under. */
+  contractHash?: string;
+  /** The non-accepted candidate's identity (RV2507), when journaled. */
+  candidateHash?: string;
+  candidateChars?: number;
+  /** The rejected candidate's transcript blob, under retention. */
+  candidateRef?: string;
+  /** The failed validators with their reasons, verbatim. */
+  failed: readonly SynthesisCandidateFailure[];
+  /** The hosting span's dispatch label (RV2901), when journaled. */
+  spanLabel?: string;
+  /**
+  * Wall from the previous boundary (the span's start, or the prior
+  * verdict) to this verdict's stamp. Absent when the candidate is not
+  * hosted by a settled synthesize span or a stamp is missing.
+  */
+  windowMs?: number;
+  /**
+  * Provider wire requests inside this candidate's window (absorbed
+  * continuations counted). Present only when the incremental rows
+  * cover the hosting span's terminal call records exactly.
+  */
+  wires?: number;
+  /** Summed recorded usage of the window's wires; same condition. */
+  usage?: Usage;
+  /**
+  * Window wires that recorded NO usage on a non-ok outcome: the
+  * provider may have billed them anyway, so `costUsd` is a floor
+  * whenever this is nonzero.
+  */
+  usageUnknownWires?: number;
+  /**
+  * The window priced per call at the caller's table. Present only
+  * when a price function was given and it priced EVERY window wire;
+  * an unpriced model drops the field rather than shrinking it.
+  */
+  costUsd?: number;
+}
+/** What `synthesisCandidatesFromJournal` folded, beside the candidates. */
+interface JournaledSynthesisCandidateReport {
+  /** Every hosted candidate, in verdict seq order. */
+  candidates: readonly JournaledSynthesisCandidate[];
+  /** Settled synthesize spans the journal holds. */
+  synthesisSpans: number;
+  /**
+  * Finish verdicts NOT hosted by a settled synthesize span: draft
+  * stage validations in the coordination span, and verdicts inside a
+  * synthesis that never settled. Counted, never guessed into
+  * candidates.
+  */
+  unhostedVerdicts: number;
+  /**
+  * Settled synthesize spans whose incremental billing rows do not
+  * cover their terminal call records (the rows append asynchronously
+  * and may be missing); their candidates carry verdict facts only.
+  */
+  unattributedSpans: number;
+  /** Wires after a span's LAST verdict: attributed to no candidate. */
+  tailWires: number;
+}
+/**
+* Fold the finish candidates (RV2902) out of a run's journal: each
+* journaled validation verdict with the window of wall, wires, usage,
+* and priced cost that produced the candidate it judged.
+*
+* @param entries the journal of one run, in any order
+* @param priceUsd prices one call's usage at its serving model, the
+*   same shape `invoiceFromJournal` takes; omit to fold without money
+*/
+declare function synthesisCandidatesFromJournal(entries: readonly JournalEntry[], priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined): JournaledSynthesisCandidateReport;
+//#endregion
+//#region src/stores/tool-calibration.d.ts
+/** One dispatch carrying BOTH sides of the calibration pair (RV3003). */
+interface ToolCalibrationRow {
+  /** The scope the dispatch journaled under. */
+  scope: string;
+  /** The dispatch seq (the terminal's `ref`): the child's handle. */
+  handle: number;
+  /** The profile the dispatch ran under, when the terminal recorded it. */
+  agentType?: string;
+  /** The journaled terminal status. */
+  status: string;
+  /** Successful `record_evidence` executions the RV806 verdict counted. */
+  recordedEntries: number;
+  /** The declared floor the verdict was judged against. */
+  minEntries: number;
+  /** Executed tool calls the RV3002 terminal subset journaled. */
+  toolCallsUsed: number;
+  /** `toolCallsUsed / recordedEntries`; absent when recordedEntries is 0. */
+  callsPerEntry?: number;
+}
+/** A dispatch named but excluded from the rate: one side is NOT RECORDED. */
+interface ToolCalibrationExclusion {
+  scope: string;
+  handle: number;
+  status: string;
+}
+/** The observed calls-per-evidence-entry calibration of one journal (RV3003). */
+interface ToolCalibrationReport {
+  /** Terminal agent dispatches the journal holds, the partition's whole. */
+  dispatches: number;
+  /** Dispatches carrying both the verdict and the counter, in seq order. */
+  observed: ToolCalibrationRow[];
+  /**
+  * The observed aggregate over `observed` rows: summed executed calls
+  * against summed recorded entries, with the rate absent when the
+  * entry sum is 0. Absent entirely when no row paired.
+  */
+  aggregate?: {
+    toolCallsUsed: number;
+    recordedEntries: number;
+    callsPerEntry?: number;
+  };
+  /** A declared contract whose counter was never journaled (pre-RV3002 journals). */
+  evidenceOnly: ToolCalibrationExclusion[];
+  /** A journaled counter with no declared contract: nothing to divide by. */
+  budgetOnly: ToolCalibrationExclusion[];
+  /** Dispatches carrying neither side. */
+  unobserved: number;
+}
+/**
+* Folds the observed tool-budget calibration from a journal (RV3003):
+* every terminal agent entry is partitioned by which sides of the
+* evidence/counter pair it recorded, the paired rows carry their
+* per-dispatch rate, and the aggregate is the number a host compares
+* against its declared `estCallsPerEntry`. Pure over the entries, so
+* live and resumed journals fold identically; nothing is re-derived
+* and no checkpoint blob is read.
+*/
+declare function toolCalibrationFromJournal(entries: readonly JournalEntry[]): ToolCalibrationReport;
+//#endregion
 //#region src/stores/jsonl.d.ts
 declare class JsonlFileStore implements MetaLookupStore {
   private readonly dir;
@@ -13773,6 +14029,32 @@ declare function statementFromRows(input: {
   rows: readonly Record<string, unknown>[];
   map: StatementColumnMap;
 }): ProviderStatement;
+/** How {@link statementRowsFromDelimited} splits cells; default ','. */
+interface DelimitedStatementOptions {
+  delimiter?: "," | ";" | "	" | "|";
+}
+/**
+* Parses a delimited billing export (the CSV/TSV a provider console
+* hands a host) into the header-keyed rows {@link statementFromRows}
+* consumes (RV2908). The library deliberately hard-codes NO provider's
+* export format: the host owns the column map, this owns only the
+* delimited grammar, and the pair closes the last manual step between
+* a downloaded export and {@link reconcileStatement}.
+*
+* Fail-closed at the record, like the rest of this module: a data row
+* whose cell count differs from the header, a quote opened and never
+* closed, a stray quote inside an unquoted cell, an empty or duplicate
+* header name, all refuse typed with the line instead of flowing a
+* shifted column into a reconciliation, because a column shifted one
+* to the left prices `outputTokens` as dollars and calls it evidence.
+* RFC 4180 quoting is honored (quoted cells may carry the delimiter,
+* doubled quotes, and line breaks); CRLF and lone LF both delimit
+* records; one trailing empty line is an artifact of every exporter
+* and is ignored. Cells come back as raw strings, so an empty cell
+* reads as "the export does not carry this figure" downstream, exactly
+* the absence contract `statementFromRows` documents.
+*/
+declare function statementRowsFromDelimited(text: string, options?: DelimitedStatementOptions): Record<string, string>[];
 //#endregion
 //#region src/engine/persisted-terminal.d.ts
 /**
@@ -14876,6 +15158,23 @@ interface PostFanInBreakdown {
 * composition in {@link reduceCriticalPath}.
 */
 declare const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
+/**
+* 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
+* split demands a label on EVERY synthesize span, and the comparison
+* run that shipped the journal fold still refused it because this one
+* dispatch stayed anonymous while the claim judge was labelled.
+*/
+declare const FINAL_COMPOSITION_LABEL = "final-composition";
+/**
+* The label an incremental synthesis note dispatches under (RV2901).
+* Notes ride role 'synthesize' and are composition-side work, so both
+* reducers count them toward the composition half of the split; the
+* label exists so a journal reader can tell WHICH composition spans
+* were notes without guessing from their size.
+*/
+declare const SYNTHESIS_NOTE_LABEL = "synthesis-note";
 declare function reduceCriticalPath(events: Iterable<WorkflowEvent>): CriticalPath;
 //#endregion
 //#region src/runner/sandbox-bridge.d.ts
@@ -14950,4 +15249,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, 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, 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, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, JournaledChild, JournaledChildRoster, JournaledCriticalPath, 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, 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, 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, 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, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, 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, 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 };

package/dist/index.js

@@ -7902,6 +7902,7 @@ var Replayer = class {
 			if (patch.checkpointRef !== void 0) entry.checkpointRef = patch.checkpointRef;
 			if (patch.evidence !== void 0) entry.evidence = patch.evidence;
 			if (patch.evidenceEntries !== void 0) entry.evidenceEntries = patch.evidenceEntries;
+			if (patch.toolBudget !== void 0) entry.toolBudget = patch.toolBudget;
 			if (patch.artifacts !== void 0) entry.artifacts = toJournalValue(patch.artifacts, "terminal artifacts");
 			if (patch.escalation !== void 0) entry.escalation = toJournalValue(patch.escalation, "escalation report");
 			if (patch.memoizeOutcome !== void 0) entry.memoizeOutcome = patch.memoizeOutcome;
@@ -8972,7 +8973,8 @@ function childRostersFromJournal(entries) {
 			...abandoned.isAbandoned(dispatch.seq) ? { abandoned: true } : {},
 			...terminal?.costAttribution?.agentType === void 0 ? {} : { agentType: terminal.costAttribution.agentType },
 			...terminal === void 0 ? {} : { status: terminal.status },
-			...terminal?.evidence === void 0 ? {} : { evidence: { ...terminal.evidence } }
+			...terminal?.evidence === void 0 ? {} : { evidence: { ...terminal.evidence } },
+			...terminal?.toolBudget === void 0 ? {} : { toolBudget: { ...terminal.toolBudget } }
 		});
 	}
 	return [...rosters.values()];
@@ -9221,6 +9223,23 @@ function reduceInvocationTable(events) {
 * composition in {@link reduceCriticalPath}.
 */
 const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
+/**
+* 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
+* split demands a label on EVERY synthesize span, and the comparison
+* run that shipped the journal fold still refused it because this one
+* dispatch stayed anonymous while the claim judge was labelled.
+*/
+const FINAL_COMPOSITION_LABEL = "final-composition";
+/**
+* The label an incremental synthesis note dispatches under (RV2901).
+* Notes ride role 'synthesize' and are composition-side work, so both
+* reducers count them toward the composition half of the split; the
+* label exists so a journal reader can tell WHICH composition spans
+* were notes without guessing from their size.
+*/
+const SYNTHESIS_NOTE_LABEL = "synthesis-note";
 /** Total length of the union of possibly overlapping intervals. */
 function unionLength(intervals) {
 	const positive = intervals.filter((interval) => interval.to > interval.from);
@@ -9380,7 +9399,7 @@ function reduceCriticalPath(events) {
 }
 //#endregion
 //#region src/stores/critical-path.ts
-const parse = (at) => {
+const parse$1 = (at) => {
 	if (at === void 0) return;
 	const ms = Date.parse(at);
 	return Number.isFinite(ms) ? ms : void 0;
@@ -9403,8 +9422,8 @@ function criticalPathFromJournal(entries) {
 	let labelledSynthesis = false;
 	let unlabelledSynthesis = false;
 	for (const entry of ordered) {
-		const startedAt = parse(entry.startedAt);
-		const endedAt = parse(entry.endedAt);
+		const startedAt = parse$1(entry.startedAt);
+		const endedAt = parse$1(entry.endedAt);
 		if (startedAt !== void 0) runStart = runStart === void 0 ? startedAt : Math.min(runStart, startedAt);
 		const last = endedAt ?? startedAt;
 		if (last !== void 0) runEnd = runEnd === void 0 ? last : Math.max(runEnd, last);
@@ -9453,6 +9472,249 @@ function criticalPathFromJournal(entries) {
 	return path;
 }
 //#endregion
+//#region src/stores/synthesis-candidates.ts
+const parse = (at) => {
+	if (at === void 0) return;
+	const ms = Date.parse(at);
+	return Number.isFinite(ms) ? ms : void 0;
+};
+const VERDICTS = /* @__PURE__ */ new Set([
+	"accepted",
+	"repair",
+	"rejected"
+]);
+const OPTIONAL_USAGE_KEYS = [
+	"reasoningTokens",
+	"cacheWrite5mTokens",
+	"cacheWrite1hTokens"
+];
+function sumUsage$1(rows) {
+	const total = {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0
+	};
+	for (const row of rows) {
+		if (row.usage === void 0) continue;
+		total.inputTokens += row.usage.inputTokens;
+		total.outputTokens += row.usage.outputTokens;
+		total.cacheReadTokens += row.usage.cacheReadTokens;
+		total.cacheWriteTokens += row.usage.cacheWriteTokens;
+		for (const key of OPTIONAL_USAGE_KEYS) {
+			const share = row.usage[key];
+			if (share !== void 0) total[key] = (total[key] ?? 0) + share;
+		}
+	}
+	return total;
+}
+const usageUnknown = (row) => {
+	if (row.outcome === "ok") return false;
+	const usage = row.usage;
+	if (usage === void 0) return true;
+	return usage.inputTokens === 0 && usage.outputTokens === 0 && usage.cacheReadTokens === 0 && usage.cacheWriteTokens === 0 && (usage.reasoningTokens ?? 0) === 0;
+};
+/**
+* Fold the finish candidates (RV2902) out of a run's journal: each
+* journaled validation verdict with the window of wall, wires, usage,
+* and priced cost that produced the candidate it judged.
+*
+* @param entries the journal of one run, in any order
+* @param priceUsd prices one call's usage at its serving model, the
+*   same shape `invoiceFromJournal` takes; omit to fold without money
+*/
+function synthesisCandidatesFromJournal(entries, priceUsd) {
+	const ordered = [...entries].sort((a, b) => a.seq - b.seq);
+	const spans = [];
+	for (const entry of ordered) {
+		if (entry.kind !== "agent" || entry.status === "running" || entry.status === "suspended" || entry.costAttribution?.role !== "synthesize" || typeof entry.ref !== "number") continue;
+		spans.push({
+			runningSeq: entry.ref,
+			terminalSeq: entry.seq,
+			startedAt: parse(entry.startedAt),
+			...entry.costAttribution.label === void 0 ? {} : { label: entry.costAttribution.label },
+			records: entry.providerCalls,
+			wires: [],
+			verdictSeqs: []
+		});
+	}
+	const bySeqOpen = /* @__PURE__ */ new Map();
+	for (const span of spans) bySeqOpen.set(span.runningSeq, span);
+	const verdicts = [];
+	for (const entry of ordered) {
+		if (entry.kind !== "decision") continue;
+		const value = entry.value;
+		if (value === void 0) continue;
+		if (value.decisionType === "provider-call") {
+			const wire = value;
+			if (typeof wire.agentRef !== "number") continue;
+			const span = bySeqOpen.get(wire.agentRef);
+			const record = wire.record;
+			if (span === void 0 || record === void 0 || typeof record.ordinal !== "number") continue;
+			span.wires.push({
+				seq: entry.seq,
+				ordinal: record.ordinal,
+				...typeof record.servedBy === "string" ? { servedBy: record.servedBy } : {},
+				outcome: typeof record.outcome === "string" ? record.outcome : "ok",
+				...record.usage === void 0 ? {} : { usage: record.usage },
+				wireRequests: typeof record.wireRequests === "number" ? record.wireRequests : 1
+			});
+			continue;
+		}
+		if (value.decisionType !== "orchestrator_finish_validation") continue;
+		const verdictValue = value;
+		if (typeof verdictValue.verdict !== "string" || !VERDICTS.has(verdictValue.verdict)) continue;
+		let host;
+		for (const span of spans) if (entry.seq > span.runningSeq && entry.seq < span.terminalSeq) {
+			if (host === void 0 || span.runningSeq > host.runningSeq) host = span;
+		}
+		if (host !== void 0) host.verdictSeqs.push(entry.seq);
+		verdicts.push({
+			seq: entry.seq,
+			...entry.startedAt === void 0 ? {} : { at: entry.startedAt },
+			value: verdictValue,
+			...host === void 0 ? {} : { span: host }
+		});
+	}
+	const attributable = /* @__PURE__ */ new Set();
+	let unattributedSpans = 0;
+	for (const span of spans) {
+		const recorded = (span.records ?? []).map((record) => record.ordinal).sort((a, b) => a - b);
+		const rows = [...span.wires].map((wire) => wire.ordinal).sort((a, b) => a - b);
+		if (span.records !== void 0 && recorded.length === rows.length && recorded.every((ordinal, index) => ordinal === rows[index])) attributable.add(span);
+		else unattributedSpans += 1;
+	}
+	let tailWires = 0;
+	for (const span of spans) {
+		if (!attributable.has(span)) continue;
+		const lastVerdict = span.verdictSeqs.length === 0 ? void 0 : Math.max(...span.verdictSeqs);
+		if (lastVerdict === void 0) continue;
+		for (const wire of span.wires) if (wire.seq > lastVerdict) tailWires += wire.wireRequests;
+	}
+	const candidates = [];
+	let unhostedVerdicts = 0;
+	const previousBoundary = /* @__PURE__ */ new Map();
+	for (const verdict of verdicts) {
+		const value = verdict.value;
+		if (verdict.span === void 0) {
+			unhostedVerdicts += 1;
+			continue;
+		}
+		const span = verdict.span;
+		const boundary = previousBoundary.get(span) ?? {
+			seq: span.runningSeq,
+			...span.startedAt === void 0 ? {} : { at: span.startedAt }
+		};
+		const verdictAtMs = parse(verdict.at);
+		previousBoundary.set(span, {
+			seq: verdict.seq,
+			...verdictAtMs === void 0 ? {} : { at: verdictAtMs }
+		});
+		const candidate = {
+			verdict: value.verdict,
+			verdictSeq: verdict.seq,
+			...verdict.at === void 0 ? {} : { verdictAt: verdict.at },
+			...typeof value.callId === "string" ? { callId: value.callId } : {},
+			...typeof value.repairsUsed === "number" ? { repairsUsed: value.repairsUsed } : {},
+			...typeof value.maxRepairs === "number" ? { maxRepairs: value.maxRepairs } : {},
+			...typeof value.contractHash === "string" ? { contractHash: value.contractHash } : {},
+			...typeof value.candidateHash === "string" ? { candidateHash: value.candidateHash } : {},
+			...typeof value.candidateChars === "number" ? { candidateChars: value.candidateChars } : {},
+			...typeof value.candidateRef === "string" ? { candidateRef: value.candidateRef } : {},
+			failed: Array.isArray(value.failed) ? value.failed.filter((failure) => typeof failure.name === "string").map((failure) => ({
+				name: failure.name,
+				reasons: Array.isArray(failure.reasons) ? failure.reasons.filter((reason) => typeof reason === "string") : []
+			})) : [],
+			...span.label === void 0 ? {} : { spanLabel: span.label }
+		};
+		if (boundary.at !== void 0 && verdictAtMs !== void 0) candidate.windowMs = Math.max(0, verdictAtMs - boundary.at);
+		if (attributable.has(span)) {
+			const window = span.wires.filter((wire) => wire.seq > boundary.seq && wire.seq < verdict.seq);
+			candidate.wires = window.reduce((sum, wire) => sum + wire.wireRequests, 0);
+			candidate.usage = sumUsage$1(window);
+			const unknown = window.filter((wire) => usageUnknown(wire)).length;
+			if (unknown > 0) candidate.usageUnknownWires = unknown;
+			if (priceUsd !== void 0) {
+				let priced = 0;
+				let complete = true;
+				for (const wire of window) {
+					const usd = wire.servedBy === void 0 || wire.usage === void 0 ? void 0 : priceUsd(wire.servedBy, wire.usage);
+					if (usd === void 0) {
+						complete = false;
+						break;
+					}
+					priced += usd;
+				}
+				if (complete) candidate.costUsd = priced;
+			}
+		}
+		candidates.push(candidate);
+	}
+	return {
+		candidates,
+		synthesisSpans: spans.length,
+		unhostedVerdicts,
+		unattributedSpans,
+		tailWires
+	};
+}
+//#endregion
+//#region src/stores/tool-calibration.ts
+/**
+* Folds the observed tool-budget calibration from a journal (RV3003):
+* every terminal agent entry is partitioned by which sides of the
+* evidence/counter pair it recorded, the paired rows carry their
+* per-dispatch rate, and the aggregate is the number a host compares
+* against its declared `estCallsPerEntry`. Pure over the entries, so
+* live and resumed journals fold identically; nothing is re-derived
+* and no checkpoint blob is read.
+*/
+function toolCalibrationFromJournal(entries) {
+	const ordered = [...entries].sort((a, b) => a.seq - b.seq);
+	const observed = [];
+	const evidenceOnly = [];
+	const budgetOnly = [];
+	let dispatches = 0;
+	let unobserved = 0;
+	for (const entry of ordered) {
+		if (entry.kind !== "agent" || entry.ref === void 0 || entry.status === "running") continue;
+		dispatches += 1;
+		const named = {
+			scope: entry.scope,
+			handle: entry.ref,
+			status: String(entry.status ?? "")
+		};
+		if (entry.evidence !== void 0 && entry.toolBudget !== void 0) observed.push({
+			...named,
+			...entry.costAttribution?.agentType === void 0 || entry.costAttribution.agentType === "" ? {} : { agentType: entry.costAttribution.agentType },
+			recordedEntries: entry.evidence.recordedEntries,
+			minEntries: entry.evidence.minEntries,
+			toolCallsUsed: entry.toolBudget.used,
+			...entry.evidence.recordedEntries > 0 ? { callsPerEntry: entry.toolBudget.used / entry.evidence.recordedEntries } : {}
+		});
+		else if (entry.evidence !== void 0) evidenceOnly.push(named);
+		else if (entry.toolBudget !== void 0) budgetOnly.push(named);
+		else unobserved += 1;
+	}
+	const report = {
+		dispatches,
+		observed,
+		evidenceOnly,
+		budgetOnly,
+		unobserved
+	};
+	if (observed.length > 0) {
+		const toolCallsUsed = observed.reduce((sum, row) => sum + row.toolCallsUsed, 0);
+		const recordedEntries = observed.reduce((sum, row) => sum + row.recordedEntries, 0);
+		report.aggregate = {
+			toolCallsUsed,
+			recordedEntries,
+			...recordedEntries > 0 ? { callsPerEntry: toolCallsUsed / recordedEntries } : {}
+		};
+	}
+	return report;
+}
+//#endregion
 //#region src/stores/jsonl.ts
 /**
 * JsonlFileStore (M2-T01): the durable file store. One JSON entry per
@@ -16125,6 +16387,94 @@ function statementFromRows(input) {
 		})
 	};
 }
+/**
+* Parses a delimited billing export (the CSV/TSV a provider console
+* hands a host) into the header-keyed rows {@link statementFromRows}
+* consumes (RV2908). The library deliberately hard-codes NO provider's
+* export format: the host owns the column map, this owns only the
+* delimited grammar, and the pair closes the last manual step between
+* a downloaded export and {@link reconcileStatement}.
+*
+* Fail-closed at the record, like the rest of this module: a data row
+* whose cell count differs from the header, a quote opened and never
+* closed, a stray quote inside an unquoted cell, an empty or duplicate
+* header name, all refuse typed with the line instead of flowing a
+* shifted column into a reconciliation, because a column shifted one
+* to the left prices `outputTokens` as dollars and calls it evidence.
+* RFC 4180 quoting is honored (quoted cells may carry the delimiter,
+* doubled quotes, and line breaks); CRLF and lone LF both delimit
+* records; one trailing empty line is an artifact of every exporter
+* and is ignored. Cells come back as raw strings, so an empty cell
+* reads as "the export does not carry this figure" downstream, exactly
+* the absence contract `statementFromRows` documents.
+*/
+function statementRowsFromDelimited(text, options) {
+	const delimiter = options?.delimiter ?? ",";
+	const records = [];
+	let cells = [];
+	let cell = "";
+	let quoted = false;
+	let cellHadQuote = false;
+	let line = 1;
+	const endCell = () => {
+		cells.push(cell);
+		cell = "";
+		cellHadQuote = false;
+	};
+	const endRecord = () => {
+		endCell();
+		records.push(cells);
+		cells = [];
+	};
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (quoted) {
+			if (char === "\"") {
+				if (text[index + 1] === "\"") {
+					cell += "\"";
+					index += 1;
+					continue;
+				}
+				quoted = false;
+				continue;
+			}
+			if (char === "\n") line += 1;
+			cell += char;
+			continue;
+		}
+		if (char === "\"") {
+			if (cell.length > 0 || cellHadQuote) throw new ConfigError(`statementRowsFromDelimited: line ${String(line)} carries a quote inside an unquoted cell; quote the whole cell (RFC 4180) or fix the export`);
+			quoted = true;
+			cellHadQuote = true;
+			continue;
+		}
+		if (char === delimiter) {
+			endCell();
+			continue;
+		}
+		if (char === "\r" && text[index + 1] === "\n") continue;
+		if (char === "\n") {
+			endRecord();
+			line += 1;
+			continue;
+		}
+		cell += char;
+	}
+	if (quoted) throw new ConfigError(`statementRowsFromDelimited: a quoted cell opened on line ${String(line)} never closes; the export is torn`);
+	if (cell.length > 0 || cellHadQuote || cells.length > 0) endRecord();
+	if (records.length === 0) throw new ConfigError("statementRowsFromDelimited: the export carries no header record");
+	const header = records[0];
+	const seen = /* @__PURE__ */ new Set();
+	header.forEach((name, index) => {
+		if (name.length === 0) throw new ConfigError(`statementRowsFromDelimited: header column ${String(index)} is empty; every column needs a name for the map to address`);
+		if (seen.has(name)) throw new ConfigError(`statementRowsFromDelimited: header names column '${name}' twice; an ambiguous address cannot be mapped`);
+		seen.add(name);
+	});
+	return records.slice(1).map((record, index) => {
+		if (record.length !== header.length) throw new ConfigError(`statementRowsFromDelimited: data record ${String(index)} carries ${String(record.length)} cell(s) against ${String(header.length)} header column(s); a shifted column prices the wrong figure, so a ragged export refuses instead`);
+		return Object.fromEntries(header.map((name, column) => [name, record[column]]));
+	});
+}
 //#endregion
 //#region src/engine/persisted-terminal.ts
 const REFUSAL_MESSAGES = {
@@ -18049,7 +18399,13 @@ function createCtx(internals, rootWorkflow) {
 			}
 			{
 				const durable = readToolBudgetDecisions(internals.replayer.snapshot(), matched.running.seq);
-				if (durable !== void 0 && replayedToolCallsUsed !== void 0) {
+				if (terminal?.toolBudget !== void 0) {
+					const restoredSummary = { used: terminal.toolBudget.used };
+					if (terminal.toolBudget.cap !== void 0) restoredSummary.cap = terminal.toolBudget.cap;
+					if (durable !== void 0 && durable.extensionsGranted > 0) restoredSummary.extensionsGranted = durable.extensionsGranted;
+					if (durable !== void 0 && durable.finalizationWindowEntered) restoredSummary.finalizationWindowEntered = true;
+					result.toolBudget = restoredSummary;
+				} else if (durable !== void 0 && replayedToolCallsUsed !== void 0) {
 					const restoredSummary = { used: replayedToolCallsUsed };
 					if (durable.cap !== void 0) restoredSummary.cap = durable.cap;
 					if (durable.extensionsGranted > 0) restoredSummary.extensionsGranted = durable.extensionsGranted;
@@ -18815,6 +19171,10 @@ function createCtx(internals, rootWorkflow) {
 		if (result.artifacts !== void 0) terminalPatch.artifacts = result.artifacts;
 		if (result.evidence !== void 0) terminalPatch.evidence = result.evidence;
 		if (result.evidenceEntries !== void 0) terminalPatch.evidenceEntries = [...result.evidenceEntries];
+		if (result.toolBudget !== void 0) terminalPatch.toolBudget = {
+			used: result.toolBudget.used,
+			...result.toolBudget.cap === void 0 ? {} : { cap: result.toolBudget.cap }
+		};
 		if (result.abortClass !== void 0) {
 			terminalPatch.memoizeOutcome = true;
 			if (terminalPatch.error !== void 0) {
@@ -21201,6 +21561,8 @@ function pairDraftClaims(draftText, rows, options) {
 	const max = requirePositiveInteger(options?.max ?? 40, "pairDraftClaims max");
 	const maxPoolPerPair = requirePositiveInteger(options?.maxPoolPerPair ?? 3, "pairDraftClaims maxPoolPerPair");
 	const maxExcerptChars = requirePositiveInteger(options?.maxExcerptChars ?? 400, "pairDraftClaims maxExcerptChars");
+	const targetShare = options?.targetCoverageShare;
+	if (targetShare !== void 0 && (typeof targetShare !== "number" || !Number.isFinite(targetShare) || targetShare <= 0 || targetShare > 1)) throw new ConfigError(`pairDraftClaims targetCoverageShare must be a number in (0, 1]; got ` + JSON.stringify(targetShare));
 	const poolByPath = /* @__PURE__ */ new Map();
 	for (const row of rows) for (const sentence of sentencesOf(row.text)) {
 		const anchors = anchorsOf(sentence, pattern);
@@ -21292,13 +21654,37 @@ function pairDraftClaims(draftText, rows, options) {
 			});
 		}
 	}
-	const reported = (critical === void 0 ? candidates : [...candidates.filter((candidate) => candidate.critical), ...candidates.filter((candidate) => !candidate.critical)]).slice(0, max);
+	const ordered = critical === void 0 ? candidates : [...candidates.filter((candidate) => candidate.critical), ...candidates.filter((candidate) => !candidate.critical)];
+	let reported;
+	let maxCut;
+	let targetSentences;
+	if (targetShare === void 0) {
+		reported = ordered.slice(0, max);
+		maxCut = candidates.length > reported.length;
+	} else {
+		targetSentences = Math.min(draftCitingSentences, Math.ceil(targetShare * draftCitingSentences));
+		const covering = /* @__PURE__ */ new Set();
+		const wanted = [];
+		for (const candidate of ordered) {
+			if (candidate.critical) {
+				wanted.push(candidate);
+				covering.add(candidate.sentence);
+				continue;
+			}
+			if (covering.size >= targetSentences || covering.has(candidate.sentence)) continue;
+			wanted.push(candidate);
+			covering.add(candidate.sentence);
+		}
+		reported = wanted.slice(0, max);
+		maxCut = wanted.length > reported.length;
+	}
 	const coveredSentences = new Set(reported.map((candidate) => candidate.sentence));
 	const fold = {
 		pairs: reported.map((candidate) => candidate.pair),
-		truncated: candidates.length > reported.length,
+		truncated: maxCut,
 		draftCitingSentences,
-		coveredCitingSentences: coveredSentences.size
+		coveredCitingSentences: coveredSentences.size,
+		...targetSentences === void 0 ? {} : { targetCoveredSentences: targetSentences }
 	};
 	if (critical !== void 0) {
 		const reportedAnchors = new Set(reported.map((candidate) => candidate.pair.anchor));
@@ -22044,7 +22430,12 @@ function validateOrchestrateOptions(opts) {
 		if (synthesis.instructions !== void 0 && typeof synthesis.instructions !== "string") throw new ConfigError(`orchestrate synthesis.instructions must be a string; got ${typeof synthesis.instructions}`);
 		const facts = synthesis;
 		if (facts.policyFacts !== void 0 && typeof facts.policyFacts !== "boolean") throw new ConfigError(`orchestrate synthesis.policyFacts must be a boolean; got ${typeof facts.policyFacts}`);
-		if (facts.runFacts !== void 0 && typeof facts.runFacts !== "boolean") throw new ConfigError(`orchestrate synthesis.runFacts must be a boolean; got ${typeof facts.runFacts}`);
+		if (facts.runFacts !== void 0 && typeof facts.runFacts !== "boolean") {
+			if (typeof facts.runFacts !== "object" || facts.runFacts === null || Array.isArray(facts.runFacts)) throw new ConfigError(`orchestrate synthesis.runFacts must be a boolean or { workflowSoFar?: boolean }; got ${typeof facts.runFacts}`);
+			const runFactsSpec = facts.runFacts;
+			for (const key of Object.keys(runFactsSpec)) if (key !== "workflowSoFar") throw new ConfigError(`orchestrate synthesis.runFacts carries unknown key '${key}'; the object form takes only workflowSoFar`);
+			if (runFactsSpec["workflowSoFar"] !== void 0 && typeof runFactsSpec["workflowSoFar"] !== "boolean") throw new ConfigError(`orchestrate synthesis.runFacts.workflowSoFar must be a boolean; got ${typeof runFactsSpec["workflowSoFar"]}`);
+		}
 		if (synthesis.estCost !== void 0) requireNonNegativeNumber(synthesis.estCost, "orchestrate synthesis.estCost");
 	}
 	if (opts.contradictions !== void 0) {
@@ -22105,10 +22496,14 @@ function validateOrchestrateOptions(opts) {
 			if (consistency.runFacts !== true) throw new ConfigError("orchestrate claimConsistency.runFactTerms rides the runFacts pass; set claimConsistency.runFacts true");
 			if (!Array.isArray(consistency.runFactTerms) || consistency.runFactTerms.some((term) => typeof term !== "string" || term.length === 0)) throw new ConfigError("orchestrate claimConsistency.runFactTerms must be an array of nonempty strings; got " + JSON.stringify(consistency.runFactTerms));
 		}
-		for (const [label, ratio] of [["minimumCoverageRatio", consistency.minimumCoverageRatio], ["runFactCoverageRatio", consistency.runFactCoverageRatio]]) if (ratio !== void 0 && (typeof ratio !== "number" || !Number.isFinite(ratio) || ratio <= 0 || ratio > 1)) throw new ConfigError(`orchestrate claimConsistency.${label} must be a number in (0, 1]; got ` + JSON.stringify(ratio));
+		for (const [label, ratio] of [
+			["minimumCoverageRatio", consistency.minimumCoverageRatio],
+			["runFactCoverageRatio", consistency.runFactCoverageRatio],
+			["coverageTarget", consistency.coverageTarget]
+		]) if (ratio !== void 0 && (typeof ratio !== "number" || !Number.isFinite(ratio) || ratio <= 0 || ratio > 1)) throw new ConfigError(`orchestrate claimConsistency.${label} must be a number in (0, 1]; got ` + JSON.stringify(ratio));
 		if (consistency.runFactCoverageRatio !== void 0 && consistency.runFacts !== true) throw new ConfigError("orchestrate claimConsistency.runFactCoverageRatio rides the runFacts pass; set claimConsistency.runFacts true");
 		if (consistency.onLowCoverage !== void 0 && consistency.onLowCoverage !== "report" && consistency.onLowCoverage !== "fail") throw new ConfigError("orchestrate claimConsistency.onLowCoverage must be 'report' or 'fail'; got " + JSON.stringify(consistency.onLowCoverage));
-		if (consistency.onLowCoverage !== void 0 && consistency.minimumCoverageRatio === void 0 && consistency.runFactCoverageRatio === void 0) throw new ConfigError("orchestrate claimConsistency.onLowCoverage needs a declared floor; set minimumCoverageRatio or runFactCoverageRatio");
+		if (consistency.onLowCoverage !== void 0 && consistency.minimumCoverageRatio === void 0 && consistency.runFactCoverageRatio === void 0 && consistency.coverageTarget === void 0) throw new ConfigError("orchestrate claimConsistency.onLowCoverage needs a declared floor; set minimumCoverageRatio, runFactCoverageRatio, or coverageTarget");
 		if (consistency.judge !== void 0) {
 			const judge = consistency.judge;
 			if (typeof judge !== "object" || judge === null || Array.isArray(judge)) throw new ConfigError(`orchestrate claimConsistency.judge must be an object; got ${JSON.stringify(consistency.judge)}`);
@@ -23780,6 +24175,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const noteOpts = {
 				role: "synthesize",
 				result: "full",
+				label: SYNTHESIS_NOTE_LABEL,
 				tools: finishOnly,
 				limits: spec.noteLimits ?? { maxTurns: 2 },
 				...spec.model === void 0 ? {} : { model: spec.model },
@@ -23787,7 +24183,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...spec.estCost === void 0 ? {} : { estCost: spec.estCost },
 				[kTerminalTool]: { name: FINISH_TOOL_NAME }
 			};
-			return runtime.runInScope(noteState, () => ctx.agent(prompt, noteOpts));
+			return runtime.runInScope(noteState, () => ctx.agent(prompt, noteOpts)).then((settled) => {
+				noteInternalSettle(settled);
+				return settled;
+			});
 		};
 		/**
 		* Note dispatch is idempotent per child: the settle hook and the
@@ -23945,6 +24344,33 @@ function makeOrchestratorWorkflow(goal, opts) {
 		*/
 		let synthesisSkipDecisionRef;
 		/**
+		* The orchestration's own settled internal spans so far (RV3004):
+		* the coordination dispatch, claim judges, synthesis notes, and
+		* settled compositions, folded through
+		* {@link executionFactsOf} in dispatch order the moment each
+		* settles. Replay-stable by the same argument as the RUN FACTS
+		* child line: every ingredient restores verbatim from the journal
+		* and the settle order is deterministic, so a resumed composition
+		* re-derives identical SO FAR bytes. A dispatch that never settled
+		* (a declined judge admission, a crash) contributes nothing, which
+		* is RV1209, not an undercount.
+		*/
+		const internalSpansSoFar = {
+			spans: 0,
+			wireRequests: 0,
+			wireIdsMissing: 0,
+			inputTokens: 0,
+			outputTokens: 0
+		};
+		const noteInternalSettle = (settled) => {
+			const facts = executionFactsOf(settled);
+			internalSpansSoFar.spans += 1;
+			internalSpansSoFar.wireRequests += facts.wireRequests;
+			internalSpansSoFar.wireIdsMissing += facts.wireIdsMissing;
+			internalSpansSoFar.inputTokens += facts.inputTokens;
+			internalSpansSoFar.outputTokens += facts.outputTokens;
+		};
+		/**
 		* The bounded contradiction pass's findings (RV1302), set exactly
 		* when the pass is configured: an EMPTY array is a fact (the pass
 		* ran and the pool agreed) and `undefined` is a different fact
@@ -24116,7 +24542,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 				max: spec.max ?? 40,
 				...spec.maxPoolPerPair === void 0 ? {} : { maxPoolPerPair: spec.maxPoolPerPair },
 				...spec.maxExcerptChars === void 0 ? {} : { maxExcerptChars: spec.maxExcerptChars },
-				...spec.critical === void 0 ? {} : { critical: spec.critical }
+				...spec.critical === void 0 ? {} : { critical: spec.critical },
+				...spec.coverageTarget === void 0 ? {} : { targetCoverageShare: spec.coverageTarget }
 			});
 			const runFold = spec.runFacts === true ? pairRunFactClaims(draftText, {
 				text: `The run ${internals.runId} made ${String(factWires)} provider wire requests across ${String(poolChildren)} accepted children, with token totals ${String(factInput)} input and ${String(factOutput)} output (the run's own recorded execution facts; harness-observed, not production evidence). ${factRows.join(" ")}`,
@@ -24129,7 +24556,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 				]
 			}, {
 				...spec.runFactTerms === void 0 ? {} : { terms: spec.runFactTerms },
-				...spec.maxExcerptChars === void 0 ? {} : { maxExcerptChars: spec.maxExcerptChars }
+				...spec.maxExcerptChars === void 0 ? {} : { maxExcerptChars: spec.maxExcerptChars },
+				...spec.coverageTarget === void 0 ? {} : { max: Number.MAX_SAFE_INTEGER }
 			}) : void 0;
 			const allPairs = runFold === void 0 ? fold.pairs : [...fold.pairs, ...runFold.pairs];
 			const onFound = spec.onFound ?? "report";
@@ -24139,6 +24567,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				pairs: allPairs.length,
 				truncated: fold.truncated,
 				coveredCitingSentences: fold.coveredCitingSentences,
+				...spec.coverageTarget === void 0 ? {} : { coverageTarget: spec.coverageTarget },
 				...fold.criticalUncovered === void 0 ? {} : {
 					criticalUncovered: fold.criticalUncovered,
 					criticalUncoveredTotal: fold.criticalUncoveredTotal ?? 0
@@ -24149,14 +24578,15 @@ function makeOrchestratorWorkflow(goal, opts) {
 					runFactCandidates: runFold.candidates
 				},
 				...(() => {
+					const coverageFloor = spec.minimumCoverageRatio ?? spec.coverageTarget;
 					const coverageRatio = fold.draftCitingSentences === 0 ? 1 : fold.coveredCitingSentences / fold.draftCitingSentences;
 					const runFactRatio = runFold === void 0 || runFold.candidates === 0 ? void 0 : runFold.pairs.length / runFold.candidates;
-					const belowCoverage = spec.minimumCoverageRatio !== void 0 && fold.draftCitingSentences > 0 && coverageRatio < spec.minimumCoverageRatio;
+					const belowCoverage = coverageFloor !== void 0 && fold.draftCitingSentences > 0 && coverageRatio < coverageFloor;
 					const belowRunFacts = spec.runFactCoverageRatio !== void 0 && runFactRatio !== void 0 && runFactRatio < spec.runFactCoverageRatio;
 					if (!belowCoverage && !belowRunFacts) return {};
 					return { lowCoverage: {
 						coverageRatio,
-						...spec.minimumCoverageRatio === void 0 ? {} : { coverageFloor: spec.minimumCoverageRatio },
+						...coverageFloor === void 0 ? {} : { coverageFloor },
 						...runFactRatio === void 0 ? {} : { runFactRatio },
 						...spec.runFactCoverageRatio === void 0 ? {} : { runFactFloor: spec.runFactCoverageRatio }
 					} };
@@ -24240,6 +24670,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			let judged;
 			try {
 				judged = await runtime.runInScope(judgeState, () => ctx.agent(judgePrompt, judgeOpts));
+				noteInternalSettle(judged);
 			} catch (declined) {
 				if (!(declined instanceof BudgetExhaustedError)) throw declined;
 				claimConsistencyMeta = finishMeta({
@@ -24557,6 +24988,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 					};
 				});
 			})();
+			const runFactsEnabled = spec.runFacts === true || typeof spec.runFacts === "object" && spec.runFacts !== null;
+			const runFactsSoFar = typeof spec.runFacts === "object" && spec.runFacts !== null && spec.runFacts.workflowSoFar === true;
 			const prompt = [
 				"You are the synthesis invocation of an orchestrated run. Compose the FINAL result of the run from the goal, the coordination draft, and the settled child evidence below by calling finish({ result }) EXACTLY once. Preserve the evidence and citations the draft relies on; do not invent findings. " + (exposeTools ? "Beside finish, get_child_result and read_child_artifact page any SETTLED child's FULL output and artifacts by handle (each DIGEST row carries its handle); read what the validators will hold you to before finishing." : "No other tool exists."),
 				...repeatedClaims === void 0 ? [] : ["Repeated claims across children were deduplicated before this prompt: only the first occurrence of each repeated line remains in the digest, and the REPEATED CLAIMS index below lists each one with its reporters."],
@@ -24586,7 +25019,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 						finalizationReservesUsed: reservesUsed
 					})}`;
 				})()] : [],
-				...spec.runFacts === true ? [(() => {
+				...runFactsEnabled ? [(() => {
 					const byStatus = {};
 					let wireRequests = 0;
 					let wireIdsMissing = 0;
@@ -24612,6 +25045,29 @@ function makeOrchestratorWorkflow(goal, opts) {
 						outputTokens
 					})} (live-observed by run ${internals.runId}, this run's own harness; production evidence it is not; the settled children ONLY, excluding this orchestrator, judges, and synthesis; the whole run's totals are the terminal envelope and invoice)`;
 				})()] : [],
+				...runFactsSoFar ? [(() => {
+					let wireRequests = internalSpansSoFar.wireRequests;
+					let wireIdsMissing = internalSpansSoFar.wireIdsMissing;
+					let inputTokens = internalSpansSoFar.inputTokens;
+					let outputTokens = internalSpansSoFar.outputTokens;
+					for (const [, record] of settledEntries) {
+						const facts = executionFactsOf(record.settled);
+						wireRequests += facts.wireRequests;
+						wireIdsMissing += facts.wireIdsMissing;
+						inputTokens += facts.inputTokens;
+						outputTokens += facts.outputTokens;
+					}
+					return `RUN FACTS SO FAR: ${JSON.stringify({
+						scope: "run-so-far-at-this-dispatch",
+						runId: internals.runId,
+						children: settledEntries.length,
+						internalSpans: internalSpansSoFar.spans,
+						wireRequests,
+						wireIdsMissing,
+						inputTokens,
+						outputTokens
+					})} (live-observed by run ${internals.runId}, this run's own harness; production evidence it is not; the settled children PLUS this orchestration's settled coordination, judge, note, and composition spans as of THIS dispatch; it excludes this dispatch itself and anything still running, so the whole run's totals remain the terminal envelope and invoice)`;
+				})()] : [],
 				`GOAL: ${goal}`,
 				`DRAFT: ${draftJson}`,
 				`DIGEST: ${digestJson}`,
@@ -24653,6 +25109,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const synthesisOpts = {
 				role: "synthesize",
 				result: "full",
+				label: FINAL_COMPOSITION_LABEL,
 				tools: synthesisTools,
 				[kExposureWait]: true,
 				limits: spec.limits ?? { maxTurns: 4 },
@@ -24668,6 +25125,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				}
 			};
 			const synthesized = await runtime.runInScope(synthesisState, () => ctx.agent(prompt, synthesisOpts));
+			noteInternalSettle(synthesized);
 			synthesisSchemaRejectedExchanges = synthesized.schemaRejectedTerminalExchanges ?? 0;
 			synthesisSchemaRecoveredExchanges = synthesized.schemaRecoveredTerminalExchanges ?? 0;
 			if (configuredReserveUsd > 0) {
@@ -24796,6 +25254,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 		let result;
 		try {
 			result = await runtime.runInScope(orchestratorState, () => ctx.agent(orchestratorPrompt(goal, opts?.maxSpawns, promptLines.length === 0 ? void 0 : promptLines), agentOpts));
+			noteInternalSettle(result);
 		} catch (thrown) {
 			if (thrown instanceof BudgetExhaustedError) {
 				const repairEntryRef = thrown.data?.entryRef;
@@ -27882,6 +28341,7 @@ function createEngine(options) {
 		const handlePromise = (async () => {
 			if (resumeOptions?.run?.budgetUsd !== void 0) requireNonNegativeNumber(resumeOptions.run.budgetUsd, "ResumeOptions.run.budgetUsd");
 			if (resumeOptions?.run?.maxInFlightExposureUsd !== void 0) requireNonNegativeNumber(resumeOptions.run.maxInFlightExposureUsd, "ResumeOptions.run.maxInFlightExposureUsd");
+			if (resumeOptions?.bodyHash !== void 0 && resumeOptions.bodyHash !== "warn" && resumeOptions.bodyHash !== "refuse") throw new ConfigError(`ResumeOptions.bodyHash must be 'warn' or 'refuse'; got ` + JSON.stringify(resumeOptions.bodyHash));
 			const meta = await readRunMeta(journal, runId);
 			let supplied = wf;
 			if (supplied === void 0 && meta?.workflowSourceRef === void 0) {
@@ -27910,10 +28370,13 @@ function createEngine(options) {
 					if (meta?.workflowHash !== void 0 && meta.workflowHash !== expectedHash) throw new ConfigError(`resume binding mismatch: the supplied CompiledWorkflow source hash differs from the one recorded for run '${runId}'`);
 				} else {
 					const expectedHash = hashWorkflowBody(supplied);
-					if (meta?.workflowHash !== void 0 && meta.workflowHash !== expectedHash) process.emitWarning(`resume: the body of workflow '${supplied.name}' changed since run '${runId}' started; orphans and misses will be reported honestly`, {
-						code: "RULVAR_RESUME_HASH_MISMATCH",
-						type: "RulvarWarning"
-					});
+					if (meta?.workflowHash !== void 0 && meta.workflowHash !== expectedHash) {
+						if (resumeOptions?.bodyHash === "refuse") throw new ConfigError(`resume: the body of workflow '${supplied.name}' changed since run '${runId}' started and ResumeOptions.bodyHash is 'refuse'; resume with the original body, or drop the option to proceed under the loud warning`);
+						process.emitWarning(`resume: the body of workflow '${supplied.name}' changed since run '${runId}' started; orphans and misses will be reported honestly`, {
+							code: "RULVAR_RESUME_HASH_MISMATCH",
+							type: "RulvarWarning"
+						});
+					}
 				}
 				bound = supplied;
 			}
@@ -28411,4 +28874,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, 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, 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, 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, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, 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, 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 };

package/package.json

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