@rulvar/core 1.245.0 → 1.247.0

package/dist/index.d.ts

@@ -922,6 +922,18 @@ interface CostAttributionFacts {
   */
   label?: string;
   finalizeReserve?: boolean;
+  /**
+  * What dispatched a semantic repair round (RV4105): 'claim' (the
+  * RV3307 contradiction round), 'citation' (the RV4004 entailment
+  * round), 'coverage' (the RV4202 round armed by a non-'full' final
+  * grade alone), or 'combined' (one bounded round carrying more than
+  * one defect class, RV4202), stamped at dispatch beside
+  * `phase: 'repair'`, so the repair ledger attributes the round
+  * without cross-reading metas. Absent on every other dispatch and
+  * on journals written before it shipped (absence means NOT
+  * RECORDED, RV1209). Policy, never identity.
+  */
+  repairTrigger?: "claim" | "citation" | "coverage" | "combined";
 }
 /**
 * The per-model slices of a terminal entry: the recorded split when the
@@ -1761,6 +1773,15 @@ interface TerminalEnvelope {
   */
   claimConsistencyMeta?: Record<string, unknown>;
   /**
+  * The one-word semantic verdict (RV4209), mirrored beside the meta
+  * it was folded from: 'clean' | 'findings' | 'partial' | 'vacuous'
+  * | 'waived' | 'not-judged' plus the counts and the waiver
+  * (SemanticTerminalVerdict), so an event-only or HTTP consumer
+  * gates on the same one derivation the CLI reads. Absent when no
+  * semantic machinery was configured; absence means NOT RECORDED.
+  */
+  semanticTerminalVerdict?: Record<string, unknown>;
+  /**
   * The host declared config identity the run was started under
   * (RV3210), echoed here since RV3304 so a decision consumer binds
   * the verdict above to the configuration that produced it without a
@@ -3712,6 +3733,147 @@ declare class ExternalRegistry {
   private resolveDetached;
 }
 //#endregion
+//#region src/l0/spi/regulated-posture.d.ts
+/**
+* The construction-side posture attestation (RV4101; the debt RV4009
+* named). The regulated floor binds what flows through
+* CreateEngineOptions / RunOptions / OrchestrateOptions, but the
+* postures that decide whether a tool list can drift under a run or
+* whether a provider executes tools outside the permission chain live
+* on CONSTRUCTIONS: the mcp() source and the AI SDK bridge adapter.
+* RV4009 deliberately excluded them from the profile hash ("a hash
+* must not imply what it cannot verify") and named them in prose
+* beside the call. This descriptor makes them verifiable: a
+* risk-bearing construction exposes `describeRegulatedPosture()`, a
+* PURE snapshot of what was chosen at construction time (no wire, no
+* connect, no side effects), and `compileRegulatedProfile` walks the
+* constructions reachable from its options, refuses a loosened
+* posture naming the field, and folds the sorted descriptors into the
+* hashed posture map beside an `unrecognized` count of the
+* constructions that exposed nothing, so the hash names its own blind
+* spot instead of implying totality.
+*
+* The descriptor is a snapshot, not a lease, and the window between
+* compile time and use is held by re-assertion (RV4102, the RV1608
+* template): the compiled options wrap each attested construction so
+* every use of its risk seam (`tools()` on a source, `stream()` on an
+* adapter) re-reads and re-judges the descriptor, refusing a posture
+* that moved since compile. The cross-process half of the window
+* needs no wrapper: a mutated construction compiles to a different
+* profile hash, and the RV3210 resume assertion refuses it.
+*/
+/** The posture an mcp() tool source chose at construction (RV1516/RV1808). */
+interface McpSourceRegulatedPosture {
+  /** Descriptor shape version; bumps when the meaning changes. */
+  regulatedPosture: 1;
+  kind: "mcp-source";
+  /** The source id (`mcp:stdio:<command>`, `mcp:http:<url>`, `mcp:inprocess`). */
+  name: string;
+  /** What a listChanged notification means for this source (RV1516). */
+  drift: "rekey" | "refuse";
+  /**
+  * The discovery bounds (RV1808); `declared` is the all-four
+  * predicate `requireBounds` enforces (maxTools, maxPages,
+  * maxSchemaBytes, timeouts.discoveryMs), and the declared values
+  * ride beside it so the profile hash moves when a bound moves.
+  */
+  bounds: {
+    declared: boolean;
+    maxTools?: number;
+    maxPages?: number;
+    maxSchemaBytes?: number;
+    discoveryMs?: number;
+  };
+}
+/** The posture a bridgeAiSdk() adapter chose at construction. */
+interface AiSdkBridgeRegulatedPosture {
+  /** Descriptor shape version; bumps when the meaning changes. */
+  regulatedPosture: 1;
+  kind: "ai-sdk-bridge";
+  /** The adapter id. */
+  name: string;
+  /**
+  * Whether provider-executed tool results are admitted past the
+  * seam; 'allow' runs tools outside the permission chain and the
+  * journal, which the regulated floor refuses.
+  */
+  providerExecutedTools: "allow" | "deny";
+}
+/**
+* The posture a first-party model adapter chose at construction
+* (RV4204, the sixth comparison experiment): before it, only mcp()
+* and the AI SDK bridge attested, so `unrecognized >= 1` on nearly
+* every real compile and a `require-recognized` floor was
+* unsatisfiable by construction. The risk seams a model adapter
+* actually owns are its egress (where the wire bytes go) and its
+* caps-refresh pagination bound; both enter the hashed posture map,
+* so a moved base URL or a dropped bound moves the fingerprint.
+*/
+interface ModelAdapterRegulatedPosture {
+  /** Descriptor shape version; bumps when the meaning changes. */
+  regulatedPosture: 1;
+  kind: "model-adapter";
+  /** The adapter id ('anthropic', 'openai'). */
+  name: string;
+  /**
+  * Where the adapter's wire bytes go: the provider's official
+  * endpoint, a declared base-URL override (its origin rides beside
+  * this value so the hash pins the egress), or a preconstructed
+  * client the adapter cannot see through, named honestly.
+  */
+  transport: "official" | "custom-base-url" | "preconstructed-client";
+  /** Present exactly under 'custom-base-url': the override's origin. */
+  baseUrlOrigin?: string;
+  /**
+  * The caps-refresh pagination bound (RV2904), for adapters that
+  * expose one: `declared` mirrors whether the host capped the sweep,
+  * and the value rides beside it. Absent on adapters with no
+  * declarable bound.
+  */
+  capsBound?: {
+    declared: boolean;
+    maxPages?: number;
+  };
+}
+/**
+* The posture an isolated tool executor chose at construction
+* (RV4204). The executor is the one construction that dispatches
+* HOST-SIDE effects, and the regulated floor requires its ledger: an
+* effect no ledger records is an effect nobody can reconcile, the
+* billingReceipts doctrine applied to tools.
+*/
+interface ToolExecutorRegulatedPosture {
+  /** Descriptor shape version; bumps when the meaning changes. */
+  regulatedPosture: 1;
+  kind: "tool-executor";
+  /** The reference flavor ('subprocess', 'container') or a host name. */
+  name: string;
+  /** Whether a ToolEffectLedger records every dispatch (intent first). */
+  ledger: boolean;
+  /** Host env names reaching the child, the exact allowlist. */
+  allowEnv: readonly string[];
+  /** The resolved per-call ceilings (defaults resolve at construction). */
+  bounds: {
+    timeoutMs: number;
+    maxOutputBytes: number;
+  };
+  /**
+  * The isolation seam, per flavor: a subprocess names whether a
+  * sandbox launcher wraps the command; a container names its network
+  * mode and root-filesystem posture.
+  */
+  isolation: {
+    flavor: "subprocess";
+    sandboxed: boolean;
+  } | {
+    flavor: "container";
+    network: string;
+    readOnlyRoot: boolean;
+  };
+}
+/** What `describeRegulatedPosture()` returns: one of the known shapes. */
+type RegulatedPostureDescriptor = McpSourceRegulatedPosture | AiSdkBridgeRegulatedPosture | ModelAdapterRegulatedPosture | ToolExecutorRegulatedPosture;
+//#endregion
 //#region src/l0/spi/toolsource.d.ts
 /**
 * Declarative risk metadata on the tool contract. Policy input, not
@@ -3794,6 +3956,15 @@ interface ToolSourceSession {
 interface ToolSource {
   id: string;
   tools(session: ToolSourceSession): Promise<ToolDef[]>;
+  /**
+  * The construction-side posture attestation (RV4101): a PURE
+  * snapshot of the risk postures this source chose at construction
+  * (no wire, no connect, no side effects), read by
+  * `compileRegulatedProfile` to refuse a loosened posture and hash a
+  * tightened one. Optional: a source without it counts into the
+  * profile's `unrecognized` tally instead of being implied verified.
+  */
+  describeRegulatedPosture?(): RegulatedPostureDescriptor;
 }
 //#endregion
 //#region src/l0/spi/executor.d.ts
@@ -3856,6 +4027,14 @@ interface IsolatedExecRequest {
 interface ToolExecutorProvider {
   /** Runs one dispatch to its JSON result; throws to signal tool failure. */
   run(request: IsolatedExecRequest): Promise<Json>;
+  /**
+  * The construction-side posture attestation (RV4204): a PURE
+  * snapshot of what the executor chose at construction (ledger,
+  * env allowlist, ceilings, isolation seam), read by
+  * `compileRegulatedProfile` and folded into the hashed posture map;
+  * see the `regulated-posture` module.
+  */
+  describeRegulatedPosture?(): RegulatedPostureDescriptor;
 }
 /**
 * The engine's executor registry: at most one provider per non-inprocess
@@ -4020,6 +4199,15 @@ interface ProviderAdapter {
   countTokens?(req: ChatRequest, opts?: {
     signal?: AbortSignal;
   }): Promise<number>;
+  /**
+  * The construction-side posture attestation (RV4101): a PURE
+  * snapshot of the risk postures this adapter chose at construction
+  * (no wire, no side effects), read by `compileRegulatedProfile` to
+  * refuse a loosened posture and hash a tightened one. Optional: an
+  * adapter without it counts into the profile's `unrecognized` tally
+  * instead of being implied verified.
+  */
+  describeRegulatedPosture?(): RegulatedPostureDescriptor;
 }
 //#endregion
 //#region src/l0/spi/knowledge.d.ts
@@ -4501,8 +4689,25 @@ interface QuotaReservationRequest {
   provider: string;
   /** The serving model, re-reserved per failover target. */
   model: string;
-  /** The engine's configured tenant; absent when the host set none. */
+  /**
+  * The tenant of the reservation: the engine's configured tenant, or
+  * the run scope's under `quota.tenantFrom: 'scope'` (RV4205);
+  * absent when neither names one.
+  */
   tenant?: string;
+  /**
+  * The run's execution scope dimensions (RV4205), stamped by the ctx
+  * completion so dimension-pinned QuotaRules can match them; absent
+  * on unscoped runs, byte identical to before the field.
+  */
+  scope?: {
+    tenant?: string;
+    account?: string;
+    project?: string;
+    legalDomain?: string;
+    region?: string;
+    providerAccount?: string;
+  };
   /** The run paying for the attempt; observability only. */
   runId?: string;
   estimate: QuotaEstimate;
@@ -4592,6 +4797,19 @@ interface QuotaRule {
   provider?: string;
   model?: string;
   tenant?: string;
+  /**
+  * Scope-dimension pins (RV4205): a rule naming any of these matches
+  * only reservations whose run scope carries the same value, so a
+  * host caps by billing account, project, legal domain, region, or
+  * provider account without a limiter fork. A reservation with no
+  * scope (an unscoped run) matches none of them, exactly the tenant
+  * rule's semantics.
+  */
+  account?: string;
+  project?: string;
+  legalDomain?: string;
+  region?: string;
+  providerAccount?: string;
   /** Wire attempts admitted per window; the exact, hard cap. */
   requestsPerMinute?: number;
   /**
@@ -4720,6 +4938,15 @@ interface EngineQuotaConfig {
   /** Stamped on every reservation of this engine's runs. */
   tenant?: string;
   /**
+  * Where the reservation tenant comes from (RV4205). 'engine' (the
+  * default, historical bytes): the `tenant` above. 'scope': the
+  * RUN's recorded ExecutionScope.tenant, so one engine serving many
+  * tenants debits each run's reservations to the tenant the run
+  * declared; a run whose scope names no tenant reserves tenant-less,
+  * exactly like an engine that set none.
+  */
+  tenantFrom?: "engine" | "scope";
+  /**
   * What a limiter infrastructure FAILURE (reserve throwing) means:
   * 'deny' (default, fail closed) converts it into a retryable
   * transport-class denial; 'allow' logs a warning and dispatches
@@ -4788,6 +5015,8 @@ declare const DEFAULT_MAX_QUOTA_DENIALS = 8;
 interface EngineQuotaRuntime {
   limiter: QuotaLimiter;
   tenant?: string;
+  /** Where the reservation tenant comes from (RV4205); absent reads 'engine'. */
+  tenantFrom?: "engine" | "scope";
   onLimiterError: "deny" | "allow";
   /** Pre-wire continuation admission (RV1013); see {@link EngineQuotaConfig}. */
   reserveContinuations: boolean;
@@ -7799,10 +8028,34 @@ declare function acceptanceTailRequiredUsd(spec: AcceptanceTailSpec): {
 * an operator can diff them by eye and a test can assert them equal.
 */
 declare function formatAcceptanceTailTerms(terms: AcceptanceTailTerms): string;
-/** The declared wire counts of one orchestration plan (RV4005). */
+/**
+* The declared wire counts of one orchestration plan (RV4005). Since
+* RV4206 the intake is CLOSED: an unknown key is a typed ConfigError
+* instead of a silent zero. The sixth comparison experiment's harness
+* passed `repairRound` and `transportRetries` (plausible names this
+* spec never had) and `childWires: 4` for four children of ten turns
+* each; every unknown key was ignored and the estimate answered
+* confidently for a plan nobody had declared.
+*/
 interface WireCapacitySpec {
-  /** Fan-out provider dispatches: children times their turns. */
-  childWires: number;
+  /**
+  * Fan-out provider dispatches: children TIMES their turns, the
+  * total, not the child count. Optional since RV4206 when the
+  * structural pair below is given; declaring both is legal only when
+  * they agree (`childWires === children * turnsPerChild`), refused
+  * typed otherwise.
+  */
+  childWires?: number;
+  /**
+  * The structural fan-out declaration (RV4206): `children` workers of
+  * `turnsPerChild` provider dispatches each. Declare BOTH or neither;
+  * the pair exists because `childWires` invites passing the child
+  * count where the wire total belongs, the exact call the sixth
+  * comparison harness made.
+  */
+  children?: number;
+  /** See `children`; the two resolve to `children * turnsPerChild` fan-out wires. */
+  turnsPerChild?: number;
   /** Coordination loop dispatches, the finish exchanges included. */
   coordinationWires?: number;
   /** Composition invocations of the base plan (the initial synthesis). */
@@ -7816,11 +8069,29 @@ interface WireCapacitySpec {
   * to read `repairRoundDeltaWires` as the whole round.
   */
   judgeWires?: number;
+  /**
+  * Citation entailment audit judge dispatches (RV4206): one per pass,
+  * so 1 unarmed and the UNARMED reading here too when you read
+  * `repairRoundDeltaWires` as the whole round. The audit's wires were
+  * previously unnameable in this spec while the acceptance tail
+  * priced their money: the sixth comparison run's capacity model
+  * simply lost them.
+  */
+  citationJudgeWires?: number;
   /** Separate extract dispatches, when the finish rides one (RV3908 spares the schema'd final). */
   extractWires?: number;
 }
 /** What one orchestration plan costs in wires, base and worst case (RV4005). */
 interface WireCapacityEstimate {
+  /**
+  * What these numbers ARE (RV4206): a fold over the counts the
+  * caller DECLARED, never a measurement of a run. The literal exists
+  * so a capacity report that embeds the estimate carries its
+  * provenance on its face, the `CostReport.basis` precedent: the
+  * sixth comparison run's answer presented a declared estimate over
+  * a misdeclared plan as the runtime's own economics.
+  */
+  basis: "declared-estimate";
   /** The plan's wire total with no repair of any kind. */
   baseWires: number;
   /**
@@ -8214,6 +8485,18 @@ interface EngineDefaults {
   */
   countTokens?: "allow" | "deny";
   /**
+  * The toolset attestation floor (RV4204, the sixth comparison
+  * experiment): with this set, a spawn that resolves a NON-EMPTY
+  * toolset must run under a profile whose `toolsetAttestation` pins
+  * it, or it refuses typed at spawn time, before any provider call.
+  * The pin already binds call-level tool overrides and registered
+  * names for attested profiles (RV1514); what it could not bind was
+  * a spawn riding a profile that declared no tools and no pin, with
+  * the tools arriving per call. Off by default: every existing
+  * config keeps its bytes. `compileRegulatedProfile` arms it.
+  */
+  requireToolsetAttestation?: boolean;
+  /**
   * The engine-wide prompt-cache policy (RV2006). Absent means 'auto':
   * the agent loop attaches CacheHint breakpoints (after tools, after
   * system, and the sliding deepest message, TTL '5m') on every turn
@@ -8474,10 +8757,19 @@ interface RunOptions {
   * The bounded execution scope (RV4007): recorded at genesis into
   * RunMeta and a journal decision, immutable for the run's life (no
   * resume door), lifted onto the invoice header and carried by the
-  * export bundle. Attribution only: the library never interprets it.
+  * export bundle. Attribution only: the library never interprets it,
+  * with one declared exception since RV4205: a quota config with
+  * `tenantFrom: 'scope'` reads the scope's tenant into its
+  * reservations.
   */
   scope?: ExecutionScope;
   /**
+  * What an unknown scope field does (RV4205): 'drop' (the default,
+  * the historical bytes, pinned) or 'reject' (typed refusal by
+  * name). `compileRegulatedProfile` enforces 'reject'.
+  */
+  scopePolicy?: ScopePolicy;
+  /**
   * The opt-in in-flight exposure cap (RV711): bounds spent money plus
   * the summed worst-case estimates of live dispatches. The per-turn
   * guard checks money already SPENT, so under `budgetUsd` alone N
@@ -8819,17 +9111,50 @@ interface ExecutionScope {
   account?: string;
   /** The project or workload name. */
   project?: string;
+  /**
+  * The governing legal domain (RV4205, the sixth comparison
+  * experiment's P0.2): host-defined vocabulary (a jurisdiction, a
+  * regulatory regime), the first of the three named dimensions the
+  * experiment's question bound to routing and audit.
+  */
+  legalDomain?: string;
+  /** The deployment or data-residency region, host-defined (RV4205). */
+  region?: string;
+  /** The provider-side billing account identity, host-defined (RV4205). */
+  providerAccount?: string;
+}
+/**
+* What an UNKNOWN scope field does (RV4205). 'drop' (the default, the
+* RV4007/RV4107 posture byte for byte) silently discards it from the
+* normalized copy, which keeps junk fields from moving the recorded
+* identity; 'reject' refuses it typed by name, because a dimension
+* the engine cannot record is a dimension nothing downstream can bind
+* to routing, quota, or audit, and a host that declared it meant it.
+* `compileRegulatedProfile` enforces 'reject'.
+*/
+interface ScopePolicy {
+  unknown?: "drop" | "reject";
 }
 /**
 * Validates and copies a declared scope (RV4007): own properties only
 * (the RV1205 doctrine: a prototype member must never resolve),
 * non-empty strings of at most 256 chars, at least one field, and the
 * copy is what gets recorded, so later host mutation of the passed
-* object cannot move the recorded identity.
+* object cannot move the recorded identity. Under
+* `policy.unknown: 'reject'` (RV4205) an own enumerable field outside
+* the named dimensions refuses typed by name instead of dropping.
 */
-declare function normalizeExecutionScope(value: unknown, site: string): ExecutionScope;
+declare function normalizeExecutionScope(value: unknown, site: string, policy?: ScopePolicy): ExecutionScope;
 /** The canonical identity string of a scope (RV4007): JCS bytes, total and deterministic. */
 declare function executionScopeKey(scope: ExecutionScope): string;
+/**
+* The canonical digest of a scope (RV4205): sha256 over the JCS bytes
+* of the NORMALIZED scope, a fixed-length identity for causal records
+* (the genesis decision, the invoice header) and external joins, so a
+* FinOps pipeline correlates runs by one column instead of comparing
+* structured objects field by field.
+*/
+declare function executionScopeDigest(scope: ExecutionScope): string;
 /** Content hash of an in-process workflow body (run-to-definition binding). */
 declare function hashWorkflowBody(wf: Workflow<never, never> | Workflow<unknown, unknown>): string;
 /** Content hash of a compiled workflow source (run-to-definition binding). */
@@ -9674,6 +9999,18 @@ interface ClaimPairOptions {
   * historical first-`max` selection, byte for byte.
   */
   targetCoverageShare?: number;
+  /**
+  * Collect the citing sentences the reported pairs left UNCOVERED
+  * (RV4202, the sixth comparison experiment): the coverage-armed
+  * repair round needs the sentences themselves for its prompt, not
+  * only their count, because "raise the coverage" is actionable to a
+  * composing model exactly when it can see which claims the pool
+  * never grounded. Distinct collapsed sentences, draft order, each
+  * cut to `maxExcerptChars`, capped at
+  * {@link MAX_UNCOVERED_SENTENCES}; the uncapped count rides beside
+  * the list. Unset = byte-identical fold output.
+  */
+  reportUncovered?: boolean;
 }
 /** What the fold produced, beside the pairs themselves. */
 interface ClaimPairsFold {
@@ -9706,12 +10043,27 @@ interface ClaimPairsFold {
   criticalUncovered?: string[];
   /** The uncapped count behind `criticalUncovered`; present with it. */
   criticalUncoveredTotal?: number;
+  /**
+  * Present only when `reportUncovered` was set (RV4202): the distinct
+  * citing sentences with no reported pair, draft order, each cut to
+  * `maxExcerptChars`, capped at {@link MAX_UNCOVERED_SENTENCES}. A
+  * sentence lands here for any of the three uncovered causes (no
+  * intersecting pool reading, verbatim agreement dropped every
+  * reading, or a bound cut its candidates); telling them apart is the
+  * repair round's job, which is exactly why the sentences ride the
+  * prompt instead of a cause taxonomy riding the meta.
+  */
+  uncoveredSentences?: string[];
+  /** The uncapped count behind `uncoveredSentences`; present with it. */
+  uncoveredSentencesTotal?: number;
 }
 declare const DEFAULT_MAX_CLAIM_PAIRS = 40;
 declare const DEFAULT_MAX_POOL_PER_PAIR = 3;
 declare const DEFAULT_MAX_PAIR_EXCERPT_CHARS = 400;
 /** Bound on the reported uncovered-critical anchor list (RV1603). */
 declare const MAX_CRITICAL_UNCOVERED = 32;
+/** Bound on the reported uncovered citing-sentence list (RV4202). */
+declare const MAX_UNCOVERED_SENTENCES = 24;
 /**
 * Folds the composed draft against the settled pool it composed from:
 * every draft sentence citing an anchor is paired with the pool
@@ -10754,6 +11106,15 @@ interface OrchestrateAcceptance {
 }
 /** How many rejected finishes are repaired by default: the plan's repair once. */
 declare const DEFAULT_FINISH_MAX_REPAIRS = 1;
+/**
+* The word ceiling of a 'digest' coordination draft (RV4210): the
+* digest is a structural evidence map the composing invocation writes
+* prose FROM, and the ceiling is the teeth that keep it from decaying
+* back into the full prose draft it exists to replace. The sixth
+* comparison run's contract-policy draft cost 344.8 seconds of model
+* output and was then rewritten whole by the composition.
+*/
+declare const DIGEST_DRAFT_MAX_WORDS = 400;
 /** The sectional round's owning sections and marker roster (RV3803). */
 interface SectionalRoundPlan {
   /** Every H2 marker of the retained document, in document order. */
@@ -10873,6 +11234,38 @@ interface FinishValidationSpec {
   */
   retainRejectedCandidates?: boolean;
   /**
+  * The candidate persistence policy (RV4207, the sixth comparison
+  * experiment): ONE declaration that closes the candidate lineage
+  * surface, superseding the boolean above (declaring both is a
+  * ConfigError; the boolean stays for existing configs).
+  *
+  * Declared (either mode), EVERY finish-validation decision carries
+  * the candidate identity, the ACCEPTED verdict included: the sha256
+  * over the canonical resolved document (the deterministic patch or
+  * the sectional splice applied first) and its char count, so the
+  * whole chain proposed/repaired/rejected/accepted reads off
+  * `synthesisCandidatesFromJournal` (and `rulvar inspect
+  * --candidates`) by hash, and the accepted hash is the same recipe
+  * the claim judge's `judgedHash` and the audit's `auditedHash` bind
+  * (`candidateHashOf`: sha256 over the JCS serialization; see
+  * `verifyCandidateBytes` for the audit recipe). Undeclared, the
+  * decisions keep their historical bytes exactly (identity on
+  * non-accepted verdicts only).
+  *
+  * `'transcript'` additionally retains each REJECTED candidate's
+  * bytes as its own addressable blob, byte for byte the
+  * `retainRejectedCandidates: true` behavior. `'hash-only'` retains
+  * no bytes ON PURPOSE and says so: every non-accepted decision
+  * carries `bytesUnavailableReason: 'hash-only-persistence'`, so an
+  * auditor finding no blob reads a policy, not an accident; a
+  * declared 'transcript' whose store write failed stamps
+  * `'store-write-failed'` the same way. The experiment's auditor
+  * recovered the rejected composition only by digging a binary
+  * transcript with no documented recipe; the reason field is the
+  * difference between "not retained by declared policy" and "lost".
+  */
+  candidatePersistence?: "transcript" | "hash-only";
+  /**
   * 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
@@ -10940,11 +11333,29 @@ interface FinishValidationSpec {
   * bound: validators that fold the children snapshot (the evidence
   * share) can still fail the pre-pass when a child settles between
   * the draft finish and synthesis; the pre-pass stays the authority.
+  *
+  * The sentinel `'digest'` (RV4210, the sixth comparison experiment)
+  * inverts the draft's economics for configurations that do NOT use
+  * `skipWhenDraftValid`: the harness under audit forced a full
+  * contract-valid prose draft (344.8 s of model output) that the
+  * composition then rewrote whole, because `draftPolicy: 'contract'`
+  * is priced for the skip gate it was built to feed. Under 'digest'
+  * the coordination prompt asks for a compact STRUCTURAL EVIDENCE
+  * MAP (one list row per planned section naming its claims and the
+  * evidence behind them) and the gate enforces the inversion
+  * deterministically: at least one list row, at most
+  * {@link DIGEST_DRAFT_MAX_WORDS} words, so the draft cannot decay
+  * back into the prose it replaces. The synthesis invocation embeds
+  * the digest exactly as it embeds any draft; wire counts are
+  * unchanged. Because a digest is NOT a candidate deliverable, the
+  * intake refuses the combinations that would ship or judge it as
+  * one: `synthesis.skipWhenDraftValid` and
+  * `synthesis.fallbackToValidDraft` are both ConfigError beside it.
   */
   draftPolicy?: {
     /** Minimum whitespace-separated words the draft must carry. */minWords?: number; /** Literal markers the draft text must contain. */
     requireSections?: string[];
-  } | "contract";
+  } | "contract" | "digest";
   /**
   * Sectional bounded repair (RV808b). A rejected finish used to
   * resend the WHOLE document to fix one violated section: on the
@@ -11219,6 +11630,17 @@ interface OrchestrateOptions {
   * method, internalized. See {@link OrchestrateCitationAudit}.
   */
   citationAudit?: OrchestrateCitationAudit;
+  /**
+  * The atomic production posture (RV4201, the sixth comparison
+  * experiment): one declaration that a run may settle accepted only
+  * clean (full final coverage, zero surviving contradictions, zero
+  * surviving unsupported citations, no waiver, or exactly the one
+  * pinned-hash waiver). Intake refuses any `claimConsistency` /
+  * `citationAudit` field that contradicts it, so the observing
+  * postures the sixth experiment shipped under cannot coexist with
+  * the declaration. See {@link OrchestrateSemanticAcceptance}.
+  */
+  semanticAcceptance?: OrchestrateSemanticAcceptance;
 }
 /**
 * The citation entailment audit's knobs (RV4004). The sample derives
@@ -11243,6 +11665,22 @@ interface OrchestrateCitationAudit {
   maxSampled?: number;
   /** Lines after the cited line an excerpt may carry; default 3. */
   window?: number;
+  /**
+  * The resolver generation (RV4208). Default 1, the fixed downward
+  * window above, byte identical for every existing config. Declaring
+  * 2 excerpts the bounded LOGICAL UNIT the cited line belongs to
+  * (heading section, list item, table row with its header, code
+  * comment plus declaration, paragraph; `citationUnitExcerptOf`) and
+  * audits EVERY anchor of a compound sentence as its own row against
+  * its nearest claim clause, with the unit type and a truncation
+  * flag on the row and `resolverVersion: 2` on the meta. The sixth
+  * comparison experiment's confirmed false negatives were window
+  * artifacts: a section heading whose support lives below the fixed
+  * window, and only a sentence's first anchor ever sampled. Opt-in
+  * because the sample derives from the audited document's hash and
+  * v2 changes which rows exist and what the judge reads.
+  */
+  resolver?: 1 | 2;
   /** The judge invocation's knobs, exactly the claim judge's shape. */
   judge?: {
     model?: ModelSpec;
@@ -11261,10 +11699,15 @@ interface OrchestrateCitationAudit {
   * composition, the repaired document is re-audited (a fresh sample
   * from its new hash), a configured claim pass past the draft
   * rejudges the rewritten document, and unsupported rows that
-  * survive fail the run typed. One round exactly; arming BOTH this
-  * 'repair' and `claimConsistency.onFound: 'repair'` is a
-  * ConfigError, because the run grants one bounded repair round and
-  * two consumers of it would pay two extra compositions.
+  * survive fail the run typed. One round exactly, shared (RV4202):
+  * arming BOTH this 'repair' and `claimConsistency.onFound:
+  * 'repair'` grants the same ONE bounded round, which then fires
+  * after the first audit pass carrying both defect lists (the judged
+  * claim contradictions and the unsupported citations, plus the
+  * uncovered sentences when `coverageRepair` is armed), and BOTH
+  * judges re-rule on the repaired document's new hash before
+  * survivors of either class fail the run typed. The budget never
+  * grows past one extra composition.
   */
   onFound?: "report" | "repair" | "fail";
 }
@@ -11514,7 +11957,12 @@ interface OrchestrateClaimConsistency {
   * it and why. `expiresAt` (ISO 8601) bounds the standing waiver: an
   * expired one refuses exactly like no waiver, evaluated once at
   * the enforcement point and journaled, so a resume replays the
-  * recorded verdict instead of re-reading the clock. Requires
+  * recorded verdict instead of re-reading the clock (RV4104): a run
+  * that waived, crashed, and outlived its waiver finishes under the
+  * recorded exception. The frozen decision licenses exactly the
+  * document it judged: an entry carrying a `judgedHash` is honored
+  * only for that hash (the RV603 bound), and entries written before
+  * the field existed stay reusable. Requires
   * `coveragePolicy: 'strict-final'`; declaring it without the
   * policy is a ConfigError, because a waiver over an unenforced
   * grade is a signature over nothing.
@@ -11524,6 +11972,102 @@ interface OrchestrateClaimConsistency {
     reason: string;
     expiresAt?: string;
   };
+  /**
+  * Coverage joins the bounded repair round (RV4202, the sixth
+  * comparison experiment). The experiment's run reached its
+  * strict-final gate with a 'partial' grade and had exactly two
+  * doors: a typed refusal or the standing waiver, because the round
+  * armed on FINDINGS alone; the uncovered 27 percent of its citing
+  * sentences was a defect class no machinery could consume. With
+  * this set, a final grade that is not 'full' arms the same ONE
+  * bounded round (RV3307): the still-uncovered citing sentences ride
+  * the round's prompt as the UNCOVERED CLAIMS block (ground each
+  * claim in material the pool actually read, or drop the citation),
+  * the repaired document is re-paired and re-judged from its new
+  * hash, and a grade that is STILL not 'full' after the round meets
+  * the strict-final gate exactly as before (the typed refusal, or a
+  * waiver where the posture allows one). Requires `onFound:
+  * 'repair'` (the round is that posture's machinery) and
+  * `coveragePolicy: 'strict-final'` (the gate whose refusal the
+  * round averts); a ConfigError otherwise. Off by default: every
+  * existing config keeps its bytes, round triggers included.
+  */
+  coverageRepair?: boolean;
+}
+/**
+* The atomic production posture (RV4201, the sixth comparison
+* experiment). The experiment's run was configured knob by knob:
+* `report` findings postures, a standing waiver, no repair round, and
+* every one of those choices was individually legal while their SUM
+* quietly meant "observe and ship anyway"; the run then settled
+* accepted over a partial grade, a judged contradiction, and five
+* unsupported citations. This declaration is the one object that says
+* the opposite, in full, and intake REFUSES any underlying field that
+* contradicts it (nothing is filled: a signature has no blanks, so
+* the host writes the machinery the declaration binds). Under it a
+* run can settle accepted only when the FINAL document's claim
+* coverage graded 'full', zero judged contradictions and zero
+* unsupported (unresolved included) sampled citations survived the
+* one bounded round where the posture arms it, and no waiver stood,
+* except the pinned-hash form, which licenses exactly one reviewed
+* document. `compileRegulatedProfile` fills and enforces this
+* declaration for regulated runs (RV4201); plain orchestrations opt
+* in by declaring it.
+*/
+interface OrchestrateSemanticAcceptance {
+  /**
+  * The document the verdicts must describe: the FINAL one, always.
+  * Requires `claimConsistency.stage` 'final' or 'both'; the literal
+  * exists so the signature spells its object out.
+  */
+  judgedStage: "final";
+  /**
+  * The only acceptable final coverage grade. Requires
+  * `claimConsistency.coveragePolicy: 'strict-final'`, and refuses a
+  * declared `coverageTarget` below 1, because a pass sized to cover
+  * less than everything can never grade 'full' on a citing document:
+  * the declaration would be unsatisfiable by construction.
+  */
+  claimCoverage: "full";
+  /**
+  * What a judged claim contradiction does: 'repair-once-then-fail'
+  * requires `claimConsistency.onFound: 'repair'` (survivors of the
+  * bounded round already fail typed) plus `coverageRepair: true` (the
+  * one round serves every armed defect class, coverage included);
+  * 'fail' requires `onFound: 'fail'`. The observing postures
+  * ('report', 'carry') refuse at intake.
+  */
+  contradictions: "repair-once-then-fail" | "fail";
+  /**
+  * What an unsupported sampled citation does, same mapping onto
+  * `citationAudit.onFound`; 'report' refuses at intake.
+  */
+  citations: "repair-once-then-fail" | "fail";
+  /**
+  * What a sampled citation that resolves NOTHING does. Mechanically
+  * unresolved rows are unsupported findings already (the
+  * citedValueValidator doctrine), so the field binds no new
+  * machinery; it exists because a signature that is silent about the
+  * rows no judge ever saw would be a blank exactly where the sixth
+  * experiment's audit found its five.
+  */
+  unresolved: "fail";
+  /**
+  * The waiver posture. 'forbid': `claimConsistency.waiver` must be
+  * absent, and a journaled `claim_coverage_waived` decision
+  * surfacing under this declaration refuses typed (a journal that
+  * waived under a config that forbids waivers is a config/journal
+  * mismatch, not an authority). The pinned form carries the sha256
+  * of the ONE document the waiver may license (the claim meta's
+  * `judgedHash`, 64 hex chars): a signature under a reviewed
+  * document, never a blank cheque, so a re-run that composes any
+  * other bytes refuses exactly as if no waiver stood. Requires a
+  * declared `claimConsistency.waiver` naming the principal and the
+  * reason.
+  */
+  waiver: "forbid" | {
+    judgedHash: string;
+  };
 }
 /** One judged contradiction: the pair plus the judge's one-sentence reason. */
 interface ClaimContradictionFinding extends ClaimPair {
@@ -11670,6 +12214,14 @@ interface OrchestrateClaimConsistencyMeta {
   */
   firstPassFindings?: number;
   /**
+  * The coverage grade of the FIRST pass (RV4202), present exactly
+  * when a coverage-armed round ran (`passes` exceeds 1 under
+  * `coverageRepair`): the meta above always describes the LAST pass,
+  * so without this field a 'full' grade earned through the round
+  * would be indistinguishable from a clean first verdict.
+  */
+  firstPassCoverage?: ClaimCoverageGrade;
+  /**
   * Bounded semantic repair rounds actually dispatched at this stage
   * (RV3904); today 0 or 1, the evidence-grade precedent. Distinct
   * from the finish validation's mechanical `repairsUsed`, which
@@ -12552,7 +13104,8 @@ interface RunInternals {
     schemas?: Record<string, SchemaSpec>; /** Registered tool profile names for toolsetRef (M7-T05). */
     toolsets?: Record<string, ToolsOption>; /** Registered mechanical gate profiles (M7-T10). */
     gates?: Record<string, MechanicalGateProfile>; /** Engine-wide admission countTokens policy (RV1804); default 'allow'. */
-    countTokens?: "allow" | "deny"; /** The engine-wide prompt-cache policy (RV2006); profile and call opts win. */
+    countTokens?: "allow" | "deny"; /** The toolset attestation floor (RV4204); default off. */
+    requireToolsetAttestation?: boolean; /** The engine-wide prompt-cache policy (RV2006); profile and call opts win. */
     cache?: CachePolicy; /** The receipt posture of the billing seam (RV3405); default 'async'. */
     billingReceipts?: "async" | "awaited" | "intent";
   };
@@ -12569,6 +13122,22 @@ interface RunInternals {
   * absent = no shared quota, byte-identical to before the feature.
   */
   quota?: EngineQuotaRuntime;
+  /**
+  * The run's recorded execution scope (RV4205): the normalized copy
+  * genesis records, threaded so the quota completion can read the
+  * scope's tenant under `tenantFrom: 'scope'` and stamp the scope
+  * dimensions onto reservations for dimension-matched rules.
+  * Structural (not the engine's ExecutionScope named type) because
+  * ctx deliberately imports nothing from engine.ts.
+  */
+  executionScope?: {
+    tenant?: string;
+    account?: string;
+    project?: string;
+    legalDomain?: string;
+    region?: string;
+    providerAccount?: string;
+  };
   /** The configured price table's version; pinned in decision entries (M4-T06). */
   pricingVersion?: string;
   /** budgetDefaults.flatReserveUsd; last resort of the reserve formula. */
@@ -12655,6 +13224,26 @@ declare function executeWorkflow<A, R>(internals: RunInternals, wf: Workflow<A,
 */
 declare function attributionBucket(value: string | undefined): string;
 /**
+* The byAgentType bucket of one attributed slice (RV4206, the RV3905
+* vacuum-fill precedent carried to the agent-type table). A declared
+* agentType always wins, verbatim. The vacuum, an absent or empty
+* agentType, is FILLED from facts the journal already records instead
+* of stamping new bytes: role 'orchestrate' names the bucket
+* 'orchestrator' (the coordination loop and the forced-finish wake),
+* and role 'synthesize' names it by the dispatch label through the
+* ONE {@link synthesizeSpanClassOf} classifier: 'synthesizer' for
+* compositions and notes, 'claim-judge' and 'citation-judge' for the
+* two judges, with an unknown label keeping the honest 'unknown'.
+* Because the derivation reads only recorded facts, the live report,
+* the journal fold, and every ARCHIVED journal report the same named
+* buckets: the sixth comparison run's report read byAgentType 100%
+* 'unknown' over a run whose every dispatch had a nameable stage, and
+* that same journal now folds to named rows retroactively. Both
+* accumulation sites and the journal fold call this one function, the
+* RV3302 no-drift doctrine.
+*/
+declare function agentTypeBucket(agentType: string | undefined, role: string | undefined, label: string | undefined): string;
+/**
 * The scope key rule of the byScope rollup (RV3805). The root's OWN
 * scope is the empty string BY CONSTRUCTION: present data whose string
 * happens to be empty, not an absence, so it folds under the
@@ -12796,7 +13385,19 @@ interface CostReport {
   * run's one draft repair wire read 'coordination').
   */
   byPhase: Record<string, number>;
-  /** Spawn agentType names; absent and empty fold under 'unknown' (RV3604). */
+  /**
+  * Spawn agentType names; absent and empty fold under 'unknown'
+  * (RV3604). Since RV4206 the vacuum is FILLED by pure derivation
+  * from recorded facts (`agentTypeBucket` over agentType, role, and
+  * dispatch label, the RV3905 phase precedent): the orchestrator's
+  * own dispatches read 'orchestrator' (the coordination loop and the
+  * forced-finish wake), 'synthesizer' (compositions and incremental
+  * notes), 'claim-judge', and 'citation-judge'; a spawned profile
+  * always keeps its own name, no journal byte changes, and archived
+  * journals fold to the named rows retroactively. The sixth
+  * comparison run's report read this table 100% 'unknown' over a run
+  * whose every dispatch had a nameable stage.
+  */
   byAgentType: Record<string, number>;
   byRole: Record<InvocationRole, number>;
   /**
@@ -12911,6 +13512,14 @@ interface RejectedFinishCandidate {
   }[];
   /** Transcript ref holding the bytes; absent unless retention is on and the write succeeded. */
   ref?: string;
+  /**
+  * Why the bytes are not retained (RV4207), when the run declared a
+  * `candidatePersistence`: 'hash-only-persistence' is the policy
+  * saying so on purpose, 'store-write-failed' a declared retention
+  * the store refused. Absent on undeclared configs, whose rows keep
+  * their exact bytes.
+  */
+  bytesUnavailableReason?: "hash-only-persistence" | "store-write-failed";
 }
 /**
 * The roster facts of a run that died before any acceptance verdict
@@ -12995,6 +13604,18 @@ type RunOutcome<R> = {
   */
   claimConsistencyMeta?: Record<string, unknown>;
   /**
+  * The one-word semantic verdict (RV4209), lifted from the same
+  * envelope or typed error data as the meta beside it: 'clean',
+  * 'findings', 'partial', 'vacuous', 'waived', or 'not-judged', with
+  * the counts and the waiver it was folded from
+  * (SemanticTerminalVerdict). One derivation at the orchestrator
+  * chokepoint instead of every consumer re-deriving the verdict from
+  * four fields; `productionAcceptable` is the exported gate over it.
+  * Absent when no claim or citation machinery was configured, and on
+  * every run recorded before it shipped.
+  */
+  semanticTerminalVerdict?: Record<string, unknown>;
+  /**
   * The judged contradictions themselves (RV3601), lifted from the
   * same envelope or typed error data as the meta beside them. RV3304
   * deliberately kept the details off this surface and let the meta's
@@ -13153,7 +13774,7 @@ interface RunHandle<R> {
 //#endregion
 //#region src/engine/terminal-envelope.d.ts
 /** The outcome facts the assembler reads; a structural subset of RunOutcome. */
-type TerminalOutcomeFacts = Pick<RunOutcome<unknown>, "status" | "error" | "completion" | "deliverableAccepted" | "resultAvailable" | "acceptedArtifactRef" | "claimConsistencyMeta"> & {
+type TerminalOutcomeFacts = Pick<RunOutcome<unknown>, "status" | "error" | "completion" | "deliverableAccepted" | "resultAvailable" | "acceptedArtifactRef" | "claimConsistencyMeta" | "semanticTerminalVerdict"> & {
   usage: RunOutcome<unknown>["usage"];
   cost: Pick<RunOutcome<unknown>["cost"], "totalUsd" | "grossUsd" | "byModel"> & {
     usageApprox?: boolean;
@@ -14378,7 +14999,9 @@ interface JournaledCriticalPath {
   /** `synthesisMs / runWallMs`, under the same conditions. */
   synthesisShare?: number;
   /**
-  * Synthesis that is NOT the claim judge (RV1604). Present only when
+  * Synthesis that is COMPOSITION (RV1604; classified through
+  * {@link synthesizeSpanClassOf} since RV4206, so a judge of either
+  * kind and an unknown label never land here). Present only when
   * EVERY synthesize span in the journal carried a label: one
   * unlabelled span would make the split a guess, and the split exists
   * because a guess here read a 54 second judge as a second final
@@ -14388,6 +15011,23 @@ interface JournaledCriticalPath {
   /** Synthesis that IS the claim judge; same all-or-nothing condition. */
   semanticJudgeMs?: number;
   /**
+  * Synthesis that is the citation entailment audit judge (RV4206);
+  * same all-or-nothing condition. Until this field the audit judge
+  * read as final composition in every archived journal, the same
+  * blindness the live reducer had.
+  */
+  citationJudgeMs?: number;
+  /** Settled citation-judge spans, counted; same condition. */
+  citationJudgeSpans?: number;
+  /**
+  * Synthesis whose label this fold's classifier does not know
+  * (RV4206); same condition. Nonzero means the split beside it is a
+  * floor, never silently "composition".
+  */
+  unclassifiedSynthesisMs?: number;
+  /** Settled unclassified synthesize spans, counted; same condition. */
+  unclassifiedSynthesisSpans?: number;
+  /**
   * The stage split of `semanticJudgeMs` (RV3404), same all-or-nothing
   * condition: the draft pass is the exact judge label and every
   * suffixed variant is a post draft pass over the composed document
@@ -14459,13 +15099,17 @@ interface JournaledPostFanIn {
   /** Union of settled synthesize spans clipped to the window. */
   synthesisCoveredMs: number;
   /**
-  * The composition half of the covered spans, clipped; present under
+  * The composition share of the covered spans, clipped; present under
   * the same all-or-nothing labelling condition as the top level
   * split, and equal to the live breakdown's reading of the same run.
   */
   finalCompositionMs?: number;
-  /** The judge half, clipped; same condition. */
+  /** The claim-judge share, clipped; same condition. */
   semanticJudgeMs?: number;
+  /** The citation-judge share, clipped (RV4206); same condition. */
+  citationJudgeMs?: number;
+  /** The unclassified share, clipped (RV4206); same condition. */
+  unclassifiedSynthesisMs?: number;
   /** `postFanInMs` minus `synthesisCoveredMs`, floored at zero. */
   unaccountedMs: number;
   /** `unaccountedMs / postFanInMs` when the window is positive. */
@@ -14479,10 +15123,26 @@ interface JournaledPostFanIn {
 declare function criticalPathFromJournal(entries: readonly JournalEntry[]): JournaledCriticalPath;
 //#endregion
 //#region src/stores/repair-ledger.d.ts
-/** One granted repair, folded from its journaled verdict (RV4002). */
+/** One counted repair, folded from its journaled verdict or dispatch (RV4002/RV4105). */
 interface RepairLedgerRound {
-  /** Which gate granted it: the draft gate, a composition invocation, or the RV3307 round's own pool. */
-  stage: "draft" | "composition" | "round";
+  /**
+  * Which gate granted it (the draft gate, a composition invocation,
+  * or the RV3307 round's own pool), or 'semantic' for a dispatched
+  * semantic repair round itself (RV4105): the round has no verdict
+  * decision, so its row folds from the settled dispatch entry.
+  */
+  stage: "draft" | "composition" | "round" | "semantic";
+  /**
+  * What dispatched the semantic round (RV4105): 'claim' (the RV3307
+  * contradiction round), 'citation' (the RV4004 entailment round),
+  * 'coverage' (the RV4202 round armed by a non-'full' final grade
+  * alone), or 'combined' (one bounded round carrying more than one
+  * defect class, RV4202), read from the
+  * `costAttribution.repairTrigger` stamped at dispatch. Absent on
+  * non-semantic rows and on journals written before the stamp
+  * shipped (absence means NOT RECORDED, RV1209).
+  */
+  trigger?: "claim" | "citation" | "coverage" | "combined";
   /** The verdict decision's seq: the repair's address in the run. */
   seq: number;
   /** The finish call id the verdict was keyed by, when journaled. */
@@ -14517,7 +15177,12 @@ interface RepairLedger {
   semantic: number;
   /** draft + composition + semantic. */
   total: number;
-  /** One row per counted repair, in seq order (semantic rounds carry no verdict row). */
+  /**
+  * One row per counted repair, in seq order. Semantic rounds carry
+  * their own rows since RV4105 (stage 'semantic', with the trigger
+  * when the journal stamped one), so their wires have a home and
+  * `semantic: 2` is decomposable without cross-reading metas.
+  */
   rounds: readonly RepairLedgerRound[];
   /**
   * Finish-validation 'repair' verdicts with no journaled stage: the
@@ -14537,6 +15202,33 @@ interface RepairLedger {
 declare function repairLedgerFromJournal(entries: readonly JournalEntry[], priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined): RepairLedger;
 //#endregion
 //#region src/stores/synthesis-candidates.d.ts
+/**
+* THE candidate hash recipe (RV4207), written down where the fold that
+* reads it lives: sha256 (hex) over the JCS canonical serialization of
+* the candidate VALUE, `null` for an absent one. This is the recipe
+* behind every `candidateHash` a finish-validation decision journals,
+* the claim judge's `judgedHash`, the citation audit's `auditedHash`,
+* and `draftToFinal`'s pair, so one function answers "which document"
+* across every surface. Two facts an auditor needs spelled out: a
+* STRING document hashes as its JSON encoding (the quotes and escapes
+* included), not as raw text bytes; and exporting the text to a file
+* with a trailing newline changes the FILE's sha256 while this hash is
+* unchanged, verify against the exact value, never the file. The sixth
+* comparison experiment's auditor re-derived all of this from source
+* because no exported function said it.
+*/
+declare function candidateHashOf(candidate: unknown): string;
+/**
+* Verifies retained candidate bytes against a journaled candidateHash
+* (RV4207). The retained blob holds the candidate's TEXT verbatim (the
+* document itself for a string result, its JSON serialization
+* otherwise), while the hash covers the canonical VALUE, so the check
+* tries the value both ways: as the string document, then as parsed
+* JSON. Returns false on any mismatch or unparsable bytes, never
+* throws: the caller is an audit path, and a corrupt blob is a finding
+* there, not a crash.
+*/
+declare function verifyCandidateBytes(bytes: Uint8Array | string, hash: string): boolean;
 /** One failed validator on a journaled finish verdict, verbatim. */
 interface SynthesisCandidateFailure {
   name: string;
@@ -14557,11 +15249,27 @@ interface JournaledSynthesisCandidate {
   maxRepairs?: number;
   /** The contract generation the verdict was rendered under. */
   contractHash?: string;
-  /** The non-accepted candidate's identity (RV2507), when journaled. */
+  /**
+  * The candidate's identity (RV2507): the {@link candidateHashOf}
+  * hash and the char count. Journaled on every non-accepted verdict
+  * since RV2507, and on the ACCEPTED verdict too under a declared
+  * `candidatePersistence` (RV4207), where it names the resolved
+  * document (deterministic patch or sectional splice applied), so
+  * the whole chain reads by hash.
+  */
   candidateHash?: string;
   candidateChars?: number;
   /** The rejected candidate's transcript blob, under retention. */
   candidateRef?: string;
+  /**
+  * Why the candidate's BYTES are not retained (RV4207), from the
+  * decision itself: 'hash-only-persistence' names the declared
+  * policy, 'store-write-failed' a retention that was declared and
+  * refused by the store. Absent on journals written before the
+  * field, and everywhere no reason applies; a blob later deleted by
+  * retention leaves the hash and this field as the honest remainder.
+  */
+  bytesUnavailableReason?: string;
   /** The failed validators with their reasons, verbatim. */
   failed: readonly SynthesisCandidateFailure[];
   /** The hosting span's dispatch label (RV2901), when journaled. */
@@ -15191,13 +15899,20 @@ interface InvoiceExport {
   * genesis `execution_scope` decision: who this run executed for, as
   * the host named it, on the money document a FinOps pipeline
   * actually consumes. Absent on unscoped runs, so their exports keep
-  * their bytes.
+  * their bytes. The RV4205 dimensions ride the same object, and
+  * `executionScopeDigest` beside it is the fixed-length join column
+  * (present exactly when the genesis decision recorded one).
   */
   executionScope?: {
     tenant?: string;
     account?: string;
     project?: string;
+    legalDomain?: string;
+    region?: string;
+    providerAccount?: string;
   };
+  /** The canonical scope digest (RV4205), lifted from the same decision. */
+  executionScopeDigest?: string;
   /**
   * The unknown-outcome intent lane (RV4006): `provider-intent`
   * decisions (the 'intent' receipt posture journals one before every
@@ -16513,12 +17228,49 @@ interface CitationAuditRow {
   /** The range end when the citation is `path:start-end`. */
   endLine?: number;
   /**
+  * Which anchor of a compound sentence this row audits (RV4208,
+  * resolver v2 only): zero-based, in sentence order. Resolver v1
+  * samples only a sentence's FIRST anchor, so the field is absent
+  * there and on every earlier row.
+  */
+  anchorOrdinal?: number;
+  /**
+  * The claim clause NEAREST this row's anchor (RV4208, resolver v2
+  * only): the sentence segment, split at clause boundaries, that
+  * contains the anchor. A compound sentence cites three files for
+  * three different claims; judging each anchor against the WHOLE
+  * sentence asks whether the lines entail claims they were never
+  * cited for.
+  */
+  clause?: string;
+  /**
   * The resolved lines, `L<n>: <text>` per line. Absent when the
   * FIRST cited line does not resolve in the host snapshot, which is
   * itself an unsupported verdict: a citation nothing resolves is not
   * provenance (the citedValueValidator doctrine).
   */
   excerpt?: string;
+  /**
+  * What resolver v2 excerpted (RV4208): the bounded logical unit's
+  * type, its line count, and whether the caps clipped it. Absent
+  * under resolver v1, whose window is fixed and self-describing.
+  */
+  unit?: CitationExcerptUnit;
+}
+/** The bounded logical unit resolver v2 excerpts (RV4208). */
+interface CitationExcerptUnit {
+  /**
+  * 'section' a heading plus its body to the next heading; 'list-item'
+  * a list marker plus its continuation lines; 'table-row' a table row
+  * with its header pair when adjacent; 'comment-declaration' a code
+  * comment block plus the declaration it documents; 'paragraph' a
+  * blank-line-delimited run, the default.
+  */
+  type: "section" | "list-item" | "table-row" | "comment-declaration" | "paragraph";
+  /** Lines the excerpt carries. */
+  lines: number;
+  /** Present when the line or char caps clipped the unit. */
+  truncated?: true;
 }
 /** One judged (or mechanically decided) non-supported citation. */
 interface CitationAuditFinding {
@@ -16546,6 +17298,20 @@ interface CitationAuditPlanOptions {
   maxSampled?: number;
   /** Lines after the cited line an excerpt may carry; default 3. */
   window?: number;
+  /**
+  * The resolver generation (RV4208): 1, the default, is the fixed
+  * downward window above, byte identical for every existing config.
+  * 2 excerpts the bounded LOGICAL UNIT the cited line belongs to
+  * ({@link citationUnitExcerptOf}) and audits EVERY anchor of a
+  * compound sentence as its own row against its nearest claim
+  * clause. The sixth comparison experiment's false negatives were
+  * exactly window artifacts: a section heading whose support lives
+  * below the window, and only a sentence's first anchor ever
+  * sampled. Opt-in because the sample derives from the document
+  * hash: v2 changes which rows exist and what the judge reads, so a
+  * declared config must choose it.
+  */
+  resolver?: 1 | 2;
 }
 declare const DEFAULT_CITATION_SAMPLE_PER_SECTION = 2;
 declare const DEFAULT_CITATION_MAX_SAMPLED = 24;
@@ -16562,6 +17328,7 @@ declare function resolveCitationAuditPlan(options: CitationAuditPlanOptions): {
   samplePerSection: number;
   maxSampled: number;
   window: number;
+  resolver: 1 | 2;
 };
 /**
 * The deterministic stratified sample (RV4004): per H2 section, up to
@@ -16578,8 +17345,17 @@ declare function sampleCitationRows(document: string, plan: {
   pattern: string;
   samplePerSection: number;
   maxSampled: number;
+  resolver?: 1 | 2;
 }, seed: string): Omit<CitationAuditRow, "excerpt">[];
 /**
+* The claim clause nearest an anchor (RV4208): the sentence segment,
+* cut at clause boundaries (';' or ',' followed by whitespace), that
+* contains the anchor position. Pure text arithmetic, no NLP: the
+* point is to hand the judge the claim half the anchor was cited FOR
+* instead of the whole compound sentence.
+*/
+declare function clauseAround(sentence: string, anchorIndex: number): string;
+/**
 * Resolves one sampled citation's excerpt through the host's pure
 * snapshot resolver. The FIRST cited line failing to resolve returns
 * undefined (an unsupported citation by doctrine); later lines simply
@@ -16587,6 +17363,36 @@ declare function sampleCitationRows(document: string, plan: {
 * snapshot goes).
 */
 declare function citationExcerptOf(resolve: (target: CitationTarget) => string | undefined, row: Pick<CitationAuditRow, "path" | "line" | "endLine">, window: number): string | undefined;
+/**
+* Resolver v2's excerpt: the bounded LOGICAL UNIT the cited line
+* belongs to (RV4208), through the same pure line resolver v1 reads.
+* The v1 window is a fixed downward slice, and the sixth comparison
+* experiment's confirmed false negative was structural: a section
+* heading cited as the anchor with its support three lines below the
+* window. The unit rules, all bounded by {@link
+* MAX_CITATION_EXCERPT_LINES} and {@link MAX_CITATION_EXCERPT_CHARS}
+* with a `truncated` flag when clipped:
+*
+* - heading: the SECTION, the heading plus following lines to the
+*   next heading;
+* - table row: the row, with the header pair above it when adjacent;
+* - list item: the marker line plus its more-indented continuation
+*   lines;
+* - code comment: the comment BLOCK (expanded upward to its start)
+*   plus the declaration lines it documents, to the first blank line;
+* - anything else: the paragraph, expanded upward and downward to the
+*   nearest blank or heading line.
+*
+* An explicit `path:start-end` range keeps range semantics (the host
+* cited exact lines; second-guessing them would audit a different
+* citation): the ranged lines, clipped by the caps. The FIRST cited
+* line failing to resolve returns undefined, the unsupported-by-
+* doctrine verdict v1 renders.
+*/
+declare function citationUnitExcerptOf(resolve: (target: CitationTarget) => string | undefined, row: Pick<CitationAuditRow, "path" | "line" | "endLine">): {
+  excerpt: string;
+  unit: CitationExcerptUnit;
+} | undefined;
 /** The audit judge's structured verdict schema (mirrors the claim judge). */
 declare const CITATION_JUDGE_SCHEMA: {
   readonly type: "object";
@@ -16627,6 +17433,101 @@ declare function parseCitationVerdicts(output: unknown, rowIndexes: readonly num
   reason: string;
 }> | undefined;
 //#endregion
+//#region src/orchestrator/semantic-verdict.d.ts
+/**
+* The semantic terminal verdict (RV4209, the sixth comparison
+* experiment). The envelope has carried every semantic FACT for
+* releases (the claim meta, the audit meta, the waiver, the findings),
+* and still no surface answered the one production question in one
+* word: is this document semantically CLEAN? The CLI's `--strict`
+* deliberately keeps exit 0 on `partial` and `vacuous` (they break no
+* contract the pass declares), the experiment's run settled ok under a
+* standing waiver with three unsupported citations, and every consumer
+* re-derived the same verdict from four fields by hand, each with its
+* own bugs. This module is the ONE derivation: a pure fold over the
+* envelope's own facts, stamped onto the envelope by orchestrate, so
+* the CLI gate, the HTTP response, and the event stream read the SAME
+* verdict by construction instead of three re-derivations.
+*/
+/** The one-word semantic verdict plus the facts it was folded from. */
+interface SemanticTerminalVerdict {
+  /**
+  * The verdict, in refusal precedence order:
+  * - 'not-judged': semantic machinery was configured and nothing
+  *   usable judged the shipped document (a failed or declined judge,
+  *   or a draft-stage verdict the synthesis then rewrote);
+  * - 'findings': a judge ruled and defects stand (contradictions or
+  *   unsupported sampled citations);
+  * - 'waived': acceptance was licensed by a standing exception, not
+  *   by coverage;
+  * - 'partial': coverage graded below 'full' ('partial' or
+  *   'critical-uncovered') with no waiver standing;
+  * - 'vacuous': the document cited nothing, so the configured pass
+  *   verified nothing;
+  * - 'clean': every configured judge ruled on the shipped document
+  *   and found nothing.
+  */
+  verdict: "clean" | "findings" | "partial" | "vacuous" | "waived" | "not-judged";
+  /** The judged document's hash: the claim judgedHash, else the audit auditedHash. */
+  finalHash?: string;
+  /** The final claim-coverage grade, verbatim from the meta. */
+  coverage?: string;
+  /** Judged claim contradictions standing at settle. */
+  contradictions: number;
+  /** Sampled citations judged UNSUPPORTED at settle. */
+  unsupportedCitations: number;
+  /** Sampled citations judged partial at settle: findings, not stops. */
+  partialCitations: number;
+  /** Bounded semantic repair rounds the run actually dispatched. */
+  semanticRepairRounds: number;
+  /** The standing exception that licensed acceptance, when one did. */
+  waiver?: {
+    principal: string;
+    reason: string;
+    expiresAt?: string;
+    coverage: string;
+  };
+  /**
+  * Why nothing usable judged the document, when 'not-judged': stable
+  * codes ('claim-judge-failed', 'claim-judge-declined',
+  * 'citation-judge-failed', 'citation-judge-declined',
+  * 'draft-rewritten-unjudged'). Empty on every other verdict.
+  */
+  judgeFailures: string[];
+}
+/** The envelope facts the fold reads; every field optional and untrusted. */
+interface SemanticVerdictInput {
+  claimConsistencyMeta?: Record<string, unknown>;
+  citationAuditMeta?: Record<string, unknown>;
+  claimCoverageWaiver?: Record<string, unknown>;
+  draftToFinal?: Record<string, unknown>;
+}
+/**
+* Folds the one semantic verdict out of envelope facts (RV4209).
+* Returns undefined when NO semantic meta is present: nothing was
+* configured, nothing judged anything, and absence must keep meaning
+* NOT RECORDED rather than a fabricated verdict. Never throws on
+* malformed shapes: an untyped field reads as absent, and the verdict
+* degrades toward 'not-judged', the fail-closed direction.
+*/
+declare function semanticTerminalVerdictOf(input: SemanticVerdictInput): SemanticTerminalVerdict | undefined;
+/**
+* The production acceptance predicate (RV4209): the one boolean a
+* production consumer gates on, with the stable reason when it
+* refuses. A verdict is production-acceptable exactly when it exists
+* and reads 'clean': 'partial' and 'vacuous' are legal diagnostics
+* (strict keeps exit 0 on them by documented design), 'waived' is a
+* human exception a machine gate must surface rather than inherit,
+* and an ABSENT verdict means nothing judged anything, which a
+* production gate reads fail closed. Exported so the CLI's
+* `--acceptance-policy production`, a server consumer, and a host
+* pipeline apply the SAME rule instead of three re-derivations.
+*/
+declare function productionAcceptable(verdict: SemanticTerminalVerdict | undefined): {
+  ok: boolean;
+  reason?: string;
+};
+//#endregion
 //#region src/engine/events.d.ts
 /**
 * The distance between the telemetry counter bases of two consecutive
@@ -16818,17 +17719,24 @@ interface CriticalPath {
   postFanInMs?: number;
   /**
   * Summed wall of completed 'synthesize' spans (0 when none). Since
-  * RV1604 this is exactly `finalCompositionMs + semanticJudgeMs`,
-  * kept whole for existing consumers: the name predates the claim
-  * judge riding the same role, and the eighteenth comparison
-  * benchmark read a 54-second `synthesisMs` as a second final
-  * composition when the run had SKIPPED synthesis and the bucket was
-  * entirely the judge and its extract. Read the split fields.
+  * RV4206 this is exactly `finalCompositionMs + semanticJudgeMs +
+  * citationJudgeMs + unclassifiedSynthesisMs`, kept whole for
+  * existing consumers: the name predates the judges riding the same
+  * role, and the eighteenth comparison benchmark read a 54-second
+  * `synthesisMs` as a second final composition when the run had
+  * SKIPPED synthesis and the bucket was entirely the judge and its
+  * extract. Read the split fields.
   */
   synthesisMs: number;
   /**
-  * Completed 'synthesize' spans that ARE final composition (every
-  * synthesize span not labeled as the claim judge), summed (RV1604).
+  * Completed 'synthesize' spans that ARE final composition, summed
+  * (RV1604; classified through {@link synthesizeSpanClassOf} since
+  * RV4206): the engine's own composition labels plus every
+  * unlabelled span (composition was the only unlabelled engine
+  * dispatch before RV2901 named it). A span whose label this
+  * classifier does not know lands in `unclassifiedSynthesisMs`
+  * instead of here: the sixth comparison run read 368889 ms of
+  * "final composition" of which 154019 ms was the citation judge.
   */
   finalCompositionMs: number;
   /**
@@ -16849,6 +17757,32 @@ interface CriticalPath {
   /** The post draft half of the split; see `draftJudgeMs`. */
   finalJudgeMs: number;
   /**
+  * Completed 'synthesize' spans that are the citation entailment
+  * audit judge (labels {@link CITATION_JUDGE_LABEL} and its suffixed
+  * variants), summed (RV4206). Until this bucket existed the audit
+  * judge folded into `finalCompositionMs` on BOTH surfaces: the
+  * sixth comparison run's 368889 ms "composition" was 214870 ms of
+  * composition plus 154019 ms of this judge, `compositionSpans` then
+  * counted the judge as a second composition (the legible signature
+  * of a repair round on a run that had none), and `lastCandidateMs`
+  * stretched to the judge's end while the candidate had settled
+  * 154 seconds earlier.
+  */
+  citationJudgeMs: number;
+  /** Completed citation-judge synthesize spans, counted (RV4206). */
+  citationJudgeSpans: number;
+  /**
+  * Completed 'synthesize' spans whose label names NEITHER a judge
+  * nor a composition (RV4206): a vocabulary member this classifier
+  * does not know. Nonzero means the split beside it is a floor, and
+  * saying so is the whole point: an unknown synthesize label used to
+  * fold silently into `finalCompositionMs`, which is exactly how the
+  * citation judge hid there for four releases.
+  */
+  unclassifiedSynthesisMs: number;
+  /** Completed unclassified synthesize spans, counted; nonzero flags the split as a floor. */
+  unclassifiedSynthesisSpans: number;
+  /**
   * Completed composition-side synthesize spans, counted (RV3404): two
   * compositions on one run is the legible signature of the bounded
   * repair round (RV3307), and a count survives where milliseconds
@@ -16963,10 +17897,18 @@ interface PostFanInBreakdown {
   coordinationToolCallsByName: Record<string, number>;
   /** Completed 'synthesize' span wall clipped to the window. */
   synthesisMs: number;
-  /** The final-composition half of `synthesisMs`, clipped (RV1604). */
+  /** The composition share of `synthesisMs`, clipped (RV1604; RV4206 classification). */
   finalCompositionMs: number;
-  /** The claim-judge half of `synthesisMs`, clipped (RV1604). */
+  /** The claim-judge share of `synthesisMs`, clipped (RV1604). */
   semanticJudgeMs: number;
+  /** The citation-judge share of `synthesisMs`, clipped (RV4206). */
+  citationJudgeMs: number;
+  /**
+  * The unclassified share of `synthesisMs`, clipped (RV4206):
+  * nonzero flags the itemization as a floor, exactly like the
+  * top-level counter.
+  */
+  unclassifiedSynthesisMs: number;
   /** Union length of every covered interval above. */
   coveredMs: number;
   /** postFanInMs minus coveredMs, floored at zero. */
@@ -17007,6 +17949,49 @@ declare function isClaimJudgeLabel(label: string | undefined): boolean;
 */
 declare function claimJudgeStageOf(label: string | undefined): "draft" | "final" | undefined;
 /**
+* The label the citation entailment audit judge dispatches under
+* (RV4004; named here since RV4206 so the reducers and the
+* orchestrator share one constant, the CLAIM_JUDGE_LABEL precedent):
+* the audit judge rides role 'synthesize' exactly like the claim
+* judge, and until RV4206 no reducer knew its name, so its wall
+* folded into final composition on both surfaces.
+*/
+declare const CITATION_JUDGE_LABEL = "citation-entailment-judge";
+/**
+* Which audit pass a citation judge label names (RV4206): the exact
+* {@link CITATION_JUDGE_LABEL} is the first pass over the shipped
+* document, and every suffixed variant is a post round re-audit
+* (today `citation-entailment-judge-round`, the RV4004 round and the
+* RV4202 merged round both dispatch it). `undefined` for every other
+* label; one classifier for both reducers, the RV3302 doctrine.
+*/
+declare function citationJudgePassOf(label: string | undefined): "first" | "round" | undefined;
+/**
+* The ONE synthesize-span classifier both reducers fold through
+* (RV4206, the RV3302 doctrine extended from a judge predicate to the
+* whole vocabulary): the sixth comparison experiment's citation judge
+* (label {@link CITATION_JUDGE_LABEL}, role 'synthesize') was
+* recognized by neither reducer and fell into `finalCompositionMs` on
+* both, so the run's 368889 ms "composition" was half verdict, its
+* `compositionSpans: 2` faked a repair round's signature on a clean
+* run, and `lastCandidateMs` overshot the candidate by 154 seconds.
+*
+* - 'claim-judge': {@link claimJudgeStageOf} recognizes the label.
+* - 'citation-judge': {@link citationJudgePassOf} recognizes it.
+* - 'composition': the engine's own composition labels
+*   ({@link FINAL_COMPOSITION_LABEL}, {@link SYNTHESIS_NOTE_LABEL},
+*   suffixed variants included) and every UNLABELLED span: streams
+*   recorded before RV2901 carry no labels, and composition was the
+*   only unlabelled engine dispatch, so absence keeps its historical
+*   reading.
+* - 'unclassified': any OTHER label. A present label this classifier
+*   does not know is a NEW vocabulary member, and folding it silently
+*   into composition is exactly the failure this function exists to
+*   end; the reducers bucket it under `unclassifiedSynthesisMs` with
+*   its own nonzero span counter.
+*/
+declare function synthesizeSpanClassOf(label: string | undefined): "claim-judge" | "citation-judge" | "composition" | "unclassified";
+/**
 * Total length of the union of possibly overlapping intervals, exported
 * (RV3404) so the journal fold computes its window coverage through the
 * SAME arithmetic the live RV710 decomposition uses, never a sibling
@@ -17053,6 +18038,17 @@ declare function compileRegulatedProfile(input: {
   engine: CreateEngineOptions;
   run: RunOptions;
   orchestrate?: OrchestrateOptions;
+  /**
+  * The construction floor's strictness (RV4204). The default keeps
+  * the RV4101 posture: constructions exposing no descriptor are
+  * COUNTED into the hash as `unrecognized`, so the hash names its
+  * own blind spot. 'require-recognized' turns the count into a typed
+  * refusal naming the blind constructions: satisfiable since the
+  * first-party adapters and the reference executors attest (RV4204),
+  * so a compile with zero foreign constructions can now demand zero
+  * blind spots.
+  */
+  construction?: "require-recognized";
 }): RegulatedProfile;
 //#endregion
 //#region src/runner/sandbox-bridge.d.ts
@@ -17127,4 +18123,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, AcceptanceTailSpec, AcceptanceTailTerms, 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, ApprovalRevocationOutcome, 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, CITATION_JUDGE_SCHEMA, 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, CitationAuditFinding, CitationAuditPlanOptions, CitationAuditRow, CitationAuditSectionMeta, 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_EXCERPT_WINDOW, DEFAULT_CITATION_MAX_SAMPLED, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CITATION_SAMPLE_PER_SECTION, DEFAULT_CLAIM_JUDGE_MAX_TURNS, DEFAULT_COMPACTION_THRESHOLD, DEFAULT_ESCALATION_LIMITS, DEFAULT_EVIDENCE_CALLS_PER_ENTRY, DEFAULT_EVIDENCE_GRADE_PHRASES, DEFAULT_EVIDENCE_MIN_SHARE, DEFAULT_EVIDENCE_OVERHEAD_CALLS, DEFAULT_FINISH_MAX_REPAIRS, DEFAULT_FLAT_RESERVE_USD, DEFAULT_MAX_CHILDREN_PER_NODE, DEFAULT_MAX_CLAIM_PAIRS, DEFAULT_MAX_CONTRADICTIONS, DEFAULT_MAX_DEPTH, DEFAULT_MAX_EXCERPT_CHARS, DEFAULT_MAX_OSCILLATIONS_PER_KEY, DEFAULT_MAX_PAIR_EXCERPT_CHARS, DEFAULT_MAX_PINNED_WORKTREES, DEFAULT_MAX_POOL_PER_PAIR, DEFAULT_MAX_QUOTA_DENIALS, DEFAULT_MAX_REVISIONS_PER_RUN, DEFAULT_MAX_RUN_FACT_PAIRS, DEFAULT_MAX_TOTAL_SPAWNS, DEFAULT_MAX_TURNS, DEFAULT_MODEL_RETRY_ATTEMPTS, DEFAULT_NO_PROGRESS_TURNS, DEFAULT_PER_RUN_CONCURRENCY, DEFAULT_RETRY_POLICY, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DEFAULT_SYNTHESIS_MAX_TURNS, DEFAULT_SYNTHESIS_NOTE_MAX_TURNS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DelimitedStatementOptions, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, ExecutionScope, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishRepairHint, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, JournaledChild, JournaledChildRoster, JournaledCriticalPath, JournaledPostFanIn, JournaledSynthesisCandidate, JournaledSynthesisCandidateReport, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CITATION_EXCERPT_CHARS, MAX_CITATION_EXCERPT_LINES, 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, OpenWireIntent, OperationDisposition, OrchestrateAcceptance, OrchestrateCitationAudit, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDeterministicPatches, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, OutputContractManifest, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, RegulatedProfile, RejectedFinishCandidate, RepairLedger, RepairLedgerRound, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SectionalRoundPlan, SemanticPassSummary, SemanticPassesSummary, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, SynthesisCandidateFailure, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TelemetryScope, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminalTelemetryScopes, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCalibrationExclusion, ToolCalibrationReport, ToolCalibrationRow, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, ToolInit, type ToolRisk, ToolRuntime, type ToolSource, type ToolSourceSession, ToolsOption, ToolsetAttestation, TranscriptSerializationHook, type TranscriptStore, TriggerClass, TtlState, Usage, UsageLimits, UsageSlice, VerifiedRecommendation, WAIT_FOR_EVENTS_SCHEMA, WAIT_FOR_EVENTS_TOOL_NAME, WAKE_SUMMARY_RENDER_BUDGET_CHARS, WakeBudgetBlock, WakeDigest, WakeTrigger, WireCapacityEstimate, WireCapacitySpec, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, acceptanceJudgePasses, acceptanceTailRequiredUsd, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, applyClaimOps, applyFinishRepairHints, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationExcerptOf, citationTargetsValidator, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileRegulatedProfile, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, executionScopeKey, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatAcceptanceTailTerms, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, insertRunIdIntoSentence, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastMechanicalRepairCostUsd, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeExecutionScope, normalizeFallbacks, openWireIntentsOf, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseCitationVerdicts, parseModelRef, parseScopePath, parseTerminalEnvelope, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, repairLedgerFromJournal, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveCitationAuditPlan, resolveModelInvocation, resolvePricing, resolveToolset, retentionKeyOf, retryClassOf, retryDelayMs, retryWireMultiplier, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sampleCitationRows, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, scopeBucket, sectionCitationsValidator, sectionPatternCountValidator, sectionalRoundPlan, selectStructuredOutputTier, selfTestFinishValidation, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, wireCapacityEstimate, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };
+export { AWAIT_SCHEMA, AbandonAttempt, AbandonFold, AbandonPayload, AbandonedSpendView, AbortClass, AcceptanceChildSummary, AcceptanceTailSpec, AcceptanceTailTerms, 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 AiSdkBridgeRegulatedPosture, type AppliedPricingRow, ApproachSignatureInputs, ApprovalDecision, ApprovalIdentityInput, ApprovalRevocationOutcome, 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, CITATION_JUDGE_LABEL, CITATION_JUDGE_SCHEMA, 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, CitationAuditFinding, CitationAuditPlanOptions, CitationAuditRow, CitationAuditSectionMeta, CitationExcerptUnit, 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_EXCERPT_WINDOW, DEFAULT_CITATION_MAX_SAMPLED, DEFAULT_CITATION_PATTERN, DEFAULT_CITATION_SAMPLE, DEFAULT_CITATION_SAMPLE_PER_SECTION, 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, DIGEST_DRAFT_MAX_WORDS, DataKeyProvider, DebitResult, DecisionChainRow, DeclaredLadder, DedupIndex, DedupNote, DedupedClaims, DelimitedStatementOptions, DerivedKey, DeriverRegistry, type DeterminismConfig, DeterminismError, type DeterminismEvents, type DeterminismMode, DispositionRule, DispositionTable, DocumentedRates, DonorCandidate, DonorRef, DroppedItem, EMIT_RESULT_TOOL, EMPTY_AUTHORITY_HASH, EMPTY_SCHEMA_HASH, EMPTY_TOOLSET_HASH, ESCALATE_TOOL_NAME, ESCALATION_REPORT_SCHEMA, ESCALATION_REQUEST_SCHEMA, EVENT_SEGMENT_STRIDE, EXPOSURE_WAIT_SWEEP_MS, EffectiveUsageLimits, Effort, Engine, EngineDefaults, EngineQuotaConfig, EngineQuotaRuntime, EntryBillingFold, EntryBillingUnit, EntryKind, EntryRef, EntryStatus, EnvelopeEncryption, EnvelopeEncryptionOptions, ErrorClass, ErrorCode, ErrorPolicy, EscalatedResult, EscalationDecision, EscalationDecisionAbortedError, EscalationDigest, EscalationKind, EscalationLimits, EscalationOptions, EscalationReport, EscalationRequest, EventBus, EvidenceContract, type EvidenceRef, type ExecKeyDerivation, ExecutionScope, type ExecutorRegistry, type ExplorationSummary, ExtensionAppendInput, ExtensionDispatchSpec, ExternalIdentityInput, ExternalRegistry, ExtractNecessityInput, FINALIZE_SYNTHESIS_INSTRUCTION, FINAL_COMPOSITION_LABEL, FINISH_LESSON_CAP_CHARS, FINISH_SCHEMA, FINISH_SECTIONAL_SCHEMA, FINISH_TOOL_NAME, FUTURE_RATES_TOLERANCE_MS, FailRunError, FailoverTarget, FailoverTrigger, FallbackField, FallbackTrigger, FencedCodeMode, FileModelKnowledgeStore, FileModelKnowledgeStoreOptions, FileTranscriptStore, type FinalizationWindowBudget, FinishContract, FinishContractCitations, FinishContractGoldenReject, FinishContractManifest, FinishContractSectionPattern, FinishInfo, FinishRepairHint, FinishSelfTestFailure, FinishSelfTestFixtures, FinishSelfTestReport, FinishValidationChild, FinishValidationInput, FinishValidationSpec, FinishValidationVerdict, FinishValidator, GET_CHILD_RESULT_SCHEMA, GET_CHILD_RESULT_TOOL_NAME, GET_SETTLED_CHILD_RESULTS_SCHEMA, GET_SETTLED_CHILD_RESULTS_TOOL_NAME, Gate, GateAudit, type GateRecord, GitWorktreeProvider, GitWorktreeProviderOptions, GraftBoot, HashVersion, HookVerdict, IMPLEMENTATION_PROFILE_LIMITS, INBOX_PROPOSAL_TTL_DAYS, IN_FLIGHT_EXPOSURE_REFUSAL_PREFIX, IdentityInput, InMemoryStore, InMemoryTranscriptStore, InProcessRunner, IncrementalSynthesisResult, InvalidResolutionError, InvocationRole, type InvocationTable, InvoiceCardinality, InvoiceExport, InvoicePricingProvenance, InvoiceReconciliation, InvoiceRow, type IsolatedExecContext, type IsolatedExecRequest, type IsolatedExecutorTag, type IsolationProvider, type IsolationSpec, Issue$1 as Issue, JOURNAL_ENVELOPE_MARKER, JournalCompatSubCode, JournalCompatibilityError, JournalEntry, JournalIntegrityError, JournalMatcher, JournalMissError, JournalOperation, JournalOrderViolation, type JournalPricingSnapshot, JournalSealedError, JournalSerializationContext, JournalSerializationHook, type JournalStore, JournaledChild, JournaledChildRoster, JournaledCriticalPath, JournaledPostFanIn, JournaledSynthesisCandidate, JournaledSynthesisCandidateReport, type Json, JsonSchema, JsonlFileStore, KB_ACTIVE_CLAIMS_CAP, KB_CARD_RENDER_BUDGET_CHARS, type KbProposal, type KbProposalTrigger, KeyDeriver, KeyRing, KeyedLimiter, KnowledgeCasError, type KnowledgeSnapshot, LARGE_VALUE_WARN_BYTES, LEGACY_LTID_PREFIX, LEGACY_SIGNATURE_INPUTS, LINEAGE_SIG_VERSION, LadderSpec, type LeasableStore, type Lease, LeaseHeldError, Ledger, LineageCounters, LineageIndex, LineageRef, LineageRelation, LineageStats, LogicalRunTelemetry, LogicalTaskId, MASKED_SECRET, MAX_CHILD_RESULT_PAGE_CHARS, MAX_CITATION_EXCERPT_CHARS, MAX_CITATION_EXCERPT_LINES, MAX_CRITICAL_UNCOVERED, MAX_DEPTH_CEILING, MAX_RUN_FACTS_SHEET_CHARS, MAX_RUN_ID_LENGTH, MAX_TIMER_DELAY_MS, MAX_UNCOVERED_SENTENCES, MatchResult, McpConfig, type McpSourceRegulatedPosture, McpToolSource, MechanicalGateProfile, MechanicalGateVerdict, MemoryQuotaLimiter, type MetaLookupStore, type ModelAdapterRegulatedPosture, type ModelCaps, ModelChoice, type ModelClaim, ModelEpochInputs, type ModelKnowledgeHandle, type ModelKnowledgeStore, ModelListConstraint, ModelRef, ModelRetry, ModelSpec, Msg, NoProgressDetector, NodeId, NodeLinkValue, NonSerializableValueError, ORCHESTRATE_WORKFLOW_NAME, OnEscalation, OpenWireIntent, OperationDisposition, OrchestrateAcceptance, OrchestrateCitationAudit, OrchestrateClaimConsistency, OrchestrateClaimConsistencyMeta, OrchestrateContradictions, OrchestrateContradictionsMeta, OrchestrateDeterministicPatches, OrchestrateDraftToFinal, OrchestrateOptions, OrchestrateSemanticAcceptance, OrchestrateSynthesis, OrchestrateSynthesisSkipReason, OrchestratorBudgetSpec, OrchestratorCapConfigError, OrchestratorExtension, OrchestratorExtensionIO, OrchestratorRuntime, Out, OutputContractManifest, PARALLEL_AGENTS_SCHEMA, PROGRESS_REPORT_TOOL_NAME, ParallelSiteCounter, Part, PendingExternal, PendingToolTurn, PermissionConfig, PermissionGate, PermissionHook, PermissionPreset, PermissionRule, PermissionVerdict, PersistedTerminalRefusal, PersistedTerminalResult, type PhaseRow, PhaseTarget, PilotAgentProfileOptions, PilotAgentProfileResult, type PinnedPricingSegment, PipelineCollected, PipelineOpts, PlanInvariantError, type PostFanInBreakdown, PreflightAdmissionRow, PreflightFinding, PreflightInput, PreflightOrchestratorSpec, PreflightReport, PreflightSpawnReport, PreflightSpawnSpec, PreflightToolCeiling, PriceTable, PricedComponent, PricedComponents, PricedUsage, type Pricing, type PricingTier, ProgressReport, type ProviderAdapter, ProviderCallRecord, ProviderStatement, QUOTA_WINDOW_MS, QualityFloors, QuotaCounters, type QuotaDecision, type QuotaEstimate, type QuotaLimiter, type QuotaReservationRequest, QuotaRule, QuotaWindowSnapshot, READ_CHILD_ARTIFACT_SCHEMA, READ_CHILD_ARTIFACT_TOOL_NAME, RESEARCH_PROFILE_LIMITS, REVIEW_PROFILE_LIMITS, ROLE_EFFORT_DEFAULTS, ROOT_ACCOUNT, ROOT_SCOPE, RUN_FACTS_ANCHOR, RUN_PROFILES, RUN_SETTLE_DECISION_TYPE, RandIdentityInput, RandPayload, RateLimitObservation, ReconcileOptions, ReconcileResult, ReconcileStatementOptions, RefEntryAppender, RefEntryClassification, RefusalInfo, type RegulatedPostureDescriptor, RegulatedProfile, RejectedFinishCandidate, RepairLedger, RepairLedgerRound, RepeatedClaim, ReplayDisposition, ReplayMode, ReplayPlanHashMismatch, Replayer, RepositoryResearchToolset, RepositoryResearchToolsetOptions, ResearchAgentProfileOptions, ResearchAgentProfileResult, ResearchEvidenceEntry, ResolutionArbiter, ResolutionAttempt, ResolutionBy, ResolutionFold, ResolutionLayer, ResolutionOutcome, ResolutionPayload, ResolvedInvocation, ResolvedToolset, ResumeHandle, ResumeOptions, ResumePreview, ResumeReport, RetryClass, RetryPolicy, ReuseConfig, RiskRuleValue, Role, RulvarError, RulvarErrorCode, RunAgentOptions, RunAuditVerdict, RunBudget, RunEventSink, RunExport, RunFactPairOptions, RunFactPairsFold, RunFactsSheet, type RunFilter, RunHandle, RunInternals, type RunMeta, RunOptions, RunOutcome, RunProfile, RunStateAudit, RunStatus, RuntimeEventSink, SANDBOX_AGENT_OPT_KEYS, SPAWN_ADMISSION_DECISION_TYPE, SPAWN_AGENT_SCHEMA, SYNTHESIS_NOTE_LABEL, SandboxBridge, SandboxBridgeOptions, SandboxError, SandboxHostToWorker, SandboxMethod, SandboxWorkerToHost, SchemaPair, SchemaSpec, SchemaValidationResult, ScopePolicy, ScopeSegment, ScriptRejected, ScriptRunner, ScrubNote, SecretMasker, SectionMatchMode, SectionPatternEntry, SectionalRoundPlan, SemanticPassSummary, SemanticPassesSummary, SemanticTerminalVerdict, SemanticVerdictInput, Semaphore, SerializationHook, Settled, SettlementError, ShellPatternRules, ShellSegment, ShellVerdict, SinglePhaseAppend, SpanMinter, SpanRegistry, SpawnAdmissionValue, SpawnAgentParams, SpawnKey, SpawnLineage, SpawnLineageOpt, SpawnOrigin, SpawnRecord, Spend, Stage, type StandardJSONSchemaV1, type StandardSchemaV1, StatementCategoryRow, StatementColumnMap, StatementCoverage, StatementReconciliation, StatementRequestRow, StepIdentityInput, type StreamHooks, StructuredOutputTier, SupersededError, SuspendedAppend, SuspensionState, SynthesisCandidateFailure, TERMINAL_TELEMETRY_SCOPE, TOOL_NAME_PATTERN, type TaskClass, TaskDigest, TaskSpec, TelemetryScope, type TerminalEnvelope, TerminalOutcomeFacts, TerminalPatch, TerminalTelemetryScopes, TerminationAccount, TerminationAccountSnapshot, TerminationDeniedValue, TerminationDeniedWriter, TerminationInitValue, TerminationLimits, TerminationResource, ToolAuthority, type ToolBudgetSummary, ToolCalibrationExclusion, ToolCalibrationReport, ToolCalibrationRow, ToolCallRequest, ToolChoice, type ToolContext, ToolContextSeed, ToolContract, type ToolDef, type ToolEvents, type ToolExecutor, type ToolExecutorProvider, type ToolExecutorRegulatedPosture, 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, WireCapacityEstimate, WireCapacitySpec, WireError, Workflow, WorkflowCallOpts, type WorkflowEvent, type WorkflowEventBody, WorkflowRegistry, acceptanceJudgePasses, acceptanceTailRequiredUsd, accountSpendFromJournal, admissionReserveUsd, affordableOutputTokens, agentErrorFromWire, agentErrorToWire, agentResultWire, agentScope, agentTypeBucket, applyClaimOps, applyFinishRepairHints, applyStructuredOutputTier, approachSigCoarse, approachSigOf, archiveDeprecatedModelOps, assertFencedWrites, assertSafeRunId, atCompactionThreshold, attestToolset, attributionBucket, auditRun, auditRuns, buildAbandonFold, buildAdapterRegistry, buildCostReport, buildDeriverRegistry, buildOrchestratorTools, buildTerminationInitValue, buildToolContext, canRideLoopTurn, candidateHashOf, canonicalIsolationTag, canonicalizeLadder, canonicalizeSchema, capIssues, capsHashOf, checkFloors, checkpointRefFor, childCoveragePrefix, childRostersFromJournal, citationExcerptOf, citationJudgePassOf, citationTargetsValidator, citationUnitExcerptOf, citedValueValidator, claimCoverageOf, claimExpired, claimExpiry, claimIssues, claimJudgeStageOf, claimOpIssues, classifyAgentError, classifyAttemptOutcome, clauseAround, collectDeclaredLadders, compactMessages, compareRates, compilePermissionChain, compilePermissionPreset, compileRegulatedProfile, compileSecretMasker, compileVerifiedLayer, constantTimeEqual, costReportFromJournal, countsAgainstLimit, createCanonicalIdMinter, createCtx, createEngine, createEnvelopeEncryption, createSandboxBridge, criticalPathFromJournal, currentOnlyKeyRing, decodeCheckpoint, dedupeRepeatedClaims, defineWorkflow, deriveContentKey, deriverV1, deriverV2, digestOf, dispatchProjectionReserveUsd, dispositionHook, emptyDigestBlocks, emptyToolset, encodeCheckpoint, enforceToolsetAttestation, entryUsageSlices, escalateTool, evaluatePermission, evaluateReuse, evidenceGradeValidator, evidencePreservedValidator, executeWorkflow, executionFactsOf, executionScopeDigest, executionScopeKey, exhaustionCodeOf, extractCandidate, failoverTriggerOf, fallbackTriggerOf, filterClaimsForRun, finalizeFires, findContradictions, finishContract, foldLedger, foldTermination, formatAcceptanceTailTerms, formatCharacterValidator, formatRePrompt, formatScopePath, hasFencedWrites, hasMetaLookup, hashRunArgs, hashRunOutput, hashWorkflowBody, hashWorkflowSource, headingStructureValidator, identityJcs, implementationAgentProfile, insertRunIdIntoSentence, invoiceFromJournal, isClaimJudgeLabel, isEscalated, isSchemaPairSpec, isStandardSchemaSpec, isStrictCompatibleSchema, journalPricingSnapshot, kMaxOf, knowledgeHash, ladderLengthOf, ladderRungChoice, lastMechanicalRepairCostUsd, lastRunSettle, latestProgressReport, lexShellCommand, liftRetainedParts, lineageWeightOf, localKeyProvider, logicalRunTelemetry, makeOrchestratorWorkflow, manifestValidators, maskSecrets, maskSecretsDeep, maskSecretsJson, matchArgvPattern, matchShellCommand, mcp, memoryQuotaLimiter, mergeQuotaDenial, mergeUsageLimits, metaMatchesFilter, minMatchesValidator, modelEpochOf, modelKnowledgeCard, modelSpecIdentity, needsSeparateExtract, nextFailover, nodeLinkKey, normalizeApproachTag, normalizeEntry, normalizeExecutionScope, normalizeFallbacks, openWireIntentsOf, orchestrate, orchestratorAdmissionEstCostUsd, pairDraftClaims, pairRunFactClaims, parallelScope, parseCitationVerdicts, parseModelRef, parseScopePath, parseTerminalEnvelope, persistedTerminalEnvelope, phiInitialOf, pilotAgentProfile, pipelineScope, planNodeScope, preflightEstimate, priceComponentsOf, priceEntryBilling, priceEntryUsage, priceUsdOf, productionAcceptable, profileCard, profileRegistrySnapshotHash, progressReportTool, projectHistory, projectIdentity, projectToJsonSchema, proposalStatement, providerOf, quotaActualRequestsDelta, quotaActualTokens, quotaEstimateTokens, quotaRuleAdmission, quotaRuleKey, quotaRuleMatches, readRunMeta, readTerminationInit, reconcileRunMeta, reconcileStatement, reduceAuditTrail, reduceCriticalPath, reduceDecisionChain, reduceInvocationTable, registryKeyRing, remeasureQueue, renderContractRequirements, repairLedgerFromJournal, replayDisposition, repositoryResearchToolset, requiredFieldsValidator, requiredMentionsValidator, requiredSectionsValidator, researchAgentProfile, resolveCitationAuditPlan, resolveModelInvocation, resolvePricing, resolveToolset, retentionKeyOf, retryClassOf, retryDelayMs, retryWireMultiplier, reviewAgentProfile, roleConfiguredInRouting, roundOneDisposition, runAgent, runProfile, sampleCitationRows, sanitizeTerminalText, sanitizeTokenCount, sanitizeUsage, sanitizeUsageDelta, scanJournalCompatibility, schemaHash, schemaHashOfSpec, scopeBucket, sectionCitationsValidator, sectionPatternCountValidator, sectionalRoundPlan, selectStructuredOutputTier, selfTestFinishValidation, semanticTerminalVerdictOf, shouldCompact, snapshotQuotaRules, snapshotUsage, spawnDepthOf, spliceSections, statementFromRows, statementRowsFromDelimited, stripFencedBlocks, sumUsage, summarizeInstruction, summarizeOutput, synthesisCandidatesFromJournal, synthesizeSpanClassOf, terminalEnvelopeOf, terminationConfigDrift, tierWithinCaps, toApprovalDecision, toJournalValue, tool, toolAuthority, toolCalibrationFromJournal, toolContract, toolContractHash, toolsetAuthorityHash, toolsetHash, ttlState, unionOfIntervalsMs, usageViolations, validateDetachedResolution, validateEditorialCommit, validateEngineQuotaConfig, validateEntryShape, validateEscalationLimits, validateEscalationReport, validateQuotaRules, validateRetryPolicy, validateSchemaSpec, validateTerminationLimits, validateToolsetAttestation, validateUsageLimits, verifyCandidateBytes, wireCapacityEstimate, wordCountValidator, workflowScope, workflowSourceRef, wrapJournalStore, wrapTranscriptStore };