@rulvar/core 1.227.0 → 1.229.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
@@ -2181,6 +2216,22 @@ type CoreEvents = {
   */
   belowFloorOkChildren?: string[];
   /**
+  * What the children had produced when the run died BEFORE any
+  * acceptance verdict (RV2602), lifted on its own rather than with
+  * the completion, because it exists for the terminal where there
+  * is no completion to lift. Present exactly when children were
+  * spawned and no acceptance verdict exists, so it never overlaps
+  * the fields above. Frozen at the moment of death, ahead of the
+  * RV1903 exit barrier, which is why `unsettled` can be non-empty.
+  */
+  childrenAtFailure?: {
+    spawned: number;
+    settled: number;
+    statusCounts: Record<string, number>;
+    belowFloorOkChildren?: string[];
+    unsettled?: string[];
+  };
+  /**
   * Present and false ONLY when nothing durable records this
   * terminal: a settlement write failed (the run_settle journal
   * append or the terminal RunMeta projection, RV907), or the
@@ -5542,6 +5593,16 @@ interface RunAgentOptions<S extends SchemaSpec = JsonSchema> {
       remaining: number;
       reserveCalls: number;
       budget: FinalizationWindowBudget;
+      /**
+      * Present exactly when RV1208 widened the reserve past the
+      * configured one (RV2601): the outstanding evidence entries, and
+      * the floor they are outstanding against. Absent means the
+      * configured reserve is what bound, so the arithmetic behind an
+      * unexpected reserve is always in the journal and never only in
+      * the notice the model read.
+      */
+      evidenceDeficit?: number;
+      minEntries?: number;
     }) => Promise<void>;
   };
   /** Emits agent:stream deltas when true (telemetry only). */
@@ -9725,6 +9786,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
@@ -10113,6 +10198,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. */
@@ -10284,6 +10398,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
@@ -11546,6 +11693,62 @@ 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;
+}
+/**
+* The roster facts of a run that died before any acceptance verdict
+* (RV2602): a fold over the children's own journaled terminals, so an
+* `exhausted` or failed orchestration still names the work it paid for.
+*/
+interface ChildrenAtFailure {
+  /** Children admitted, whether or not they settled. */
+  spawned: number;
+  /** Of those, the ones carrying a terminal at the moment of death. */
+  settled: number;
+  /** Their statuses, counted; the same vocabulary a child terminal uses. */
+  statusCounts: Record<string, number>;
+  /**
+  * Children that settled `ok` under a declared evidence contract they
+  * did not meet. The acceptance fold names these too, but only after
+  * it runs: the fourth parity run's silent worker was `ok` with zero
+  * recorded entries and its run never reached acceptance at all.
+  */
+  belowFloorOkChildren?: string[];
+  /** Children still running when the run gave up; absent when none were. */
+  unsettled?: string[];
+}
 interface AcceptanceChildSummary {
   child: string;
   status: string;
@@ -11608,6 +11811,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.
   */
@@ -11632,7 +11885,28 @@ type RunOutcome<R> = {
   * verdict. Replay-stable: the roster is journaled inside the single
   * acceptance decision.
   */
-  acceptanceChildren?: AcceptanceChildSummary[]; /** Pipeline drops and onError:'null' losses; silent losses are forbidden. */
+  acceptanceChildren?: AcceptanceChildSummary[];
+  /**
+  * What the children had produced when the run died BEFORE its
+  * acceptance policy ever rendered a verdict (RV2602).
+  *
+  * Every other field on this envelope describes a policy's claim, and
+  * a policy that never ran claims nothing: an orchestration whose
+  * coordination loop crosses its ceiling mid-roster settles with
+  * `completion` absent, and until this shipped the terminal said
+  * nothing at all about work that was already paid for, even though
+  * every child terminal was in the journal. Deliberately NOT
+  * `childStatusCounts`: that field is the acceptance fold's number,
+  * and a fold done by no policy must not borrow its name.
+  *
+  * Present exactly when children were spawned AND no acceptance
+  * verdict exists, so the two readings never overlap and neither can
+  * be mistaken for the other. Frozen at the moment of death, before
+  * the RV1903 exit barrier settles the stragglers, which is why
+  * `unsettled` can be non-empty: those children had not landed when
+  * the run gave up.
+  */
+  childrenAtFailure?: ChildrenAtFailure; /** Pipeline drops and onError:'null' losses; silent losses are forbidden. */
   dropped: DroppedItem[]; /** Suspensions open at settle time (M2). */
   pending: PendingExternal[];
   usage: Usage;
@@ -12575,7 +12849,98 @@ declare function lastRunSettle(entries: readonly JournalEntry[]): {
   seq: number;
   outputHash?: string;
   completion?: "complete" | "partial" | "rejected";
+  /**
+  * The rejected finish candidates the settle recorded (RV2507),
+  * read back for offline readers (RV2605). The settle persists the
+  * whole completion lift, so this needs no re-fold and no
+  * validator re-run; it is parsed defensively, exactly like
+  * `completion`, so a foreign or older journal reads as "not
+  * recorded" rather than as a claim.
+  */
+  rejectedFinishCandidates?: RejectedFinishCandidate[];
 } | 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;
@@ -14408,4 +14773,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, ChildrenAtFailure, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, 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 };

package/dist/index.js

@@ -8736,15 +8736,139 @@ function lastRunSettle(entries) {
 		const value = entry.value;
 		if (value?.decisionType === "run_settle" && typeof value.runStatus === "string" && RUN_STATUSES.has(value.runStatus)) {
 			const completion = value.completion;
+			const rejected = readRejectedFinishCandidates(value.rejectedFinishCandidates);
 			return {
 				runStatus: value.runStatus,
 				seq: entry.seq,
 				...typeof value.outputHash === "string" ? { outputHash: value.outputHash } : {},
-				...completion === "complete" || completion === "partial" || completion === "rejected" ? { completion } : {}
+				...completion === "complete" || completion === "partial" || completion === "rejected" ? { completion } : {},
+				...rejected === void 0 ? {} : { rejectedFinishCandidates: rejected }
 			};
 		}
 	}
 }
