@rulvar/core 1.205.0 → 1.207.0

package/dist/index.d.ts

@@ -6758,6 +6758,23 @@ interface BudgetReserve {
   reserveUsd: number;
   /** The child sub-account ceiling; absent when the parent is uncapped. */
   childCeilingUsd?: number;
+  /**
+  * The reserve derivation (RV2004): where reserveUsd came from, so a
+  * journal reader never reverse-engineers the arithmetic. 'estCost'
+  * is the declared estimate (spawn opts or the agentType profile),
+  * 'default' the engine flat reserve.
+  */
+  source?: "estCost" | "default";
+  /**
+  * Set when the derived reserve was clamped DOWN to the child's
+  * ceiling: 'explicit-budget' by a declared budgetUsd,
+  * 'fraction-ceiling' by the childBudgetFraction allowance an ORIGIN
+  * WITH a materialized allowance account enforces (ctx.workflow).
+  * The spawn-tool path never carries 'fraction-ceiling': its
+  * dispatch enforces no fraction account, and journaling that clamp
+  * is exactly the parity rerun's 0.50-versus-0.70 lie (RV2004).
+  */
+  clampedBy?: "explicit-budget" | "fraction-ceiling";
 }
 /** The lineage block every non-reject verdict carries (DEF-3). */
 interface AdmitLineage {
@@ -6801,6 +6818,25 @@ type AdmitRejectReason = {
   code: "osc_guard";
   spawnKey: SpawnKey;
   oscillationCount: number;
+} | {
+  /**
+  * The sequential roster feasibility refusal (RV2005): under a
+  * declared acceptance.minSpawnedChildren, the whole remaining
+  * roster (priced at this seat's own projection) plus the live
+  * in-flight exposure does not fit the parent remainder, so the
+  * FIRST infeasible seat refuses before any child is paid. The
+  * batchGate symmetry (RV1908) on the seat-by-seat path the
+  * parity rerun's model actually took, where three seats were
+  * paid in full under a floor of four the money could never
+  * reach.
+  */
+  code: "roster_floor";
+  floor: number;
+  admittedChildren: number;
+  seatsRemaining: number;
+  perSeatProjectionUsd: number;
+  liveExposureUsd: number;
+  remainderUsd: number;
 } | {
   /**
   * The declared estimate cannot fit the child's own ceiling: the
@@ -6842,6 +6878,20 @@ interface AdmitSpec {
   */
   pendingReserveUsd?: number;
   /**
+  * The sequential roster feasibility inputs (RV2005), passed by the
+  * SINGLE spawn_agent path when acceptance.minSpawnedChildren is
+  * declared: the admission projects the whole REMAINING roster at
+  * this seat's own dispatch projection, live in-flight exposure
+  * included, and refuses the first infeasible seat typed
+  * 'roster_floor' before any child is paid. Batch seats never carry
+  * this: the RV1908 batchGate already judged their batch entire.
+  */
+  roster?: {
+    floor: number;
+    admittedChildren: number;
+    liveExposureUsd: number;
+  };
+  /**
   * Lineage continuation (DEF-3); absence mints a fresh lineage root. A
   * continuation demands a causeRef: the seq of the entry that caused the
   * rebirth.
@@ -8734,7 +8784,7 @@ interface OrchestratorRuntime {
       causeRef: number;
     };
     taskClass?: string;
-  }): Promise<{
+  }, origin?: "spawn_agent" | "parallel_agents"): Promise<{
     handle: number;
   }>;
   awaitAny(handles: number[]): Promise<TaskDigest>;
@@ -9535,6 +9585,19 @@ interface OrchestrateOptions {
   */
   parallelAdmission?: "fail-fast" | "try-all" | "all-or-none";
   /**
+  * The batch-spawn discipline (RV2005). The third parity rerun's
+  * model ignored the instruction to spawn its roster in one
+  * parallel_agents call and spawned seat by seat through spawn_agent,
+  * so the RV1908 batchGate never saw a batch and the roster
+  * feasibility rode on per-seat luck. 'reject-spawn-agent' refuses
+  * every SINGLE spawn_agent call typed (code 'batch_required',
+  * nothing journaled, nothing paid) so model disobedience cannot
+  * split the policy: the model reads the refusal and re-issues the
+  * wave as one parallel_agents batch. Absent, both tools behave as
+  * documented.
+  */
+  requireBatchSpawn?: "reject-spawn-agent";
+  /**
   * The opt in deterministic host validation of the finish result, with
   * bounded repair; see {@link FinishValidationSpec}.
   */
@@ -13096,6 +13159,18 @@ interface PreflightReport {
     * fourth workers. Present whenever the wave has rows.
     */
     requiredMinimumCeilingUsd?: number;
+    /**
+    * The live-root-exposure term of the wave projection (RV2004): the
+    * orchestrator's own worst-case turn floor, the money coordination
+    * has ALWAYS already spent (and holds in flight) by the time any
+    * spawn tool runs. The parity rerun's fourth seat fit the plain
+    * wave (5.95 under 6.00) and was refused live by exactly this
+    * term; the embedded spawn gate and requiredMinimumCeilingUsd now
+    * carry it, so a seat that cannot admit live cannot admit in
+    * preflight either. Present on orchestrate waves whose
+    * coordination turn prices.
+    */
+    liveRootExposureTermUsd?: number;
     wave: PreflightAdmissionRow[];
     admitted: number;
     denied: number;

package/dist/index.js

@@ -16047,15 +16047,49 @@ var AdmissionController = class {
 			},
 			statsBefore
 		};
+		if (spec.roster !== void 0) {
+			const seatsRemaining = spec.roster.floor - spec.roster.admittedChildren;
+			if (seatsRemaining > 0) {
+				const perSeatProjectionUsd = this.projectedDispatchReserveUsd(spec);
+				const remainder = this.budget.remainderOf(spec.parentAccountScope);
+				if (remainder !== void 0 && remainder < seatsRemaining * perSeatProjectionUsd + spec.roster.liveExposureUsd) return {
+					verdict: {
+						kind: "reject",
+						reason: {
+							code: "roster_floor",
+							floor: spec.roster.floor,
+							admittedChildren: spec.roster.admittedChildren,
+							seatsRemaining,
+							perSeatProjectionUsd,
+							liveExposureUsd: spec.roster.liveExposureUsd,
+							remainderUsd: remainder
+						}
+					},
+					statsBefore
+				};
+			}
+		}
+		const spawnToolOrigin = spec.origin === "spawn_agent" || spec.origin === "parallel_agents";
 		let childCeilingUsd;
 		const parentRemainder = this.budget.remainderOf(spec.parentAccountScope);
-		if (parentRemainder !== void 0) {
+		if (spawnToolOrigin) {
+			if (spec.budgetUsd !== void 0) childCeilingUsd = spec.budgetUsd;
+		} else if (parentRemainder !== void 0) {
 			const fractionCap = this.childBudgetFraction * parentRemainder;
 			childCeilingUsd = spec.budgetUsd === void 0 ? fractionCap : Math.min(spec.budgetUsd, fractionCap);
 		} else if (spec.budgetUsd !== void 0) childCeilingUsd = spec.budgetUsd;
 		let reserveUsd = spec.estCostUsd ?? this.flatReserveUsd;
-		if (childCeilingUsd !== void 0) reserveUsd = Math.min(reserveUsd, childCeilingUsd);
-		const reserve = { reserveUsd };
+		const source = spec.estCostUsd === void 0 ? "default" : "estCost";
+		let clampedBy;
+		if (childCeilingUsd !== void 0 && reserveUsd > childCeilingUsd) {
+			clampedBy = spec.budgetUsd !== void 0 && childCeilingUsd === spec.budgetUsd ? "explicit-budget" : "fraction-ceiling";
+			reserveUsd = childCeilingUsd;
+		}
+		const reserve = {
+			reserveUsd,
+			source
+		};
+		if (clampedBy !== void 0) reserve.clampedBy = clampedBy;
 		if (childCeilingUsd !== void 0) reserve.childCeilingUsd = childCeilingUsd;
 		if (this.budget.spawnHeadroom <= 0) return {
 			verdict: {
@@ -19235,7 +19269,7 @@ function buildOrchestratorTools(runtime, profileCardText, options) {
 			for (const [index, task] of tasks.entries()) {
 				let spawned;
 				try {
-					spawned = await runtime.spawn(task);
+					spawned = await runtime.spawn(task, "parallel_agents");
 				} catch (thrown) {
 					const failure = {
 						index,
@@ -21860,8 +21894,16 @@ function makeOrchestratorWorkflow(goal, opts) {
 		};
 		const executionFactsEnabled = opts?.executionFacts === true;
 		const orchestratorRuntime = {
-			async spawn(params) {
+			async spawn(params, origin = "spawn_agent") {
 				await recoveryDone;
+				if (origin === "spawn_agent" && opts?.requireBatchSpawn === "reject-spawn-agent") {
+					internals.events.emit({
+						type: "spawn:rejected",
+						code: "batch_required",
+						agentType: params.agentType
+					}, callingState.spanId);
+					throw new AdmissionRejectedError("orchestrate requireBatchSpawn 'reject-spawn-agent': single spawn_agent calls are refused; submit the whole wave as ONE parallel_agents call so the batch roster feasibility gate sees it entire", { data: { reason: { code: "batch_required" } } });
+				}
 				const specKey = jcsSerialize(params);
 				const recoveredOrdinal = unclaimedRecoveredBySpec.get(specKey)?.shift();
 				if (recoveredOrdinal !== void 0) {
@@ -21895,14 +21937,20 @@ function makeOrchestratorWorkflow(goal, opts) {
 				const profile = Object.hasOwn(advertisedProfiles, params.agentType) ? advertisedProfiles[params.agentType] : void 0;
 				const profileModel = profile?.model;
 				if (profileModel !== void 0 && typeof profileModel !== "string" && "ladder" in profileModel) throw new ConfigError(`agentType '${params.agentType}' declares a ladder; ladder execution is owned by the plan extension, which resolves each rung attempt to a concrete model override; spawn a concrete profile instead`);
+				const rosterFloor = (opts?.acceptance)?.minSpawnedChildren;
 				const decision = admission.admit({
-					origin: "spawn_agent",
+					origin,
 					name: params.agentType,
 					childScope: scope,
 					parentAccountScope: callingState.budgetScope ?? "run",
 					nodeKey: scope,
 					...params.budgetUsd === void 0 ? {} : { budgetUsd: params.budgetUsd },
 					...profile?.estCost === void 0 ? {} : { estCostUsd: profile.estCost },
+					...origin === "spawn_agent" && rosterFloor !== void 0 ? { roster: {
+						floor: rosterFloor,
+						admittedChildren: admittedSpawnCount,
+						liveExposureUsd: internals.budget.liveExposureUsd
+					} } : {},
 					...params.lineage === void 0 ? {} : { lineage: {
 						continues: params.lineage.continues,
 						causeRef: params.lineage.causeRef,
@@ -21916,7 +21964,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				}, { commitReserve: false });
 				const admissionValue = {
 					decisionType: "spawn-admission",
-					origin: "spawn_agent",
+					origin,
 					orchestratorScope: scope,
 					spawnOrdinal,
 					name: params.agentType,
@@ -24726,6 +24774,7 @@ function preflightEstimate(input) {
 	}
 	const maxSpawns = input.orchestrator?.maxSpawns;
 	const orchestrateWave = input.orchestrator !== void 0;
+	const liveRootExposureTermUsd = orchestrateWave ? units.find((unit) => unit.label === "orchestrator")?.turnFloorUsd ?? 0 : 0;
 	for (const [reportIndex, report] of spawnReports.entries()) {
 		const gate = waveGateInputs[reportIndex] ?? {};
 		for (let i = 0; i < report.count; i += 1) {
@@ -24736,7 +24785,7 @@ function preflightEstimate(input) {
 			else if (maxSpawns !== void 0 && children >= maxSpawns) deniedBy = "orchestrator-max-spawns";
 			else {
 				if (orchestrateWave && ceilingUsd !== void 0) {
-					const remainder = ceilingUsd - heldAgainstRoot();
+					const remainder = ceilingUsd - heldAgainstRoot() - liveRootExposureTermUsd;
 					const projection = dispatchProjectionReserveUsd(gate, flatReserveUsd);
 					if (remainder <= 0 || remainder <= projection) deniedBy = "budget";
 				}
@@ -24758,7 +24807,7 @@ function preflightEstimate(input) {
 	}
 	const admitted = wave.filter((row) => row.admitted).length;
 	const denied = wave.length - admitted;
-	const requiredMinimumCeilingUsd = wave.length === 0 ? void 0 : wave.reduce((sum, row) => sum + row.reserveUsd, 0) + reservedForFinalizationUsd + synthesisHoldUsd;
+	const requiredMinimumCeilingUsd = wave.length === 0 ? void 0 : wave.reduce((sum, row) => sum + row.reserveUsd, 0) + reservedForFinalizationUsd + synthesisHoldUsd + liveRootExposureTermUsd;
 	if (wave.length > 0 && denied > 0) {
 		const deniedLabels = wave.filter((row) => !row.admitted).map((row) => row.label);
 		if (admitted === 0) say({
@@ -25016,6 +25065,7 @@ function preflightEstimate(input) {
 			reservedForFinalizationUsd,
 			synthesisReserveUsd: synthesisHoldUsd,
 			...requiredMinimumCeilingUsd === void 0 ? {} : { requiredMinimumCeilingUsd },
+			...liveRootExposureTermUsd > 0 ? { liveRootExposureTermUsd } : {},
 			wave,
 			admitted,
 			denied

package/package.json

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