@rulvar/core 1.79.0 → 1.80.0

package/dist/index.d.ts

@@ -4925,6 +4925,8 @@ interface BudgetAccountView {
   spentUsd: number;
   committedReserveUsd: number;
   finalizeReserveUsd: number;
+  /** The synthesis payload hold (cycle 76); zero when none is committed. */
+  synthesisReserveUsd: number;
   parentScope?: string;
 }
 /**
@@ -5081,6 +5083,21 @@ declare class RunBudget {
   * frozen past the cap, so nothing else can take it.
   */
   releaseFinalizeReserve(scope: string): void;
+  /**
+  * Registers the synthesis payload reserve (the sixth comparison
+  * experiment, cycle 76): absolute dollars held on the orchestrator
+  * account AND the run root, so neither spawn admission nor the
+  * per-turn output clamp lets the coordination prefix eat the money
+  * the synthesis finish needs. Unlike the finalize reserve it is
+  * released BEFORE the synthesis invocation dispatches (the held
+  * money is exactly what that invocation is meant to spend), and it
+  * never joins the severing check: a coordination running against the
+  * hold is clamped smaller, never aborted. Idempotent per account:
+  * re-registering adjusts the root by the delta.
+  */
+  commitSynthesisReserve(scope: string, reserveUsd: number): void;
+  /** The synthesis dispatch consumes its reserve; see commitSynthesisReserve. */
+  releaseSynthesisReserve(scope: string): void;
   /** The reserve is replaced by real spend when the spawn settles. */
   releaseReserve(reserveUsd: number, accountScope?: string): void;
   /** Layer 2: the per-turn guard. A turn that would cross any ceiling in the chain is not dispatched. */
