@rulvar/core 1.215.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
 				} });
@@ -19831,6 +19833,14 @@ const DEFAULT_CITATION_PATTERN = "[\\w./-]+\\.\\w+:\\d+";
 /** The default preserved share, the improvement plan's RV-202 gate. */
 const DEFAULT_EVIDENCE_MIN_SHARE = .95;
 const MAX_LISTED_CITATIONS = 20;
+/**
+* The evidence-grade verdict names its offending sentences (RV2105):
+* bounded so a document written entirely in the graded register cannot
+* balloon the journaled verdict or the repair prompt, truncated per
+* sentence for the same reason.
+*/
+const MAX_NAMED_OFFENDING_SENTENCES = 5;
+const MAX_OFFENDING_SENTENCE_CHARS = 240;
 function listCitations(values) {
 	return values.length <= MAX_LISTED_CITATIONS ? values.join(", ") : `${values.slice(0, MAX_LISTED_CITATIONS).join(", ")} and ${String(values.length - MAX_LISTED_CITATIONS)} more`;
 }
@@ -20048,15 +20058,27 @@ function evidenceGradeValidator(options) {
 		name: options?.name ?? "evidence-grade",
 		validate: (input) => {
 			const unsupported = [];
+			const offenders = [];
 			for (const sentence of sentencesOf(input.text)) {
 				const haystack = sentence.toLowerCase();
 				const found = lowered.filter((phrase) => haystack.includes(phrase));
 				if (found.length === 0 || new RegExp(artifactPattern, "").test(sentence)) continue;
+				offenders.push(sentence);
 				for (const phrase of found) if (!unsupported.includes(phrase)) unsupported.push(phrase);
 			}
-			return unsupported.length === 0 ? ok : {
+			if (unsupported.length === 0) return ok;
+			const named = offenders.slice(0, MAX_NAMED_OFFENDING_SENTENCES).map((sentence) => {
+				const flat = sentence.replace(/\s+/gu, " ").trim();
+				return `offending sentence: "${flat.length <= MAX_OFFENDING_SENTENCE_CHARS ? flat : `${flat.slice(0, MAX_OFFENDING_SENTENCE_CHARS)}...`}"`;
+			});
+			const overflow = offenders.length - named.length;
+			return {
 				ok: false,
-				reasons: [`evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; each such claim must name a run id or a file:line citation beside it`]
+				reasons: [
+					`evidence-grade claims cite no run or repro artifact in their own sentence: ${listCitations(unsupported)}; each such claim must name a run id or a file:line citation beside it`,
+					...named,
+					...overflow > 0 ? [`and ${String(overflow)} more offending sentences`] : []
+				]
 			};
 		}
 	};
@@ -23382,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,
@@ -24504,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;
@@ -25040,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.215.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",