@rulvar/core 1.206.0 → 1.207.0

package/dist/index.d.ts

@@ -6818,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
@@ -6859,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.
@@ -8751,7 +8784,7 @@ interface OrchestratorRuntime {
       causeRef: number;
     };
     taskClass?: string;
-  }): Promise<{
+  }, origin?: "spawn_agent" | "parallel_agents"): Promise<{
     handle: number;
   }>;
   awaitAny(handles: number[]): Promise<TaskDigest>;
@@ -9552,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}.
   */

package/dist/index.js

@@ -16047,6 +16047,28 @@ 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);
@@ -19247,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,
@@ -21872,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) {
@@ -21907,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,
@@ -21928,7 +21964,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 				}, { commitReserve: false });
 				const admissionValue = {
 					decisionType: "spawn-admission",
-					origin: "spawn_agent",
+					origin,
 					orchestratorScope: scope,
 					spawnOrdinal,
 					name: params.agentType,

package/package.json

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