@@ -7124,6 +7141,21 @@ interface OrchestratorBudgetSpec {
   */
   finalizeReserveUsd?: number;
   /**
+  * The synthesis payload reserve (the sixth comparison experiment,
+  * cycle 76): absolute USD held out of the orchestrator sub account
+  * while the coordination loop runs, released to the synthesis
+  * invocation just before it dispatches. Without it a pricey
+  * coordination can leave the synthesis turns a remainder the budget
+  * clamp shrinks below the contract's minimal accepting payload: the
+  * finish is then cut at the output allowance before any tool call,
+  * the invocation dies at maxTurns, and a validator-bound run fails
+  * closed (the rematch run 1 lost an entire paid run exactly there).
+  * Requires the `synthesis` option (single mode); must stay below the
+  * effective cap. Declaring it changes budget arithmetic only; absent
+  * keeps every account byte identical.
+  */
+  synthesisReserveUsd?: number;
+  /**
   * A positive integer, validated before any journal entry or dispatch:
   * the turn limit of the reserved final wake.
   */

package/dist/index.js

@@ -12141,6 +12141,7 @@ var RunBudget = class {
 			spentUsd: 0,
 			committedReserveUsd: 0,
 			finalizeReserveUsd: 0,
+			synthesisReserveUsd: 0,
 			controller: new AbortController()
 		};
 		if (options.ceilingUsd !== void 0) root.ceilingUsd = options.ceilingUsd;
@@ -12185,6 +12186,7 @@ var RunBudget = class {
 			spentUsd: 0,
 			committedReserveUsd: 0,
 			finalizeReserveUsd: options.finalizeReserveUsd ?? 0,
+			synthesisReserveUsd: 0,
 			parentScope,
 			controller: new AbortController()
 		};
@@ -12236,7 +12238,8 @@ var RunBudget = class {
 			scope: account.scope,
 			spentUsd: account.spentUsd,
 			committedReserveUsd: account.committedReserveUsd,
-			finalizeReserveUsd: account.finalizeReserveUsd
+			finalizeReserveUsd: account.finalizeReserveUsd,
+			synthesisReserveUsd: account.synthesisReserveUsd
 		};
 		if (account.ceilingUsd !== void 0) view.ceilingUsd = account.ceilingUsd;
 		if (account.parentScope !== void 0) view.parentScope = account.parentScope;
@@ -12250,7 +12253,7 @@ var RunBudget = class {
 	remainderOf(scope) {
 		const account = this.accounts.get(scope);
 		if (account?.ceilingUsd === void 0) return;
-		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd);
+		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd);
 	}
 	/**
 	* The tightest allowance headroom on the chain of `scope`: the minimum
@@ -12320,7 +12323,7 @@ var RunBudget = class {
 		const chain = this.chainOf(accountScope);
 		for (const account of chain) {
 			if (account.ceilingUsd === void 0) continue;
-			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd;
+			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd + account.synthesisReserveUsd;
 			if (committed >= account.ceilingUsd || committed + reserveUsd > account.ceilingUsd) {
 				if (account.scope === "run") this.exhaustedInternal = true;
 				throw new BudgetExhaustedError(`budget ceiling reached on account '${account.scope}': spent ${account.spentUsd.toFixed(4)} USD plus committed reserves ${(account.committedReserveUsd + account.finalizeReserveUsd).toFixed(4)} USD plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
@@ -12375,6 +12378,34 @@ var RunBudget = class {
 		this.root.finalizeReserveUsd = 0;
 		this.emitUpdate();
 	}
+	/**
+	* Registers the synthesis payload reserve (the sixth comparison
+	* experiment, cycle 76): absolute dollars held on the orchestrator
+	* account AND the run root, so neither spawn admission nor the
+	* per-turn output clamp lets the coordination prefix eat the money
+	* the synthesis finish needs. Unlike the finalize reserve it is
+	* released BEFORE the synthesis invocation dispatches (the held
+	* money is exactly what that invocation is meant to spend), and it
+	* never joins the severing check: a coordination running against the
+	* hold is clamped smaller, never aborted. Idempotent per account:
+	* re-registering adjusts the root by the delta.
+	*/
+	commitSynthesisReserve(scope, reserveUsd) {
+		const account = this.accounts.get(scope);
+		if (account === void 0) throw new ConfigError(`unknown budget account '${scope}' for the synthesis reserve`);
+		const previous = account.synthesisReserveUsd;
+		account.synthesisReserveUsd = reserveUsd;
+		if (account.scope !== "run") this.root.synthesisReserveUsd = Math.max(0, this.root.synthesisReserveUsd + reserveUsd - previous);
+		this.emitUpdate();
+	}
+	/** The synthesis dispatch consumes its reserve; see commitSynthesisReserve. */
+	releaseSynthesisReserve(scope) {
+		const account = this.accounts.get(scope);
+		if (account === void 0 || account.synthesisReserveUsd === 0) return;
+		if (account.scope !== "run") this.root.synthesisReserveUsd = Math.max(0, this.root.synthesisReserveUsd - account.synthesisReserveUsd);
+		account.synthesisReserveUsd = 0;
+		this.emitUpdate();
+	}
 	/** The reserve is replaced by real spend when the spawn settles. */
 	releaseReserve(reserveUsd, accountScope = "run") {
 		for (const account of this.chainOf(accountScope)) account.committedReserveUsd = Math.max(0, account.committedReserveUsd - reserveUsd);
@@ -12407,7 +12438,7 @@ var RunBudget = class {
 		let remainingUsd;
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const headroom = account.ceilingUsd - account.spentUsd;
+			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd;
 			remainingUsd = remainingUsd === void 0 ? headroom : Math.min(remainingUsd, headroom);
 		}
 		if (remainingUsd === void 0) return;
@@ -16159,6 +16190,11 @@ function validateOrchestrateOptions(opts) {
 	if (spec.capUsd !== void 0) requireNonNegativeNumber(spec.capUsd, "orchestrate budget.capUsd");
 	if (spec.capFraction !== void 0) requireFraction(spec.capFraction, "orchestrate budget.capFraction");
 	if (spec.finalizeReserveUsd !== void 0) requireNonNegativeNumber(spec.finalizeReserveUsd, "orchestrate budget.finalizeReserveUsd");
+	if (spec.synthesisReserveUsd !== void 0) {
+		requireNonNegativeNumber(spec.synthesisReserveUsd, "orchestrate budget.synthesisReserveUsd");
+		if (opts.synthesis === void 0) throw new ConfigError("orchestrate budget.synthesisReserveUsd requires the synthesis option: the reserve holds sub account money for the separate synthesis invocation");
+		if (opts.synthesis.mode === "incremental") throw new ConfigError("orchestrate budget.synthesisReserveUsd is incompatible with synthesis.mode 'incremental': the reserve protects the single post-fan-in invocation");
+	}
 	if (spec.finalizeTurns !== void 0) requirePositiveInteger(spec.finalizeTurns, "orchestrate budget.finalizeTurns");
 	if (spec.atCap !== void 0 && spec.atCap !== "finish-with-partial" && spec.atCap !== "fail-run") throw new ConfigError(`orchestrate budget.atCap must be 'finish-with-partial' or 'fail-run'; got ${String(spec.atCap)}`);
 }
@@ -16308,12 +16344,14 @@ function makeOrchestratorWorkflow(goal, opts) {
 					liveValue: internals.pricingVersion ?? "unpriced"
 				}] : []);
 				orchestratorAccount = callingState.scope === "" ? "orchestrator" : `${callingState.scope}/orchestrator`;
