@rulvar/core 1.216.0 → 1.217.0

package/dist/index.d.ts

@@ -9992,6 +9992,17 @@ interface OrchestrateClaimConsistencyMeta {
   /** Present when the judge invocation did not settle ok. */
   judgeFailed?: true;
   /**
+  * Present when the judge invocation was refused ADMISSION and never
+  * dispatched (RV2106): the ninth parity run's judge estimate did not
+  * fit the orchestrator account's working room past the held
+  * synthesis reserve, and the bare refusal killed a run whose fan-out
+  * and draft were already complete. The declined pass degrades like a
+  * failed judge (the meta names it, the journaled decision carries
+  * the arithmetic, only the armed 'fail' posture stops the run) and
+  * the synthesis its reserve was holding money for still dispatches.
+  */
+  judgeDeclined?: true;
+  /**
   * The one field a consumer reads INSTEAD of inferring semantic
   * health from an empty findings array (RV1702):
   * {@link claimCoverageOf} over this meta, so `completion:
@@ -13068,6 +13079,20 @@ interface PreflightOrchestratorSpec {
     exposeChildResultTools?: boolean; /** Mirrors OrchestrateSynthesis.context; default 'digests'. */
     context?: "digests" | "full";
   };
+  /**
+  * The claim-consistency judge's admission estimate (RV2106), exactly
+  * OrchestrateClaimConsistency.judge.estCost: the post-fan-in judge
+  * admits against the ORCHESTRATOR account, whose working room past
+  * the held synthesis reserve the coordination loop's own turns spend
+  * from first. Declaring the estimate lets the estimator judge that
+  * room statically (`orchestrator-working-room`); absent, the finding
+  * stays silent, exactly like every other undeclared input.
+  */
+  claimConsistency?: {
+    judge?: {
+      estCost?: number;
+    };
+  };
 }
 /** The full input: engine surface, run surface, and the declared wave. */
 interface PreflightInput {

package/dist/index.js

@@ -13909,10 +13909,12 @@ var RunBudget = class {
 			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: {
+				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 ` + (account.synthesisReserveUsd > 0 ? `plus the held synthesis reserve ${account.synthesisReserveUsd.toFixed(4)} USD ` : "") + `plus the proposed reserve ${reserveUsd.toFixed(4)} USD does not fit the ceiling ${account.ceilingUsd.toFixed(4)} USD`, { data: {
 					account: account.scope,
 					spentUsd: account.spentUsd,
 					committedReserveUsd: account.committedReserveUsd,
+					finalizeReserveUsd: account.finalizeReserveUsd,
+					synthesisReserveUsd: account.synthesisReserveUsd,
 					proposedReserveUsd: reserveUsd,
 					ceilingUsd: account.ceilingUsd
 				} });
@@ -23402,7 +23404,42 @@ function makeOrchestratorWorkflow(goal, opts) {
 				...spec.judge?.effort === void 0 ? {} : { effort: spec.judge.effort },
 				...spec.judge?.estCost === void 0 ? {} : { estCost: spec.judge.estCost }
 			};
-			const judged = await runtime.runInScope(judgeState, () => ctx.agent(judgePrompt, judgeOpts));
+			let judged;
+			try {
+				judged = await runtime.runInScope(judgeState, () => ctx.agent(judgePrompt, judgeOpts));
+			} catch (declined) {
+				if (!(declined instanceof BudgetExhaustedError)) throw declined;
+				claimConsistencyMeta = finishMeta({
+					judgeInvoked: false,
+					judgeDeclined: true
+				});
+				const declineKey = deriverV2.deriveKey({ kind: "orchestrator-claim-judge-declined" });
+				if (!internals.replayer.snapshot().some((entry) => entry.kind === "decision" && entry.key === declineKey)) await internals.replayer.appendSinglePhase({
+					scope: callingState.scope,
+					key: declineKey,
+					kind: "decision",
+					status: "ok",
+					spanId: internals.spans.mint(callingState.spanId),
+					site: "orchestrator-budget",
+					value: {
+						decisionType: "orchestrator_claim_judge_declined",
+						reason: declined.message.slice(0, 300),
+						remainingUsd: internals.budget.remainingUsd(orchestratorAccount ?? "run") ?? null
+					}
+				});
+				internals.events.emit({
+					type: "log",
+					level: "warn",
+					msg: "orchestrator claim consistency judge declined by admission",
+					data: { reason: declined.message.slice(0, 300) }
+				}, callingState.spanId);
+				if (onFound === "fail") throw new FailRunError("the claim-consistency judge could not be admitted within the orchestrator account, so the armed fail posture cannot pass the draft: " + declined.message.slice(0, 300), { data: {
+					source: "orchestrator_claim_consistency",
+					claimConsistencyMeta,
+					...snapshot ?? {}
+				} });
+				return;
+			}
 			if (judged.status !== "ok" || judged.output === null || judged.output === void 0) {
 				claimConsistencyMeta = finishMeta({
 					judgeInvoked: true,
@@ -24524,6 +24561,7 @@ function preflightEstimate(input) {
 	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");
+		if (input.orchestrator.claimConsistency?.judge?.estCost !== void 0) requireNonNegativeNumber(input.orchestrator.claimConsistency.judge.estCost, "preflight.orchestrator.claimConsistency.judge.estCost");
 		const spec = input.orchestrator.budget;
 		const fraction = spec?.capFraction ?? .2;
 		const fromFraction = ceilingUsd === void 0 ? void 0 : fraction * ceilingUsd;
@@ -25060,6 +25098,17 @@ function preflightEstimate(input) {
 		code: "reserve-line-headroom",
 		message: `the admitted wave's steady state sits ${reserveLineHeadroomUsd.toFixed(4)} USD under the reserve line ${reserveLineUsd.toFixed(4)} USD (the ceiling minus the synthesis reserve), less than two coordination turn floors of headroom (${liveRootExposureTermUsd.toFixed(4)} USD each): child spend past the declared estimates eats that headroom, the coordination loop is then refused at the line, and the run settles partial with the synthesis redeemed from its reserve (RV2101); size the wave below the line or raise the ceiling to keep coordinating past it`
 	});
+	{
+		const judgeEstUsd = input.orchestrator?.claimConsistency?.judge?.estCost;
+		if (judgeEstUsd !== void 0 && effectiveCapUsd !== void 0 && synthesisHoldUsd > 0) {
+			const workingRoomUsd = effectiveCapUsd - synthesisHoldUsd;
+			if (workingRoomUsd < liveRootExposureTermUsd + judgeEstUsd) say({
+				severity: "warning",
+				code: "orchestrator-working-room",
+				message: `the orchestrator account's working room past the held synthesis reserve is ${workingRoomUsd.toFixed(4)} USD (cap ${effectiveCapUsd.toFixed(4)} minus the ${synthesisHoldUsd.toFixed(4)} USD hold), below one coordination turn floor (${liveRootExposureTermUsd.toFixed(4)} USD) plus the declared ${judgeEstUsd.toFixed(4)} USD claim-consistency judge estimate: the judge admission will be declined once the coordination loop has taken even one turn, and the pass degrades to its journaled declined verdict (RV2106); raise the cap, shrink the judge estimate, or shrink the synthesis reserve`
+			});
+		}
+	}
 	if (wave.length > 0 && denied > 0) {
 		const deniedLabels = wave.filter((row) => !row.admitted).map((row) => row.label);
 		if (admitted === 0) say({

package/package.json

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