@rulvar/core 1.242.0 → 1.243.0

package/dist/index.d.ts

@@ -6451,6 +6451,8 @@ interface BudgetAccountView {
   synthesisReserveUsd: number;
   /** The repair round's verdict hold (RV3701); zero when none is committed. */
   convergenceReserveUsd: number;
+  /** The repair round's mechanical leg (RV3802); zero when none is committed. */
+  repairReserveUsd: number;
   parentScope?: string;
 }
 /**
@@ -6772,6 +6774,26 @@ declare class RunBudget {
   commitConvergenceReserve(scope: string, reserveUsd: number): void;
   /** The verdict pass dispatch consumes its reserve; see commitConvergenceReserve. */
   releaseConvergenceReserve(scope: string): void;
+  /**
+  * Registers the repair round's MECHANICAL leg (RV3802), the money
+  * twin of the RV3602 per-invocation pool: the round's finish
+  * contract can grant one bounded mechanical repair turn, and the
+  * third comparison run's round entered exactly that turn's price
+  * short of certainty (the repair existed by pool and by contract,
+  * but nothing guaranteed the money would still be there when the
+  * candidate materialized). Held beside the verdict leg from the
+  * moment the round is admitted; released EARLY, to the round's own
+  * finish loop, at its first journaled verdict (a 'repair' verdict is
+  * about to spend the freed money on the granted turn, an 'accepted'
+  * one never needed it), where the verdict leg lives until the judge
+  * dispatch. Exactly the convergence reserve mechanics otherwise:
+  * joins the projected admission sum and both remainders, named in
+  * the refusal clause, never joined to the severing check, idempotent
+  * per account with the root adjusted by the delta.
+  */
+  commitRepairReserve(scope: string, reserveUsd: number): void;
+  /** The round's finish loop consumes its leg; see commitRepairReserve. */
+  releaseRepairReserve(scope: string): void;
   /** The reserve is replaced by real spend when the spawn settles. */
   releaseReserve(reserveUsd: number, accountScope?: string): void;
   /**
@@ -8376,12 +8398,42 @@ interface FinishValidationInput {
   */
   readonly runId?: string;
 }