+				if (spec?.synthesisReserveUsd !== void 0 && frozen.capUsd <= spec.synthesisReserveUsd) throw new OrchestratorCapConfigError(`effectiveCap ${frozen.capUsd.toFixed(4)} USD is not above the synthesis reserve ${spec.synthesisReserveUsd.toFixed(4)} USD`);
 				internals.budget.openAccount(orchestratorAccount, {
 					parentScope: callingState.budgetScope ?? "run",
 					ceilingUsd: frozen.capUsd,
 					kind: "orchestrator-cap"
 				});
 				if (extension !== void 0) internals.budget.commitFinalizeReserve(orchestratorAccount, frozen.finalizeReserveUsd);
+				if (spec?.synthesisReserveUsd !== void 0 && spec.synthesisReserveUsd > 0) internals.budget.commitSynthesisReserve(orchestratorAccount, spec.synthesisReserveUsd);
 				capState = {
 					effectiveCapUsd: frozen.capUsd,
 					finalizeReserveUsd: frozen.finalizeReserveUsd,
@@ -16335,6 +16373,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					level: "warn",
 					msg: `orchestrator budget.capUsd ${spec.capUsd.toFixed(4)} USD is bounded to ${effectiveCapUsd.toFixed(4)} USD by the default capFraction 0.2 of the run ceiling (effectiveCap = min(capUsd, capFraction * ceiling)); pass capFraction: 1.0 to make capUsd the sole bound`
 				}, callingState.spanId);
+				if (spec?.synthesisReserveUsd !== void 0 && effectiveCapUsd <= spec.synthesisReserveUsd) throw new OrchestratorCapConfigError(`effectiveCap ${effectiveCapUsd.toFixed(4)} USD is not above the synthesis reserve ${spec.synthesisReserveUsd.toFixed(4)} USD: the coordination loop would have no money at all`);
 				orchestratorAccount = callingState.scope === "" ? "orchestrator" : `${callingState.scope}/orchestrator`;
 				internals.budget.openAccount(orchestratorAccount, {
 					parentScope: callingState.budgetScope ?? "run",
@@ -16342,6 +16381,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					kind: "orchestrator-cap"
 				});
 				if (extension !== void 0) internals.budget.commitFinalizeReserve(orchestratorAccount, finalizeReserveUsd);
+				if (spec?.synthesisReserveUsd !== void 0 && spec.synthesisReserveUsd > 0) internals.budget.commitSynthesisReserve(orchestratorAccount, spec.synthesisReserveUsd);
 				capState = {
 					effectiveCapUsd,
 					finalizeReserveUsd,
@@ -17268,7 +17308,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			role: "orchestrate",
 			result: "full",
 			tools,
-			...capState === void 0 ? {} : { estCost: orchestratorAdmissionEstCostUsd(capState.effectiveCapUsd, orchestratorAccount === void 0 ? 0 : internals.budget.accountView(orchestratorAccount)?.finalizeReserveUsd ?? 0) },
+			...capState === void 0 ? {} : { estCost: orchestratorAdmissionEstCostUsd(capState.effectiveCapUsd, orchestratorAccount === void 0 ? 0 : (internals.budget.accountView(orchestratorAccount)?.finalizeReserveUsd ?? 0) + (internals.budget.accountView(orchestratorAccount)?.synthesisReserveUsd ?? 0)) },
 			...opts?.model === void 0 ? {} : { model: opts.model },
 			...opts?.limits === void 0 ? {} : { limits: opts.limits },
 			[kOnRunning]: (seq) => {
@@ -17584,7 +17624,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 				}
 			}, callingState.spanId);
 			const synthesisState = { ...callingState };
