@rulvar/core 1.192.0 → 1.193.0

package/dist/index.d.ts

@@ -12553,6 +12553,14 @@ interface PreflightOrchestratorSpec {
     };
     acceptPartialChildren?: boolean;
     acceptValidatedTerminalOutputOnLimit?: boolean;
+    /**
+    * Mirrors OrchestrateAcceptance.minSpawnedChildren (RV1901, the
+    * four-role benchmark's primary defect): declaring it lets the
+    * admission projection judge whether the declared wave can seat
+    * the roster the acceptance policy demands, instead of green-
+    * lighting a wave the settle verdict is bound to reject.
+    */
+    minSpawnedChildren?: number;
   };
   /**
   * The separate synthesis invocation (RV-211), when the orchestration
@@ -12714,6 +12722,15 @@ interface PreflightAdmissionRow {
   reserveUsd: number;
   admitted: boolean;
   deniedBy?: "budget" | "spawn-cap" | "orchestrator-max-spawns";
+  /**
+  * The run-root money already held when this row was evaluated:
+  * committed reserves of the earlier rows plus the finalization and
+  * synthesis carve-outs (RV1901). The row admits iff held + reserveUsd
+  * fits the ceiling (children strictly below it at exact fill), so a
+  * denied row's arithmetic is auditable term by term. Present only
+  * under a USD ceiling.
+  */
+  heldAtEvaluationUsd?: number;
 }
 /** The machine-readable preflight report; JSON-serializable throughout. */
 interface PreflightReport {
@@ -12756,6 +12773,15 @@ interface PreflightReport {
   admission: {
     ceilingUsd?: number;
     reservedForFinalizationUsd: number;
+    /**
+    * The synthesis payload carve-out the projection holds against the
+    * run root, exactly the live commitSynthesisReserve mirror (RV1901):
+    * a capped orchestrator with budget.synthesisReserveUsd registers it
+    * on the root before any spawn admits, so the wave arithmetic must
+    * hold it too. Zero when the orchestrator is uncapped or declares no
+    * synthesis reserve, matching the runtime that then commits none.
+    */
+    synthesisReserveUsd: number;
     wave: PreflightAdmissionRow[];
     admitted: number;
     denied: number;

package/dist/index.js

@@ -23784,9 +23784,11 @@ function preflightEstimate(input) {
 	const coordinationRepairReserve = input.orchestrator?.synthesis === void 0 ? finishRepairReserve : 0;
 	let orchestratorEcho;
 	let reservedForFinalizationUsd = 0;
+	let synthesisHoldUsd = 0;
 	let effectiveCapUsd;
 	if (input.orchestrator !== void 0) {
 		if (input.orchestrator.estInputTokens !== void 0) requireNonNegativeInteger(input.orchestrator.estInputTokens, "preflight.orchestrator.estInputTokens");
+		if (input.orchestrator.acceptance?.minSpawnedChildren !== void 0) requirePositiveInteger$2(input.orchestrator.acceptance.minSpawnedChildren, "preflight.orchestrator.acceptance.minSpawnedChildren");
 		const spec = input.orchestrator.budget;
 		const fraction = spec?.capFraction ?? .2;
 		const fromFraction = ceilingUsd === void 0 ? void 0 : fraction * ceilingUsd;
@@ -23796,6 +23798,7 @@ function preflightEstimate(input) {
 		const finalizeReserveUsd = spec?.finalizeReserveUsd ?? finalizeTurns * flatReserveUsd;
 		const reserveCommitted = input.orchestrator.extension === true;
 		if (reserveCommitted) reservedForFinalizationUsd = finalizeReserveUsd;
+		if (effectiveCapUsd !== void 0) synthesisHoldUsd = Math.max(0, spec?.synthesisReserveUsd ?? 0);
 		const echoLimits = mergeUsageLimits(input.orchestrator.limits, void 0, defaults.limits);
 		orchestratorEcho = {
 			...effectiveCapUsd === void 0 ? {} : { effectiveCapUsd },
@@ -24208,9 +24211,11 @@ function preflightEstimate(input) {
 	let committed = 0;
 	let spawned = 0;
 	let children = 0;
+	let childrenDeniedByBudget = 0;
+	const heldAgainstRoot = () => committed + reservedForFinalizationUsd + synthesisHoldUsd;
 	const admitAgainstRoot = (reserveUsd, strictAtFill = false) => {
 		if (ceilingUsd === void 0) return true;
-		const held = committed + reservedForFinalizationUsd;
+		const held = heldAgainstRoot();
 		if (held >= ceilingUsd) return false;
 		const fill = held + reserveUsd;
 		return strictAtFill ? fill < ceilingUsd : fill <= ceilingUsd;
@@ -24224,7 +24229,8 @@ function preflightEstimate(input) {
 			label: "orchestrator",
 			reserveUsd,
 			admitted: deniedBy === void 0,
-			...deniedBy === void 0 ? {} : { deniedBy }
+			...deniedBy === void 0 ? {} : { deniedBy },
+			...ceilingUsd === void 0 ? {} : { heldAtEvaluationUsd: heldAgainstRoot() }
 		});
 		if (deniedBy === void 0) {
 			committed += reserveUsd;
@@ -24243,7 +24249,7 @@ function preflightEstimate(input) {
 			else if (maxSpawns !== void 0 && children >= maxSpawns) deniedBy = "orchestrator-max-spawns";
 			else {
 				if (orchestrateWave && ceilingUsd !== void 0) {
-					const remainder = ceilingUsd - committed - reservedForFinalizationUsd;
+					const remainder = ceilingUsd - heldAgainstRoot();
 					const projection = dispatchProjectionReserveUsd(gate, flatReserveUsd);
 					if (remainder <= 0 || remainder <= projection) deniedBy = "budget";
 				}
@@ -24253,13 +24259,14 @@ function preflightEstimate(input) {
 				label,
 				reserveUsd,
 				admitted: deniedBy === void 0,
-				...deniedBy === void 0 ? {} : { deniedBy }
+				...deniedBy === void 0 ? {} : { deniedBy },
+				...ceilingUsd === void 0 ? {} : { heldAtEvaluationUsd: heldAgainstRoot() }
 			});
 			if (deniedBy === void 0) {
 				committed += reserveUsd;
 				spawned += 1;
 				children += 1;
-			}
+			} else if (deniedBy === "budget") childrenDeniedByBudget += 1;
 		}
 	}
 	const admitted = wave.filter((row) => row.admitted).length;
@@ -24277,6 +24284,19 @@ function preflightEstimate(input) {
 			message: `the declared wave admits ${String(admitted)} of ${String(wave.length)} spawns; denied before any work: ${deniedLabels.join(", ")}`
 		});
 	}
+	{
+		const acceptance = input.orchestrator?.acceptance;
+		const minSuccessfulFloor = acceptance?.childPolicy !== void 0 && acceptance.childPolicy !== "all-ok" ? acceptance.childPolicy.minSuccessful : void 0;
+		const rosterFloor = Math.max(acceptance?.minSpawnedChildren ?? 0, minSuccessfulFloor ?? 0);
+		if (rosterFloor > 0 && children < rosterFloor && childrenDeniedByBudget > 0) {
+			const demandedBy = (acceptance?.minSpawnedChildren ?? 0) >= (minSuccessfulFloor ?? 0) ? "acceptance.minSpawnedChildren" : "acceptance.childPolicy.minSuccessful";
+			say({
+				severity: "error",
+				code: "admission-below-roster-floor",
+				message: `the declared wave seats ${String(children)} of the ${String(rosterFloor)} children ${demandedBy} demands (${String(childrenDeniedByBudget)} denied by budget): the run would pay for the seated work and still settle rejected; re-admission after a child settles frees money only when its settled spend stays below the released reserve`
+			});
+		}
+	}
 	if (ceilingUsd === void 0 && wave.length > 0) say({
 		severity: "info",
 		code: "no-usd-ceiling",
@@ -24500,6 +24520,7 @@ function preflightEstimate(input) {
 		admission: {
 			...ceilingUsd === void 0 ? {} : { ceilingUsd },
 			reservedForFinalizationUsd,
+			synthesisReserveUsd: synthesisHoldUsd,
 			wave,
 			admitted,
 			denied

package/package.json

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