+/**
+* The rejected finish candidates of a persisted settle, or `undefined`
+* (RV2605). The WHOLE list drops on any malformed row, the same posture
+* the live lift takes (RV2507): a partial history read as complete
+* would under-report exactly the runs that misbehaved most.
+*/
+function readRejectedFinishCandidates(raw) {
+	if (!Array.isArray(raw) || raw.length === 0) return;
+	const rows = [];
+	for (const row of raw) {
+		if (typeof row !== "object" || row === null) return;
+		const { callId, verdict, hash, chars, failed, ref } = row;
+		if (typeof callId !== "string" || verdict !== "repair" && verdict !== "rejected" || typeof hash !== "string" || typeof chars !== "number" || !Number.isSafeInteger(chars) || chars < 0 || !Array.isArray(failed) || ref !== void 0 && typeof ref !== "string") return;
+		const validators = [];
+		for (const entry of failed) {
+			if (typeof entry !== "object" || entry === null) return;
+			const { name, reasons } = entry;
+			if (typeof name !== "string" || !Array.isArray(reasons) || reasons.some((reason) => typeof reason !== "string")) return;
+			validators.push({
+				name,
+				reasons
+			});
+		}
+		rows.push({
+			callId,
+			verdict,
+			hash,
+			chars,
+			failed: validators,
+			...ref === void 0 ? {} : { ref }
+		});
+	}
+	return rows;
+}
+/**
+* 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.
+*/
+const TERMINAL_TELEMETRY_SCOPE = Object.freeze({
+	status: "terminal",
+	value: "terminal",
+	error: "terminal",
+	envelope: "terminal",
+	completion: "terminal",
+	childStatusCounts: "cumulative",
+	degradedReasons: "cumulative",
+	salvagedPartialChildren: "cumulative",
+	salvagedTerminalOutputChildren: "cumulative",
+	belowFloorOkChildren: "cumulative",
+	acceptanceChildren: "cumulative",
+	semanticPasses: "terminal",
+	claimConsistencyMeta: "terminal",
+	synthesisSkipped: "terminal",
+	deliverableAccepted: "terminal",
+	resultAvailable: "terminal",
+	acceptedArtifactRef: "terminal",
+	rejectedFinishCandidates: "cumulative",
+	dropped: "cumulative",
+	pending: "terminal",
+	usage: "cumulative",
+	cost: "cumulative",
+	"cost.totalUsd": "cumulative",
+	"cost.grossUsd": "cumulative",
+	"cost.wireRequests": "cumulative",
+	"cost.orchestrator.spentUsd": "cumulative",
+	"cost.orchestrator.wakes": "segment",
+	"cost.orchestrator.forcedFinish": "segment",
+	"cost.orchestrator.reserveUsedUsd": "segment",
+	transportRetries: "segment",
+	schemaRejectedFinishExchanges: "segment",
+	schemaRecoveredFinishExchanges: "segment"
+});
+/**
+* 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.
+*/
+function logicalRunTelemetry(entries) {
+	const statuses = [];
+	const entriesPerSegment = [];
+	let sinceLastSettle = 0;
+	for (const entry of entries) {
+		sinceLastSettle += 1;
+		if (entry.kind !== "decision") continue;
+		const value = entry.value;
+		if (value?.decisionType !== "run_settle" || typeof value.runStatus !== "string" || !RUN_STATUSES.has(value.runStatus)) continue;
+		statuses.push(value.runStatus);
+		entriesPerSegment.push(sinceLastSettle);
+		sinceLastSettle = 0;
+	}
+	return {
+		segments: statuses.length,
+		statuses,
+		entriesPerSegment,
+		entries: entries.length,
+		entriesAfterLastSettle: sinceLastSettle
+	};
+}
 function structure(entries) {
 	const referenced = /* @__PURE__ */ new Set();
 	for (const entry of entries) if (entry.ref !== void 0) referenced.add(entry.ref);
@@ -11568,10 +11692,11 @@ async function runAgent(options) {
 		if (state === void 0) return;
 		const reserve = reserveFor(state.budget);
 		const deficit = evidenceDeficit();
+		const widenedByDeficit = state.budget !== "turns" && finalizationWindow?.reserveForEvidenceDeficit === true && deficit > 0;
 		const commit = () => {
 			windowEntered = true;
 			windowNoticeFired = true;
-			pendingWindowNotices.push(finalizationWindowNoticeText(state.remaining, reserve, state.budget, state.budget !== "turns" && finalizationWindow?.reserveForEvidenceDeficit === true && deficit > 0 ? deficit : void 0));
+			pendingWindowNotices.push(finalizationWindowNoticeText(state.remaining, reserve, state.budget, widenedByDeficit ? deficit : void 0));
 			events?.emit({
 				type: "log",
 				level: "info",
@@ -11586,7 +11711,11 @@ async function runAgent(options) {
 		return durable({
 			remaining: state.remaining,
 			reserveCalls: reserve,
-			budget: state.budget
+			budget: state.budget,
+			...widenedByDeficit ? {
+				evidenceDeficit: deficit,
+				minEntries: options.evidenceContract?.minEntries ?? 0
+			} : {}
 		}).then(commit);
 	};
 	const flushWindowNotices = () => {
@@ -21629,6 +21758,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 retain = fv.retainRejectedCandidates;
+		if (retain !== void 0 && typeof retain !== "boolean") throw new ConfigError("orchestrate finishValidation.retainRejectedCandidates must be a boolean");
 		const draftPolicy = fv.draftPolicy;
 		if (draftPolicy !== void 0) {
 			if (draftPolicy !== "contract" && (typeof draftPolicy !== "object" || draftPolicy === null)) throw new ConfigError("orchestrate finishValidation.draftPolicy must be an object or the sentinel 'contract'");
@@ -21763,6 +21894,9 @@ function validateOrchestrateOptions(opts) {
 			if (opts.synthesis === void 0) throw new ConfigError("orchestrate claimConsistency.onFound 'carry' requires synthesis: without the post-fan-in invocation there is no prompt to carry the findings into; use 'report' or 'fail'");
 			if (opts.synthesis.mode === "incremental") throw new ConfigError("orchestrate claimConsistency.onFound 'carry' needs a 'single' synthesis: the deterministic 'incremental' reconciliation has no prompt for the findings to ride");
 		}
+		const stage = consistency.stage ?? "draft";
+		if (stage !== "draft" && stage !== "final" && stage !== "both") throw new ConfigError("orchestrate claimConsistency.stage must be 'draft', 'final' or 'both'; got " + JSON.stringify(consistency.stage));
+		if (stage !== "draft" && opts.synthesis === void 0) throw new ConfigError(`orchestrate claimConsistency.stage '${stage}' requires synthesis: without the post-fan-in invocation the coordination draft IS the final artifact, and the default 'draft' already judges it`);
 		if (consistency.pattern !== void 0) {
 			if (typeof consistency.pattern !== "string") throw new ConfigError(`orchestrate claimConsistency.pattern must be a string; got ${typeof consistency.pattern}`);
 			let probe;
@@ -22041,6 +22175,52 @@ function makeOrchestratorWorkflow(goal, opts) {
 		};
 		barrier.run = exitBarrier;
 		/**
+		* Whether an acceptance verdict exists (RV2602). The roster fold
+		* below reports only where no policy ever spoke: two folds of the
+		* same children under two different authorities would be one
+		* reading too many, and the acceptance decision is the authority
+		* wherever it exists.
+		*/
+		let acceptanceRendered = false;
+		/**
+		* The pre-acceptance roster (RV2602): what the children had
+		* produced at the moment the run gave up. The facts are already in
+		* the journal, one child terminal at a time, and the terminal said
+		* nothing about them because every surface that names children
+		* hangs off the acceptance fold. The fourth parity run is the
+		* shape: a worker settled `ok` with zero recorded evidence entries
+		* under a declared contract, and the run died before acceptance
+		* could say so.
+		*
+		* Read BEFORE the exit barrier, so it is the roster the verdict
+		* would have frozen, not the one the stragglers land on later.
+		*/
+		const rosterAtFailure = () => {
+			if (acceptanceRendered) return;
+			const roster = [...byOrdinal.values()];
+			if (roster.length === 0) return;
+			const statusCounts = {};
+			const belowFloor = [];
+			const unsettled = [];
+			for (const record of roster) {
+				const settled = record.settled;
+				if (settled === void 0) {
+					unsettled.push(record.nodeId);
+					continue;
+				}
+				statusCounts[settled.status] = (statusCounts[settled.status] ?? 0) + 1;
+				if (settled.status === "ok" && settled.evidence !== void 0 && !settled.evidence.met) belowFloor.push(record.nodeId);
+			}
+			return {
+				spawned: roster.length,
+				settled: roster.length - unsettled.length,
+				statusCounts,
+				...belowFloor.length === 0 ? {} : { belowFloorOkChildren: belowFloor },
+				...unsettled.length === 0 ? {} : { unsettled }
+			};
+		};
+		barrier.roster = rosterAtFailure;
+		/**
 		* The journaled spec behind each recovered ordinal: the idempotent
 		* re-execution guard compares it against the incoming call, because
 		* after a cross-attempt resume a REGENERATED turn (the boundary
@@ -23075,6 +23255,25 @@ function makeOrchestratorWorkflow(goal, opts) {
 					});
 				}
 				const repairsUsed = known.filter((candidate) => candidate.verdict !== "accepted" && contractGenerationCurrent(candidate)).length;
+				const rejectedCandidate = failed.length > 0;
+				let candidateRef;
+				if (rejectedCandidate && validationSpec.retainRejectedCandidates === true) {
+					const ref = `${internals.runId}/finish-rejected/${call.id}`;
+					try {
+						await internals.transcripts.put(ref, new TextEncoder().encode(input.text), internals.lease);
+						candidateRef = ref;
+					} catch (writeFailed) {
+						internals.events.emit({
+							type: "log",
+							level: "warn",
+							msg: "orchestrator rejected finish candidate not retained",
+							data: {
+								ref,
+								reason: (writeFailed instanceof Error ? writeFailed.message : String(writeFailed)).slice(0, 200)
+							}
+						}, callingState.spanId);
+					}
+				}
 				decision = {
 					decisionType: "orchestrator_finish_validation",
 					callId: call.id,
@@ -23082,7 +23281,12 @@ function makeOrchestratorWorkflow(goal, opts) {
 					failed,
 					repairsUsed,
 					maxRepairs,
-					...validationSpec.contract === void 0 ? {} : { contractHash: validationSpec.contract.hash }
+					...validationSpec.contract === void 0 ? {} : { contractHash: validationSpec.contract.hash },
+					...rejectedCandidate ? {
+						candidateHash: createHash("sha256").update(jcsSerialize(result), "utf8").digest("hex"),
+						candidateChars: input.text.length,
+						...candidateRef === void 0 ? {} : { candidateRef }
+					} : {}
 				};
 				await internals.replayer.appendSinglePhase({
 					scope: callingState.scope,
@@ -23550,6 +23754,14 @@ function makeOrchestratorWorkflow(goal, opts) {
 		*/
 		let synthesisSkippedByValidDraft = false;
 		/**
+		* The journal seq of the skip decision that carried the RV510 gate
+		* (RV2506): the addressable provenance of the artifact a skipped
+		* run settles on, since a skipped synthesis leaves no accepted
+		* finish-validation decision behind and the draft's acceptance
+		* lives in the skip entry instead.
+		*/
+		let synthesisSkipDecisionRef;
+		/**
 		* The bounded contradiction pass's findings (RV1302), set exactly
 		* when the pass is configured: an EMPTY array is a fact (the pass
 		* ran and the pool agreed) and `undefined` is a different fact
@@ -23569,6 +23781,18 @@ function makeOrchestratorWorkflow(goal, opts) {
 		/** Set whenever the pass ran, findings or not (the RV1404 pairing). */
 		let claimConsistencyMeta;
 		/**
+		* Which document the claim-consistency pass judges (RV2509),
+		* default `'draft'`: the historical ordering, byte for byte.
+		*/
+		const claimStage = opts?.claimConsistency?.stage ?? "draft";
+		/**
+		* Under `stage: 'both'` the pre-synthesis verdict, kept beside the
+		* final one (RV2509): `claimConsistencyMeta` reports the SHIPPED
+		* document because that is what a consumer gates on, and the draft
+		* verdict is the record of the gate that let the synthesis run.
+		*/
+		let claimConsistencyDraftMeta;
+		/**
 		* The salvage arms the acceptance decision counted (RV1403), set on
 		* the accepted path AFTER the decision, fresh or rolled forward
 		* from the journal, so live and resume read the same lists; a
@@ -23666,7 +23890,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 		* entry, so a resume replays the verdict with zero paid calls and
 		* this pass journals nothing of its own.
 		*/
-		const runClaimConsistencyPass = async (draft, snapshot) => {
+		const runClaimConsistencyPass = async (draft, snapshot, stage = "draft") => {
 			const spec = opts?.claimConsistency;
 			if (spec === void 0) return;
 			await recoveryDone;
@@ -23762,7 +23986,9 @@ function makeOrchestratorWorkflow(goal, opts) {
 				};
 				return {
 					...bare,
-					coverage: claimCoverageOf(bare)
+					coverage: claimCoverageOf(bare),
+					judgedStage: stage,
+					judgedHash: createHash("sha256").update(jcsSerialize(draft ?? null), "utf8").digest("hex")
 				};
 			};
 			if (spec.onLowCoverage === "fail" && metaBase.lowCoverage !== void 0) {
@@ -23821,7 +24047,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			const judgeOpts = {
 				role: "synthesize",
 				result: "full",
-				label: CLAIM_JUDGE_LABEL,
+				label: stage === "draft" ? CLAIM_JUDGE_LABEL : `${CLAIM_JUDGE_LABEL}-final`,
 				schema: CLAIM_JUDGE_SCHEMA,
 				limits: spec.judge?.limits ?? { maxTurns: 3 },
 				...spec.judge?.model === void 0 ? {} : { model: spec.judge.model },
@@ -23837,7 +24063,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					judgeInvoked: false,
 					judgeDeclined: true
 				});
-				const declineKey = deriverV2.deriveKey({ kind: "orchestrator-claim-judge-declined" });
+				const declineKey = deriverV2.deriveKey({ kind: stage === "draft" ? "orchestrator-claim-judge-declined" : "orchestrator-claim-judge-declined-final" });
 				if (!internals.replayer.snapshot().some((entry) => entry.kind === "decision" && entry.key === declineKey)) await internals.replayer.appendSinglePhase({
 					scope: callingState.scope,
 					key: declineKey,
@@ -23956,6 +24182,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const prior = internals.replayer.snapshot().filter((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.key === skipKey).at(-1);
 				if (prior !== void 0 && applies(prior.value)) {
 					synthesisSkippedByValidDraft = true;
+					synthesisSkipDecisionRef = prior.seq;
 					announceSkip(prior.seq);
 					return draft;
 				}
@@ -24070,6 +24297,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 						});
 						if (orchestratorAccount !== void 0 && (opts?.budget?.synthesisReserveUsd ?? 0) > 0) internals.budget.releaseSynthesisReserve(orchestratorAccount);
 						synthesisSkippedByValidDraft = true;
+						synthesisSkipDecisionRef = skipEntry.seq;
 						announceSkip(skipEntry.seq);
 						return draft;
 					}
@@ -24637,14 +24865,83 @@ function makeOrchestratorWorkflow(goal, opts) {
 			};
 			return { used: true };
 		};
+		/**
+		* The explicit deliverable verdict (RV2506, the 1.226.0 comparison
+		* run): whether the artifact THIS terminal carries was accepted by
+		* the declared finish contract, whether there is an artifact to
+		* read at all, and where its acceptance is journaled. The harness
+		* that scored the comparison could not answer the first question
+		* from the terminal: it read `status: 'ok'`, and the run had in
+		* fact accepted its children, failed its synthesis three times,
+		* and settled carrying nothing the contract ever accepted. Every
+		* input is a fact the run already journaled, so the verdict is
+		* derived, never remembered, and a resume re-derives the same one.
+		*
+		* `deliverableAccepted` is ABSENT (never false) when no
+		* `finishValidation` was declared: nothing judged anything, and
+		* the RV1209 provenance doctrine says absence means NOT RECORDED.
+		* `acceptedArtifactRef` names the decision entry that holds the
+		* acceptance, which is the finish-validation decision on the
+		* ordinary path, the RV510 skip decision when the gate skipped the
+		* synthesis, and the RV2505 regression decision when a failing
+		* synthesis handed the run back to its draft: three different
+		* entries, one question, one field.
+		*/
+		const deliverableVerdict = (artifact) => {
+			const resultAvailable = artifact !== void 0 && artifact !== null;
+			if (validationSpec === void 0) return { resultAvailable };
+			if (synthesisRegressed !== void 0) return {
+				resultAvailable,
+				deliverableAccepted: true,
+				acceptedArtifactRef: synthesisRegressed.decisionRef
+			};
+			if (synthesisSkipDecisionRef !== void 0) return {
+				resultAvailable,
+				deliverableAccepted: true,
+				acceptedArtifactRef: synthesisSkipDecisionRef
+			};
+			const accepted = internals.replayer.snapshot().filter((entry) => {
+				if (entry.kind !== "decision" || entry.scope !== callingState.scope) return false;
+				const value = entry.value;
+				return value?.decisionType === "orchestrator_finish_validation" && value.verdict === "accepted" && contractGenerationCurrent(value);
+			}).at(-1);
+			return accepted === void 0 ? {
+				resultAvailable,
+				deliverableAccepted: false
+			} : {
+				resultAvailable,
+				deliverableAccepted: true,
+				acceptedArtifactRef: accepted.seq
+			};
+		};
+		/**
+		* The rejected candidates of the CURRENT contract generation, in
+		* judgement order (RV2507): a pure fold over decisions the journal
+		* already holds, so a resume re-derives the identical list without
+		* re-running a validator. A superseded generation's rejections stay
+		* in the journal as the history they are and drop out here, exactly
+		* as they drop out of the repair budget.
+		*/
+		const rejectedFinishCandidates = () => validationDecisions().filter((decision) => decision.verdict !== "accepted" && contractGenerationCurrent(decision) && decision.candidateHash !== void 0).map((decision) => ({
+			callId: decision.callId,
+			verdict: decision.verdict,
+			hash: decision.candidateHash ?? "",
+			chars: decision.candidateChars ?? 0,
+			failed: decision.failed,
+			...decision.candidateRef === void 0 ? {} : { ref: decision.candidateRef }
+		}));
 		const enrichSynthesisFailure = (thrown, snapshot) => {
 			const passTruth = {
 				...claimConsistencyMeta === void 0 ? {} : { claimConsistencyMeta },
 				semanticPasses: semanticPassesSummary({
 					ran: false,
 					reason: "synthesis-failed"
-				})
+				}),
+				resultAvailable: false,
+				...validationSpec === void 0 ? {} : { deliverableAccepted: false }
 			};
+			const rejected = rejectedFinishCandidates();
+			if (rejected.length > 0) passTruth.rejectedFinishCandidates = rejected;
 			if (thrown instanceof BudgetExhaustedError) throw new BudgetExhaustedError(thrown.message, { data: {
 				...thrown.data ?? {},
 				...snapshot ?? {},
@@ -24674,18 +24971,22 @@ function makeOrchestratorWorkflow(goal, opts) {
 		if (result.status !== "ok") throw new ConfigError(`the orchestrator agent terminated with status '${result.status}'` + (result.errorMessage === void 0 ? "" : `: ${result.errorMessage}`));
 		if (opts?.acceptance === void 0) {
 			await runContradictionPass();
-			await runClaimConsistencyPass(result.output);
+			if (claimStage !== "final") await runClaimConsistencyPass(result.output);
+			let bare;
 			try {
-				return await runSynthesis(result.output);
+				bare = await runSynthesis(result.output);
 			} catch (thrown) {
 				await journalSynthesisAdmissionDecline(thrown);
-				if ((await draftFallbackOnRegression(result.output, thrown)).used) return result.output;
-				return enrichSynthesisFailure(thrown);
+				if ((await draftFallbackOnRegression(result.output, thrown)).used) bare = result.output;
+				else return enrichSynthesisFailure(thrown);
 			}
+			if (claimStage !== "draft") await runClaimConsistencyPass(bare, void 0, "final");
+			return bare;
 		}
 		const acceptanceKey = "acceptance";
 		const priorAcceptance = internals.replayer.snapshot().find((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.key === acceptanceKey);
 		let decision;
+		acceptanceRendered = true;
 		if (priorAcceptance !== void 0) decision = priorAcceptance.value;
 		else {
 			const childStatusCounts = {};
@@ -24875,13 +25176,14 @@ function makeOrchestratorWorkflow(goal, opts) {
 			...decision.salvagedPartialChildren === void 0 ? {} : { salvagedPartialChildren: decision.salvagedPartialChildren },
 			...decision.salvagedTerminalOutputChildren === void 0 ? {} : { salvagedTerminalOutputChildren: decision.salvagedTerminalOutputChildren }
 		});
-		await runClaimConsistencyPass(result.output, {
+		const acceptanceSnapshot = {
 			completion: decision.completion,
 			childStatusCounts: decision.childStatusCounts,
 			degradedReasons: decision.degradedReasons,
 			...decision.salvagedPartialChildren === void 0 ? {} : { salvagedPartialChildren: decision.salvagedPartialChildren },
 			...decision.salvagedTerminalOutputChildren === void 0 ? {} : { salvagedTerminalOutputChildren: decision.salvagedTerminalOutputChildren }
-		});
+		};
+		if (claimStage !== "final") await runClaimConsistencyPass(result.output, acceptanceSnapshot);
 		let synthesizedFinal;
 		try {
 			synthesizedFinal = await runSynthesis(result.output);
@@ -24898,10 +25200,31 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...decision.children === void 0 ? {} : { acceptanceChildren: decision.children }
 			});
 		}
+		if (claimStage !== "draft") {
+			claimConsistencyDraftMeta = claimStage === "both" ? claimConsistencyMeta : void 0;
+			await runClaimConsistencyPass(synthesizedFinal, acceptanceSnapshot, "final");
+		}
 		const envelopeSchemaRecovered = (result.schemaRecoveredTerminalExchanges ?? 0) + synthesisSchemaRecoveredExchanges;
+		const deliverable = deliverableVerdict(synthesizedFinal);
+		const draftToFinal = opts?.synthesis === void 0 ? void 0 : (() => {
+			const hashOf = (value) => createHash("sha256").update(jcsSerialize(value ?? null), "utf8").digest("hex");
+			const draftHash = hashOf(result.output);
+			const finalHash = hashOf(synthesizedFinal);
+			return {
+				draftHash,
+				finalHash,
+				rewritten: draftHash !== finalHash,
+				...claimConsistencyMeta === void 0 ? {} : { claimsJudgedOn: claimStage }
+			};
+		})();
+		const envelopeRejectedCandidates = rejectedFinishCandidates();
 		return {
 			result: synthesizedFinal,
 			completion: decision.completion,
+			resultAvailable: deliverable.resultAvailable,
+			...deliverable.deliverableAccepted === void 0 ? {} : { deliverableAccepted: deliverable.deliverableAccepted },
+			...deliverable.acceptedArtifactRef === void 0 ? {} : { acceptedArtifactRef: deliverable.acceptedArtifactRef },
+			...envelopeRejectedCandidates.length === 0 ? {} : { rejectedFinishCandidates: envelopeRejectedCandidates },
 			childStatusCounts: decision.childStatusCounts,
 			degradedReasons: decision.degradedReasons,
 			...decision.salvagedPartialChildren === void 0 ? {} : { salvagedPartialChildren: decision.salvagedPartialChildren },
@@ -24921,6 +25244,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...claimFindingsFound === void 0 ? {} : { claimContradictions: claimFindingsFound },
 				claimConsistencyMeta
 			},
+			...claimConsistencyDraftMeta === void 0 ? {} : { claimConsistencyDraftMeta },
+			...draftToFinal === void 0 ? {} : { draftToFinal },
 			semanticPasses: semanticPassesSummary(opts?.synthesis === void 0 ? {
 				ran: false,
 				reason: "not-configured"
@@ -24934,6 +25259,16 @@ function makeOrchestratorWorkflow(goal, opts) {
 		const barrier = {};
 		try {
 			return await orchestrationBody(ctx, barrier);
+		} catch (thrown) {
+			const roster = barrier.roster?.();
+			if (roster === void 0) throw thrown;
+			const widen = (data) => ({
+				...data ?? {},
+				...data?.childrenAtFailure === void 0 ? { childrenAtFailure: roster } : {}
+			});
+			if (thrown instanceof BudgetExhaustedError) throw new BudgetExhaustedError(thrown.message, { data: widen(thrown.data) });
+			if (thrown instanceof FailRunError) throw new FailRunError(thrown.message, { data: widen(thrown.data) });
+			throw thrown;
 		} finally {
 			await barrier.run?.();
 		}
@@ -26525,6 +26860,42 @@ function workflowSourceRef(runId) {
 * telemetry, never authority), and an invalid counts record drops the
 * counts while keeping a valid completion.
 */
+/**
+* The pre-acceptance roster lift (RV2602), deliberately NOT gated on a
+* completion.
+*
+* Every other lifted field rides {@link liftRunCompletion}, which bails
+* out the moment there is no completion literal, and that is exactly
+* right: those fields report what an acceptance policy CLAIMED. This
+* one exists for the case where no policy ever ran, so gating it on a
+* completion would gate it on the very thing that is missing.
+*
+* Same posture as its siblings otherwise: a well formed record mirrors,
+* anything malformed drops silently rather than half-mirroring, so a
+* consumer never reads a partial roster as a whole one.
+*/
+function liftChildrenAtFailure(candidate) {
+	if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return;
+	const raw = candidate.childrenAtFailure;
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return;
+	const { spawned, settled, statusCounts, belowFloorOkChildren, unsettled } = raw;
+	const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+	if (!count(spawned) || !count(settled)) return;
+	if (typeof statusCounts !== "object" || statusCounts === null || Array.isArray(statusCounts)) return;
+	const entries = Object.entries(statusCounts);
+	if (!entries.every(([, value]) => count(value))) return;
+	const names = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string") ? [...value] : void 0;
+	const below = belowFloorOkChildren === void 0 ? void 0 : names(belowFloorOkChildren);
+	const open = unsettled === void 0 ? void 0 : names(unsettled);
+	if (belowFloorOkChildren !== void 0 && below === void 0 || unsettled !== void 0 && open === void 0) return;
+	return {
+		spawned,
+		settled,
+		statusCounts: Object.fromEntries(entries),
+		...below === void 0 ? {} : { belowFloorOkChildren: below },
+		...open === void 0 ? {} : { unsettled: open }
+	};
+}
 function liftRunCompletion(candidate) {
 	if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return;
 	const completion = candidate.completion;
@@ -26579,6 +26950,21 @@ function liftRunCompletion(candidate) {
 	if (typeof metaCandidate === "object" && metaCandidate !== null && !Array.isArray(metaCandidate)) lifted.claimConsistencyMeta = { ...metaCandidate };
 	const skippedCandidate = candidate.synthesisSkipped;
 	if (typeof skippedCandidate === "boolean" || typeof skippedCandidate === "string") lifted.synthesisSkipped = skippedCandidate;
+	const acceptedCandidate = candidate.deliverableAccepted;
+	if (typeof acceptedCandidate === "boolean") lifted.deliverableAccepted = acceptedCandidate;
+	const availableCandidate = candidate.resultAvailable;
+	if (typeof availableCandidate === "boolean") lifted.resultAvailable = availableCandidate;
+	const artifactRefCandidate = candidate.acceptedArtifactRef;
+	if (typeof artifactRefCandidate === "number" && Number.isSafeInteger(artifactRefCandidate) && artifactRefCandidate >= 0) lifted.acceptedArtifactRef = artifactRefCandidate;
+	const rejectedCandidates = candidate.rejectedFinishCandidates;
+	if (Array.isArray(rejectedCandidates)) {
+		const validRow = (row) => {
+			if (typeof row !== "object" || row === null) return false;
+			const { callId, verdict, hash, chars, failed, ref } = row;
+			return typeof callId === "string" && (verdict === "repair" || verdict === "rejected") && typeof hash === "string" && typeof chars === "number" && Number.isSafeInteger(chars) && chars >= 0 && (ref === void 0 || typeof ref === "string") && Array.isArray(failed) && failed.every((entry) => typeof entry === "object" && entry !== null && typeof entry.name === "string" && Array.isArray(entry.reasons) && entry.reasons.every((reason) => typeof reason === "string"));
+		};
+		if (rejectedCandidates.every(validRow)) lifted.rejectedFinishCandidates = rejectedCandidates.map((row) => ({ ...row }));
+	}
 	return lifted;
 }
 /**
@@ -27163,6 +27549,8 @@ function createEngine(options) {
 			if (wireError !== void 0) outcomeFacts.error = wireError;
 			let lifted = liftRunCompletion(status === "ok" || status === "exhausted" ? outcomeFacts.value : status === "error" ? wireError?.data : void 0);
 			if (lifted === void 0 && status === "exhausted") lifted = liftRunCompletion(wireError?.data);
+			const childrenAtFailure = liftChildrenAtFailure(status === "ok" || status === "exhausted" ? outcomeFacts.value : wireError?.data) ?? liftChildrenAtFailure(wireError?.data);
+			if (childrenAtFailure !== void 0) outcomeFacts.childrenAtFailure = childrenAtFailure;
 			if (lifted !== void 0) {
 				outcomeFacts.completion = lifted.completion;
 				if (lifted.childStatusCounts !== void 0) outcomeFacts.childStatusCounts = lifted.childStatusCounts;
@@ -27174,6 +27562,10 @@ function createEngine(options) {
 				if (lifted.semanticPasses !== void 0) outcomeFacts.semanticPasses = lifted.semanticPasses;
 				if (lifted.claimConsistencyMeta !== void 0) outcomeFacts.claimConsistencyMeta = lifted.claimConsistencyMeta;
 				if (lifted.synthesisSkipped !== void 0) outcomeFacts.synthesisSkipped = lifted.synthesisSkipped;
+				if (lifted.deliverableAccepted !== void 0) outcomeFacts.deliverableAccepted = lifted.deliverableAccepted;
+				if (lifted.resultAvailable !== void 0) outcomeFacts.resultAvailable = lifted.resultAvailable;
+				if (lifted.acceptedArtifactRef !== void 0) outcomeFacts.acceptedArtifactRef = lifted.acceptedArtifactRef;
+				if (lifted.rejectedFinishCandidates !== void 0) outcomeFacts.rejectedFinishCandidates = lifted.rejectedFinishCandidates;
 			}
 			let settlementFailure;
 			let supersededBy;
@@ -27252,6 +27644,7 @@ function createEngine(options) {
 				totalUsd: outcome.cost.totalUsd,
 				...outcome.cost.usageApprox === true ? { usageApprox: true } : {},
 				...lifted === void 0 ? {} : lifted,
+				...childrenAtFailure === void 0 ? {} : { childrenAtFailure },
 				...settlementFailure !== void 0 ? { settled: false } : supersededBy !== void 0 ? {
 					settled: false,
 					settledReason: "superseded"
@@ -27835,4 +28228,4 @@ function createSandboxBridge(ctx, options) {
 	};
 }
 //#endregion
-export { AWAIT_SCHEMA, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, 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, AdmissionController, AdmissionRejectedError, AgentCallError, BUDGET_ABORT_REASON, BudgetExhaustedError, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, ConfigError, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DedupIndex, DeterminismError, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EscalationDecisionAbortedError, EventBus, ExternalRegistry, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FileModelKnowledgeStore, FileTranscriptStore, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, GitWorktreeProvider, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, InvalidResolutionError, JOURNAL_ENVELOPE_MARKER, JournalCompatibilityError, JournalMatcher, JournalMissError, JournalOrderViolation, JournalSealedError, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, KeyedLimiter, KnowledgeCasError, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LeaseHeldError, LineageIndex, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, ModelRetry, NoProgressDetector, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OrchestratorCapConfigError, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, PlanInvariantError, QUOTA_WINDOW_MS, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, ReplayPlanHashMismatch, Replayer, ResolutionArbiter, ResolutionFold, RulvarError, RunBudget, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxError, ScriptRejected, Semaphore, SettlementError, SpanRegistry, SupersededError, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, TerminationAccount, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, 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 };

package/package.json

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