-			if (orchestratorAccount !== void 0) synthesisState.budgetScope = orchestratorAccount;
+			if (orchestratorAccount !== void 0) {
+				synthesisState.budgetScope = orchestratorAccount;
+				internals.budget.releaseSynthesisReserve(orchestratorAccount);
+			}
 			const synthesisBreak = validationSpec === void 0 ? void 0 : validationAbort.signal;
 			if (synthesisBreak !== void 0) synthesisState.signal = callingState.signal === void 0 ? synthesisBreak : AbortSignal.any([callingState.signal, synthesisBreak]);
 			const synthesisOpts = {
@@ -18237,7 +18280,7 @@ function preflightEstimate(input) {
 				turns: projectedProviderTurnsOf(orchLimits, overallExecutedCeiling(orchLimits, toolCeilingsOf(orchLimits))) + coordinationRepairReserve,
 				count: 1
 			});
-			if (effectiveCapUsd !== void 0) orchestratorReserveUsd = Math.max(0, orchestratorAdmissionEstCostUsd(effectiveCapUsd, reservedForFinalizationUsd));
+			if (effectiveCapUsd !== void 0) orchestratorReserveUsd = Math.max(0, orchestratorAdmissionEstCostUsd(effectiveCapUsd, reservedForFinalizationUsd + (input.orchestrator.budget?.synthesisReserveUsd ?? 0)));
 			else if (pricing === void 0) orchestratorReserveUsd = 0;
 			else orchestratorReserveUsd = admissionReserveUsd({
 				...input.orchestrator.estInputTokens === void 0 ? {} : { inputTokens: input.orchestrator.estInputTokens },
@@ -18293,6 +18336,21 @@ function preflightEstimate(input) {
 					spawn: "synthesis"
 				});
 				contractFeasibilityFindings(outputBound, "synthesis", servedBy);
+				{
+					const contract = input.finishValidation?.contract;
+					const pricing = pricingOf(servedBy);
+					if (contract !== void 0 && pricing !== void 0 && pricing.outputUsdPerMTok > 0) {
+						const minTokens = Math.ceil(JSON.stringify({ result: contract.goldenAccept.text }).length / 4);
+						const payloadUsd = minTokens / 1e6 * pricing.outputUsdPerMTok;
+						const declared = input.orchestrator?.budget?.synthesisReserveUsd;
+						if (declared === void 0 || declared < payloadUsd) say({
+							severity: "warning",
+							code: "synthesis-reserve-unfunded",
+							message: `the contract's minimal accepting payload is about ${String(minTokens)} output tokens, about ${payloadUsd.toFixed(4)} USD at the output rate of '${servedBy}', and the orchestrator sub account holds ${declared === void 0 ? "no synthesis reserve" : `only ${declared.toFixed(4)} USD`} for it: a pricey coordination prefix can leave the synthesis turns a remainder the budget clamp shrinks below the payload, cutting the finish before any tool call; declare budget.synthesisReserveUsd at or above the payload price`,
+							spawn: "synthesis"
+						});
+					}
+				}
 				const projected = projectedProviderTurnsOf(merged, overallExecutedCeiling(merged, toolCeilingsOf(merged))) + finishRepairReserve;
 				if (orchestratorEcho !== void 0) orchestratorEcho.synthesis = {
 					projectedProviderTurns: projected,
@@ -18315,10 +18373,12 @@ function preflightEstimate(input) {
 	let committed = 0;
 	let spawned = 0;
 	let children = 0;
-	const admitAgainstRoot = (reserveUsd) => {
+	const admitAgainstRoot = (reserveUsd, strictAtFill = false) => {
 		if (ceilingUsd === void 0) return true;
 		const held = committed + reservedForFinalizationUsd;
-		return !(held >= ceilingUsd || held + reserveUsd > ceilingUsd);
+		if (held >= ceilingUsd) return false;
+		const fill = held + reserveUsd;
+		return strictAtFill ? fill < ceilingUsd : fill <= ceilingUsd;
 	};
 	if (input.orchestrator !== void 0) {
 		const reserveUsd = orchestratorReserveUsd ?? flatReserveUsd;
@@ -18350,9 +18410,9 @@ function preflightEstimate(input) {
 				if (orchestrateWave && ceilingUsd !== void 0) {
 					const remainder = ceilingUsd - committed - reservedForFinalizationUsd;
 					const projection = dispatchProjectionReserveUsd(gate, flatReserveUsd);
-					if (remainder <= 0 || remainder < projection) deniedBy = "budget";
+					if (remainder <= 0 || remainder <= projection) deniedBy = "budget";
 				}
-				if (deniedBy === void 0 && !admitAgainstRoot(reserveUsd)) deniedBy = "budget";
+				if (deniedBy === void 0 && !admitAgainstRoot(reserveUsd, orchestrateWave)) deniedBy = "budget";
 			}
 			wave.push({
 				label,

package/package.json

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