@rulvar/core 1.100.0 → 1.102.0

package/dist/index.d.ts

@@ -4719,26 +4719,47 @@ interface RunAgentOptions<S extends SchemaSpec = JsonSchema> {
   * already promised the raised cap), never re-admitted or re-announced,
   * and a restored window entry keeps the summary's
   * finalizationWindowEntered truthful even when a later grant moved the
-  * counts back out of the window. The hooks are fire-and-forget from
-  * the loop's view; pressure notices stay events and are never
-  * journaled. Absent, the loop is byte-identical to before.
+  * counts back out of the window.
+  *
+  * Both hooks are AWAITED before the thing they authorize becomes
+  * observable (RV601): a grant lifts no expiry and queues no notice
+  * until its decision is durable, and the window regime binds no call
+  * until its entry is. A rejected append therefore leaves the grant
+  * unissued and the entry unrecorded, and the rejection propagates
+  * exactly like a failed boundary checkpoint rather than being
+  * swallowed. Pressure notices stay events and are never journaled.
+  * Absent, the loop is byte-identical to before.
   */
   toolBudgetDurability?: {
     restored?: {
       extensionsGranted: number;
       finalizationWindowEntered: boolean;
+      /**
+      * The effective cap the journaled grant announced (RV602). It
+      * anchors the resumed ceiling, because the live `maxToolCalls`
+      * and `increment` are not part of the dispatch identity and may
+      * legitimately drift between segments: without the anchor the two
+      * recovery paths (pure replay, which reads the journal, and live
+      * resume, which recomputed) disagreed, and a promise already made
+      * to the model could be silently revoked. Validated as a
+      * persistent inlet: a non-integer, or one below the base cap, is
+      * ignored with a warning, leaving the count derivation as the
+      * floor. Grants taken AFTER the restore point still measure the
+      * current increment from this anchor.
+      */
+      cap?: number;
     };
     onExtensionGrant?: (grant: {
       grant: number;
       maxExtensions: number;
       toolCallsUsed: number;
       cap: number;
-    }) => void;
+    }) => Promise<void>;
     onWindowEntry?: (entry: {
       remaining: number;
       reserveCalls: number;
       budget: FinalizationWindowBudget;
-    }) => void;
+    }) => Promise<void>;
   };
   /** Emits agent:stream deltas when true (telemetry only). */
   stream?: boolean;
@@ -7909,6 +7930,32 @@ interface OrchestrateSynthesis {
   * accordingly).
   */
   context?: "digests" | "full";
