@rulvar/core 1.226.0 → 1.228.0

package/dist/index.d.ts

@@ -2170,7 +2170,42 @@ type CoreEvents = {
   * read null while the journal held the verdict.
   */
   claimConsistencyMeta?: Record<string, unknown>; /** The synthesis-skip marker from the same envelope; same lift (RV2203). */
-  synthesisSkipped?: boolean | string; /** Children accepted through validated terminal output salvage on 'limit'; same lift. */
+  synthesisSkipped?: boolean | string;
+  /**
+  * Whether the artifact this terminal carries was accepted by the
+  * declared finish contract, and whether there is one to read at
+  * all (RV2506); same lift. `deliverableAccepted` is absent, never
+  * false, when no finish contract was declared. The pair is what
+  * `status` and `completion` cannot say between them: an accepted
+  * child roster over a synthesis that never passed its contract
+  * reads `status: 'ok'`, `completion: 'complete'`,
+  * `deliverableAccepted: false`.
+  */
+  deliverableAccepted?: boolean;
+  resultAvailable?: boolean;
+  /**
+  * The journal seq of the decision recording that acceptance
+  * (RV2506); absent whenever `deliverableAccepted` is not true.
+  */
+  acceptedArtifactRef?: number;
+  /**
+  * Every finish candidate the declared contract did NOT accept, in
+  * judgement order (RV2507); same lift, absent when there was
+  * none. Each row identifies the candidate (`callId`, `hash`,
+  * `chars`) and names the validators that rejected it, with `ref`
+  * pointing at the retained bytes where the host asked for them.
+  */
+  rejectedFinishCandidates?: {
+    callId: string;
+    verdict: "repair" | "rejected";
+    hash: string;
+    chars: number;
+    failed: {
+      name: string;
+      reasons: string[];
+    }[];
+    ref?: string;
+  }[]; /** Children accepted through validated terminal output salvage on 'limit'; same lift. */
   salvagedTerminalOutputChildren?: string[];
   /**
   * Children that settled 'ok' below their declared evidence floor
@@ -5225,6 +5260,17 @@ interface BudgetHooks {
   */
   remainingUsd?: () => number | undefined;
   /**
+  * Layer 2b asked of the IN-FLIGHT EXPOSURE ceiling (RV2503), wired
+  * only when the cap is configured: the output tokens the exposure
+  * room still affords for this prompt. The dispatch clamps to it too,
+  * so a turn whose full plan overshoots the exposure line is SHORTENED
+  * rather than refused while the budget can still pay for it. An
+  * answer below the serving model's output floor is ignored, so a
+  * genuine exposure exhaustion still refuses through
+  * `admitTurnExposure` with its own typed reason.
+  */
+  maxExposureOutputTokens?: (servedBy: ModelRef, estimatedInputTokens: number) => number | undefined;
+  /**
   * The in-flight exposure admission (RV711), wired only when the cap
   * is configured. Called synchronously right before each provider
   * dispatch attempt with the attempt's own request estimate: the
@@ -6270,6 +6316,8 @@ declare class RunBudget {
   * reservation surface is inert and reserveTurnExposure never binds.
   */
   readonly maxInFlightExposureUsd?: number;
+  /** The opt-in lone-dispatch clamp (RV2503); see maxExposureOutputTokens. */
+  private readonly clampTurnToExposure;
   private readonly lifetimeSpawnCap;
   private readonly events?;
   private readonly priceUsd?;
@@ -6334,7 +6382,8 @@ declare class RunBudget {
   private readonly invalidPriceWarned;
   constructor(options: {
     ceilingUsd?: number; /** The opt-in in-flight exposure cap (RV711); see reserveTurnExposure. */
-    maxInFlightExposureUsd?: number;
+    maxInFlightExposureUsd?: number; /** The opt-in lone-dispatch clamp (RV2503); see maxExposureOutputTokens. */
+    clampTurnToExposure?: boolean;
     lifetimeSpawnCap?: number;
     events?: RuntimeEventSink;
     priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined; /** Raw price-row resolution for the layer-2b output bound. */
@@ -6637,6 +6686,53 @@ declare class RunBudget {
   remainingUsd(accountScope?: string): number | undefined;
   maxAffordableOutputTokens(servedBy: ModelRef, estimatedInputTokens: number, accountScope?: string): number | undefined;
   /**
+  * The same layer-2b question asked of the IN-FLIGHT EXPOSURE ceiling
+  * (RV2503): the output tokens `cap - spent - live estimates` still
+  * affords from `servedBy` for an estimated prompt, priced by the
+  * settlement function like every other estimate here.
+  *
+  * The clamp above has always existed for the budget ceiling while
+  * {@link reserveTurnExposure} only ever answered yes or no, so a
+  * turn whose FULL planned output overshot the exposure line was
+  * refused outright even when a shorter one fit and the budget could
+  * pay for it. The 1.226.0 comparison run died exactly there: it held
+  * 0.8642 USD of budget, the exposure ceiling had 0.5642 USD of room,
+  * the mandatory repair turn was estimated at 0.7066 USD against an
+  * 18000 token output plan, and the dispatch was refused before any
+  * provider call. The same turn, re-issued after the operator raised
+  * the ceiling, wrote 12840 output tokens and cost 0.4788 USD: it fit
+  * the ceiling that refused it, and a clamp to the ~13253 tokens the
+  * room afforded would have let it run.
+  *
+  * Answered ONLY for a dispatch that is alone in flight, which is the
+  * whole difference between a refusal that means something and one
+  * that means nothing. With siblings live the refusal is TRANSIENT:
+  * RV1902 parks on it and the turn runs at its full planned length
+  * the moment one of them releases, so shortening it would trade a
+  * complete answer for a truncated one and buy nothing. With nothing
+  * live the refusal is PERMANENT (RV2003's sweep wakes such a waiter
+  * 'drained' precisely because no hold will ever return), and the
+  * only choices left are a shorter turn or no turn at all. The
+  * concurrent-wave bound of RV711 is therefore untouched.
+  *
+  * Opt-in through `RunOptions.clampTurnToExposure`, so the drained
+  * refusal terminals RV1902, RV2002 and RV2003 built out of live
+  * parity deaths keep their shapes until a host asks for this one.
+  *
+  * Undefined when the clamp is not armed, when the cap is not
+  * configured, when anything is in flight, or when the model has no
+  * price row, so a run that declares nothing keeps every byte of its
+  * historical path. Zero or
+  * negative when the room cannot even pay for the prompt, the same
+  * convention {@link maxAffordableOutputTokens} inherits from
+  * `affordableOutputTokens`; the caller decides what a sub-floor
+  * answer means, and the loop deliberately ignores one so a true
+  * exposure exhaustion still refuses through
+  * {@link reserveTurnExposure} with its own typed reason instead of
+  * an output-floor verdict.
+  */
+  maxExposureOutputTokens(servedBy: ModelRef, estimatedInputTokens: number): number | undefined;
+  /**
   * Live accounting; spend propagates from `accountScope` to every
   * ancestor. Crossing a ceiling severs the crossing account's subtree
   * via its layer-3 AbortSignal (overshoot bounded by one turn per
@@ -7630,6 +7726,33 @@ interface RunOptions {
   */
   maxInFlightExposureUsd?: number;
   /**
+  * Layer 2b against the exposure ceiling (RV2503), opt-in and
+  * meaningful only beside `maxInFlightExposureUsd`. Armed, a dispatch
+  * with NOTHING else in flight has its planned output clamped to the
+  * tokens the remaining exposure room affords instead of being
+  * refused outright, exactly as the budget ceiling has always clamped
+  * it. The 1.226.0 comparison run is the case: nothing was live, the
+  * budget still held 0.8642 USD, the mandatory repair turn's FULL
+  * 18000 token plan priced 0.7066 USD against 0.5642 USD of room, and
+  * the dispatch was refused before any provider call; the same work,
+  * re-issued after an operator raised the ceiling, wrote 12840 output
+  * tokens for 0.4788 USD. A refusal with nothing live buys nothing,
+  * because no hold will ever release to fund the full plan.
+  *
+  * Deliberately scoped and deliberately off by default. With siblings
+  * in flight the refusal is transient and the RV1902/RV2002 waits
+  * park on it, so the wave keeps the full-length turn RV711 promised
+  * and nothing here applies. When the room cannot even fund the
+  * serving model's output floor, the clamp stands aside and the
+  * dispatch refuses through the usual typed `in-flight-exposure`
+  * path, so the drained-refusal terminals (RV1902, RV2002, RV2003)
+  * keep their shapes. Absent, every byte of dispatch behavior is
+  * historical. Like `strictPricing`, this is a per-segment posture: it
+  * is not recorded in RunMeta and a resumed segment carries only what
+  * its own options declare.
+  */
+  clampTurnToExposure?: boolean;
+  /**
   * The opt-in strict pre-egress pricing gate (RV1508): every paid
   * dispatch must resolve a well-formed price row for its serving
   * model BEFORE the wire call, or the dispatch refuses typed
@@ -7988,6 +8111,15 @@ interface FinishValidationInput {
   * evidence the children actually produced.
   */
   readonly children?: readonly FinishValidationChild[];
+  /**
+  * The id of the run being judged (RV2501). Optional in the TYPE only
+  * so hand built inputs stay source compatible; the orchestrator
+  * runtime always supplies it, at every gate that judges a finish
+  * (the validator-bound finish, the contract draft gate, and the
+  * skipWhenDraftValid pre-pass), so a validator can accept the run's
+  * own id as the artifact a claim about THIS run points at.
+  */
+  readonly runId?: string;
 }
 /** The verdict of one validator over one finish attempt. */
 type FinishValidationVerdict = {
@@ -8281,7 +8413,22 @@ declare const DEFAULT_ARTIFACT_PATTERN = "(?:run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}|[\
 * paragraphs away no longer satisfies the grade. Purely textual: what
 * the referenced artifact contains is
 * {@link citedValueValidator}'s question, and whether it exists on
-* disk is the host's. Default name 'evidence-grade'.
+* disk is the host's.
+*
+* The run's OWN id is an artifact (RV2501). `DEFAULT_ARTIFACT_PATTERN`
+* only ever matched the literal word `run` followed by a ULID, so the
+* escape the verdict advertised was unreachable for every run whose id
+* the engine did not mint in that exact shape: the comparison run's
+* `comparison-rulvar-v12260-aug09-...` matched nothing, its synthesis
+* had no artifact it could name, and a document that told the truth
+* about the run it was part of could not be written at all. When
+* {@link FinishValidationInput.runId} is supplied (the orchestrator
+* runtime always supplies it), a sentence carrying that id verbatim as
+* a whole token satisfies the grade, and the verdict names the id so
+* 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.
+* Default name 'evidence-grade'.
 */
 declare function evidenceGradeValidator(options?: {
   /** Overrides {@link DEFAULT_EVIDENCE_GRADE_PHRASES}; matched case-insensitively. */phrases?: readonly string[]; /** Overrides {@link DEFAULT_ARTIFACT_PATTERN}. */
@@ -8314,6 +8461,27 @@ interface CitationTarget {
 * ({@link citationTargetsValidator} judges every citation with no such
 * precondition).
 *
+* One span class is IDENTITY, not assertion (RV2502, the 1.226.0
+* comparison run): a span naming the artefact under review says which
+* commit, run, or release the document is about, and asserts nothing
+* about any cited line. That run's synthesis wrote its frozen commit
+* sha beside source citations and the validator demanded the sha appear
+* in the cited source, an impossible repair, in the same verdict that
+* demanded three real value fixes; two granted repairs burned and the
+* finish was rejected. Three shapes are structural and always excluded:
+* a commit sha (12 to 64 hex characters, long enough that ordinary hex
+* literals stay judged), a release version (`1.2.3`, `v1.2.3`, with an
+* optional prerelease or build tail), and the run's own id when the
+* runtime supplies `runId`. Host vocabulary is declared: `notValues`
+* lists spans this document writes as identity, verdict words like
+* `conditionally ready` among them.
+*
+* The run-id exclusion is what makes the bundle self consistent
+* (RV2501, RV2202): the evidence grade instructs a failing model to
+* write this run's id inside the offending sentence, and before RV2502
+* doing so beside a citation traded an evidence-grade failure for a
+* cited-value one. The two repair instructions now compose.
+*
 * `resolve` is host code and must be PURE over a snapshot the host
 * froze before the run, exactly like every other finish validator: a
 * resolver that reads the filesystem live would make a verdict depend
@@ -8326,6 +8494,12 @@ declare function citedValueValidator(options: {
   resolve: (target: CitationTarget) => string | undefined; /** Lines AFTER the cited one that may carry the value; default 0. */
   window?: number; /** Overrides {@link DEFAULT_CITATION_PATTERN}; must capture `path:line`. */
   pattern?: string;
+  /**
+  * Spans this host writes as IDENTITY rather than as a value asserted
+  * about a citation (RV2502), matched whole and case sensitively.
+  * Commit shas, versions, and the run's own id need no declaration.
+  */
+  notValues?: readonly string[];
   name?: string;
 }): FinishValidator;
 /**
@@ -8606,16 +8780,26 @@ declare function pairRunFactClaims(draftText: string, sheet: RunFactsSheet, opti
 *
 * - `'full'`: every citing sentence the draft carries had at least one
 *   judged pair, nothing was cut by a bound, no declared critical
-*   anchor was missed, and the judge (when needed) settled ok. A draft
-*   with zero citing sentences grades `'full'` vacuously: there was
-*   nothing to verify, and saying `'partial'` would imply a subset was
-*   chosen.
+*   anchor was missed, and the judge (when needed) settled ok.
+* - `'vacuous'` (RV2508): the draft carried NO citing sentence, so the
+*   configured pass verified nothing. This used to grade `'full'` on
+*   the reasoning that saying `'partial'` would imply a subset was
+*   chosen, which is true and beside the point: `'full'` is the
+*   strongest word in the vocabulary and it was standing over a
+*   denominator of zero, the same silent green the grade exists to
+*   abolish, at its extreme.
 * - `'partial'`: the pass verified a strict subset: the pair bound
 *   truncated the fold, a run-facts bound truncated the run-claim
 *   pairs, or citing sentences exist that no judged pair covers.
 * - `'critical-uncovered'`: at least one DECLARED critical anchor got
 *   no judged pair; stronger than `'partial'` because the caller named
 *   exactly these claims as the ones that must not go unverified.
+* - `'judge-declined'` (RV2508): the judge invocation was refused
+*   ADMISSION and never dispatched (RV2106), so nothing was judged at
+*   all. It ranks with a failed judge and above everything the counts
+*   could say, because those counts describe a pass that did not
+*   happen; before this the flag was invisible to the grade and a
+*   declined judge over a citation-free draft graded `'full'`.
 * - `'judge-failed'`: the judge invocation did not settle ok, so
 *   nothing was judged at all; every other reading of the meta is
 *   moot.
@@ -8624,7 +8808,7 @@ declare function pairRunFactClaims(draftText: string, sheet: RunFactsSheet, opti
 * and total over metas written BEFORE the grade shipped, so a consumer
 * can grade a persisted outcome from an older engine.
 */
-type ClaimCoverageGrade = "full" | "partial" | "critical-uncovered" | "judge-failed";
+type ClaimCoverageGrade = "full" | "vacuous" | "partial" | "critical-uncovered" | "judge-declined" | "judge-failed";
 /** The subset of the claim-consistency meta the grade derives from. */
 interface ClaimCoverageInput {
   /** Draft sentences carrying at least one parsable anchor. */
@@ -8639,6 +8823,12 @@ interface ClaimCoverageInput {
   runFactPairsTruncated?: true;
   /** True when the judge invocation did not settle ok. */
   judgeFailed?: true;
+  /**
+  * True when the judge invocation was refused ADMISSION and never
+  * dispatched (RV2106). The orchestrator already spreads the flag into
+  * the meta it grades, so nothing at the call site changes.
+  */
+  judgeDeclined?: true;
 }
 /** Derives the {@link ClaimCoverageGrade} of a claim-consistency meta. */
 declare function claimCoverageOf(meta: ClaimCoverageInput): ClaimCoverageGrade;
@@ -9570,6 +9760,30 @@ interface FinishValidationSpec {
   */
   maxRepairs?: number;
   /**
+  * Retain the BYTES of every rejected finish candidate as its own
+  * addressable transcript blob (RV2507, the 1.226.0 comparison run),
+  * default off. The identity of a rejected candidate always rides the
+  * terminal (`rejectedFinishCandidates`: the call id, the sha256 that
+  * names WHICH document drew the verdict, its size, and the validator
+  * diffs); that costs nothing, because it is derived from decisions
+  * the journal already holds. A COPY of the document costs storage,
+  * so it is a decision the host makes: with this on, each rejected
+  * candidate is written to `<runId>/finish-rejected/<callId>` and the
+  * terminal row carries its `ref`, one `transcripts.get` away from the
+  * bytes. Turn it on for evaluation and comparison runs. The
+  * comparison run's three rejected syntheses were reachable only by an
+  * external script that re-parsed the whole agent transcript; nothing
+  * on the terminal or in the journal said where they were, or even
+  * that they differed from each other.
+  *
+  * Bounded by construction: at most `maxRepairs + 1` candidates per
+  * finish-validated invocation, under the run's own prefix, so
+  * `Engine.deleteRun` cascades over them like every other run blob. A
+  * store that refuses the write costs the run nothing: the row keeps
+  * its identity and drops its `ref`, and absence means NOT RECORDED.
+  */
+  retainRejectedCandidates?: boolean;
+  /**
   * The repair turn reserve (the v1.71 experiment review, P0.4; the
   * reserve RV-204 deliberately deferred). A nonnegative integer,
   * default 0: max EXTRA turns the invocation the validators bind (the
@@ -9958,6 +10172,35 @@ interface OrchestrateClaimConsistency {
   * silently when its judge dies.
   */
   onFound?: "report" | "carry" | "fail";
+  /**
+  * WHICH document the pass judges (RV2509), default `'draft'`, the
+  * historical behavior byte for byte. The pass has always read the
+  * coordination draft, strictly BEFORE the synthesis, so that a draft
+  * contradicting its own pool fails before anything pays to compose
+  * it. That ordering is right and stays; what it cannot do is verify
+  * the document that actually SHIPPED. The synthesis rewrites the
+  * draft, and under `'draft'` the semantic verdict on the terminal
+  * describes a document no consumer ever receives: the twenty-fifth
+  * comparison run's judge cleared a draft and the synthesis then
+  * composed a different text three times over.
+  *
+  * `'final'` moves the pass after the synthesis, over the artifact the
+  * run settles on. `'both'` keeps the pre-synthesis gate AND judges
+  * the final, at the price of a second judge invocation; the terminal
+  * then reports the FINAL pass in `claimConsistencyMeta` (the shipped
+  * document is what a consumer gates on) and the earlier one in
+  * `claimConsistencyDraftMeta`.
+  *
+  * Every meta says which document it read (`judgedStage`,
+  * `judgedHash`), and the envelope's `draftToFinal` says whether the
+  * synthesis changed the document at all, so the question "is this
+  * verdict about what I received" is a field read under every setting,
+  * including the default.
+  *
+  * Meaningful only with a `synthesis` configured: without one the
+  * draft IS the final and all three settings judge the same document.
+  */
+  stage?: "draft" | "final" | "both";
   /** The judge invocation's own knobs; the routing chain applies otherwise. */
   judge?: {
     /** Model override for the judge invocation. */model?: ModelSpec; /** Canonical effort of the judge invocation. */
@@ -10129,6 +10372,39 @@ interface OrchestrateClaimConsistencyMeta {
   * "fully verified" when the judge saw 40 of 144 citing sentences.
   */
   coverage: ClaimCoverageGrade;
+  /**
+  * WHICH document this verdict describes (RV2509): `'draft'` for the
+  * pre-synthesis pass, `'final'` for a pass over the artifact the run
+  * settles on. Always present since RV2509, so a coverage grade can
+  * never be read as a claim about the shipped document when it was
+  * rendered over the draft the synthesis replaced.
+  */
+  judgedStage: "draft" | "final";
+  /**
+  * sha256 over the canonical document this verdict read (RV2509).
+  * Compare it against the envelope's `draftToFinal.finalHash`: equal
+  * means the judged document IS the one that shipped, unequal means
+  * the synthesis rewrote what the judge cleared.
+  */
+  judgedHash: string;
+}
+/**
+* How the shipped artifact relates to the draft the run composed it
+* from (RV2509), present on the acceptance envelope whenever a
+* synthesis was configured. Two hashes and the answer they imply: a
+* semantic verdict rendered over the draft describes the final only
+* when `rewritten` is false, and until this shipped a consumer had no
+* way to ask.
+*/
+interface OrchestrateDraftToFinal {
+  /** sha256 over the canonical coordination draft. */
+  draftHash: string;
+  /** sha256 over the canonical artifact the run settled on. */
+  finalHash: string;
+  /** False exactly when the two hashes agree: the synthesis returned the draft unchanged. */
+  rewritten: boolean;
+  /** Which documents the claim-consistency pass actually judged; absent when it never ran. */
+  claimsJudgedOn?: "draft" | "final" | "both";
 }
 /**
 * The synthesis invocation's own knobs (RV-211). Everything else about
@@ -10296,6 +10572,39 @@ interface OrchestrateSynthesis {
   */
   carryDraftGaps?: boolean;
   /**
+  * The no-regression floor under the synthesis (RV2505, the 1.226.0
+  * comparison run). That run's coordination draft satisfied the FULL
+  * declared contract, `skipWhenDraftValid` was off because the
+  * operator wanted the composing pass anyway, and the synthesis then
+  * failed the same bundle three times and died mid repair: the run
+  * settled with NO result at all, having paid for four workers, the
+  * draft that would have passed, and three rejected compositions.
+  * With `true`, a synthesis that fails terminally does not throw away
+  * a draft the contract accepts. The failure is caught at the
+  * post-fan-in chokepoint, the coordination draft is judged by the
+  * same `finishValidation.validators` that bind the synthesis finish,
+  * and a draft every validator accepts becomes the run result under a
+  * journaled 'orchestrator_synthesis_regressed' decision (the failure
+  * message, the validator names, the draft hash, the contract
+  * generation) plus a warn 'orchestrator synthesis regressed' log; the
+  * envelope carries `synthesisRegressed`. A draft that fails too
+  * journals 'orchestrator_synthesis_fallback_declined' naming ITS
+  * failing validators and the original failure rethrows untouched, so
+  * the decline is auditable instead of silent. Deterministic by
+  * construction: only the declared contract judges, never a quality
+  * heuristic, and the verdict is a pure function of the draft, so a
+  * resume re-derives it without re-running the paid invocation.
+  * Requires `finishValidation` (a ConfigError at intake otherwise:
+  * without a contract there is nothing to judge either document by),
+  * which transitively limits it to mode 'single'. Orthogonal to
+  * `skipWhenDraftValid`: that gate decides whether to PAY for the
+  * synthesis, this floor decides what to do when the paid one comes
+  * back worse than the draft, and with both on a valid draft skips
+  * before there is anything to regress. Default false: no catch, no
+  * decision entry, no envelope field, byte for byte.
+  */
+  fallbackToValidDraft?: boolean;
+  /**
   * The structured evidence index (RV808b): a deterministic per-child
   * citation map in the 'single' synthesis prompt, so the composing
   * model can target its reads instead of re-reading the whole
@@ -11358,6 +11667,40 @@ interface SemanticPassesSummary {
   claimConsistency: SemanticPassSummary;
   synthesis: SemanticPassSummary;
 }
+/**
+* One finish candidate the declared contract did NOT accept (RV2507).
+* The 1.226.0 comparison run rejected three syntheses; nothing on its
+* terminal said so, nothing said whether the three differed from each
+* other, and the only way to read them was an external script that
+* re-parsed the whole agent transcript. The row is the artifact that
+* dig produced, made first class.
+*
+* `hash` is the sha256 over the canonical candidate: two rows with the
+* same hash are the model serving the same document twice, which is a
+* different failure from three genuine attempts and used to be
+* invisible. `ref` is present exactly under
+* `finishValidation.retainRejectedCandidates`, and points at a
+* transcript blob holding the candidate verbatim; without it the row
+* still identifies and sizes what was rejected, and names the
+* validators that did it.
+*/
+interface RejectedFinishCandidate {
+  /** The finish tool call this candidate arrived on. */
+  callId: string;
+  /** `'repair'` when another turn was granted, `'rejected'` when this was the last. */
+  verdict: "repair" | "rejected";
+  /** sha256 over the canonical candidate; identity, not location. */
+  hash: string;
+  /** The candidate's length in characters, honest whether or not the bytes were retained. */
+  chars: number;
+  /** Each validator that rejected it, with its reasons: the diff. */
+  failed: {
+    name: string;
+    reasons: string[];
+  }[];
+  /** Transcript ref holding the bytes; absent unless retention is on and the write succeeded. */
+  ref?: string;
+}
 interface AcceptanceChildSummary {
   child: string;
   status: string;
@@ -11420,6 +11763,56 @@ type RunOutcome<R> = {
   claimConsistencyMeta?: Record<string, unknown>; /** The synthesis-skip marker from the same envelope; same lift and posture (RV2203). */
   synthesisSkipped?: boolean | string;
   /**
+  * Whether the artifact THIS terminal carries was accepted by the
+  * declared finish contract (RV2506), lifted from the same envelope or
+  * typed error data. The one question `status` and `completion` cannot
+  * answer between them: the 1.226.0 comparison run accepted its
+  * children (`completion: 'complete'` was earned by the acceptance
+  * policy over child statuses), then failed its synthesis against the
+  * contract three times and settled carrying nothing the contract ever
+  * accepted, and the scoring harness read `status: 'ok'` and could not
+  * tell. Absent, NEVER false, when no `finishValidation` was declared:
+  * nothing judged anything, and absence means NOT RECORDED (RV1209).
+  * False means a contract was declared and the artifact here did not
+  * pass it, including the case where nothing was ever judged because
+  * the run died first.
+  */
+  deliverableAccepted?: boolean;
+  /**
+  * Whether this terminal carries a deliverable to read at all
+  * (RV2506); same lift and posture. False on every enriched failure
+  * (an `error` outcome carries no value by construction) and on an
+  * accepted run whose synthesis resolved to null. Distinct from
+  * `deliverableAccepted`: an unjudged artifact still EXISTS, and a run
+  * with no artifact still has a completion claim.
+  */
+  resultAvailable?: boolean;
+  /**
+  * The journal seq of the decision entry that records the acceptance
+  * of the artifact this terminal carries (RV2506); same lift and
+  * posture, absent whenever `deliverableAccepted` is not true. Three
+  * different entries answer to it, which is the point of having one
+  * field: the accepted `orchestrator_finish_validation` decision on
+  * the ordinary path, the `orchestrator_synthesis_skip` decision when
+  * the RV510 gate settled on a valid draft, and the
+  * `orchestrator_synthesis_regressed` decision when the RV2505 floor
+  * handed a failing synthesis back to its draft. Read it with
+  * `rulvar inspect` (or any journal reader) to see WHICH validators
+  * rendered the acceptance and over WHICH draft hash.
+  */
+  acceptedArtifactRef?: number;
+  /**
+  * Every finish candidate the declared contract did NOT accept, in the
+  * order they were judged (RV2507); same lift and posture. Present
+  * only when there was at least one, so a run that passed first try
+  * keeps its exact terminal. It rides the ok terminal as well as the
+  * failed one: a run that recovered on its second attempt still owes a
+  * post-mortem the first, and the comparison analysis that had to
+  * reconstruct three rejected syntheses from a transcript is the
+  * reason the field exists.
+  */
+  rejectedFinishCandidates?: RejectedFinishCandidate[];
+  /**
   * Children accepted through validated terminal output salvage on
   * 'limit'; same lift and posture.
   */
@@ -12388,6 +12781,88 @@ declare function lastRunSettle(entries: readonly JournalEntry[]): {
   outputHash?: string;
   completion?: "complete" | "partial" | "rejected";
 } | undefined;
+/**
+* Whether a terminal figure counts THIS segment's work or the whole
+* logical run (RV2510).
+*
+* * `'segment'`: only the segment that produced this terminal. A
+*   resumed run reports the resumed segment's number, and the figure
+*   for the logical run is the SUM over every segment
+*   ({@link logicalRunTelemetry} computes it).
+* * `'cumulative'`: the whole logical run, every prior segment
+*   included, because the figure folds from the journal (money, usage),
+*   resumes from the journaled ledger (the spawn count), or is
+*   RE-DERIVED by replay (the loss list: a resumed segment re-executes
+*   the workflow and reads the same journaled terminals, so the drops
+*   of earlier segments come back). Summing these across segments
+*   double counts.
+* * `'terminal'`: not a count at all: a claim about the run as it
+*   stands at this settle, which a later segment can only replace.
+*/
+type TelemetryScope = "segment" | "cumulative" | "terminal";
+/**
+* The scope of every field the engine writes onto a terminal (RV2510),
+* as one exported table rather than as sentences scattered through
+* field docs.
+*
+* The twenty-fifth comparison run was killed and resumed, and its two
+* terminals mixed both kinds with nothing marking which was which: the
+* money was cumulative, the wake count and the replay figures were not,
+* and reconciling them into one honest account of the logical run was
+* hand work over a joined journal. Keys are field paths as a consumer
+* reads them off `RunOutcome` (`cost.orchestrator.wakes`); the
+* doctrine test holds this table against the keys a real outcome
+* carries, so a new terminal field cannot ship without declaring what
+* it counts.
+*/
+declare const TERMINAL_TELEMETRY_SCOPE: Readonly<Record<string, TelemetryScope>>;
+/** One logical run's telemetry, folded across every segment (RV2510). */
+interface LogicalRunTelemetry {
+  /** How many settles the journal records: the number of segments that ran. */
+  segments: number;
+  /** Each segment's settled status, in journal order. */
+  statuses: RunStatus[];
+  /**
+  * Journal entries each segment APPENDED, in the same order: its own
+  * share of the run's durable work, which is the one honest
+  * per-segment measure of effort a resumed run has. A pure-replay
+  * segment that appended nothing but its settle reads 1.
+  */
+  entriesPerSegment: number[];
+  /**
+  * Entries the run holds in total. Equal to the sum of
+  * `entriesPerSegment` plus whatever follows the last settle: the
+  * partition is exact BECAUSE it is a partition, which is what makes
+  * this figure safe to read beside a cumulative one.
+  */
+  entries: number;
+  /**
+  * Entries appended AFTER the last settle. Nonzero means the journal
+  * continued past its terminal (RV1407: a detached resolution
+  * awaiting its resume, or a successor segment over a stale settle),
+  * so the last status is not the run's last word.
+  */
+  entriesAfterLastSettle: number;
+}
+/**
+* Folds a run's journal into the logical run's telemetry (RV2510): how
+* many segments ran, how each settled, and how much durable work each
+* one did, from entries the journal already holds. No new field, so it
+* reads journals written by every prior version exactly as well as
+* today's.
+*
+* The replay dedup is the design. Cumulative figures are deliberately
+* NOT here: money and usage fold from the WHOLE journal through
+* `costReportFromJournal` and the usage ledger, and re-summing them per
+* segment would count every replayed operation once per segment that
+* replayed it, which is exactly the reconciliation this fold exists to
+* make unnecessary. What it reports instead is a PARTITION of the
+* journal by settle boundary, so no entry is counted twice by
+* construction, and the segment-scoped figures a terminal carries
+* ({@link TERMINAL_TELEMETRY_SCOPE} names them) can be read against the
+* segment that produced them.
+*/
+declare function logicalRunTelemetry(entries: readonly JournalEntry[]): LogicalRunTelemetry;
 type RunAuditVerdict = "consistent" | "meta-behind" | "stranded" | "suspect";
 interface RunStateAudit {
   runId: string;
@@ -13277,7 +13752,11 @@ interface PreflightInput {
     * Mirrors FinishValidationSpec.maxRepairs (default
     * {@link DEFAULT_FINISH_MAX_REPAIRS}): with zero, the first
     * rejection is final and there is no repair exchange to fund, so
-    * the repair-reserve-unfunded warning stays silent.
+    * the repair-reserve-unfunded warning stays silent. It also SIZES
+    * the mandatory synthesis tail (RV2504): every granted repair can
+    * write to the output allowance, so the tail
+    * `synthesis-reserve-below-cap-composition` prices is one
+    * composition plus this many turns, whatever the turn reserve says.
     */
     maxRepairs?: number;
     /**
@@ -14216,4 +14695,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, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_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, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, 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_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BillingComponent, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CachePolicy, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RejectedFinishCandidate, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TelemetryScope, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };