@rulvar/core 1.225.0 → 1.227.0

package/dist/index.d.ts

@@ -5225,6 +5225,17 @@ interface BudgetHooks {
   */
   remainingUsd?: () => number | undefined;
   /**
+  * Layer 2b asked of the IN-FLIGHT EXPOSURE ceiling (RV2503), wired
+  * only when the cap is configured: the output tokens the exposure
+  * room still affords for this prompt. The dispatch clamps to it too,
+  * so a turn whose full plan overshoots the exposure line is SHORTENED
+  * rather than refused while the budget can still pay for it. An
+  * answer below the serving model's output floor is ignored, so a
+  * genuine exposure exhaustion still refuses through
+  * `admitTurnExposure` with its own typed reason.
+  */
+  maxExposureOutputTokens?: (servedBy: ModelRef, estimatedInputTokens: number) => number | undefined;
+  /**
   * The in-flight exposure admission (RV711), wired only when the cap
   * is configured. Called synchronously right before each provider
   * dispatch attempt with the attempt's own request estimate: the
@@ -6270,6 +6281,8 @@ declare class RunBudget {
   * reservation surface is inert and reserveTurnExposure never binds.
   */
   readonly maxInFlightExposureUsd?: number;
+  /** The opt-in lone-dispatch clamp (RV2503); see maxExposureOutputTokens. */
+  private readonly clampTurnToExposure;
   private readonly lifetimeSpawnCap;
   private readonly events?;
   private readonly priceUsd?;
@@ -6334,7 +6347,8 @@ declare class RunBudget {
   private readonly invalidPriceWarned;
   constructor(options: {
     ceilingUsd?: number; /** The opt-in in-flight exposure cap (RV711); see reserveTurnExposure. */
-    maxInFlightExposureUsd?: number;
+    maxInFlightExposureUsd?: number; /** The opt-in lone-dispatch clamp (RV2503); see maxExposureOutputTokens. */
+    clampTurnToExposure?: boolean;
     lifetimeSpawnCap?: number;
     events?: RuntimeEventSink;
     priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined; /** Raw price-row resolution for the layer-2b output bound. */
@@ -6637,6 +6651,53 @@ declare class RunBudget {
   remainingUsd(accountScope?: string): number | undefined;
   maxAffordableOutputTokens(servedBy: ModelRef, estimatedInputTokens: number, accountScope?: string): number | undefined;
   /**
+  * The same layer-2b question asked of the IN-FLIGHT EXPOSURE ceiling
+  * (RV2503): the output tokens `cap - spent - live estimates` still
+  * affords from `servedBy` for an estimated prompt, priced by the
+  * settlement function like every other estimate here.
+  *
+  * The clamp above has always existed for the budget ceiling while
+  * {@link reserveTurnExposure} only ever answered yes or no, so a
+  * turn whose FULL planned output overshot the exposure line was
+  * refused outright even when a shorter one fit and the budget could
+  * pay for it. The 1.226.0 comparison run died exactly there: it held
+  * 0.8642 USD of budget, the exposure ceiling had 0.5642 USD of room,
+  * the mandatory repair turn was estimated at 0.7066 USD against an
+  * 18000 token output plan, and the dispatch was refused before any
+  * provider call. The same turn, re-issued after the operator raised
+  * the ceiling, wrote 12840 output tokens and cost 0.4788 USD: it fit
+  * the ceiling that refused it, and a clamp to the ~13253 tokens the
+  * room afforded would have let it run.
+  *
+  * Answered ONLY for a dispatch that is alone in flight, which is the
+  * whole difference between a refusal that means something and one
+  * that means nothing. With siblings live the refusal is TRANSIENT:
+  * RV1902 parks on it and the turn runs at its full planned length
+  * the moment one of them releases, so shortening it would trade a
+  * complete answer for a truncated one and buy nothing. With nothing
+  * live the refusal is PERMANENT (RV2003's sweep wakes such a waiter
+  * 'drained' precisely because no hold will ever return), and the
+  * only choices left are a shorter turn or no turn at all. The
+  * concurrent-wave bound of RV711 is therefore untouched.
+  *
+  * Opt-in through `RunOptions.clampTurnToExposure`, so the drained
+  * refusal terminals RV1902, RV2002 and RV2003 built out of live
+  * parity deaths keep their shapes until a host asks for this one.
+  *
+  * Undefined when the clamp is not armed, when the cap is not
+  * configured, when anything is in flight, or when the model has no
+  * price row, so a run that declares nothing keeps every byte of its
+  * historical path. Zero or
+  * negative when the room cannot even pay for the prompt, the same
+  * convention {@link maxAffordableOutputTokens} inherits from
+  * `affordableOutputTokens`; the caller decides what a sub-floor
+  * answer means, and the loop deliberately ignores one so a true
+  * exposure exhaustion still refuses through
+  * {@link reserveTurnExposure} with its own typed reason instead of
+  * an output-floor verdict.
+  */
+  maxExposureOutputTokens(servedBy: ModelRef, estimatedInputTokens: number): number | undefined;
+  /**
   * Live accounting; spend propagates from `accountScope` to every
   * ancestor. Crossing a ceiling severs the crossing account's subtree
   * via its layer-3 AbortSignal (overshoot bounded by one turn per
@@ -7630,6 +7691,33 @@ interface RunOptions {
   */
   maxInFlightExposureUsd?: number;
   /**
+  * Layer 2b against the exposure ceiling (RV2503), opt-in and
+  * meaningful only beside `maxInFlightExposureUsd`. Armed, a dispatch
+  * with NOTHING else in flight has its planned output clamped to the
+  * tokens the remaining exposure room affords instead of being
+  * refused outright, exactly as the budget ceiling has always clamped
+  * it. The 1.226.0 comparison run is the case: nothing was live, the
+  * budget still held 0.8642 USD, the mandatory repair turn's FULL
+  * 18000 token plan priced 0.7066 USD against 0.5642 USD of room, and
+  * the dispatch was refused before any provider call; the same work,
+  * re-issued after an operator raised the ceiling, wrote 12840 output
+  * tokens for 0.4788 USD. A refusal with nothing live buys nothing,
+  * because no hold will ever release to fund the full plan.
+  *
+  * Deliberately scoped and deliberately off by default. With siblings
+  * in flight the refusal is transient and the RV1902/RV2002 waits
+  * park on it, so the wave keeps the full-length turn RV711 promised
+  * and nothing here applies. When the room cannot even fund the
+  * serving model's output floor, the clamp stands aside and the
+  * dispatch refuses through the usual typed `in-flight-exposure`
+  * path, so the drained-refusal terminals (RV1902, RV2002, RV2003)
+  * keep their shapes. Absent, every byte of dispatch behavior is
+  * historical. Like `strictPricing`, this is a per-segment posture: it
+  * is not recorded in RunMeta and a resumed segment carries only what
+  * its own options declare.
+  */
+  clampTurnToExposure?: boolean;
+  /**
   * The opt-in strict pre-egress pricing gate (RV1508): every paid
   * dispatch must resolve a well-formed price row for its serving
   * model BEFORE the wire call, or the dispatch refuses typed
@@ -7988,6 +8076,15 @@ interface FinishValidationInput {
   * evidence the children actually produced.
   */
   readonly children?: readonly FinishValidationChild[];
+  /**
+  * The id of the run being judged (RV2501). Optional in the TYPE only
+  * so hand built inputs stay source compatible; the orchestrator
+  * runtime always supplies it, at every gate that judges a finish
+  * (the validator-bound finish, the contract draft gate, and the
+  * skipWhenDraftValid pre-pass), so a validator can accept the run's
+  * own id as the artifact a claim about THIS run points at.
+  */
+  readonly runId?: string;
 }
 /** The verdict of one validator over one finish attempt. */
 type FinishValidationVerdict = {
@@ -8281,7 +8378,22 @@ declare const DEFAULT_ARTIFACT_PATTERN = "(?:run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}|[\
 * paragraphs away no longer satisfies the grade. Purely textual: what
 * the referenced artifact contains is
 * {@link citedValueValidator}'s question, and whether it exists on
-* disk is the host's. Default name 'evidence-grade'.
+* disk is the host's.
+*
+* The run's OWN id is an artifact (RV2501). `DEFAULT_ARTIFACT_PATTERN`
+* only ever matched the literal word `run` followed by a ULID, so the
+* escape the verdict advertised was unreachable for every run whose id
+* the engine did not mint in that exact shape: the comparison run's
+* `comparison-rulvar-v12260-aug09-...` matched nothing, its synthesis
+* had no artifact it could name, and a document that told the truth
+* about the run it was part of could not be written at all. When
+* {@link FinishValidationInput.runId} is supplied (the orchestrator
+* runtime always supplies it), a sentence carrying that id verbatim as
+* a whole token satisfies the grade, and the verdict names the id so
+* the repair instruction is executable rather than aspirational. An id
+* shorter than `MIN_RUN_ID_ARTIFACT_CHARS` (six) is ignored, and
+* without an id the verdict is byte identical to the historical one.
+* Default name 'evidence-grade'.
 */
 declare function evidenceGradeValidator(options?: {
   /** Overrides {@link DEFAULT_EVIDENCE_GRADE_PHRASES}; matched case-insensitively. */phrases?: readonly string[]; /** Overrides {@link DEFAULT_ARTIFACT_PATTERN}. */
@@ -8314,6 +8426,27 @@ interface CitationTarget {
 * ({@link citationTargetsValidator} judges every citation with no such
 * precondition).
 *
+* One span class is IDENTITY, not assertion (RV2502, the 1.226.0
+* comparison run): a span naming the artefact under review says which
+* commit, run, or release the document is about, and asserts nothing
+* about any cited line. That run's synthesis wrote its frozen commit
+* sha beside source citations and the validator demanded the sha appear
+* in the cited source, an impossible repair, in the same verdict that
+* demanded three real value fixes; two granted repairs burned and the
+* finish was rejected. Three shapes are structural and always excluded:
+* a commit sha (12 to 64 hex characters, long enough that ordinary hex
+* literals stay judged), a release version (`1.2.3`, `v1.2.3`, with an
+* optional prerelease or build tail), and the run's own id when the
+* runtime supplies `runId`. Host vocabulary is declared: `notValues`
+* lists spans this document writes as identity, verdict words like
+* `conditionally ready` among them.
+*
+* The run-id exclusion is what makes the bundle self consistent
+* (RV2501, RV2202): the evidence grade instructs a failing model to
+* write this run's id inside the offending sentence, and before RV2502
+* doing so beside a citation traded an evidence-grade failure for a
+* cited-value one. The two repair instructions now compose.
+*
 * `resolve` is host code and must be PURE over a snapshot the host
 * froze before the run, exactly like every other finish validator: a
 * resolver that reads the filesystem live would make a verdict depend
@@ -8326,6 +8459,12 @@ declare function citedValueValidator(options: {
   resolve: (target: CitationTarget) => string | undefined; /** Lines AFTER the cited one that may carry the value; default 0. */
   window?: number; /** Overrides {@link DEFAULT_CITATION_PATTERN}; must capture `path:line`. */
   pattern?: string;
+  /**
+  * Spans this host writes as IDENTITY rather than as a value asserted
+  * about a citation (RV2502), matched whole and case sensitively.
+  * Commit shas, versions, and the run's own id need no declaration.
+  */
+  notValues?: readonly string[];
   name?: string;
 }): FinishValidator;
 /**
@@ -8606,16 +8745,26 @@ declare function pairRunFactClaims(draftText: string, sheet: RunFactsSheet, opti
 *
 * - `'full'`: every citing sentence the draft carries had at least one
 *   judged pair, nothing was cut by a bound, no declared critical
-*   anchor was missed, and the judge (when needed) settled ok. A draft
-*   with zero citing sentences grades `'full'` vacuously: there was
-*   nothing to verify, and saying `'partial'` would imply a subset was
-*   chosen.
+*   anchor was missed, and the judge (when needed) settled ok.
+* - `'vacuous'` (RV2508): the draft carried NO citing sentence, so the
+*   configured pass verified nothing. This used to grade `'full'` on
+*   the reasoning that saying `'partial'` would imply a subset was
+*   chosen, which is true and beside the point: `'full'` is the
+*   strongest word in the vocabulary and it was standing over a
+*   denominator of zero, the same silent green the grade exists to
+*   abolish, at its extreme.
 * - `'partial'`: the pass verified a strict subset: the pair bound
 *   truncated the fold, a run-facts bound truncated the run-claim
 *   pairs, or citing sentences exist that no judged pair covers.
 * - `'critical-uncovered'`: at least one DECLARED critical anchor got
 *   no judged pair; stronger than `'partial'` because the caller named
 *   exactly these claims as the ones that must not go unverified.
+* - `'judge-declined'` (RV2508): the judge invocation was refused
+*   ADMISSION and never dispatched (RV2106), so nothing was judged at
+*   all. It ranks with a failed judge and above everything the counts
+*   could say, because those counts describe a pass that did not
+*   happen; before this the flag was invisible to the grade and a
+*   declined judge over a citation-free draft graded `'full'`.
 * - `'judge-failed'`: the judge invocation did not settle ok, so
 *   nothing was judged at all; every other reading of the meta is
 *   moot.
@@ -8624,7 +8773,7 @@ declare function pairRunFactClaims(draftText: string, sheet: RunFactsSheet, opti
 * and total over metas written BEFORE the grade shipped, so a consumer
 * can grade a persisted outcome from an older engine.
 */
-type ClaimCoverageGrade = "full" | "partial" | "critical-uncovered" | "judge-failed";
+type ClaimCoverageGrade = "full" | "vacuous" | "partial" | "critical-uncovered" | "judge-declined" | "judge-failed";
 /** The subset of the claim-consistency meta the grade derives from. */
 interface ClaimCoverageInput {
   /** Draft sentences carrying at least one parsable anchor. */
@@ -8639,6 +8788,12 @@ interface ClaimCoverageInput {
   runFactPairsTruncated?: true;
   /** True when the judge invocation did not settle ok. */
   judgeFailed?: true;
+  /**
+  * True when the judge invocation was refused ADMISSION and never
+  * dispatched (RV2106). The orchestrator already spreads the flag into
+  * the meta it grades, so nothing at the call site changes.
+  */
+  judgeDeclined?: true;
 }
 /** Derives the {@link ClaimCoverageGrade} of a claim-consistency meta. */
 declare function claimCoverageOf(meta: ClaimCoverageInput): ClaimCoverageGrade;
@@ -10296,6 +10451,39 @@ interface OrchestrateSynthesis {
   */
   carryDraftGaps?: boolean;
   /**
+  * The no-regression floor under the synthesis (RV2505, the 1.226.0
+  * comparison run). That run's coordination draft satisfied the FULL
+  * declared contract, `skipWhenDraftValid` was off because the
+  * operator wanted the composing pass anyway, and the synthesis then
+  * failed the same bundle three times and died mid repair: the run
+  * settled with NO result at all, having paid for four workers, the
+  * draft that would have passed, and three rejected compositions.
+  * With `true`, a synthesis that fails terminally does not throw away
+  * a draft the contract accepts. The failure is caught at the
+  * post-fan-in chokepoint, the coordination draft is judged by the
+  * same `finishValidation.validators` that bind the synthesis finish,
+  * and a draft every validator accepts becomes the run result under a
+  * journaled 'orchestrator_synthesis_regressed' decision (the failure
+  * message, the validator names, the draft hash, the contract
+  * generation) plus a warn 'orchestrator synthesis regressed' log; the
+  * envelope carries `synthesisRegressed`. A draft that fails too
+  * journals 'orchestrator_synthesis_fallback_declined' naming ITS
+  * failing validators and the original failure rethrows untouched, so
+  * the decline is auditable instead of silent. Deterministic by
+  * construction: only the declared contract judges, never a quality
+  * heuristic, and the verdict is a pure function of the draft, so a
+  * resume re-derives it without re-running the paid invocation.
+  * Requires `finishValidation` (a ConfigError at intake otherwise:
+  * without a contract there is nothing to judge either document by),
+  * which transitively limits it to mode 'single'. Orthogonal to
+  * `skipWhenDraftValid`: that gate decides whether to PAY for the
+  * synthesis, this floor decides what to do when the paid one comes
+  * back worse than the draft, and with both on a valid draft skips
+  * before there is anything to regress. Default false: no catch, no
+  * decision entry, no envelope field, byte for byte.
+  */
+  fallbackToValidDraft?: boolean;
+  /**
   * The structured evidence index (RV808b): a deterministic per-child
   * citation map in the 'single' synthesis prompt, so the composing
   * model can target its reads instead of re-reading the whole
@@ -13277,7 +13465,11 @@ interface PreflightInput {
     * Mirrors FinishValidationSpec.maxRepairs (default
     * {@link DEFAULT_FINISH_MAX_REPAIRS}): with zero, the first
     * rejection is final and there is no repair exchange to fund, so
-    * the repair-reserve-unfunded warning stays silent.
+    * the repair-reserve-unfunded warning stays silent. It also SIZES
+    * the mandatory synthesis tail (RV2504): every granted repair can
+    * write to the output allowance, so the tail
+    * `synthesis-reserve-below-cap-composition` prices is one
+    * composition plus this many turns, whatever the turn reserve says.
     */
     maxRepairs?: number;
     /**

package/dist/index.js

@@ -10926,11 +10926,16 @@ function applyOutputBudget(req, target, budget) {
 	const floor = outputFloorOf(target);
 	if (req.maxOutputTokens !== void 0 && req.maxOutputTokens < floor) throw new ConfigError(`the per-turn output cap ${String(req.maxOutputTokens)} is below the ${String(floor)} token output floor of ${target.resolved.ref}; the provider would reject every dispatch, so raise limits.maxOutputTokensPerTurn to at least the floor`);
 	const hook = budget?.maxAffordableOutputTokens;
-	if (hook === void 0) return req;
-	const affordable = hook(target.resolved.ref, estimateInputTokens(req.messages));
+	const exposureHook = budget?.maxExposureOutputTokens;
+	if (hook === void 0 && exposureHook === void 0) return req;
+	const estimatedInput = estimateInputTokens(req.messages);
+	const budgetAffordable = hook?.(target.resolved.ref, estimatedInput);
+	const exposureAffordable = exposureHook?.(target.resolved.ref, estimatedInput);
+	const usableExposure = exposureAffordable !== void 0 && exposureAffordable >= floor ? exposureAffordable : void 0;
+	const affordable = budgetAffordable === void 0 ? usableExposure : usableExposure === void 0 ? budgetAffordable : Math.min(budgetAffordable, usableExposure);
 	if (affordable === void 0) return req;
 	if (affordable < floor) {
-		const zeroInputAffordable = hook(target.resolved.ref, 0);
+		const zeroInputAffordable = hook?.(target.resolved.ref, 0);
 		if (zeroInputAffordable !== void 0 && zeroInputAffordable < floor) throw new BudgetExhaustedError(floor === 1 ? `the remaining budget cannot afford one output token from ${target.resolved.ref}; the turn was not dispatched` : `the remaining budget cannot afford the ${String(floor)} token output floor of ${target.resolved.ref}; the turn was not dispatched`, { data: { reason: "output-floor" } });
 		return {
 			...req,
@@ -13572,7 +13577,12 @@ async function runAgent(options) {
 * model, and a turn that cannot afford one output token is denied before
 * dispatch. Layer 3: the AbortSignal ceiling severing live streams, with
 * partial usage written usageApprox.
-* B0 is immutable after start: no API tops it up.
+* B0 is immutable WITHIN a segment: no API tops up a live run's ceiling
+* (RV2511 corrects the older "immutable after start", which RV2208 made
+* false). The one thing that can change it is `ResumeOptions.run`, an
+* explicit host decision journaled as its own decision entry, and it
+* takes effect only by opening a NEW segment: a live run can never
+* raise the bound it is already being measured against.
 *
 * The account tree: the run root plus one
 * sub-account per admitted child workflow (and, from M7, the orchestrator
@@ -13677,6 +13687,8 @@ var RunBudget = class {
 	* reservation surface is inert and reserveTurnExposure never binds.
 	*/
 	maxInFlightExposureUsd;
+	/** The opt-in lone-dispatch clamp (RV2503); see maxExposureOutputTokens. */
+	clampTurnToExposure = false;
 	lifetimeSpawnCap;
 	events;
 	priceUsd;
@@ -13745,6 +13757,7 @@ var RunBudget = class {
 			requireValidCeiling(options.maxInFlightExposureUsd, "maxInFlightExposureUsd");
 			this.maxInFlightExposureUsd = options.maxInFlightExposureUsd;
 		}
+		this.clampTurnToExposure = options.clampTurnToExposure === true;
 		this.lifetimeSpawnCap = options.lifetimeSpawnCap ?? 500;
 		if (options.events !== void 0) this.events = options.events;
 		if (options.priceUsd !== void 0) this.priceUsd = options.priceUsd;
@@ -14327,6 +14340,59 @@ var RunBudget = class {
 		return affordableOutputTokens(pricing, remainingUsd, estimatedInputTokens);
 	}
 	/**
+	* The same layer-2b question asked of the IN-FLIGHT EXPOSURE ceiling
+	* (RV2503): the output tokens `cap - spent - live estimates` still
+	* affords from `servedBy` for an estimated prompt, priced by the
+	* settlement function like every other estimate here.
+	*
+	* The clamp above has always existed for the budget ceiling while
+	* {@link reserveTurnExposure} only ever answered yes or no, so a
+	* turn whose FULL planned output overshot the exposure line was
+	* refused outright even when a shorter one fit and the budget could
+	* pay for it. The 1.226.0 comparison run died exactly there: it held
+	* 0.8642 USD of budget, the exposure ceiling had 0.5642 USD of room,
+	* the mandatory repair turn was estimated at 0.7066 USD against an
+	* 18000 token output plan, and the dispatch was refused before any
+	* provider call. The same turn, re-issued after the operator raised
+	* the ceiling, wrote 12840 output tokens and cost 0.4788 USD: it fit
+	* the ceiling that refused it, and a clamp to the ~13253 tokens the
+	* room afforded would have let it run.
+	*
+	* Answered ONLY for a dispatch that is alone in flight, which is the
+	* whole difference between a refusal that means something and one
+	* that means nothing. With siblings live the refusal is TRANSIENT:
+	* RV1902 parks on it and the turn runs at its full planned length
+	* the moment one of them releases, so shortening it would trade a
+	* complete answer for a truncated one and buy nothing. With nothing
+	* live the refusal is PERMANENT (RV2003's sweep wakes such a waiter
+	* 'drained' precisely because no hold will ever return), and the
+	* only choices left are a shorter turn or no turn at all. The
+	* concurrent-wave bound of RV711 is therefore untouched.
+	*
+	* Opt-in through `RunOptions.clampTurnToExposure`, so the drained
+	* refusal terminals RV1902, RV2002 and RV2003 built out of live
+	* parity deaths keep their shapes until a host asks for this one.
+	*
+	* Undefined when the clamp is not armed, when the cap is not
+	* configured, when anything is in flight, or when the model has no
+	* price row, so a run that declares nothing keeps every byte of its
+	* historical path. Zero or
+	* negative when the room cannot even pay for the prompt, the same
+	* convention {@link maxAffordableOutputTokens} inherits from
+	* `affordableOutputTokens`; the caller decides what a sub-floor
+	* answer means, and the loop deliberately ignores one so a true
+	* exposure exhaustion still refuses through
+	* {@link reserveTurnExposure} with its own typed reason instead of
+	* an output-floor verdict.
+	*/
+	maxExposureOutputTokens(servedBy, estimatedInputTokens) {
+		const cap = this.maxInFlightExposureUsd;
+		if (!this.clampTurnToExposure || cap === void 0 || this.inFlightExposureUsd > 0) return;
+		const pricing = this.pricingOf?.(servedBy);
+		if (pricing === void 0) return;
+		return affordableOutputTokens(pricing, Math.max(0, cap - this.root.spentUsd), estimatedInputTokens);
+	}
+	/**
 	* Live accounting; spend propagates from `accountScope` to every
 	* ancestor. Crossing a ceiling severs the crossing account's subtree
 	* via its layer-3 AbortSignal (overshoot bounded by one turn per
@@ -18132,6 +18198,7 @@ function createCtx(internals, rootWorkflow) {
 				remainingUsd: () => internals.budget.remainingUsd(budgetAccount),
 				...internals.budget.strictPricing === void 0 ? {} : { assertPricedDispatch: (servedBy) => internals.budget.assertPricedDispatch(servedBy) },
 				...internals.budget.maxInFlightExposureUsd === void 0 ? {} : {
+					maxExposureOutputTokens: (servedBy, estimatedInputTokens) => internals.budget.maxExposureOutputTokens(servedBy, estimatedInputTokens),
 					admitTurnExposure: (servedBy, estimatedInputTokens, plannedOutputTokens) => internals.budget.reserveTurnExposure(servedBy, estimatedInputTokens, plannedOutputTokens, `agent:${running.seq}`),
 					awaitExposureRelease: (signal) => internals.budget.awaitExposureRelease(signal),
 					liveExposureUsd: () => internals.budget.liveExposureUsd
@@ -19954,6 +20021,29 @@ const MAX_LISTED_CITATIONS = 20;
 */
 const MAX_NAMED_OFFENDING_SENTENCES = 5;
 const MAX_OFFENDING_SENTENCE_CHARS = 240;
+/**
+* The shortest run id {@link evidenceGradeValidator} will accept as an
+* artifact (RV2501). The floor mirrors the id half of
+* {@link DEFAULT_ARTIFACT_PATTERN}: a two character id would satisfy
+* nearly every sentence by accident, which is the fail-open the empty
+* pattern guard exists to prevent. The id is additionally matched as a
+* whole identifier, so it cannot be credited from inside a longer
+* word, and only inside the sentence making the claim.
+*/
+const MIN_RUN_ID_ARTIFACT_CHARS = 6;
+/**
+* True when `value` occurs in `haystack` as a whole IDENTIFIER
+* (RV2501). Deliberately not {@link containsToken}: that boundary
+* class carries the dot, so an id written at the end of a sentence is
+* followed by the sentence period and would never be credited, which
+* is the most natural place to write one. Word characters alone bound
+* an id, so `x<id>y` is refused while `` `<id>` `` and `<id>.` are
+* credited. The value is matched literally (metacharacters escaped).
+*/
+function containsIdentifier(haystack, value) {
+	const escaped = value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+	return new RegExp(`(?<!\\w)${escaped}(?!\\w)`, "u").test(haystack);
+}
 function listCitations(values) {
 	return values.length <= MAX_LISTED_CITATIONS ? values.join(", ") : `${values.slice(0, MAX_LISTED_CITATIONS).join(", ")} and ${String(values.length - MAX_LISTED_CITATIONS)} more`;
 }
@@ -20228,7 +20318,22 @@ const DEFAULT_ARTIFACT_PATTERN = "(?:run[ -]?[0-9A-HJKMNP-TV-Z]{6,26}|[\\w./-]+\
 * paragraphs away no longer satisfies the grade. Purely textual: what
 * the referenced artifact contains is
 * {@link citedValueValidator}'s question, and whether it exists on
-* disk is the host's. Default name 'evidence-grade'.
+* disk is the host's.
+*
+* The run's OWN id is an artifact (RV2501). `DEFAULT_ARTIFACT_PATTERN`
+* only ever matched the literal word `run` followed by a ULID, so the
+* escape the verdict advertised was unreachable for every run whose id
+* the engine did not mint in that exact shape: the comparison run's
+* `comparison-rulvar-v12260-aug09-...` matched nothing, its synthesis
+* had no artifact it could name, and a document that told the truth
+* about the run it was part of could not be written at all. When
+* {@link FinishValidationInput.runId} is supplied (the orchestrator
+* runtime always supplies it), a sentence carrying that id verbatim as
+* a whole token satisfies the grade, and the verdict names the id so
+* the repair instruction is executable rather than aspirational. An id
+* shorter than `MIN_RUN_ID_ARTIFACT_CHARS` (six) is ignored, and
+* without an id the verdict is byte identical to the historical one.
+* Default name 'evidence-grade'.
 */
 function evidenceGradeValidator(options) {
 	const phrases = options?.phrases === void 0 ? [...DEFAULT_EVIDENCE_GRADE_PHRASES] : requireNonEmptyStrings(options.phrases, "evidenceGradeValidator phrases");
@@ -20246,10 +20351,11 @@ function evidenceGradeValidator(options) {
 		validate: (input) => {
 			const unsupported = [];
 			const offenders = [];
+			const runId = typeof input.runId === "string" && input.runId.trim().length >= MIN_RUN_ID_ARTIFACT_CHARS ? input.runId.trim() : void 0;
 			for (const sentence of sentencesOf(input.text)) {
 				const haystack = sentence.toLowerCase();
 				const found = lowered.filter((phrase) => haystack.includes(phrase));
-				if (found.length === 0 || new RegExp(artifactPattern, "").test(sentence)) continue;
+				if (found.length === 0 || new RegExp(artifactPattern, "").test(sentence) || runId !== void 0 && containsIdentifier(sentence, runId)) continue;
 				offenders.push(sentence);
 				for (const phrase of found) if (!unsupported.includes(phrase)) unsupported.push(phrase);
 			}
@@ -20262,7 +20368,7 @@ function evidenceGradeValidator(options) {
 			return {
 				ok: false,
 				reasons: [
-					`evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; give each such claim a file:line citation in its own sentence, or state its run id in a SEPARATE sentence carrying no source citation (a run id written beside a path:line citation is not in the cited window and trades this failure for a cited-value one)`,
+					runId === void 0 ? `evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; give each such claim a file:line citation in its own sentence, or state its run id in a SEPARATE sentence carrying no source citation (a run id written beside a path:line citation is not in the cited window and trades this failure for a cited-value one)` : `evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; write this run's id ${runId} inside each such sentence, or give the claim a file:line citation instead (the id may share a sentence with a source citation: cited-value reads a run id as identity, not as a value asserted about the cited line)`,
 					...named,
 					...overflow > 0 ? [`and ${String(overflow)} more offending sentences`] : []
 				]
@@ -20273,6 +20379,15 @@ function evidenceGradeValidator(options) {
 /** Splits a citation into its path and line halves at the LAST colon. */
 const CITATION_TAIL$1 = /^(.*):(\d+)$/u;
 /**
+* A commit sha span (RV2502). Twelve hex characters is the floor: real
+* abbreviations run 7 to 12 and full shas 40, while shorter hex words
+* (`deadbeef`) are ordinary literals a document may legitimately assert
+* about a cited line, so they stay judged.
+*/
+const COMMIT_SHA_SPAN = /^[0-9a-f]{12,64}$/u;
+/** A release version span (RV2502), with an optional tail. */
+const VERSION_SPAN = /^v?\d+\.\d+\.\d+(?:[-+][0-9A-Za-z][0-9A-Za-z.-]*)?$/u;
+/**
 * True when `value` occurs in `haystack` as a WHOLE token (RV1402, the
 * seventeenth comparison experiment P0-1). Substring matching credited
 * an asserted `3` against a line that says `30`, so the validator
@@ -20308,6 +20423,27 @@ function containsToken(haystack, value) {
 * ({@link citationTargetsValidator} judges every citation with no such
 * precondition).
 *
+* One span class is IDENTITY, not assertion (RV2502, the 1.226.0
+* comparison run): a span naming the artefact under review says which
+* commit, run, or release the document is about, and asserts nothing
+* about any cited line. That run's synthesis wrote its frozen commit
+* sha beside source citations and the validator demanded the sha appear
+* in the cited source, an impossible repair, in the same verdict that
+* demanded three real value fixes; two granted repairs burned and the
+* finish was rejected. Three shapes are structural and always excluded:
+* a commit sha (12 to 64 hex characters, long enough that ordinary hex
+* literals stay judged), a release version (`1.2.3`, `v1.2.3`, with an
+* optional prerelease or build tail), and the run's own id when the
+* runtime supplies `runId`. Host vocabulary is declared: `notValues`
+* lists spans this document writes as identity, verdict words like
+* `conditionally ready` among them.
+*
+* The run-id exclusion is what makes the bundle self consistent
+* (RV2501, RV2202): the evidence grade instructs a failing model to
+* write this run's id inside the offending sentence, and before RV2502
+* doing so beside a citation traded an evidence-grade failure for a
+* cited-value one. The two repair instructions now compose.
+*
 * `resolve` is host code and must be PURE over a snapshot the host
 * froze before the run, exactly like every other finish validator: a
 * resolver that reads the filesystem live would make a verdict depend
@@ -20318,6 +20454,9 @@ function containsToken(haystack, value) {
 */
 function citedValueValidator(options) {
 	if (typeof options.resolve !== "function") throw new ConfigError("citedValueValidator resolve must be a function");
+	if (options.notValues !== void 0) {
+		if (!Array.isArray(options.notValues) || options.notValues.some((value) => typeof value !== "string" || value.length === 0)) throw new ConfigError("citedValueValidator notValues must be an array of non empty strings");
+	}
 	const window = options.window ?? 0;
 	if (!Number.isInteger(window) || window < 0) throw new ConfigError(`citedValueValidator window must be a non negative integer; got ${String(window)}`);
 	const pattern = options.pattern ?? "[\\w./-]+\\.\\w+:\\d+";
@@ -20326,10 +20465,17 @@ function citedValueValidator(options) {
 	} catch (thrown) {
 		throw new ConfigError(`citedValueValidator pattern does not compile: ${thrown instanceof Error ? thrown.message : String(thrown)}`);
 	}
+	const declaredNotValues = new Set(options.notValues ?? []);
 	return {
 		name: options.name ?? "cited-value",
 		validate: (input) => {
 			const reasons = [];
+			const runId = typeof input.runId === "string" && input.runId.trim().length >= MIN_RUN_ID_ARTIFACT_CHARS ? input.runId.trim() : void 0;
+			/**
+			* True when the span NAMES the artefact under review instead of
+			* asserting something about a cited line (RV2502).
+			*/
+			const isIdentity = (span) => declaredNotValues.has(span) || span === runId || COMMIT_SHA_SPAN.test(span) || VERSION_SPAN.test(span);
 			for (const sentence of sentencesOf(input.text)) {
 				const spans = [...sentence.matchAll(/`([^`]+)`/gu)].map((match) => match[1]);
 				const citations = [];
@@ -20341,7 +20487,7 @@ function citedValueValidator(options) {
 						path: parsed[1],
 						line
 					});
-					else values.push(span);
+					else if (!isIdentity(span)) values.push(span);
 				}
 				if (citations.length === 0 || values.length === 0) continue;
 				for (const citation of citations) {
@@ -20917,8 +21063,10 @@ function pairRunFactClaims(draftText, sheet, options) {
 /** Derives the {@link ClaimCoverageGrade} of a claim-consistency meta. */
 function claimCoverageOf(meta) {
 	if (meta.judgeFailed === true) return "judge-failed";
+	if (meta.judgeDeclined === true) return "judge-declined";
 	if ((meta.criticalUncoveredTotal ?? 0) > 0) return "critical-uncovered";
 	if (meta.truncated || meta.runFactPairsTruncated === true || meta.coveredCitingSentences < meta.draftCitingSentences) return "partial";
+	if (meta.draftCitingSentences === 0) return "vacuous";
 	return "full";
 }
 //#endregion
@@ -21545,6 +21693,11 @@ function validateOrchestrateOptions(opts) {
 			if (typeof conditional.carryDraftGaps !== "boolean") throw new ConfigError("orchestrate synthesis.carryDraftGaps must be a boolean; got " + typeof conditional.carryDraftGaps);
 			if (conditional.carryDraftGaps && conditional.skipWhenDraftValid !== true) throw new ConfigError("orchestrate synthesis.carryDraftGaps requires skipWhenDraftValid: the gaps ARE the failed pre-pass verdict, and without the pre-pass there is nothing to carry");
 		}
+		const floor = synthesis.fallbackToValidDraft;
+		if (floor !== void 0) {
+			if (typeof floor !== "boolean") throw new ConfigError("orchestrate synthesis.fallbackToValidDraft must be a boolean; got " + typeof floor);
+			if (floor && opts.finishValidation === void 0) throw new ConfigError("orchestrate synthesis.fallbackToValidDraft requires finishValidation: without a declared finish contract there is nothing to judge the draft valid by");
+		}
 		if (symmetry.context !== void 0 && symmetry.context !== "digests" && symmetry.context !== "full") throw new ConfigError("orchestrate synthesis.context must be 'digests' or 'full'; got " + JSON.stringify(symmetry.context));
 		const index = synthesis.evidenceIndex;
 		if (index !== void 0) {
@@ -22900,7 +23053,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const input = {
 					result,
 					text: typeof result === "string" ? result : JSON.stringify(result),
-					children: validationChildren()
+					children: validationChildren(),
+					runId: internals.runId
 				};
 				const failed = [];
 				for (const validator of validationSpec.validators) {
@@ -23013,7 +23167,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const input = {
 					result,
 					text,
-					children: validationChildren()
+					children: validationChildren(),
+					runId: internals.runId
 				};
 				for (const validator of validationSpec?.validators ?? []) {
 					let verdict;
@@ -23848,7 +24003,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 					const input = {
 						result: draftValue,
 						text: typeof draftValue === "string" ? draftValue : JSON.stringify(draftValue),
-						children: validationChildren()
+						children: validationChildren(),
+						runId: internals.runId
 					};
 					const failed = [];
 					for (const validator of validationSpec.validators) {
@@ -24036,13 +24192,14 @@ function makeOrchestratorWorkflow(goal, opts) {
 					}
 					return `RUN FACTS: ${JSON.stringify({
 						scope: "settled-children-only",
+						runId: internals.runId,
 						children: settledEntries.length,
 						byStatus: Object.fromEntries(Object.keys(byStatus).sort().map((status) => [status, byStatus[status]])),
 						wireRequests,
 						wireIdsMissing,
 						inputTokens,
 						outputTokens
-					})} (live-observed by this run's own harness; production evidence it is not; the settled children ONLY, excluding this orchestrator, judges, and synthesis; the whole run's totals are the terminal envelope and invoice)`;
+					})} (live-observed by run ${internals.runId}, this run's own harness; production evidence it is not; the settled children ONLY, excluding this orchestrator, judges, and synthesis; the whole run's totals are the terminal envelope and invoice)`;
 				})()] : [],
 				`GOAL: ${goal}`,
 				`DRAFT: ${draftJson}`,
@@ -24403,6 +24560,83 @@ function makeOrchestratorWorkflow(goal, opts) {
 			} : { ran: true },
 			synthesis
 		});
+		/**
+		* The no-regression fallback verdict (RV2505), set only when the
+		* floor actually caught a failing synthesis: the truncated failure
+		* message and the journal seq of the decision that recorded it.
+		*/
+		let synthesisRegressed;
+		/**
+		* The no-regression floor under the synthesis (RV2505, the 1.226.0
+		* comparison run): a synthesis that fails terminally must not throw
+		* away a coordination draft the SAME declared contract accepts.
+		* Judges the draft with the validator bundle, journals what it
+		* found either way, and answers whether the caller should settle on
+		* the draft instead of rethrowing. Pure: the verdict is a function
+		* of the draft and the validators, so a resume that re-fails the
+		* synthesis re-derives the identical answer, and the journaled
+		* decision is reused rather than duplicated.
+		*/
+		const draftFallbackOnRegression = async (draft, thrown) => {
+			if (!(opts?.synthesis?.fallbackToValidDraft === true) || validationSpec === void 0) return { used: false };
+			if (thrown instanceof ConfigError) return { used: false };
+			const draftValue = draft ?? null;
+			const draftHash = createHash("sha256").update(jcsSerialize(draftValue), "utf8").digest("hex");
+			const validatorNames = validationSpec.validators.map((validator) => validator.name);
+			const input = {
+				result: draftValue,
+				text: typeof draftValue === "string" ? draftValue : JSON.stringify(draftValue),
+				children: validationChildren()
+			};
+			const failed = [];
+			for (const validator of validationSpec.validators) {
+				let verdict;
+				try {
+					verdict = validator.validate(input);
+				} catch (validatorThrew) {
+					throw new ConfigError(`finish validator '${validator.name}' threw instead of returning a verdict during the fallbackToValidDraft judgement: ` + (validatorThrew instanceof Error ? validatorThrew.message : String(validatorThrew)));
+				}
+				if (!verdict.ok) failed.push({
+					name: validator.name,
+					reasons: verdict.reasons
+				});
+			}
+			const regressed = failed.length === 0;
+			const reason = (thrown instanceof Error ? thrown.message : String(thrown)).slice(0, 300);
+			const key = deriverV2.deriveKey({ kind: regressed ? "orchestrator-synthesis-regressed" : "orchestrator-synthesis-fallback-declined" });
+			const entryRef = internals.replayer.snapshot().find((entry) => entry.kind === "decision" && entry.key === key)?.seq ?? (await internals.replayer.appendSinglePhase({
+				scope: callingState.scope,
+				key,
+				kind: "decision",
+				status: "ok",
+				spanId: internals.spans.mint(callingState.spanId),
+				site: "orchestrator-synthesis-fallback",
+				value: {
+					decisionType: regressed ? "orchestrator_synthesis_regressed" : "orchestrator_synthesis_fallback_declined",
+					reason,
+					validators: validatorNames,
+					...regressed ? {} : { failed },
+					...validationSpec.contract === void 0 ? {} : { contractHash: validationSpec.contract.hash },
+					draftHash
+				}
+			})).seq;
+			internals.events.emit({
+				type: "log",
+				level: "warn",
+				msg: regressed ? "orchestrator synthesis regressed" : "orchestrator synthesis fallback declined",
+				data: {
+					reason,
+					decisionRef: entryRef,
+					...regressed ? {} : { draftFailed: failed.map((row) => row.name) }
+				}
+			}, callingState.spanId);
+			if (!regressed) return { used: false };
+			synthesisRegressed = {
+				reason,
+				decisionRef: entryRef
+			};
+			return { used: true };
+		};
 		const enrichSynthesisFailure = (thrown, snapshot) => {
 			const passTruth = {
 				...claimConsistencyMeta === void 0 ? {} : { claimConsistencyMeta },
@@ -24445,6 +24679,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				return await runSynthesis(result.output);
 			} catch (thrown) {
 				await journalSynthesisAdmissionDecline(thrown);
+				if ((await draftFallbackOnRegression(result.output, thrown)).used) return result.output;
 				return enrichSynthesisFailure(thrown);
 			}
 		}
@@ -24652,7 +24887,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 			synthesizedFinal = await runSynthesis(result.output);
 		} catch (thrown) {
 			await journalSynthesisAdmissionDecline(thrown);
-			enrichSynthesisFailure(thrown, {
+			if ((await draftFallbackOnRegression(result.output, thrown)).used) synthesizedFinal = result.output;
+			else enrichSynthesisFailure(thrown, {
 				completion: decision.completion,
 				childStatusCounts: decision.childStatusCounts,
 				degradedReasons: decision.degradedReasons,
@@ -24676,6 +24912,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			...envelopeSchemaRecovered === 0 ? {} : { schemaRecoveredFinishExchanges: envelopeSchemaRecovered },
 			...synthesisReserveLifecycle === void 0 ? {} : { synthesisReserve: synthesisReserveLifecycle },
 			...synthesisSkippedByValidDraft ? { synthesisSkipped: "synthesis_skipped_by_valid_draft" } : {},
+			...synthesisRegressed === void 0 ? {} : { synthesisRegressed },
 			...contradictionsFound === void 0 ? {} : {
 				contradictions: contradictionsFound,
 				contradictionsMeta
@@ -25337,12 +25574,18 @@ function preflightEstimate(input) {
 							cacheReadTokens: 0,
 							cacheWriteTokens: 0
 						});
-						const repairTurns = finishRepairReserve > 0 ? 1 : 0;
-						const requiredUsd = compositionUsd * (1 + repairTurns);
-						if (declared < requiredUsd) say({
-							severity: "warning",
+						const grantedRepairs = input.finishValidation === void 0 ? 0 : input.finishValidation.maxRepairs ?? 1;
+						const tailTurns = 1 + grantedRepairs;
+						const requiredUsd = compositionUsd * tailTurns;
+						const exposureCapUsd = input.run?.maxInFlightExposureUsd;
+						const reserveLineUsd = ceilingUsd === void 0 ? void 0 : ceilingUsd - declared;
+						const exposureRoomUsd = exposureCapUsd === void 0 || reserveLineUsd === void 0 ? void 0 : exposureCapUsd - reserveLineUsd;
+						const reserveShort = declared < requiredUsd;
+						const exposureShort = exposureRoomUsd !== void 0 && exposureRoomUsd < requiredUsd;
+						if (reserveShort || exposureShort) say({
+							severity: reserveShort && exposureShort ? "error" : "warning",
 							code: "synthesis-reserve-below-cap-composition",
-							message: `a synthesis turn writing to its ${String(outputBound)} token output allowance over the declared ${String(synthesis.estInputTokens ?? 0)} input floor prices about ${compositionUsd.toFixed(4)} USD at the rates of '${servedBy}'` + (repairTurns > 0 ? `, and the declared repair reserve prices one more such turn (about ${requiredUsd.toFixed(4)} USD total)` : "") + `; the committed synthesis reserve holds only ${declared.toFixed(4)} USD, so a composition cut at the allowance can fail its validators with no money left for the granted repair; hold the reserve at the cap arithmetic or lower maxOutputTokensPerTurn`,
+							message: `the mandatory synthesis tail is ${String(tailTurns)} turn(s) (one composition ` + (grantedRepairs === 0 ? "and no granted repair" : `plus the ${String(grantedRepairs)} granted repair(s)`) + `), each writing to its ${String(outputBound)} token output allowance over the declared ${String(synthesis.estInputTokens ?? 0)} input floor: ${String(tailTurns)} x ${compositionUsd.toFixed(4)} = ${requiredUsd.toFixed(4)} USD at the rates of '${servedBy}'` + (reserveShort ? `; the committed synthesis reserve holds only ${declared.toFixed(4)} USD` : `; the committed ${declared.toFixed(4)} USD reserve covers it`) + (exposureRoomUsd === void 0 ? "" : exposureShort ? `, and maxInFlightExposureUsd ${(exposureCapUsd ?? 0).toFixed(4)} leaves only ${exposureRoomUsd.toFixed(4)} USD above the reserve line ${(reserveLineUsd ?? 0).toFixed(4)} USD` : `, and the exposure ceiling leaves ${exposureRoomUsd.toFixed(4)} USD above the reserve line`) + ": a composition cut at the allowance can fail its validators with no room left for the repairs the runtime will grant; hold the reserve at the tail arithmetic, raise maxInFlightExposureUsd toward the ceiling, lower maxOutputTokensPerTurn, or grant fewer repairs",
 							spawn: "synthesis"
 						});
 					}
@@ -26513,6 +26756,7 @@ function createEngine(options) {
 		if (wf.kind !== "workflow" && wf.kind !== "compiled-workflow") throw new ConfigError("engine.run accepts in-process Workflow values or compileScript CompiledWorkflow values");
 		if (opts?.budgetUsd !== void 0) requireNonNegativeNumber(opts.budgetUsd, "RunOptions.budgetUsd");
 		if (opts?.maxInFlightExposureUsd !== void 0) requireNonNegativeNumber(opts.maxInFlightExposureUsd, "RunOptions.maxInFlightExposureUsd");
+		if (opts?.clampTurnToExposure !== void 0 && typeof opts.clampTurnToExposure !== "boolean") throw new ConfigError("RunOptions.clampTurnToExposure must be a boolean; got " + JSON.stringify(opts.clampTurnToExposure));
 		if (opts?.strictPricing !== void 0 && typeof opts.strictPricing !== "boolean" && (typeof opts.strictPricing !== "object" || opts.strictPricing === null || Array.isArray(opts.strictPricing))) throw new ConfigError("RunOptions.strictPricing must be a boolean or an options object; got " + JSON.stringify(opts.strictPricing));
 		if (opts?.limits !== void 0) validateUsageLimits(opts.limits, "RunOptions.limits");
 		const deadlineAtMs = opts?.deadlineAt === void 0 ? void 0 : parseDeadlineAt(opts.deadlineAt);
@@ -26550,6 +26794,7 @@ function createEngine(options) {
 		const makeBudget = () => new RunBudget({
 			...ceilingUsd === void 0 ? {} : { ceilingUsd },
 			...exposureCapUsd === void 0 ? {} : { maxInFlightExposureUsd: exposureCapUsd },
+			...opts?.clampTurnToExposure === true ? { clampTurnToExposure: true } : {},
 			...strictPricing === void 0 ? {} : {
 				strictPricing,
 				now: realNow

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/core",
-  "version": "1.225.0",
+  "version": "1.227.0",
   "description": "Rulvar core: L0 contracts, journal kernel, ctx primitives, agent runtime, model router, tool system, dynamic orchestrator, InMemory and JSONL stores, event stream.",
   "type": "module",
   "license": "Apache-2.0",