+  /**
+  * The conditional synthesis gate (RV510, the ninth comparison
+  * experiment: synthesis returned the byte-identical draft after
+  * 101.3 s and 0.5512 USD, 57.3% of post-fan-in wall time). With
+  * `true`, before the 'single' synthesis span starts the coordination
+  * draft is run through the FULL declared finish contract (the same
+  * `finishValidation.validators` that would bind the synthesis
+  * finish): a draft that passes skips the synthesis invocation
+  * entirely under a journaled 'orchestrator_synthesis_skip' decision
+  * with reason 'synthesis_skipped_by_valid_draft' (the existing skip
+  * vocabulary; the info log and the acceptance envelope carry it), and
+  * a resume rolls the journaled skip forward with zero paid calls. A
+  * draft that fails any validator goes to synthesis exactly as before,
+  * with the repair budget untouched (the gate is a pre-pass, never a
+  * journaled validation verdict). Deterministic by construction: only
+  * the declared contract judges, never a semantic delta heuristic.
+  * Requires `finishValidation` (a ConfigError at intake otherwise:
+  * without a contract there is nothing to judge the draft valid by),
+  * which transitively limits it to mode 'single'. With a configured
+  * `budget.synthesisReserveUsd` the held money is released unconsumed
+  * on the skip and no reserve lifecycle journals: there was no
+  * synthesis invocation to account. Default false: the gate, the
+  * decision entry, and the envelope field are all absent, byte for
+  * byte.
+  */
+  skipWhenDraftValid?: boolean;
 }
 /**
 * The deterministic reconciliation envelope an 'incremental' synthesis
@@ -7943,15 +7990,22 @@ interface IncrementalSynthesisResult {
 * notes were already paid during the run; the skipped step is the free
 * deterministic reconciliation). 'synthesis_skipped_by_budget_cap': the
 * orchestrator budget cap froze the plan, and a capped run settles
-* through the reserved finalizer, never synthesis. The reason is frozen
-* into the journaled decision that caused the skip (the acceptance
-* decision or the budget-cap decision), spread into the typed
-* FailRunError data on the failing paths, and announced by an info
-* 'orchestrator synthesis skipped' log event; it is absent everywhere
-* when synthesis is not configured or actually ran, so existing runs
-* stay byte identical.
-*/
-type OrchestrateSynthesisSkipReason = "synthesis_skipped_by_acceptance" | "synthesis_skipped_by_budget_cap";
+* through the reserved finalizer, never synthesis.
+* 'synthesis_skipped_by_valid_draft' (RV510): the opt-in
+* `synthesis.skipWhenDraftValid` gate ran the coordination draft
+* through the full declared finish contract and every validator
+* passed, so the synthesis invocation had nothing to add and never
+* started; unlike the other two reasons the run still settles ok with
+* the draft as its result. The reason is frozen into the journaled
+* decision that caused the skip (the acceptance decision, the
+* budget-cap decision, or the 'orchestrator_synthesis_skip' decision),
+* spread into the typed FailRunError data on the failing paths and
+* into the acceptance envelope on the valid-draft path, and announced
+* by an info 'orchestrator synthesis skipped' log event; it is absent
+* everywhere when synthesis is not configured or actually ran, so
+* existing runs stay byte identical.
+*/
+type OrchestrateSynthesisSkipReason = "synthesis_skipped_by_acceptance" | "synthesis_skipped_by_budget_cap" | "synthesis_skipped_by_valid_draft";
 declare const ORCHESTRATE_WORKFLOW_NAME = "rulvar-orchestrate";
 /**
 * Resolves per-spawn dispatch options against the engine registries

package/dist/index.js

@@ -10927,7 +10927,17 @@ async function runAgent(options) {
 	let extensionGrants = 0;
 	let extensionEvidenceAtLastGrant = 0;
 	const pendingExtensionNotices = [];
-	const effectiveMaxToolCalls = () => limits.maxToolCalls === void 0 ? void 0 : extension === void 0 ? limits.maxToolCalls : limits.maxToolCalls + extensionGrants * extension.increment;
+	/**
+	* The ceiling the effective cap is measured from (RV602). The base cap
+	* normally, so a fresh loop is byte-identical arithmetic; the journaled
+	* cap of the restored grant when a resume carried one, so drifting live
+	* limits cannot revoke a raise the journal already recorded. Grants
+	* taken after the restore point count from here at the CURRENT
+	* increment, which is the live policy doing what it should.
+	*/
+	let capBase = limits.maxToolCalls;
+	let grantsOverCapBase = 0;
+	const effectiveMaxToolCalls = () => capBase === void 0 ? void 0 : extension === void 0 ? capBase : capBase + grantsOverCapBase * extension.increment;
 	/** The limiter that ended the loop; rides the RV304 pressure snapshot. */
 	let limitLimiter;
 	/** True once the finalization reserve summary turn actually ran. */
