@rulvar/core 1.227.0 → 1.228.0

package/dist/index.d.ts

@@ -2170,7 +2170,42 @@ type CoreEvents = {
   * read null while the journal held the verdict.
   */
   claimConsistencyMeta?: Record<string, unknown>; /** The synthesis-skip marker from the same envelope; same lift (RV2203). */
-  synthesisSkipped?: boolean | string; /** Children accepted through validated terminal output salvage on 'limit'; same lift. */
+  synthesisSkipped?: boolean | string;
+  /**
+  * Whether the artifact this terminal carries was accepted by the
+  * declared finish contract, and whether there is one to read at
+  * all (RV2506); same lift. `deliverableAccepted` is absent, never
+  * false, when no finish contract was declared. The pair is what
+  * `status` and `completion` cannot say between them: an accepted
+  * child roster over a synthesis that never passed its contract
+  * reads `status: 'ok'`, `completion: 'complete'`,
+  * `deliverableAccepted: false`.
+  */
+  deliverableAccepted?: boolean;
+  resultAvailable?: boolean;
+  /**
+  * The journal seq of the decision recording that acceptance
+  * (RV2506); absent whenever `deliverableAccepted` is not true.
+  */
+  acceptedArtifactRef?: number;
+  /**
+  * Every finish candidate the declared contract did NOT accept, in
+  * judgement order (RV2507); same lift, absent when there was
+  * none. Each row identifies the candidate (`callId`, `hash`,
+  * `chars`) and names the validators that rejected it, with `ref`
+  * pointing at the retained bytes where the host asked for them.
+  */
+  rejectedFinishCandidates?: {
+    callId: string;
+    verdict: "repair" | "rejected";
+    hash: string;
+    chars: number;
+    failed: {
+      name: string;
+      reasons: string[];
+    }[];
+    ref?: string;
+  }[]; /** Children accepted through validated terminal output salvage on 'limit'; same lift. */
   salvagedTerminalOutputChildren?: string[];
   /**
   * Children that settled 'ok' below their declared evidence floor
@@ -9725,6 +9760,30 @@ interface FinishValidationSpec {
   */
   maxRepairs?: number;
   /**
+  * Retain the BYTES of every rejected finish candidate as its own
+  * addressable transcript blob (RV2507, the 1.226.0 comparison run),
+  * default off. The identity of a rejected candidate always rides the
+  * terminal (`rejectedFinishCandidates`: the call id, the sha256 that
+  * names WHICH document drew the verdict, its size, and the validator
+  * diffs); that costs nothing, because it is derived from decisions
+  * the journal already holds. A COPY of the document costs storage,
+  * so it is a decision the host makes: with this on, each rejected
+  * candidate is written to `<runId>/finish-rejected/<callId>` and the
+  * terminal row carries its `ref`, one `transcripts.get` away from the
+  * bytes. Turn it on for evaluation and comparison runs. The
+  * comparison run's three rejected syntheses were reachable only by an
+  * external script that re-parsed the whole agent transcript; nothing
+  * on the terminal or in the journal said where they were, or even
+  * that they differed from each other.
+  *
+  * Bounded by construction: at most `maxRepairs + 1` candidates per
+  * finish-validated invocation, under the run's own prefix, so
+  * `Engine.deleteRun` cascades over them like every other run blob. A
+  * store that refuses the write costs the run nothing: the row keeps
+  * its identity and drops its `ref`, and absence means NOT RECORDED.
+  */
+  retainRejectedCandidates?: boolean;
+  /**
   * The repair turn reserve (the v1.71 experiment review, P0.4; the
   * reserve RV-204 deliberately deferred). A nonnegative integer,
   * default 0: max EXTRA turns the invocation the validators bind (the
@@ -10113,6 +10172,35 @@ interface OrchestrateClaimConsistency {
   * silently when its judge dies.
   */
   onFound?: "report" | "carry" | "fail";
+  /**
+  * WHICH document the pass judges (RV2509), default `'draft'`, the
+  * historical behavior byte for byte. The pass has always read the
+  * coordination draft, strictly BEFORE the synthesis, so that a draft
+  * contradicting its own pool fails before anything pays to compose
+  * it. That ordering is right and stays; what it cannot do is verify
+  * the document that actually SHIPPED. The synthesis rewrites the
+  * draft, and under `'draft'` the semantic verdict on the terminal
+  * describes a document no consumer ever receives: the twenty-fifth
+  * comparison run's judge cleared a draft and the synthesis then
+  * composed a different text three times over.
+  *
+  * `'final'` moves the pass after the synthesis, over the artifact the
+  * run settles on. `'both'` keeps the pre-synthesis gate AND judges
+  * the final, at the price of a second judge invocation; the terminal
+  * then reports the FINAL pass in `claimConsistencyMeta` (the shipped
+  * document is what a consumer gates on) and the earlier one in
+  * `claimConsistencyDraftMeta`.
+  *
+  * Every meta says which document it read (`judgedStage`,
+  * `judgedHash`), and the envelope's `draftToFinal` says whether the
+  * synthesis changed the document at all, so the question "is this
+  * verdict about what I received" is a field read under every setting,
+  * including the default.
+  *
+  * Meaningful only with a `synthesis` configured: without one the
+  * draft IS the final and all three settings judge the same document.
+  */
+  stage?: "draft" | "final" | "both";
   /** The judge invocation's own knobs; the routing chain applies otherwise. */
   judge?: {
     /** Model override for the judge invocation. */model?: ModelSpec; /** Canonical effort of the judge invocation. */
@@ -10284,6 +10372,39 @@ interface OrchestrateClaimConsistencyMeta {
   * "fully verified" when the judge saw 40 of 144 citing sentences.
   */
   coverage: ClaimCoverageGrade;
+  /**
+  * WHICH document this verdict describes (RV2509): `'draft'` for the
+  * pre-synthesis pass, `'final'` for a pass over the artifact the run
+  * settles on. Always present since RV2509, so a coverage grade can
+  * never be read as a claim about the shipped document when it was
+  * rendered over the draft the synthesis replaced.
+  */
+  judgedStage: "draft" | "final";
+  /**
+  * sha256 over the canonical document this verdict read (RV2509).
+  * Compare it against the envelope's `draftToFinal.finalHash`: equal
+  * means the judged document IS the one that shipped, unequal means
+  * the synthesis rewrote what the judge cleared.
+  */
+  judgedHash: string;
+}
+/**
+* How the shipped artifact relates to the draft the run composed it
+* from (RV2509), present on the acceptance envelope whenever a
+* synthesis was configured. Two hashes and the answer they imply: a
+* semantic verdict rendered over the draft describes the final only
+* when `rewritten` is false, and until this shipped a consumer had no
+* way to ask.
+*/
+interface OrchestrateDraftToFinal {
+  /** sha256 over the canonical coordination draft. */
+  draftHash: string;
+  /** sha256 over the canonical artifact the run settled on. */
+  finalHash: string;
+  /** False exactly when the two hashes agree: the synthesis returned the draft unchanged. */
+  rewritten: boolean;
+  /** Which documents the claim-consistency pass actually judged; absent when it never ran. */
+  claimsJudgedOn?: "draft" | "final" | "both";
 }
 /**
 * The synthesis invocation's own knobs (RV-211). Everything else about
@@ -11546,6 +11667,40 @@ interface SemanticPassesSummary {
   claimConsistency: SemanticPassSummary;
   synthesis: SemanticPassSummary;
 }
+/**
+* One finish candidate the declared contract did NOT accept (RV2507).
+* The 1.226.0 comparison run rejected three syntheses; nothing on its
+* terminal said so, nothing said whether the three differed from each
+* other, and the only way to read them was an external script that
+* re-parsed the whole agent transcript. The row is the artifact that
+* dig produced, made first class.
+*
+* `hash` is the sha256 over the canonical candidate: two rows with the
+* same hash are the model serving the same document twice, which is a
+* different failure from three genuine attempts and used to be
+* invisible. `ref` is present exactly under
+* `finishValidation.retainRejectedCandidates`, and points at a
+* transcript blob holding the candidate verbatim; without it the row
+* still identifies and sizes what was rejected, and names the
+* validators that did it.
+*/
+interface RejectedFinishCandidate {
+  /** The finish tool call this candidate arrived on. */
+  callId: string;
+  /** `'repair'` when another turn was granted, `'rejected'` when this was the last. */
+  verdict: "repair" | "rejected";
+  /** sha256 over the canonical candidate; identity, not location. */
+  hash: string;
+  /** The candidate's length in characters, honest whether or not the bytes were retained. */
+  chars: number;
+  /** Each validator that rejected it, with its reasons: the diff. */
+  failed: {
+    name: string;
+    reasons: string[];
+  }[];
+  /** Transcript ref holding the bytes; absent unless retention is on and the write succeeded. */
+  ref?: string;
+}
 interface AcceptanceChildSummary {
   child: string;
   status: string;
@@ -11608,6 +11763,56 @@ type RunOutcome<R> = {
   claimConsistencyMeta?: Record<string, unknown>; /** The synthesis-skip marker from the same envelope; same lift and posture (RV2203). */
   synthesisSkipped?: boolean | string;
   /**
+  * Whether the artifact THIS terminal carries was accepted by the
+  * declared finish contract (RV2506), lifted from the same envelope or
+  * typed error data. The one question `status` and `completion` cannot
+  * answer between them: the 1.226.0 comparison run accepted its
+  * children (`completion: 'complete'` was earned by the acceptance
+  * policy over child statuses), then failed its synthesis against the
+  * contract three times and settled carrying nothing the contract ever
+  * accepted, and the scoring harness read `status: 'ok'` and could not
+  * tell. Absent, NEVER false, when no `finishValidation` was declared:
+  * nothing judged anything, and absence means NOT RECORDED (RV1209).
+  * False means a contract was declared and the artifact here did not
+  * pass it, including the case where nothing was ever judged because
+  * the run died first.
+  */
+  deliverableAccepted?: boolean;
+  /**
+  * Whether this terminal carries a deliverable to read at all
+  * (RV2506); same lift and posture. False on every enriched failure
+  * (an `error` outcome carries no value by construction) and on an
+  * accepted run whose synthesis resolved to null. Distinct from
+  * `deliverableAccepted`: an unjudged artifact still EXISTS, and a run
+  * with no artifact still has a completion claim.
+  */
+  resultAvailable?: boolean;
+  /**
+  * The journal seq of the decision entry that records the acceptance
+  * of the artifact this terminal carries (RV2506); same lift and
+  * posture, absent whenever `deliverableAccepted` is not true. Three
+  * different entries answer to it, which is the point of having one
+  * field: the accepted `orchestrator_finish_validation` decision on
+  * the ordinary path, the `orchestrator_synthesis_skip` decision when
+  * the RV510 gate settled on a valid draft, and the
+  * `orchestrator_synthesis_regressed` decision when the RV2505 floor
+  * handed a failing synthesis back to its draft. Read it with
+  * `rulvar inspect` (or any journal reader) to see WHICH validators
+  * rendered the acceptance and over WHICH draft hash.
+  */
+  acceptedArtifactRef?: number;
+  /**
+  * Every finish candidate the declared contract did NOT accept, in the
+  * order they were judged (RV2507); same lift and posture. Present
+  * only when there was at least one, so a run that passed first try
+  * keeps its exact terminal. It rides the ok terminal as well as the
+  * failed one: a run that recovered on its second attempt still owes a
+  * post-mortem the first, and the comparison analysis that had to
+  * reconstruct three rejected syntheses from a transcript is the
+  * reason the field exists.
+  */
+  rejectedFinishCandidates?: RejectedFinishCandidate[];
+  /**
   * Children accepted through validated terminal output salvage on
   * 'limit'; same lift and posture.
   */
@@ -12576,6 +12781,88 @@ declare function lastRunSettle(entries: readonly JournalEntry[]): {
   outputHash?: string;
   completion?: "complete" | "partial" | "rejected";
 } | undefined;
+/**
+* Whether a terminal figure counts THIS segment's work or the whole
+* logical run (RV2510).
+*
+* * `'segment'`: only the segment that produced this terminal. A
+*   resumed run reports the resumed segment's number, and the figure
+*   for the logical run is the SUM over every segment
+*   ({@link logicalRunTelemetry} computes it).
+* * `'cumulative'`: the whole logical run, every prior segment
+*   included, because the figure folds from the journal (money, usage),
+*   resumes from the journaled ledger (the spawn count), or is
+*   RE-DERIVED by replay (the loss list: a resumed segment re-executes
+*   the workflow and reads the same journaled terminals, so the drops
+*   of earlier segments come back). Summing these across segments
+*   double counts.
+* * `'terminal'`: not a count at all: a claim about the run as it
+*   stands at this settle, which a later segment can only replace.
+*/
+type TelemetryScope = "segment" | "cumulative" | "terminal";
+/**
+* The scope of every field the engine writes onto a terminal (RV2510),
+* as one exported table rather than as sentences scattered through
+* field docs.
+*
+* The twenty-fifth comparison run was killed and resumed, and its two
+* terminals mixed both kinds with nothing marking which was which: the
+* money was cumulative, the wake count and the replay figures were not,
+* and reconciling them into one honest account of the logical run was
+* hand work over a joined journal. Keys are field paths as a consumer
+* reads them off `RunOutcome` (`cost.orchestrator.wakes`); the
+* doctrine test holds this table against the keys a real outcome
+* carries, so a new terminal field cannot ship without declaring what
+* it counts.
+*/
+declare const TERMINAL_TELEMETRY_SCOPE: Readonly<Record<string, TelemetryScope>>;
+/** One logical run's telemetry, folded across every segment (RV2510). */
+interface LogicalRunTelemetry {
+  /** How many settles the journal records: the number of segments that ran. */
+  segments: number;
+  /** Each segment's settled status, in journal order. */
+  statuses: RunStatus[];
+  /**
+  * Journal entries each segment APPENDED, in the same order: its own
+  * share of the run's durable work, which is the one honest
+  * per-segment measure of effort a resumed run has. A pure-replay
+  * segment that appended nothing but its settle reads 1.
+  */
+  entriesPerSegment: number[];
+  /**
+  * Entries the run holds in total. Equal to the sum of
+  * `entriesPerSegment` plus whatever follows the last settle: the
+  * partition is exact BECAUSE it is a partition, which is what makes
+  * this figure safe to read beside a cumulative one.
+  */
+  entries: number;
+  /**
+  * Entries appended AFTER the last settle. Nonzero means the journal
+  * continued past its terminal (RV1407: a detached resolution
+  * awaiting its resume, or a successor segment over a stale settle),
+  * so the last status is not the run's last word.
+  */
+  entriesAfterLastSettle: number;
+}
+/**
+* Folds a run's journal into the logical run's telemetry (RV2510): how
+* many segments ran, how each settled, and how much durable work each
+* one did, from entries the journal already holds. No new field, so it
+* reads journals written by every prior version exactly as well as
+* today's.
+*
+* The replay dedup is the design. Cumulative figures are deliberately
+* NOT here: money and usage fold from the WHOLE journal through
+* `costReportFromJournal` and the usage ledger, and re-summing them per
+* segment would count every replayed operation once per segment that
+* replayed it, which is exactly the reconciliation this fold exists to
+* make unnecessary. What it reports instead is a PARTITION of the
+* journal by settle boundary, so no entry is counted twice by
+* construction, and the segment-scoped figures a terminal carries
+* ({@link TERMINAL_TELEMETRY_SCOPE} names them) can be read against the
+* segment that produced them.
+*/
+declare function logicalRunTelemetry(entries: readonly JournalEntry[]): LogicalRunTelemetry;
 type RunAuditVerdict = "consistent" | "meta-behind" | "stranded" | "suspect";
 interface RunStateAudit {
   runId: string;
@@ -14408,4 +14695,4 @@ interface SandboxBridge {
 declare const SANDBOX_AGENT_OPT_KEYS: readonly string[];
 declare function createSandboxBridge(ctx: Ctx<never>, options: SandboxBridgeOptions): SandboxBridge;
 //#endregion
-export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BillingComponent, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CachePolicy, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, type AdaptiveEvents, AdmissionController, AdmissionDecision, AdmissionRejectedError, AdmissionStatsBefore, AdmitLineage, AdmitRejectReason, AdmitSpec, AdmitVerdict, AgentCallError, AgentError, type AgentEvents, AgentIdentityInput, type AgentInvocationRow, AgentOpts, AgentProfile, AgentProfilePermissions, AgentProfileTemplateOptions, AgentResult, AgentResultMeta, AgentStatus, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, Artifact, AttemptOutcomeClass, AuditCategory, AuditRecord, AuditRunsOptions, BUDGET_ABORT_REASON, BaseAppend, BillingComponent, BriefOpts, BudgetAccountView, BudgetDefaults, BudgetExhaustedError, BudgetExhaustionDiagnostics, BudgetHooks, BudgetReserve, type Bytes, CANCEL_AGENT_SCHEMA, CHECKPOINT_FORMAT_V1, CLAIM_JUDGE_LABEL, CLAIM_STATEMENT_MAX_CHARS, CLAIM_TTL_DAYS, COMPACTION_SUMMARY_PREFIX, CURRENT_HASH_VERSION, CacheHint, CachePolicy, CacheTtl, CanUseTool, CanonicalId, CanonicalIdentity, CanonicalLadderSpec, CanonicalModelSpec, ChatEvent, ChatRequest, CheckpointState, ChildArtifactPage, ChildExecutionFacts, ChildIdentityInput, ChildResultPage, CitationTarget, type ClaimClass, ClaimContradictionFinding, ClaimCoverageGrade, ClaimCoverageInput, type ClaimOp, ClaimPair, ClaimPairOptions, ClaimPairsFold, ClaimPoolReading, type ClaimStatus, ClaimValidationOptions, CollectOpts, CollectedTurn, CompactionConfig, CompiledPermissionChain, CompiledWorkflow, ComponentDelta, ConfigError, Contradiction, ContradictionClaim, ContradictionOptions, ContradictionSource, type CoreEvents, CostAttribution, CostAttributionFacts, type CostBasis, CostReport, CreateEngineOptions, type CriticalPath, Ctx, DECISION_CHAIN_KINDS, DEFAULT_ANCHOR_PATTERN, DEFAULT_ARTIFACT_PATTERN, DEFAULT_CHILD_BUDGET_FRACTION, DEFAULT_CHILD_RESULT_PAGE_CHARS, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MatchResult, McpConfig, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OperationDisposition, OrchestrateAcceptance, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RejectedFinishCandidate, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_AGENT_SCHEMA, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TelemetryScope, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, invoiceFromJournal, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeFallbacks, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseModelRef, parseScopePath, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredSectionsValidator, researchAgentProfile, resolveModelInvocation, resolvePricing, resolveToolset, retryClassOf, retryDelayMs, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, sectionCitationsValidator, sectionPatternCountValidator, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };

package/dist/index.js

@@ -8745,6 +8745,94 @@ function lastRunSettle(entries) {
 		}
 	}
 }
+/**
+* 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);
@@ -21629,6 +21717,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 +21853,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;
@@ -23075,6 +23168,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 +23194,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 +23667,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 +23694,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 +23803,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 +23899,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 +23960,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 +23976,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 +24095,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 +24210,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 +24778,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,14 +24884,17 @@ 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);
@@ -24875,13 +25088,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 +25112,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 +25156,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"
@@ -26579,6 +26816,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;
 }
 /**
@@ -27174,6 +27426,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;
@@ -27835,4 +28091,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.228.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",