+/**
+* One structured repair hint on a failed verdict (RV3801): the exact
+* edit whose application satisfies this validator, precise enough for
+* the HOST to perform without a provider wire. The third comparison
+* run died with its repair pool spent on a failure class whose remedy
+* the evidence-grade verdict already prescribed word for word (write
+* this run's id inside each offending sentence); a remedy that
+* deterministic must not cost a model turn. A hint is advisory: the
+* finish loop attempts the patch only when EVERY failure of the
+* candidate carries hints, re-runs the FULL validator set over the
+* patched document, and falls back to the ordinary model repair pool
+* when the patch does not survive re-validation.
+*/
+interface FinishRepairHint {
+  /** The one host-side edit the loop knows how to apply. */
+  readonly mechanism: "insert-run-id";
+  /** Offset of the offending sentence's first character in the judged text. */
+  readonly start: number;
+  /** Offset one past the offending sentence's last character. */
+  readonly end: number;
+  /**
+  * The offending sentence verbatim (never normalized or clipped): the
+  * loop refuses the patch unless `text.slice(start, end)` equals it,
+  * so a stale hint can never edit the wrong bytes.
+  */
+  readonly sentence: string;
+  /** The identifier whose insertion the verdict prescribes. */
+  readonly insert: string;
+}
 /** The verdict of one validator over one finish attempt. */
 type FinishValidationVerdict = {
   ok: true;
 } | {
   ok: false;
   reasons: string[];
+  repairHints?: FinishRepairHint[];
 };
 /**
 * A deterministic host validator of the orchestrator finish result.
@@ -8519,6 +8571,33 @@ declare const DEFAULT_CITATION_PATTERN = "[\\w./-]+\\.\\w+:\\d+";
 /** The default preserved share, the improvement plan's RV-202 gate. */
 declare const DEFAULT_EVIDENCE_MIN_SHARE = .95;
 /**
+* The deterministic edit behind the `insert-run-id` mechanism
+* (RV3801): the id lands INSIDE the sentence, before its trailing
+* terminator run (a `.`, `!`, or `?` with any closing quotes,
+* brackets, or markdown emphasis after it), or at the very end when
+* the sentence carries no terminator. Inside matters: appended AFTER
+* the terminator the id would belong to the NEXT sentence under the
+* shared `sentencesOf` segmentation and the re-validation would fail
+* the same sentence again. Exported so tests and hosts can reproduce
+* the loop's exact bytes.
+*/
+declare function insertRunIdIntoSentence(sentence: string, insert: string): string;
+/**
+* Applies `insert-run-id` repair hints to a judged text (RV3801): each
+* `[start, end)` window is replaced by
+* {@link insertRunIdIntoSentence}(window, insert), right to left so
+* earlier offsets stay valid, every other byte identical. Fail closed:
+* `undefined` (never a partial patch) when the set is empty, any
+* window is out of bounds or empty, or two windows overlap; the caller
+* treats a refused patch exactly like an absent one and proceeds to
+* the model repair pool.
+*/
+declare function applyFinishRepairHints(text: string, hints: readonly {
+  start: number;
+  end: number;
+  insert: string;
+}[]): string | undefined;
+/**
 * The RV-202 evidence preservation contract: the finish result must
 * PRESERVE the citations the children actually produced. Distinct
 * matches of `pattern` are collected across the outputs of children
@@ -8683,6 +8762,13 @@ declare const DEFAULT_ARTIFACT_PATTERN = "(?:run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}|[\
 * the repair instruction is executable rather than aspirational. An id
 * shorter than `MIN_RUN_ID_ARTIFACT_CHARS` (six) is ignored, and
 * without an id the verdict is byte identical to the historical one.
+*
+* With the id in hand the failure also carries {@link FinishRepairHint}
+* rows (RV3801), one per offending sentence, so the finish loop can
+* perform the verdict's own prescription host side without spending a
+* provider wire; the reasons stay byte identical either way, and the
+* hints are bounded (at most `MAX_REPAIR_HINTS` offenders) and fail
+* closed (an id whose bytes could split a sentence is never hinted).
 * Default name 'evidence-grade'.
 */
 declare function evidenceGradeValidator(options?: {
@@ -10060,6 +10146,28 @@ interface OrchestrateAcceptance {
 }
 /** How many rejected finishes are repaired by default: the plan's repair once. */
 declare const DEFAULT_FINISH_MAX_REPAIRS = 1;
+/** The sectional round's owning sections and marker roster (RV3803). */
+interface SectionalRoundPlan {
+  /** Every H2 marker of the retained document, in document order. */
+  sections: string[];
+  /** The markers owning at least one finding excerpt, document order. */
+  targets: string[];
+}
+/**
+* Plans the sectional claim repair round (RV3803): which H2 sections
+* of the accepted pre-repair document own the judged findings. The
+* third comparison run's round regenerated the WHOLE 43k character
+* document to consume findings that lived in a handful of sentences,
+* and the tail after fan-in was 80.1 percent of the run's wall. Each
+* finding's `draftExcerpt` (whitespace collapsed by the pairing fold)
+* is located in the document through a collapse-aware scan, and its
+* owning section is the nearest H2 line above it. Fail closed to the
+* FULL regeneration (undefined, the historical round byte for byte)
+* whenever the plan cannot be exact: no excerpts, a document without
+* H2 headings, duplicated markers (the splice grammar needs unique
+* lines), or any excerpt the scan cannot locate.
+*/
+declare function sectionalRoundPlan(document: string, excerpts: readonly string[]): SectionalRoundPlan | undefined;
 /**
 * Character cap of the HOST VALIDATION LESSONS prompt block (RV3603):
 * the bounded repair round's prompt folds the run's journaled finish
@@ -10174,6 +10282,21 @@ interface FinishValidationSpec {
   */
   repairTurnReserve?: number;
   /**
+  * The declared price of ONE mechanical repair turn in USD (RV3802),
+  * the money twin of `repairTurnReserve`'s turn grant: the bounded
+  * claim repair round (`claimConsistency.onFound: 'repair'`) holds
+  * this beside the verdict money (RV3701) from the moment the round
+  * is admitted, so the one repair turn the round's own finish
+  * contract can grant is funded when the candidate materializes; the
+  * leg releases to the round's finish loop at its first journaled
+  * verdict. Undeclared, the hold falls back to the run's own observed
+  * last mechanical repair price (`lastMechanicalRepairCostUsd` over
+  * the journal, absent when no priced repair window exists), else
+  * zero, which keeps every pre-RV3802 admission byte identical. A
+  * nonnegative finite number; refused typed otherwise.
+  */
+  estRepairCostUsd?: number;
+  /**
   * The coordination draft gate (the v1.74 experiment review, P0.3),
   * meaningful ONLY with `synthesis` configured: with validators bound
   * to the synthesis finish, the coordination finish is an unvalidated
@@ -11796,6 +11919,8 @@ interface CostAttribution {
   byModel: Map<string, number>;
   byPhase: Map<string, number>;
   byAgentType: Map<string, number>;
+  /** Keyed by the raw journal scope (RV3805); '' is the root's own scope. */
+  byScope: Map<string, number>;
   byRole: Map<InvocationRole, number>;
   unpriced: Array<{
     model: string;
@@ -11959,6 +12084,16 @@ declare function executeWorkflow<A, R>(internals: RunInternals, wf: Workflow<A,
 */
 declare function attributionBucket(value: string | undefined): string;
 /**
+* The scope key rule of the byScope rollup (RV3805). The root's OWN
+* scope is the empty string BY CONSTRUCTION: present data whose string
+* happens to be empty, not an absence, so it folds under the
+* addressable name 'root' instead of the RV3604 'unknown' fallback,
+* which stays reserved for a scope that is truly missing. Children
+* keep their scope strings verbatim. One rule for both builders, so
+* the live report and the journal fold cannot disagree on the key.
+*/
+declare function scopeBucket(scope: string | undefined): string;
+/**
 * Folds the per-run attribution buckets into the normative CostReport.
 * Live attribution buckets never see abandoned subtrees, so a host
 * that tracked abandoned spend itself passes it as `abandoned`;
@@ -12081,6 +12216,18 @@ interface CostReport {
   byAgentType: Record<string, number>;
   byRole: Record<InvocationRole, number>;
   /**
+  * Spend per journal scope (RV3805): the root and every child are
+  * addressable rows whose sum equals `totalUsd`, so the children
+  * versus whole-workflow cut (the third comparison analysis had to
+  * hand-aggregate it from invoice rows) reads off the report
+  * directly. The root's OWN scope is the empty string BY
+  * CONSTRUCTION, present data rather than an absence, so it folds
+  * under the named 'root' bucket; children keep their scope strings
+  * verbatim, and only a truly absent scope folds under 'unknown',
+  * the RV3604 fallback.
+  */
+  byScope: Record<string, number>;
+  /**
   * All-zero with forcedFinish false in runs without a dynamic
   * orchestrator (or when no cap resolved, so no sub-account opened).
   * Folded purely from the journal: spentUsd is the priced usage of
@@ -13767,6 +13914,13 @@ interface JournaledSynthesisCandidate {
   /** The hosting span's dispatch label (RV2901), when journaled. */
   spanLabel?: string;
   /**
+  * The hosting span's running entry seq (RV3802): the span's identity
+  * within the run, so two candidates can be read as neighbors of ONE
+  * composition invocation (the repair-turn pairing below) instead of
+  * accidental neighbors across spans. Absent exactly when unhosted.
+  */
+  spanSeq?: number;
+  /**
   * 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.
@@ -13825,6 +13979,20 @@ interface JournaledSynthesisCandidateReport {
 *   same shape `invoiceFromJournal` takes; omit to fold without money
 */
 declare function synthesisCandidatesFromJournal(entries: readonly JournalEntry[], priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined): JournaledSynthesisCandidateReport;
+/**
+* The observed price of the run's LAST mechanical repair turn
+* (RV3802): the window of the candidate that FOLLOWED a 'repair'
+* verdict inside the same settled synthesize span, priced by the same
+* per-call fold every candidate window uses. This is the fallback the
+* repair round's mechanical money leg sizes itself from when the host
+* declared no estimate: by the time the round is admitted the initial
+* composition has settled, so a mechanical repair it performed is a
+* priced window in the journal. Fail closed under RV1209: no such
+* pairing, an unattributed span, or an unpriceable window all return
+* undefined (never a guessed number), and the caller treats undefined
+* as an inert zero-size leg.
+*/
+declare function lastMechanicalRepairCostUsd(entries: readonly JournalEntry[], priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined): number | undefined;
 //#endregion
 //#region src/stores/tool-calibration.d.ts
 /** One dispatch carrying BOTH sides of the calibration pair (RV3003). */
@@ -14830,7 +14998,12 @@ interface PreflightOrchestratorSpec {
     * (this same `judge.estCost` first, else the run's own observed
     * post draft judge price) until that pass admits, so the
     * declared estimate is not only judged before the run but enforced
-    * inside it.
+    * inside it. The mechanical leg has the same twin (RV3802): the
+    * one repair turn the round's finish contract can grant is held as
+    * `finishValidation.estRepairCostUsd` (else the run's observed
+    * last mechanical repair price) beside the verdict money, released
+    * to the round's finish loop at its first verdict; the runtime
+    * enforcement of the `repairTurnReserve` turn grant's price.
     */
     onFound?: "report" | "carry" | "fail" | "repair";
     /**
@@ -15992,4 +16165,4 @@ interface SandboxBridge {
 declare const SANDBOX_AGENT_OPT_KEYS: readonly string[];
 declare function createSandboxBridge(ctx: Ctx<never>, options: SandboxBridgeOptions): SandboxBridge;
 //#endregion
-export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BillingComponent, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CachePolicy, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, ChildrenAtFailure, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DelimitedStatementOptions, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, JournaledChild, JournaledChildRoster, JournaledCriticalPath, JournaledPostFanIn, JournaledSynthesisCandidate, JournaledSynthesisCandidateReport, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, OutputContractManifest, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RejectedFinishCandidate, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, SynthesisCandidateFailure, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TelemetryScope, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminalTelemetryScopes, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCalibrationExclusion, ToolCalibrationReport, ToolCalibrationRow, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BillingComponent, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CachePolicy, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, ChildrenAtFailure, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DelimitedStatementOptions, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishRepairHint, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, JournaledChild, JournaledChildRoster, JournaledCriticalPath, JournaledPostFanIn, JournaledSynthesisCandidate, JournaledSynthesisCandidateReport, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, OutputContractManifest, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RejectedFinishCandidate, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SectionalRoundPlan, 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, applyFinishRepairHints, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, insertRunIdIntoSentence, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastMechanicalRepairCostUsd, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, scopeBucket, sectionCitationsValidator, sectionPatternCountValidator, sectionalRoundPlan, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -9878,7 +9878,8 @@ function synthesisCandidatesFromJournal(entries, priceUsd) {
 				name: failure.name,
 				reasons: Array.isArray(failure.reasons) ? failure.reasons.filter((reason) => typeof reason === "string") : []
 			})) : [],
-			...span.label === void 0 ? {} : { spanLabel: span.label }
+			...span.label === void 0 ? {} : { spanLabel: span.label },
+			spanSeq: span.runningSeq
 		};
 		if (boundary.at !== void 0 && verdictAtMs !== void 0) candidate.windowMs = Math.max(0, verdictAtMs - boundary.at);
 		if (attributable.has(span)) {
@@ -9911,6 +9912,29 @@ function synthesisCandidatesFromJournal(entries, priceUsd) {
 		tailWires
 	};
 }
+/**
+* The observed price of the run's LAST mechanical repair turn
+* (RV3802): the window of the candidate that FOLLOWED a 'repair'
+* verdict inside the same settled synthesize span, priced by the same
+* per-call fold every candidate window uses. This is the fallback the
+* repair round's mechanical money leg sizes itself from when the host
+* declared no estimate: by the time the round is admitted the initial
+* composition has settled, so a mechanical repair it performed is a
+* priced window in the journal. Fail closed under RV1209: no such
+* pairing, an unattributed span, or an unpriceable window all return
+* undefined (never a guessed number), and the caller treats undefined
+* as an inert zero-size leg.
+*/
+function lastMechanicalRepairCostUsd(entries, priceUsd) {
+	const { candidates } = synthesisCandidatesFromJournal(entries, priceUsd);
+	let observed;
+	for (let index = 1; index < candidates.length; index += 1) {
+		const previous = candidates[index - 1];
+		const row = candidates[index];
+		if (previous?.verdict === "repair" && row?.spanSeq !== void 0 && row.spanSeq === previous.spanSeq && row.costUsd !== void 0) observed = row.costUsd;
+	}
+	return observed;
+}
 //#endregion
 //#region src/stores/tool-calibration.ts
 /**
@@ -14898,6 +14922,7 @@ var RunBudget = class {
 			finalizeReserveUsd: 0,
 			synthesisReserveUsd: 0,
 			convergenceReserveUsd: 0,
+			repairReserveUsd: 0,
 			controller: new AbortController()
 		};
 		if (options.ceilingUsd !== void 0) root.ceilingUsd = options.ceilingUsd;
@@ -14949,6 +14974,7 @@ var RunBudget = class {
 			finalizeReserveUsd: options.finalizeReserveUsd ?? 0,
 			synthesisReserveUsd: 0,
 			convergenceReserveUsd: 0,
+			repairReserveUsd: 0,
 			parentScope,
 			controller: new AbortController()
 		};
@@ -15050,7 +15076,8 @@ var RunBudget = class {
 			committedReserveUsd: account.committedReserveUsd,
 			finalizeReserveUsd: account.finalizeReserveUsd,
 			synthesisReserveUsd: account.synthesisReserveUsd,
-			convergenceReserveUsd: account.convergenceReserveUsd
+			convergenceReserveUsd: account.convergenceReserveUsd,
+			repairReserveUsd: account.repairReserveUsd
 		};
 		if (account.ceilingUsd !== void 0) view.ceilingUsd = account.ceilingUsd;
 		if (account.parentScope !== void 0) view.parentScope = account.parentScope;
@@ -15064,7 +15091,7 @@ var RunBudget = class {
 	remainderOf(scope) {
 		const account = this.accounts.get(scope);
 		if (account?.ceilingUsd === void 0) return;
-		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd - account.convergenceReserveUsd);
+		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd - account.convergenceReserveUsd - account.repairReserveUsd);
 	}
 	/**
 	* The tightest allowance headroom on the chain of `scope`: the minimum
@@ -15144,16 +15171,17 @@ var RunBudget = class {
 		}
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd + account.synthesisReserveUsd + account.convergenceReserveUsd;
+			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd + account.synthesisReserveUsd + account.convergenceReserveUsd + account.repairReserveUsd;
 			if (committed >= account.ceilingUsd || committed + reserveUsd > account.ceilingUsd) {
 				if (account.scope === "run") this.exhaustedInternal = true;
-				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD ` + (account.synthesisReserveUsd > 0 ? `plus the held synthesis reserve ${account.synthesisReserveUsd.toFixed(4)} USD ` : "") + (account.convergenceReserveUsd > 0 ? `plus the held convergence reserve ${account.convergenceReserveUsd.toFixed(4)} USD ` : "") + `plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
+				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD ` + (account.synthesisReserveUsd > 0 ? `plus the held synthesis reserve ${account.synthesisReserveUsd.toFixed(4)} USD ` : "") + (account.convergenceReserveUsd > 0 ? `plus the held convergence reserve ${account.convergenceReserveUsd.toFixed(4)} USD ` : "") + (account.repairReserveUsd > 0 ? `plus the held repair reserve ${account.repairReserveUsd.toFixed(4)} USD ` : "") + `plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
 					account: account.scope,
 					spentUsd: account.spentUsd,
 					committedReserveUsd: account.committedReserveUsd,
 					finalizeReserveUsd: account.finalizeReserveUsd,
 					synthesisReserveUsd: account.synthesisReserveUsd,
 					convergenceReserveUsd: account.convergenceReserveUsd,
+					repairReserveUsd: account.repairReserveUsd,
 					proposedReserveUsd: reserveUsd,
 					ceilingUsd: account.ceilingUsd
 				} });
@@ -15280,6 +15308,39 @@ var RunBudget = class {
 		account.convergenceReserveUsd = 0;
 		this.emitUpdate();
 	}
+	/**
+	* Registers the repair round's MECHANICAL leg (RV3802), the money
+	* twin of the RV3602 per-invocation pool: the round's finish
+	* contract can grant one bounded mechanical repair turn, and the
+	* third comparison run's round entered exactly that turn's price
+	* short of certainty (the repair existed by pool and by contract,
+	* but nothing guaranteed the money would still be there when the
+	* candidate materialized). Held beside the verdict leg from the
+	* moment the round is admitted; released EARLY, to the round's own
+	* finish loop, at its first journaled verdict (a 'repair' verdict is
+	* about to spend the freed money on the granted turn, an 'accepted'
+	* one never needed it), where the verdict leg lives until the judge
+	* dispatch. Exactly the convergence reserve mechanics otherwise:
+	* joins the projected admission sum and both remainders, named in
+	* the refusal clause, never joined to the severing check, idempotent
+	* per account with the root adjusted by the delta.
+	*/
+	commitRepairReserve(scope, reserveUsd) {
+		const account = this.accounts.get(scope);
+		if (account === void 0) throw new ConfigError(`unknown budget account '${scope}' for the repair reserve`);
+		const previous = account.repairReserveUsd;
+		account.repairReserveUsd = reserveUsd;
+		if (account.scope !== "run") this.root.repairReserveUsd = Math.max(0, this.root.repairReserveUsd + reserveUsd - previous);
+		this.emitUpdate();
+	}
+	/** The round's finish loop consumes its leg; see commitRepairReserve. */
+	releaseRepairReserve(scope) {
+		const account = this.accounts.get(scope);
+		if (account === void 0 || account.repairReserveUsd === 0) return;
+		if (account.scope !== "run") this.root.repairReserveUsd = Math.max(0, this.root.repairReserveUsd - account.repairReserveUsd);
+		account.repairReserveUsd = 0;
+		this.emitUpdate();
+	}
 	/** The reserve is replaced by real spend when the spawn settles. */
 	releaseReserve(reserveUsd, accountScope = "run") {
 		for (const account of this.chainOf(accountScope)) account.committedReserveUsd = Math.max(0, account.committedReserveUsd - reserveUsd);
@@ -15487,7 +15548,7 @@ var RunBudget = class {
 		let remaining;
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd - account.convergenceReserveUsd;
+			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd - account.convergenceReserveUsd - account.repairReserveUsd;
 			remaining = remaining === void 0 ? headroom : Math.min(remaining, headroom);
 		}
 		return remaining === void 0 ? void 0 : Math.max(0, remaining);
@@ -15730,6 +15791,27 @@ function foldBuckets(source) {
 	return folded;
 }
 /**
+* The scope key rule of the byScope rollup (RV3805). The root's OWN
+* scope is the empty string BY CONSTRUCTION: present data whose string
+* happens to be empty, not an absence, so it folds under the
+* addressable name 'root' instead of the RV3604 'unknown' fallback,
+* which stays reserved for a scope that is truly missing. Children
+* keep their scope strings verbatim. One rule for both builders, so
+* the live report and the journal fold cannot disagree on the key.
+*/
+function scopeBucket(scope) {
+	return scope === void 0 ? "unknown" : scope === "" ? "root" : scope;
+}
+/** {@link scopeBucket} over a whole live map, merging folded keys. */
+function foldScopeBuckets(source) {
+	const folded = {};
+	for (const [key, usd] of source) {
+		const bucket = scopeBucket(key);
+		folded[bucket] = (folded[bucket] ?? 0) + usd;
+	}
+	return folded;
+}
+/**
 * Folds the per-run attribution buckets into the normative CostReport.
 * Live attribution buckets never see abandoned subtrees, so a host
 * that tracked abandoned spend itself passes it as `abandoned`;
@@ -15760,6 +15842,7 @@ function buildCostReport(attribution, totalUsd, abandoned = {
 		byPhase: foldBuckets(attribution.byPhase),
 		byAgentType: foldBuckets(attribution.byAgentType),
 		byRole,
+		byScope: foldScopeBuckets(attribution.byScope),
 		orchestrator: {
 			...orchestrator,
 			share: orchestrator.spentUsd / Math.max(totalUsd, .01)
@@ -15785,6 +15868,7 @@ function costReportFromJournal(entries, priceUsd) {
 	const byModel = {};
 	const byPhase = {};
 	const byAgentType = {};
+	const byScope = {};
 	const byRole = emptyByRole();
 	const unpriced = [];
 	let totalUsd = 0;
@@ -15827,6 +15911,8 @@ function costReportFromJournal(entries, priceUsd) {
 		byPhase[phase] = (byPhase[phase] ?? 0) + priced.usd;
 		const agentType = attributionBucket(facts?.agentType);
 		byAgentType[agentType] = (byAgentType[agentType] ?? 0) + priced.usd;
+		const scope = scopeBucket(entry.scope);
+		byScope[scope] = (byScope[scope] ?? 0) + priced.usd;
 		const primaryRole = facts?.role ?? "loop";
 		for (const unit of priced.units) byRole[unit.role ?? primaryRole] += unit.usd;
 		if (facts?.budgetAccount !== void 0 && isOrchestratorAccount(facts.budgetAccount)) {
@@ -15848,6 +15934,7 @@ function costReportFromJournal(entries, priceUsd) {
 		byPhase,
 		byAgentType,
 		byRole,
+		byScope,
 		orchestrator: {
 			spentUsd: orchestratorSpentUsd,
 			share: orchestratorSpentUsd / Math.max(totalUsd, .01),
@@ -18953,6 +19040,7 @@ function createCtx(internals, rootWorkflow) {
 			});
 			bump(internals.cost.byPhase, state.phase ?? "", costUsd);
 			bump(internals.cost.byAgentType, agentType, costUsd);
+			bump(internals.cost.byScope, state.scope, costUsd);
 			internals.cost.byRole.set(primaryRole, (internals.cost.byRole.get(primaryRole) ?? 0) + costUsd);
 			if (result.status === "escalated" && result.escalation !== void 0) {
 				if (internals.replayer.snapshot().find((entry) => entry.kind === "decision" && entry.value?.targetRef === matched.running.seq) === void 0 && opts.result !== "full" && internals.onEscalation !== void 0) {
@@ -19728,6 +19816,7 @@ function createCtx(internals, rootWorkflow) {
 		}
 		bump(internals.cost.byPhase, state.phase ?? "", usd);
 		bump(internals.cost.byAgentType, agentType, usd);
+		bump(internals.cost.byScope, state.scope, usd);
 		if (result.error?.kind === "budget" || internals.budget.exhausted && result.status !== "ok") {
 			if (!internals.budget.exhausted && result.errorMessage !== void 0 && result.errorMessage.startsWith("in flight exposure cap reached")) throw new BudgetExhaustedError(result.errorMessage, { data: {
 				scope: state.scope,
@@ -21166,6 +21255,50 @@ const MAX_LISTED_CITATIONS = 20;
 const MAX_NAMED_OFFENDING_SENTENCES = 5;
 const MAX_OFFENDING_SENTENCE_CHARS = 240;
 /**
+* The most offending sentences a verdict will hint (RV3801). A
+* document broken in more places than this needs a model repair
+* anyway, and an unbounded hint set would carry unbounded sentence
+* bytes through the live verdict.
+*/
+const MAX_REPAIR_HINTS = 20;
+/**
+* The deterministic edit behind the `insert-run-id` mechanism
+* (RV3801): the id lands INSIDE the sentence, before its trailing
+* terminator run (a `.`, `!`, or `?` with any closing quotes,
+* brackets, or markdown emphasis after it), or at the very end when
+* the sentence carries no terminator. Inside matters: appended AFTER
+* the terminator the id would belong to the NEXT sentence under the
+* shared `sentencesOf` segmentation and the re-validation would fail
+* the same sentence again. Exported so tests and hosts can reproduce
+* the loop's exact bytes.
+*/
+function insertRunIdIntoSentence(sentence, insert) {
+	const at = /[.!?]['")\]*_`]*\s*$/u.exec(sentence)?.index ?? sentence.length;
+	return `${sentence.slice(0, at)} (run ${insert})${sentence.slice(at)}`;
+}
+/**
+* Applies `insert-run-id` repair hints to a judged text (RV3801): each
+* `[start, end)` window is replaced by
+* {@link insertRunIdIntoSentence}(window, insert), right to left so
+* earlier offsets stay valid, every other byte identical. Fail closed:
+* `undefined` (never a partial patch) when the set is empty, any
+* window is out of bounds or empty, or two windows overlap; the caller
+* treats a refused patch exactly like an absent one and proceeds to
+* the model repair pool.
+*/
+function applyFinishRepairHints(text, hints) {
+	if (hints.length === 0) return;
+	const ordered = [...hints].sort((a, b) => a.start - b.start);
+	let previousEnd = 0;
+	for (const hint of ordered) {
+		if (!Number.isInteger(hint.start) || !Number.isInteger(hint.end) || hint.start < previousEnd || hint.end <= hint.start || hint.end > text.length) return;
+		previousEnd = hint.end;
+	}
+	let patched = text;
+	for (const hint of [...ordered].reverse()) patched = patched.slice(0, hint.start) + insertRunIdIntoSentence(patched.slice(hint.start, hint.end), hint.insert) + patched.slice(hint.end);
+	return patched;
+}
+/**
 * The shortest run id {@link evidenceGradeValidator} will accept as an
 * artifact (RV2501). The floor mirrors the id half of
 * {@link DEFAULT_ARTIFACT_PATTERN}: a two character id would satisfy
@@ -21477,6 +21610,13 @@ const DEFAULT_ARTIFACT_PATTERN = "(?:run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}|[\\w./-]+\
 * the repair instruction is executable rather than aspirational. An id
 * shorter than `MIN_RUN_ID_ARTIFACT_CHARS` (six) is ignored, and
 * without an id the verdict is byte identical to the historical one.
+*
+* With the id in hand the failure also carries {@link FinishRepairHint}
+* rows (RV3801), one per offending sentence, so the finish loop can
+* perform the verdict's own prescription host side without spending a
+* provider wire; the reasons stay byte identical either way, and the
+* hints are bounded (at most `MAX_REPAIR_HINTS` offenders) and fail
+* closed (an id whose bytes could split a sentence is never hinted).
 * Default name 'evidence-grade'.
 */
 function evidenceGradeValidator(options) {
@@ -21496,18 +21636,32 @@ function evidenceGradeValidator(options) {
 			const unsupported = [];
 			const offenders = [];
 			const runId = typeof input.runId === "string" && input.runId.trim().length >= MIN_RUN_ID_ARTIFACT_CHARS ? input.runId.trim() : void 0;
+			let cursor = 0;
 			for (const sentence of sentencesOf(input.text)) {
+				const start = input.text.indexOf(sentence, cursor);
+				cursor = start + sentence.length;
 				const haystack = sentence.toLowerCase();
 				const found = lowered.filter((phrase) => haystack.includes(phrase));
 				if (found.length === 0 || new RegExp(artifactPattern, "").test(sentence) || runId !== void 0 && containsIdentifier(sentence, runId)) continue;
-				offenders.push(sentence);
+				offenders.push({
+					sentence,
+					start,
+					end: start + sentence.length
+				});
 				for (const phrase of found) if (!unsupported.includes(phrase)) unsupported.push(phrase);
 			}
 			if (unsupported.length === 0) return ok;
-			const named = offenders.slice(0, MAX_NAMED_OFFENDING_SENTENCES).map((sentence) => {
+			const named = offenders.slice(0, MAX_NAMED_OFFENDING_SENTENCES).map(({ sentence }) => {
 				const flat = sentence.replace(/\s+/gu, " ").trim();
 				return `offending sentence: "${flat.length <= MAX_OFFENDING_SENTENCE_CHARS ? flat : `${flat.slice(0, MAX_OFFENDING_SENTENCE_CHARS)}...`}"`;
 			});
+			const hints = runId !== void 0 && offenders.length <= MAX_REPAIR_HINTS && !/[.!?]\s|[\r\n]/u.test(runId) && offenders.every((offender) => offender.start >= 0) ? offenders.map(({ sentence, start, end }) => ({
+				mechanism: "insert-run-id",
+				start,
+				end,
+				sentence,
+				insert: runId
+			})) : void 0;
 			const overflow = offenders.length - named.length;
 			return {
 				ok: false,
@@ -21515,7 +21669,8 @@ function evidenceGradeValidator(options) {
 					runId === void 0 ? `evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; give each such claim a file:line citation in its own sentence, or state its run id in a SEPARATE sentence carrying no source citation (a run id written beside a path:line citation is not in the cited window and trades this failure for a cited-value one)` : `evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; write this run's id ${runId} inside each such sentence, or give the claim a file:line citation instead (the id may share a sentence with a source citation: cited-value reads a run id as identity, not as a value asserted about the cited line)`,
 					...named,
 					...overflow > 0 ? [`and ${String(overflow)} more offending sentences`] : []
-				]
+				],
+				...hints === void 0 ? {} : { repairHints: hints }
 			};
 		}
 	};
@@ -22763,6 +22918,72 @@ function selfTestFinishValidation(options) {
 /** How many rejected finishes are repaired by default: the plan's repair once. */
 const DEFAULT_FINISH_MAX_REPAIRS = 1;
 /**
+* The most hinted edits one deterministic repair attempt will apply
+* (RV3801): a validator caps its own hints well below this, so the
+* bound only guards against a custom validator flooding the journal
+* with patch rows; past it the candidate goes to the model pool.
+*/
+const MAX_DETERMINISTIC_PATCHES = 64;
+/**
+* Plans the sectional claim repair round (RV3803): which H2 sections
+* of the accepted pre-repair document own the judged findings. The
+* third comparison run's round regenerated the WHOLE 43k character
+* document to consume findings that lived in a handful of sentences,
+* and the tail after fan-in was 80.1 percent of the run's wall. Each
+* finding's `draftExcerpt` (whitespace collapsed by the pairing fold)
+* is located in the document through a collapse-aware scan, and its
+* owning section is the nearest H2 line above it. Fail closed to the
+* FULL regeneration (undefined, the historical round byte for byte)
+* whenever the plan cannot be exact: no excerpts, a document without
+* H2 headings, duplicated markers (the splice grammar needs unique
+* lines), or any excerpt the scan cannot locate.
+*/
+function sectionalRoundPlan(document, excerpts) {
+	if (excerpts.length === 0) return;
+	const markers = [];
+	let offset = 0;
+	for (const line of document.split("\n")) {
+		if (line.trim().startsWith("## ")) markers.push({
+			marker: line.trim(),
+			start: offset
+		});
+		offset += line.length + 1;
+	}
+	if (markers.length === 0 || new Set(markers.map((m) => m.marker)).size !== markers.length) return;
+	const collapsed = [];
+	const rawAt = [];
+	let pendingSpace = false;
+	for (let index = 0; index < document.length; index += 1) {
+		const char = document[index] ?? "";
+		if (/\s/u.test(char)) {
+			pendingSpace = collapsed.length > 0;
+			continue;
+		}
+		if (pendingSpace) {
+			collapsed.push(" ");
+			rawAt.push(index);
+			pendingSpace = false;
+		}
+		collapsed.push(char);
+		rawAt.push(index);
+	}
+	const haystack = collapsed.join("");
+	const targets = [];
+	for (const excerpt of excerpts) {
+		const at = haystack.indexOf(excerpt.trim());
+		if (at < 0) return;
+		const raw = rawAt[at] ?? -1;
+		const owner = [...markers].reverse().find((m) => m.start <= raw);
+		if (owner === void 0) return;
+		if (!targets.includes(owner.marker)) targets.push(owner.marker);
+	}
+	targets.sort((a, b) => markers.findIndex((m) => m.marker === a) - markers.findIndex((m) => m.marker === b));
+	return {
+		sections: markers.map((m) => m.marker),
+		targets
+	};
+}
+/**
 * Character cap of the HOST VALIDATION LESSONS prompt block (RV3603):
 * the bounded repair round's prompt folds the run's journaled finish
 * validation failures so the round does not relearn a lesson the run
@@ -22895,6 +23116,8 @@ function validateOrchestrateOptions(opts) {
 		}
 		if (fv.maxRepairs !== void 0) requireNonNegativeInteger(fv.maxRepairs, "orchestrate finishValidation.maxRepairs");
 		if (fv.repairTurnReserve !== void 0) requireNonNegativeInteger(fv.repairTurnReserve, "orchestrate finishValidation.repairTurnReserve");
+		const estRepair = fv.estRepairCostUsd;
+		if (estRepair !== void 0 && (typeof estRepair !== "number" || !Number.isFinite(estRepair) || estRepair < 0)) throw new ConfigError(`orchestrate finishValidation.estRepairCostUsd must be a nonnegative finite number; got ${JSON.stringify(estRepair)}`);
 		const retain = fv.retainRejectedCandidates;
 		if (retain !== void 0 && typeof retain !== "boolean") throw new ConfigError("orchestrate finishValidation.retainRejectedCandidates must be a boolean");
 		const draftPolicy = fv.draftPolicy;
@@ -24263,6 +24486,31 @@ function makeOrchestratorWorkflow(goal, opts) {
 		*/
 		let validationInvocationStart = 0;
 		/**
+		* The staged release of the round's mechanical money leg (RV3802),
+		* armed by the bounded claim repair round right before its
+		* composition dispatches and fired at the round invocation's FIRST
+		* journaled finish verdict: a 'repair' verdict is about to spend
+		* the freed money on the granted turn, an 'accepted' one never
+		* needed it, and a 'rejected' one dies into the round's own
+		* finally, which releases whatever is still armed. Live-only state
+		* on the RV808b doctrine: the hold itself is re-committed by the
+		* re-executed round code on a resume, and full replay never runs
+		* validateFinish at all.
+		*/
+		let releaseRepairLeg;
+		/**
+		* The sectional round context (RV3803), armed by the bounded claim
+		* repair round exactly when {@link sectionalRoundPlan} is exact
+		* over the accepted pre-repair document and the judged findings:
+		* the retained base, its full H2 marker roster, and the target
+		* sections owning the findings. Live state cleared in the round's
+		* finally; a resume re-derives it from replayed material (the
+		* judged findings and the accepted document both replay verbatim),
+		* so the round's prompt bytes stay identical without journaling
+		* anything new.
+		*/
+		let sectionalRoundContext;
+		/**
 		* The contract generation membership test (cycle 73). Without a
 		* contract there are no generations and every decision is current
 		* (the pre 1.77 behavior, byte identical). With one, a decision
@@ -24295,8 +24543,9 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const rows = [];
 			const seen = /* @__PURE__ */ new Set();
 			for (const decision of validationDecisions()) {
-				if (decision.failed.length === 0 || !contractGenerationCurrent(decision)) continue;
-				for (const failure of decision.failed) {
+				const taught = [...decision.failed, ...decision.deterministicRepair?.healed ?? []];
+				if (taught.length === 0 || !contractGenerationCurrent(decision)) continue;
+				for (const failure of taught) {
 					const key = JSON.stringify([failure.name, failure.reasons]);
 					if (seen.has(key)) continue;
 					seen.add(key);
@@ -24435,7 +24684,45 @@ function makeOrchestratorWorkflow(goal, opts) {
 			if (validationSpec === void 0) return { ok: true };
 			let effective = call.result ?? null;
 			let spliced = false;
-			if (finishSectional !== void 0) {
+			if (sectionalRoundContext !== void 0) {
+				const round = sectionalRoundContext;
+				const args = call.args ?? {};
+				const hasSections = Object.hasOwn(args, "sections");
+				const hasResult = Object.hasOwn(args, "result");
+				const guidance = () => ({
+					declaredSections: round.sections,
+					targetSections: round.targets,
+					instruction: "repair ONLY the target sections: call finish({ sections: { \"<marker>\": \"<new section body>\" } }); unchanged sections are spliced from the retained accepted document byte for byte and the spliced whole is validated and judged. Resubmit the full document as result only when a targeted repair is impossible."
+				});
+				if (hasSections && hasResult) return {
+					ok: false,
+					feedback: {
+						error: "pass either result (the full document) or sections (a sectional repair of the retained accepted document), never both",
+						...guidance()
+					}
+				};
+				if (hasSections) {
+					const patch = args.sections;
+					const markers = Object.keys(patch);
+					if (markers.length === 0) return {
+						ok: false,
+						feedback: {
+							error: "sections must name at least one declared section marker",
+							...guidance()
+						}
+					};
+					const unknown = markers.filter((marker) => !round.sections.includes(marker));
+					if (unknown.length > 0) return {
+						ok: false,
+						feedback: {
+							error: `sections names an undeclared section ${unknown.map((marker) => `'${marker}'`).join(", ")}; only the retained document's own markers splice`,
+							...guidance()
+						}
+					};
+					effective = spliceSections(round.base, round.sections, patch);
+					spliced = true;
+				}
+			} else if (finishSectional !== void 0) {
 				const resolution = finishSectional.resolve(call);
 				if (resolution.kind === "refused") return {
 					ok: false,
@@ -24446,6 +24733,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			}
 			const maxRepairs = validationSpec.maxRepairs ?? 1;
 			const known = validationDecisions();
+			let patchedResult;
 			let decision = known.find((candidate) => candidate.callId === call.id);
 			if (decision === void 0) {
 				const result = effective;
@@ -24456,6 +24744,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					runId: internals.runId
 				};
 				const failed = [];
+				const failureHints = [];
 				for (const validator of validationSpec.validators) {
 					let verdict;
 					try {
@@ -24468,13 +24757,66 @@ function makeOrchestratorWorkflow(goal, opts) {
 							feedback: { error: `finish validator '${validator.name}' is defective; the run fails` }
 						};
 					}
-					if (!verdict.ok) failed.push({
-						name: validator.name,
-						reasons: verdict.reasons
-					});
+					if (!verdict.ok) {
+						failed.push({
+							name: validator.name,
+							reasons: verdict.reasons
+						});
+						failureHints.push(verdict.repairHints);
+					}
+				}
+				let deterministicRepair;
+				if (failed.length > 0 && typeof result === "string" && failureHints.every((hints) => hints !== void 0 && hints.length > 0)) {
+					const merged = [];
+					const seenHints = /* @__PURE__ */ new Set();
+					for (const hints of failureHints) for (const hint of hints ?? []) {
+						const key = `${String(hint.start)}:${String(hint.end)}:${hint.insert}`;
+						if (!seenHints.has(key)) {
+							seenHints.add(key);
+							merged.push(hint);
+						}
+					}
+					const patched = merged.length <= MAX_DETERMINISTIC_PATCHES && merged.every((hint) => hint.mechanism === "insert-run-id" && result.slice(hint.start, hint.end) === hint.sentence) ? applyFinishRepairHints(result, merged) : void 0;
+					if (patched !== void 0) {
+						const patchedInput = {
+							result: patched,
+							text: patched,
+							children: input.children,
+							runId: internals.runId
+						};
+						const residual = [];
+						for (const validator of validationSpec.validators) {
+							let verdict;
+							try {
+								verdict = validator.validate(patchedInput);
+							} catch (thrown) {
+								validationTermination = new ConfigError(`finish validator '${validator.name}' threw instead of returning a verdict: ` + (thrown instanceof Error ? thrown.message : String(thrown)));
+								validationAbort.abort("rulvar:finish-validation-defect");
+								return {
+									ok: false,
+									feedback: { error: `finish validator '${validator.name}' is defective; the run fails` }
+								};
+							}
+							if (!verdict.ok) residual.push(validator.name);
+						}
+						const patchSurvived = residual.length === 0;
+						deterministicRepair = {
+							mechanism: "insert-run-id",
+							patches: merged.map(({ start, end, insert }) => ({
+								start,
+								end,
+								insert
+							})),
+							beforeHash: createHash("sha256").update(jcsSerialize(result), "utf8").digest("hex"),
+							afterHash: createHash("sha256").update(jcsSerialize(patched), "utf8").digest("hex"),
+							outcome: patchSurvived ? "accepted" : "failed",
+							...patchSurvived ? { healed: failed } : { residual }
+						};
+						if (patchSurvived) patchedResult = patched;
+					}
 				}
 				const repairsUsed = known.filter((candidate, index) => index >= validationInvocationStart && candidate.verdict !== "accepted" && contractGenerationCurrent(candidate)).length;
-				const rejectedCandidate = failed.length > 0;
+				const rejectedCandidate = failed.length > 0 && deterministicRepair?.outcome !== "accepted";
 				let candidateRef;
 				if (rejectedCandidate && validationSpec.retainRejectedCandidates === true) {
 					const ref = `${internals.runId}/finish-rejected/${call.id}`;
@@ -24496,10 +24838,11 @@ function makeOrchestratorWorkflow(goal, opts) {
 				decision = {
 					decisionType: "orchestrator_finish_validation",
 					callId: call.id,
-					verdict: failed.length === 0 ? "accepted" : repairsUsed < maxRepairs ? "repair" : "rejected",
-					failed,
+					verdict: failed.length === 0 || deterministicRepair?.outcome === "accepted" ? "accepted" : repairsUsed < maxRepairs ? "repair" : "rejected",
+					failed: deterministicRepair?.outcome === "accepted" ? [] : failed,
 					repairsUsed,
 					maxRepairs,
+					...deterministicRepair === void 0 ? {} : { deterministicRepair },
 					...validationSpec.contract === void 0 ? {} : { contractHash: validationSpec.contract.hash },
 					...rejectedCandidate ? {
 						candidateHash: createHash("sha256").update(jcsSerialize(result), "utf8").digest("hex"),
@@ -24516,11 +24859,18 @@ function makeOrchestratorWorkflow(goal, opts) {
 					site: "orchestrator-finish-validation",
 					value: decision
 				});
+				releaseRepairLeg?.();
+			}
+			if (decision.verdict === "accepted") {
+				if (patchedResult !== void 0) return {
+					ok: true,
+					resolved: { result: patchedResult }
+				};
+				return spliced ? {
+					ok: true,
+					resolved: { result: effective }
+				} : { ok: true };
 			}
-			if (decision.verdict === "accepted") return spliced ? {
-				ok: true,
-				resolved: { result: effective }
-			} : { ok: true };
 			finishSectional?.retain(effective);
 			if (decision.verdict === "rejected") {
 				if (contractGenerationCurrent(decision)) {
@@ -24541,7 +24891,11 @@ function makeOrchestratorWorkflow(goal, opts) {
 					error: "the finish result failed host validation; repair the result and call finish again",
 					failed: decision.failed,
 					repairsRemaining: decision.maxRepairs - decision.repairsUsed - 1,
-					...finishSectional === void 0 ? {} : { sectionalRepair: finishSectional.guidance() }
+					...sectionalRoundContext !== void 0 ? { sectionalRepair: {
+						declaredSections: sectionalRoundContext.sections,
+						targetSections: sectionalRoundContext.targets,
+						instruction: "repair ONLY the target sections: call finish({ sections: { \"<marker>\": \"<new section body>\" } }); unchanged sections are spliced from the retained accepted document byte for byte and the spliced whole is validated and judged. Resubmit the full document as result only when a targeted repair is impossible."
+					} } : finishSectional === void 0 ? {} : { sectionalRepair: finishSectional.guidance() }
 				}
 			};
 		};
@@ -25608,7 +25962,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const synthesisToolNames = /* @__PURE__ */ new Set([FINISH_TOOL_NAME, ...exposeTools ? [GET_CHILD_RESULT_TOOL_NAME, READ_CHILD_ARTIFACT_TOOL_NAME] : []]);
 			const synthesisTools = buildOrchestratorTools(orchestratorRuntime, fullCardText, {
 				childResultTools: exposeTools,
-				sectionalFinish: synthSectionalFinish
+				sectionalFinish: synthSectionalFinish || sectionalRoundContext !== void 0
 			}).filter((tool) => synthesisToolNames.has(tool.name));
 			if (finishSectional !== void 0 && synthSectionalFinish) finishSectional.retain(draft);
 			const settledEntries = [...byOrdinal.values()].filter((record) => record.settled !== void 0).sort((a, b) => a.spawnOrdinal - b.spawnOrdinal).map((record) => [record.handle, record]);
@@ -25686,6 +26040,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...opts?.contradictions?.onFound !== "carry" || contradictionsFound === void 0 || contradictionsFound.length === 0 ? [] : ["CHILD CONTRADICTIONS: the settled children read these cited locations differently; resolve each one EXPLICITLY in the final result (say which reading holds and why it does) instead of silently picking one. " + JSON.stringify(contradictionsFound)],
 				...opts?.claimConsistency?.onFound !== "carry" && opts?.claimConsistency?.onFound !== "repair" || claimFindingsFound === void 0 || claimFindingsFound.length === 0 ? [] : ["CLAIM CONTRADICTIONS: the composed draft contradicts the settled child pool at these cited locations; resolve each one EXPLICITLY in the final result (say which reading holds and why) instead of keeping the inverted claim. " + JSON.stringify(claimFindingsFound)],
 				...opts?.claimConsistency?.onFound !== "carry" && opts?.claimConsistency?.onFound !== "repair" || claimFindingsFound === void 0 || claimFindingsFound.length === 0 ? [] : hostValidationLessons(),
+				...sectionalRoundContext === void 0 ? [] : [`RETAINED FINAL: ${JSON.stringify(sectionalRoundContext.base)}`, "SECTIONAL ROUND: the accepted document above is RETAINED; repair ONLY the sections owning the contradicted claims by calling finish({ sections: { \"<marker>\": \"<new section body>\" } }). Unchanged sections are spliced from the retained document byte for byte and the spliced whole is validated and judged. Target sections: " + JSON.stringify(sectionalRoundContext.targets) + ". Declared markers: " + JSON.stringify(sectionalRoundContext.sections) + ". Resubmit the full document as result only when a targeted repair is impossible."],
 				...spec.policyFacts === true ? [(() => {
 					const byStatus = {};
 					let extensionsGranted = 0;
@@ -26540,6 +26895,30 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const convergenceHoldUsd = opts?.claimConsistency?.judge?.estCost ?? observedFinalJudgeCostUsd ?? 0;
 				const convergenceScope = orchestratorAccount ?? "run";
 				if (convergenceHoldUsd > 0) internals.budget.commitConvergenceReserve(convergenceScope, convergenceHoldUsd);
+				const repairHoldUsd = validationSpec === void 0 ? 0 : validationSpec.estRepairCostUsd ?? lastMechanicalRepairCostUsd(internals.replayer.snapshot(), (servedBy, usage) => internals.priceUsd(servedBy, usage)) ?? 0;
+				if (repairHoldUsd > 0) {
+					internals.budget.commitRepairReserve(convergenceScope, repairHoldUsd);
+					releaseRepairLeg = () => {
+						releaseRepairLeg = void 0;
+						internals.budget.releaseRepairReserve(convergenceScope);
+					};
+				}
+				const roundPlan = validationSpec !== void 0 && typeof synthesizedFinal === "string" ? sectionalRoundPlan(synthesizedFinal, carried.map((finding) => finding.draftExcerpt)) : void 0;
+				if (roundPlan !== void 0) {
+					sectionalRoundContext = {
+						base: synthesizedFinal,
+						...roundPlan
+					};
+					internals.events.emit({
+						type: "log",
+						level: "debug",
+						msg: "orchestrator sectional round armed",
+						data: {
+							targets: roundPlan.targets,
+							sections: roundPlan.sections.length
+						}
+					}, callingState.spanId);
+				}
 				try {
 					synthesizedFinal = await runSynthesis(result.output);
 				} catch (thrown) {
@@ -26572,6 +26951,9 @@ function makeOrchestratorWorkflow(goal, opts) {
 						...acceptanceSnapshot
 					} });
 				} finally {
+					sectionalRoundContext = void 0;
+					releaseRepairLeg = void 0;
+					if (repairHoldUsd > 0) internals.budget.releaseRepairReserve(convergenceScope);
 					if (convergenceHoldUsd > 0) internals.budget.releaseConvergenceReserve(convergenceScope);
 				}
 				try {
@@ -28775,6 +29157,7 @@ function createEngine(options) {
 				byModel: /* @__PURE__ */ new Map(),
 				byPhase: /* @__PURE__ */ new Map(),
 				byAgentType: /* @__PURE__ */ new Map(),
+				byScope: /* @__PURE__ */ new Map(),
 				byRole: /* @__PURE__ */ new Map(),
 				unpriced: [],
 				orchestrator: {
@@ -29732,4 +30115,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyFinishRepairHints, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, insertRunIdIntoSentence, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastMechanicalRepairCostUsd, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, scopeBucket, sectionCitationsValidator, sectionPatternCountValidator, sectionalRoundPlan, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/package.json

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