@@ -10979,7 +10989,7 @@ async function runAgent(options) {
 	* join the history.
 	*/
 	const tryToolBudgetGrant = () => {
-		if (extension === void 0 || limits.maxToolCalls === void 0) return false;
+		if (extension === void 0 || limits.maxToolCalls === void 0 || capBase === void 0) return false;
 		if (extensionGrants >= extension.maxExtensions) return false;
 		if (extension.requireNewEvidence !== false) {
 			if ((guard?.evidenceCount() ?? 0) <= extensionEvidenceAtLastGrant) return false;
@@ -10989,22 +10999,28 @@ async function runAgent(options) {
 			const floor = extension.minHeadroomUsd ?? 0;
 			if (floor > 0 ? remaining < floor : remaining <= 0) return false;
 		}
-		extensionGrants += 1;
-		extensionEvidenceAtLastGrant = guard?.evidenceCount() ?? 0;
-		const cap = limits.maxToolCalls + extensionGrants * extension.increment;
-		options.toolBudgetDurability?.onExtensionGrant?.({
-			grant: extensionGrants,
+		const grant = extensionGrants + 1;
+		const cap = capBase + (grantsOverCapBase + 1) * extension.increment;
+		const commit = () => {
+			extensionGrants = grant;
+			grantsOverCapBase += 1;
+			extensionEvidenceAtLastGrant = guard?.evidenceCount() ?? 0;
+			pendingExtensionNotices.push(toolBudgetExtensionNoticeText(grant, extension.maxExtensions, toolCallsUsed, cap));
+			events?.emit({
+				type: "log",
+				level: "info",
+				msg: `tool budget extended (grant ${String(grant)}/${String(extension.maxExtensions)}): maxToolCalls now ${String(cap)}`
+			});
+			return true;
+		};
+		const durable = options.toolBudgetDurability?.onExtensionGrant;
+		if (durable === void 0) return commit();
+		return durable({
+			grant,
 			maxExtensions: extension.maxExtensions,
 			toolCallsUsed,
 			cap
-		});
-		pendingExtensionNotices.push(toolBudgetExtensionNoticeText(extensionGrants, extension.maxExtensions, toolCallsUsed, cap));
-		events?.emit({
-			type: "log",
-			level: "info",
-			msg: `tool budget extended (grant ${String(extensionGrants)}/${String(extension.maxExtensions)}): maxToolCalls now ${String(cap)}`
-		});
-		return true;
+		}).then(commit);
 	};
 	const flushExtensionNotices = () => {
 		for (const text of pendingExtensionNotices.splice(0)) messages.push({
@@ -11058,19 +11074,26 @@ async function runAgent(options) {
 		if (finalizationWindow === void 0 || windowNoticeFired) return;
 		const state = windowActive();
 		if (state === void 0) return;
-		windowEntered = true;
-		windowNoticeFired = true;
-		options.toolBudgetDurability?.onWindowEntry?.({
+		const commit = () => {
+			windowEntered = true;
+			windowNoticeFired = true;
+			pendingWindowNotices.push(finalizationWindowNoticeText(state.remaining, finalizationWindow.reserveCalls, state.budget));
+			events?.emit({
+				type: "log",
+				level: "info",
+				msg: `finalization window entered: ${String(state.remaining)} of the reserved final ${String(finalizationWindow.reserveCalls)} ${state.budget} remain`
+			});
+		};
+		const durable = options.toolBudgetDurability?.onWindowEntry;
+		if (durable === void 0) {
+			commit();
+			return;
+		}
+		return durable({
 			remaining: state.remaining,
 			reserveCalls: finalizationWindow.reserveCalls,
 			budget: state.budget
-		});
-		pendingWindowNotices.push(finalizationWindowNoticeText(state.remaining, finalizationWindow.reserveCalls, state.budget));
-		events?.emit({
-			type: "log",
-			level: "info",
-			msg: `finalization window entered: ${String(state.remaining)} of the reserved final ${String(finalizationWindow.reserveCalls)} ${state.budget} remain`
-		});
+		}).then(commit);
 	};
 	const flushWindowNotices = () => {
 		for (const text of pendingWindowNotices.splice(0)) messages.push({
@@ -11127,6 +11150,7 @@ async function runAgent(options) {
 			extensionGrants = Math.min(extension.maxExtensions, Math.ceil((toolCallsUsed - limits.maxToolCalls) / extension.increment));
 			extensionEvidenceAtLastGrant = guard?.evidenceCount() ?? 0;
 		}
+		const derivedCap = limits.maxToolCalls === void 0 || extension === void 0 ? void 0 : limits.maxToolCalls + extensionGrants * extension.increment;
 		const durableRestored = options.toolBudgetDurability?.restored;
 		if (extension !== void 0 && durableRestored !== void 0) {
 			const journaled = Math.min(extension.maxExtensions, durableRestored.extensionsGranted);
@@ -11135,6 +11159,16 @@ async function runAgent(options) {
 				extensionEvidenceAtLastGrant = guard?.evidenceCount() ?? 0;
 			}
 		}
+		grantsOverCapBase = extensionGrants;
+		const journaledCap = durableRestored?.cap;
+		if (journaledCap !== void 0 && limits.maxToolCalls !== void 0 && derivedCap !== void 0) if (Number.isSafeInteger(journaledCap) && journaledCap >= limits.maxToolCalls) {
+			capBase = Math.max(journaledCap, derivedCap);
+			grantsOverCapBase = 0;
+		} else events?.emit({
+			type: "log",
+			level: "warn",
+			msg: `restored tool budget cap ${String(journaledCap)} is not an integer at or above the base cap ${String(limits.maxToolCalls)}; ignoring it and deriving from the counts`
+		});
 		if (windowActive() !== void 0 || finalizationWindow !== void 0 && durableRestored?.finalizationWindowEntered === true) {
 			windowEntered = true;
 			windowNoticeFired = true;
@@ -11231,7 +11265,10 @@ async function runAgent(options) {
 				return cap !== void 0 && toolCallsUsed >= cap ? "maxToolCalls" : guard !== void 0 && guard.unitsExhausted() ? "toolUnits" : void 0;
 			};
 			let expiredLimiter = expiryOf();
-			if (expiredLimiter === "maxToolCalls" && call.name !== options.terminalTool?.name && tryToolBudgetGrant()) expiredLimiter = expiryOf();
+			if (expiredLimiter === "maxToolCalls" && call.name !== options.terminalTool?.name) {
+				const attempt = tryToolBudgetGrant();
+				if (typeof attempt === "boolean" ? attempt : await attempt) expiredLimiter = expiryOf();
+			}
 			if (expiredLimiter !== void 0) {
 				const tail = calls.slice(index);
 				const terminalName = options.terminalTool?.name;
@@ -11419,10 +11456,14 @@ async function runAgent(options) {
 				};
 			}
 			if (finalizationWindow !== void 0) {
-				maybeMarkWindowEntry();
+				const entry = maybeMarkWindowEntry();
+				if (entry !== void 0) await entry;
 				let windowState = windowActive();
 				if (windowState !== void 0 && !windowAllows(gatedCall.name)) {
-					if (windowState.budget === "tool calls" && extension !== void 0 && windowState.remaining + extension.increment > finalizationWindow.reserveCalls && tryToolBudgetGrant()) windowState = windowActive();
+					if (windowState.budget === "tool calls" && extension !== void 0 && windowState.remaining + extension.increment > finalizationWindow.reserveCalls) {
+						const attempt = tryToolBudgetGrant();
+						if (typeof attempt === "boolean" ? attempt : await attempt) windowState = windowActive();
+					}
 					if (windowState !== void 0 && !windowAllows(gatedCall.name)) {
 						events?.emit({
 							type: "tool:end",
@@ -11492,7 +11533,8 @@ async function runAgent(options) {
 				});
 			}
 		}
-		maybeMarkWindowEntry();
+		const lastEntry = maybeMarkWindowEntry();
+		if (lastEntry !== void 0) await lastEntry;
 		return {
 			parts,
 			limitHit: false
@@ -14847,10 +14889,11 @@ function createCtx(internals, rootWorkflow) {
 			runAgentOptions.toolBudgetDurability = {
 				...durableRestored === void 0 ? {} : { restored: {
 					extensionsGranted: durableRestored.extensionsGranted,
-					finalizationWindowEntered: durableRestored.finalizationWindowEntered
+					finalizationWindowEntered: durableRestored.finalizationWindowEntered,
+					...durableRestored.cap === void 0 ? {} : { cap: durableRestored.cap }
 				} },
-				onExtensionGrant: (grant) => {
-					internals.replayer.appendSinglePhase({
+				onExtensionGrant: async (grant) => {
+					await internals.replayer.appendSinglePhase({
 						scope: state.scope,
 						key: "",
 						kind: "decision",
@@ -14863,8 +14906,8 @@ function createCtx(internals, rootWorkflow) {
 						}
 					});
 				},
-				onWindowEntry: (entry) => {
-					internals.replayer.appendSinglePhase({
+				onWindowEntry: async (entry) => {
+					await internals.replayer.appendSinglePhase({
 						scope: state.scope,
 						key: "",
 						kind: "decision",
@@ -16973,6 +17016,11 @@ function validateOrchestrateOptions(opts) {
 		if (synthesis.dedupeClaims !== void 0 && typeof synthesis.dedupeClaims !== "boolean") throw new ConfigError("orchestrate synthesis.dedupeClaims must be a boolean; got " + typeof synthesis.dedupeClaims);
 		const symmetry = synthesis;
 		if (symmetry.exposeChildResultTools !== void 0 && typeof symmetry.exposeChildResultTools !== "boolean") throw new ConfigError("orchestrate synthesis.exposeChildResultTools must be a boolean; got " + typeof symmetry.exposeChildResultTools);
+		const conditional = synthesis;
+		if (conditional.skipWhenDraftValid !== void 0) {
+			if (typeof conditional.skipWhenDraftValid !== "boolean") throw new ConfigError("orchestrate synthesis.skipWhenDraftValid must be a boolean; got " + typeof conditional.skipWhenDraftValid);
+			if (conditional.skipWhenDraftValid && opts.finishValidation === void 0) throw new ConfigError("orchestrate synthesis.skipWhenDraftValid 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));
 		if (synthesis.noteLimits !== void 0) validateUsageLimits(synthesis.noteLimits, "orchestrate synthesis.noteLimits");
 		if (synthesis.effort !== void 0 && ![
@@ -17980,6 +18028,24 @@ function makeOrchestratorWorkflow(goal, opts) {
 			if (decision.contractHash !== void 0) return decision.contractHash === hash;
 			return internals.replayer.snapshot().filter((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.value?.decisionType === "orchestrator_finish_validation_bundle").length <= 1;
 		};
+		/**
+		* The children snapshot (RV-202): spawn order, pure reads of the
+		* records the orchestrator already tracks, so validators can hold
+		* a finish result (or the RV510 draft pre-pass) against the
+		* evidence the children produced. Only the JOURNALED verdict of
+		* validateFinish survives; on replay the snapshot is never rebuilt
+		* because the entry is read by call id there.
+		*/
+		const validationChildren = () => {
+			const salvageOutputOn = opts?.acceptance?.acceptValidatedTerminalOutputOnLimit === true;
+			return [...records.values()].sort((a, b) => a.spawnOrdinal - b.spawnOrdinal).map((record) => ({
+				handle: record.handle,
+				nodeId: record.nodeId,
+				status: record.settled?.status ?? "running",
+				text: record.settled === void 0 ? "" : serializeChildOutput(record.settled),
+				...salvageOutputOn && record.settled?.status === "limit" && record.settled.output !== null && record.settled.output !== void 0 ? { salvageableOutput: true } : {}
+			}));
+		};
 		const validateFinish = async (call) => {
 			if (validationSpec === void 0) return { ok: true };
 			const maxRepairs = validationSpec.maxRepairs ?? 1;
@@ -17987,18 +18053,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 			let decision = known.find((candidate) => candidate.callId === call.id);
 			if (decision === void 0) {
 				const result = call.result ?? null;
-				const salvageOutputOn = opts?.acceptance?.acceptValidatedTerminalOutputOnLimit === true;
-				const children = [...records.values()].sort((a, b) => a.spawnOrdinal - b.spawnOrdinal).map((record) => ({
-					handle: record.handle,
-					nodeId: record.nodeId,
-					status: record.settled?.status ?? "running",
-					text: record.settled === void 0 ? "" : serializeChildOutput(record.settled),
-					...salvageOutputOn && record.settled?.status === "limit" && record.settled.output !== null && record.settled.output !== void 0 ? { salvageableOutput: true } : {}
-				}));
 				const input = {
 					result,
 					text: typeof result === "string" ? result : JSON.stringify(result),
-					children
+					children: validationChildren()
 				};
 				const failed = [];
 				for (const validator of validationSpec.validators) {
@@ -18392,11 +18450,94 @@ function makeOrchestratorWorkflow(goal, opts) {
 		* facts; absent everywhere when no reserve is configured.
 		*/
 		let synthesisReserveLifecycle;
+		/**
+		* Set exactly when the RV510 gate skipped the synthesis span (live
+		* pass and resume roll-forward alike); the acceptance envelope
+		* reports the machine reason through it.
+		*/
+		let synthesisSkippedByValidDraft = false;
 		const runSynthesis = async (draft) => {
 			const spec = opts?.synthesis;
 			if (spec === void 0) return draft;
 			await recoveryDone;
 			if (spec.mode === "incremental") return await reconcileIncremental(draft, spec);
+			if (spec.skipWhenDraftValid === true && validationSpec !== void 0) {
+				const skipKey = "synthesis-draft-valid-skip";
+				const announceSkip = (entryRef) => {
+					internals.events.emit({
+						type: "log",
+						level: "info",
+						msg: "orchestrator synthesis skipped",
+						data: {
+							reason: "synthesis_skipped_by_valid_draft",
+							skipDecisionRef: entryRef
+						}
+					}, callingState.spanId);
+				};
+				const draftValue = draft ?? null;
+				const draftHash = createHash("sha256").update(jcsSerialize(draftValue), "utf8").digest("hex");
+				const validatorNames = validationSpec.validators.map((validator) => validator.name);
+				/**
+				* A journaled skip is the authority only for the generation and
+				* the draft it judged (RV603). The documented remedy for a
+				* broken contract is to fix it and resume, and a verdict that
+				* outlives its contract defeats exactly that: the run would
+				* settle ok carrying output the CURRENT contract rejects.
+				* Bound by three facts, in descending strength: the contract
+				* identity (the same `contractGenerationCurrent` test the
+				* finish-validation decisions already use), the draft the
+				* verdict actually judged, and the validator names that
+				* rendered it. Entries written before this field existed carry
+				* no draftHash and stay reusable, so journals in flight roll
+				* forward byte for byte.
+				*/
+				const applies = (value) => contractGenerationCurrent(value) && (value.draftHash === void 0 || value.draftHash === draftHash) && (!Array.isArray(value.validators) || JSON.stringify(value.validators) === JSON.stringify(validatorNames));
+				const prior = internals.replayer.snapshot().filter((entry) => entry.kind === "decision" && entry.scope === callingState.scope && entry.key === skipKey).at(-1);
+				if (prior !== void 0 && applies(prior.value)) {
+					synthesisSkippedByValidDraft = true;
+					announceSkip(prior.seq);
+					return draft;
+				}
+				const input = {
+					result: draftValue,
+					text: typeof draftValue === "string" ? draftValue : JSON.stringify(draftValue),
+					children: validationChildren()
+				};
+				let allPassed = true;
+				for (const validator of validationSpec.validators) {
+					let verdict;
+					try {
+						verdict = validator.validate(input);
+					} catch (thrown) {
+						throw new ConfigError(`finish validator '${validator.name}' threw instead of returning a verdict during the skipWhenDraftValid pre-pass: ` + (thrown instanceof Error ? thrown.message : String(thrown)));
+					}
+					if (!verdict.ok) {
+						allPassed = false;
+						break;
+					}
+				}
+				if (allPassed) {
+					const skipEntry = await internals.replayer.appendSinglePhase({
+						scope: callingState.scope,
+						key: skipKey,
+						kind: "decision",
+						status: "ok",
+						spanId: internals.spans.mint(callingState.spanId),
+						site: "orchestrator-synthesis-skip",
+						value: {
+							decisionType: "orchestrator_synthesis_skip",
+							reason: "synthesis_skipped_by_valid_draft",
+							validators: validatorNames,
+							...validationSpec.contract === void 0 ? {} : { contractHash: validationSpec.contract.hash },
+							draftHash
+						}
+					});
+					if (orchestratorAccount !== void 0 && (opts?.budget?.synthesisReserveUsd ?? 0) > 0) internals.budget.releaseSynthesisReserve(orchestratorAccount);
+					synthesisSkippedByValidDraft = true;
+					announceSkip(skipEntry.seq);
+					return draft;
+				}
+			}
 			const exposeTools = spec.exposeChildResultTools === true;
 			const fullContext = spec.context === "full";
 			const synthesisToolNames = /* @__PURE__ */ new Set([FINISH_TOOL_NAME, ...exposeTools ? [GET_CHILD_RESULT_TOOL_NAME, READ_CHILD_ARTIFACT_TOOL_NAME] : []]);
@@ -18746,7 +18887,8 @@ function makeOrchestratorWorkflow(goal, opts) {
 			...decision.salvagedPartialChildren === void 0 ? {} : { salvagedPartialChildren: decision.salvagedPartialChildren },
 			...decision.salvagedTerminalOutputChildren === void 0 ? {} : { salvagedTerminalOutputChildren: decision.salvagedTerminalOutputChildren },
 			...envelopeSchemaRecovered === 0 ? {} : { schemaRecoveredFinishExchanges: envelopeSchemaRecovered },
-			...synthesisReserveLifecycle === void 0 ? {} : { synthesisReserve: synthesisReserveLifecycle }
+			...synthesisReserveLifecycle === void 0 ? {} : { synthesisReserve: synthesisReserveLifecycle },
+			...synthesisSkippedByValidDraft ? { synthesisSkipped: "synthesis_skipped_by_valid_draft" } : {}
 		};
 	});
 }

package/package.json

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