@rulvar/core 1.236.0 → 1.237.0

package/dist/index.d.ts

@@ -1679,6 +1679,46 @@ interface TerminalEnvelope {
   /** Agents admitted over the run's lifetime, resume seed included. */
   agentsSpawned: number;
   /**
+  * Whether the artifact this terminal carries passed the declared
+  * finish contract (RV2506), mirrored onto the envelope since RV3304:
+  * the 2026-08-12 comparison run settled ok/complete over a retained
+  * contradiction, and neither the HTTP response nor the persisted
+  * rebuild could say whether anything ever judged the deliverable.
+  * Absent when no contract judged anything; absence means NOT
+  * RECORDED, never "accepted".
+  */
+  deliverableAccepted?: boolean;
+  /**
+  * Whether this terminal carries a deliverable to read at all
+  * (RV2506); same mirror and posture. Distinct from
+  * `deliverableAccepted`: an unjudged artifact still EXISTS, and a
+  * run with no artifact still has a completion claim.
+  */
+  resultAvailable?: boolean;
+  /**
+  * The journal seq of the decision entry recording the acceptance of
+  * the artifact this terminal carries (RV2506); same mirror, absent
+  * unless the acceptance actually rendered. Read it with
+  * `rulvar inspect` to see WHICH validators accepted WHICH hash.
+  */
+  acceptedArtifactRef?: number;
+  /**
+  * The claim consistency pass meta, detached (RV3304): `judgedStage`,
+  * `judgedHash`, the coverage grade and the `findings` count, so the
+  * surface a consumer gates on says WHAT was semantically verified,
+  * over WHICH document, and what the judge found, without reaching
+  * into the workflow value. Mutating this copy never touches the
+  * outcome the engine owns.
+  */
+  claimConsistencyMeta?: Record<string, unknown>;
+  /**
+  * The host declared config identity the run was started under
+  * (RV3210), echoed here since RV3304 so a decision consumer binds
+  * the verdict above to the configuration that produced it without a
+  * second read of the run record. Absent when the run declared none.
+  */
+  configFingerprint?: string;
+  /**
   * Where THIS copy of the envelope was assembled (RV1209). Absent, the
   * historical byte contract, means the settlement chokepoint built it
   * from the live outcome, so every field above is the run's own
@@ -10361,7 +10401,12 @@ interface OrchestrateClaimConsistency {
   * explicitly (a ConfigError without that synthesis, the
   * contradictions precedent), and non-empty findings block the
   * `skipWhenDraftValid` gate: a draft contradicting its own pool
-  * never earns the skip. 'fail' fails the run typed with
+  * never earns the skip. The carry can only ride a prompt that still
+  * lies ahead, so it binds the pass that runs BEFORE the synthesis:
+  * under `stage: 'both'` the draft pass carries and the final pass
+  * reports, and `stage: 'final'` with 'carry' is a ConfigError at
+  * intake, because a posture that reads as a gate must not quietly
+  * behave as 'report'. 'fail' fails the run typed with
   * `data.source` 'orchestrator_claim_consistency' BEFORE any
   * synthesis dispatch; the judge itself has already been paid, which
   * is the honest minimum for a semantic verdict. A judge that does
@@ -10585,6 +10630,18 @@ interface OrchestrateClaimConsistencyMeta {
   */
   judgeDeclined?: true;
   /**
+  * How many judged contradictions the pass FOUND on the judged
+  * document, present exactly when the judge settled ok (RV3304): `0`
+  * is a clean verdict, a positive count is a disagreement that stayed
+  * wherever the posture did not stop the run. The findings themselves
+  * ride `claimContradictions` beside this meta on the acceptance
+  * envelope, but the meta travels ALONE onto RunOutcome, the
+  * journaled run settle, and the terminal envelope, and the
+  * 2026-08-12 comparison run settled ok/complete over a retained
+  * finding no terminal surface could count.
+  */
+  findings?: number;
+  /**
   * The one field a consumer reads INSTEAD of inferring semantic
   * health from an empty findings array (RV1702):
   * {@link claimCoverageOf} over this meta, so `completion:
@@ -12155,7 +12212,7 @@ interface RunHandle<R> {
 //#endregion
 //#region src/engine/terminal-envelope.d.ts
 /** The outcome facts the assembler reads; a structural subset of RunOutcome. */
-type TerminalOutcomeFacts = Pick<RunOutcome<unknown>, "status" | "error" | "completion"> & {
+type TerminalOutcomeFacts = Pick<RunOutcome<unknown>, "status" | "error" | "completion" | "deliverableAccepted" | "resultAvailable" | "acceptedArtifactRef" | "claimConsistencyMeta"> & {
   usage: RunOutcome<unknown>["usage"];
   cost: Pick<RunOutcome<unknown>["cost"], "totalUsd" | "grossUsd" | "byModel"> & {
     usageApprox?: boolean;
@@ -12183,7 +12240,8 @@ declare function terminalEnvelopeOf(input: {
   settlement?: {
     settledReason?: "superseded";
   };
-  provenance?: "journal";
+  provenance?: "journal"; /** The run's declared config identity (RV3210), echoed onto the envelope (RV3304). */
+  configFingerprint?: string;
 }): TerminalEnvelope;
 //#endregion
 //#region src/l0/decision-chain.d.ts
@@ -13075,6 +13133,18 @@ declare function lastRunSettle(entries: readonly JournalEntry[]): {
   * recorded" rather than as a claim.
   */
   rejectedFinishCandidates?: RejectedFinishCandidate[];
+  /**
+  * The semantic outcome the settle recorded (RV3304), read back
+  * the same defensive way: the acceptance verdict, the
+  * deliverable presence, the acceptance ref and the judge meta,
+  * so a restarted reader recovers the facts a live consumer
+  * gated on. Absent on journals written before the lift carried
+  * them; absence means NOT RECORDED, never a verdict.
+  */
+  deliverableAccepted?: boolean;
+  resultAvailable?: boolean;
+  acceptedArtifactRef?: number;
+  claimConsistencyMeta?: Record<string, unknown>;
 } | undefined;
 /**
 * Whether a terminal figure counts THIS segment's work or the whole
@@ -14055,6 +14125,17 @@ interface StatementReconciliation {
   componentToleranceUsd: number;
   verdict: "match" | "divergence" | "partial-coverage" | "no-overlap";
   /**
+  * How much of the MATCHED statement claims money (RV3306):
+  * 'complete' when every matched export row (requests mode) or every
+  * component line (categories mode) carries a dollar claim, a row
+  * total or a component split; 'partial' when some do; 'none' when
+  * the statement matched on identity and usage alone, or matched
+  * nothing. Kept apart from row coverage on purpose: coverage says
+  * the records line up, this says whether the provider actually
+  * stated dollars over them.
+  */
+  dollarCoverage: "complete" | "partial" | "none";
+  /**
   * The settlement-grade composite, first class (RV1006): true exactly
   * when the verdict is 'match' AND coverage is complete AND no row's
   * usage is unknown AND no model went unpriced. A 'match' alone is
@@ -14063,9 +14144,22 @@ interface StatementReconciliation {
   * consumer must not assemble this predicate by hand. The last two
   * conditions overlap today's verdict semantics deliberately: the
   * predicate states the full contract so it cannot drift apart from
-  * a future verdict refinement.
+  * a future verdict refinement. Note what it does NOT require: a
+  * dollar claim. A usage-only export that matches on identity and
+  * tokens reads `settleable: true`; gate MONETARY closure on
+  * `monetarySettleable` below.
   */
   settleable: boolean;
+  /**
+  * The MONETARY settlement predicate (RV3306): `settleable` AND
+  * complete dollar coverage. `settleable` answers "do the records
+  * agree"; this answers "may money close against this statement".
+  * The 2026-08-12 audit named the difference on this exact module: a
+  * usage-only request export settled 'match' without one dollar of
+  * provider evidence, and a finance pipeline gating on `settleable`
+  * alone would have closed money against it.
+  */
+  monetarySettleable: boolean;
 }
 /**
 * Reconciles the invoice against a normalized provider export. Pure and

package/dist/index.js

@@ -1327,6 +1327,20 @@ function detachedError(error) {
 	}
 }
 /**
+* A detached copy of the judge meta (RV3304), the `detachedError`
+* posture: Json shaped by construction, so a structured clone
+* reproduces it exactly, and a host that smuggled something exotic
+* past the type falls back to a shallow copy rather than throwing at
+* the settlement chokepoint.
+*/
+function detachedMeta(meta) {
+	try {
+		return structuredClone(meta);
+	} catch {
+		return { ...meta };
+	}
+}
+/**
 * Assembles one terminal envelope (RV1105). `settlement` present means
 * nothing durable records the terminal: `settled` reads false, and the
 * optional `settledReason: 'superseded'` names the fenced-out segment
@@ -1356,6 +1370,11 @@ function terminalEnvelopeOf(input) {
 	};
 	if (outcome.error !== void 0) envelope.error = detachedError(outcome.error);
 	if (outcome.completion !== void 0) envelope.completion = outcome.completion;
+	if (outcome.deliverableAccepted !== void 0) envelope.deliverableAccepted = outcome.deliverableAccepted;
+	if (outcome.resultAvailable !== void 0) envelope.resultAvailable = outcome.resultAvailable;
+	if (outcome.acceptedArtifactRef !== void 0) envelope.acceptedArtifactRef = outcome.acceptedArtifactRef;
+	if (outcome.claimConsistencyMeta !== void 0) envelope.claimConsistencyMeta = detachedMeta(outcome.claimConsistencyMeta);
+	if (input.configFingerprint !== void 0) envelope.configFingerprint = input.configFingerprint;
 	if (outcome.cost.wireRequests !== void 0) envelope.wireRequests = outcome.cost.wireRequests;
 	if (input.settlement?.settledReason !== void 0) envelope.settledReason = input.settlement.settledReason;
 	if (input.provenance !== void 0) envelope.provenance = input.provenance;
@@ -8806,17 +8825,36 @@ function lastRunSettle(entries) {
 		if (value?.decisionType === "run_settle" && typeof value.runStatus === "string" && RUN_STATUSES.has(value.runStatus)) {
 			const completion = value.completion;
 			const rejected = readRejectedFinishCandidates(value.rejectedFinishCandidates);
+			const judgeMeta = readClaimConsistencyMeta(value.claimConsistencyMeta);
 			return {
 				runStatus: value.runStatus,
 				seq: entry.seq,
 				...typeof value.outputHash === "string" ? { outputHash: value.outputHash } : {},
 				...completion === "complete" || completion === "partial" || completion === "rejected" ? { completion } : {},
-				...rejected === void 0 ? {} : { rejectedFinishCandidates: rejected }
+				...rejected === void 0 ? {} : { rejectedFinishCandidates: rejected },
+				...typeof value.deliverableAccepted === "boolean" ? { deliverableAccepted: value.deliverableAccepted } : {},
+				...typeof value.resultAvailable === "boolean" ? { resultAvailable: value.resultAvailable } : {},
+				...typeof value.acceptedArtifactRef === "number" && Number.isSafeInteger(value.acceptedArtifactRef) && value.acceptedArtifactRef >= 0 ? { acceptedArtifactRef: value.acceptedArtifactRef } : {},
+				...judgeMeta === void 0 ? {} : { claimConsistencyMeta: judgeMeta }
 			};
 		}
 	}
 }
 /**
+* The judge meta of a persisted settle, or `undefined` (RV3304). The
+* whole object drops unless its load bearing fields are shaped as the
+* live producer writes them (`judgeInvoked`, the coverage grade, the
+* judged stage and hash): a partially shaped meta read as a verdict
+* would claim semantic ground the journal does not hold, the same
+* posture as `readRejectedFinishCandidates`.
+*/
+function readClaimConsistencyMeta(raw) {
+	if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return;
+	const meta = raw;
+	if (typeof meta.judgeInvoked !== "boolean" || typeof meta.coverage !== "string" || meta.judgedStage !== "draft" && meta.judgedStage !== "final" || typeof meta.judgedHash !== "string") return;
+	return { ...raw };
+}
+/**
 * The rejected finish candidates of a persisted settle, or `undefined`
 * (RV2605). The WHOLE list drops on any malformed row, the same posture
 * the live lift takes (RV2507): a partial history read as complete
@@ -9286,6 +9324,21 @@ function reduceInvocationTable(events) {
 */
 const CLAIM_JUDGE_LABEL = "claim-consistency-judge";
 /**
+* Whether a synthesize span's label names a claim-consistency judge
+* invocation: the exact {@link CLAIM_JUDGE_LABEL}, or a suffixed
+* variant of it (the final pass dispatches under
+* `claim-consistency-judge-final` since RV2509 so the two passes of
+* `stage: 'both'` stay separable). BOTH reducers must classify through
+* this one predicate (RV3302): the live fold compared the label for
+* exact equality while the journal fold accepted the suffix, and the
+* 2026-08-12 comparison run reported semanticJudgeMs 0 with the whole
+* 272923 ms window read as final composition on the live surface
+* while the journal fold correctly split 224864 against 48059.
+*/
+function isClaimJudgeLabel(label) {
+	return label === "claim-consistency-judge" || (label?.startsWith(`claim-consistency-judge-`) ?? false);
+}
+/**
 * The label the final synthesis (composition) invocation dispatches
 * under (RV2901). The engine labelling its OWN dispatches is what lets
 * `criticalPathFromJournal` split the synthesize bucket offline: the
@@ -9366,7 +9419,7 @@ function reduceCriticalPath(events) {
 				if (started === void 0) break;
 				if (started.role === "synthesize") {
 					const wall = Math.max(0, at - started.at);
-					const judge = started.label === CLAIM_JUDGE_LABEL;
+					const judge = isClaimJudgeLabel(started.label);
 					synthesisMs += wall;
 					if (judge) semanticJudgeMs += wall;
 					else finalCompositionMs += wall;
@@ -9510,7 +9563,7 @@ function criticalPathFromJournal(entries) {
 			continue;
 		}
 		labelledSynthesis = true;
-		if (label === "claim-consistency-judge" || label.startsWith(`claim-consistency-judge-`)) semanticJudgeMs += wall;
+		if (isClaimJudgeLabel(label)) semanticJudgeMs += wall;
 		else finalCompositionMs += wall;
 	}
 	const segments = logicalRunTelemetry(ordered).segments;
@@ -16111,6 +16164,7 @@ function reconcileStatement(invoice, statement, options) {
 	let statementComponents;
 	let matchedStatementRows = 0;
 	let matchedUsdRows = 0;
+	let matchedDollarRows = 0;
 	let tokenMismatches = 0;
 	let partialOverlap = false;
 	const tokenMismatchSample = [];
@@ -16215,6 +16269,7 @@ function reconcileStatement(invoice, statement, options) {
 		for (const row of statement.rows) {
 			if (!matchedStatement.has(row.responseId)) continue;
 			matchedStatementRows += 1;
+			if (row.usd !== void 0 || row.componentsUsd !== void 0) matchedDollarRows += 1;
 			if (row.usd !== void 0) {
 				matchedUsdRows += 1;
 				totalSeen = true;
@@ -16320,6 +16375,10 @@ function reconcileStatement(invoice, statement, options) {
 	else if (matchedRows === 0 && !partialOverlap) verdict = "no-overlap";
 	else if (!coverageComplete) verdict = "partial-coverage";
 	else verdict = "match";
+	const dollarClaims = statement.kind === "requests" ? matchedDollarRows : components.filter((line) => line.statementUsd !== void 0).length;
+	const dollarSlots = statement.kind === "requests" ? matchedStatementRows : components.length;
+	const dollarCoverage = dollarSlots > 0 && dollarClaims === dollarSlots ? "complete" : dollarClaims > 0 ? "partial" : "none";
+	const settleable = verdict === "match" && coverageComplete && usageUnknownRows === 0 && unpricedModels.size === 0;
 	return {
 		mode: statement.kind,
 		coverage: {
@@ -16345,7 +16404,9 @@ function reconcileStatement(invoice, statement, options) {
 		usageUnknownRows,
 		componentToleranceUsd,
 		verdict,
-		settleable: verdict === "match" && coverageComplete && usageUnknownRows === 0 && unpricedModels.size === 0
+		dollarCoverage,
+		settleable,
+		monetarySettleable: settleable && dollarCoverage === "complete"
 	};
 }
 /** A cell that is absent by export convention: missing, null, or ''. */
@@ -16587,10 +16648,15 @@ function persistedTerminalEnvelope(input) {
 			outcome: {
 				status: settle.runStatus,
 				...settle.completion === void 0 ? {} : { completion: settle.completion },
+				...settle.deliverableAccepted === void 0 ? {} : { deliverableAccepted: settle.deliverableAccepted },
+				...settle.resultAvailable === void 0 ? {} : { resultAvailable: settle.resultAvailable },
+				...settle.acceptedArtifactRef === void 0 ? {} : { acceptedArtifactRef: settle.acceptedArtifactRef },
+				...settle.claimConsistencyMeta === void 0 ? {} : { claimConsistencyMeta: settle.claimConsistencyMeta },
 				usage: ledger.usage,
 				cost: costReportFromJournal(input.entries, input.priceUsd)
 			},
 			agentsSpawned: ledger.agentsSpawned,
+			...input.meta?.configFingerprint === void 0 ? {} : { configFingerprint: input.meta.configFingerprint },
 			provenance: "journal"
 		})
 	};
@@ -22549,6 +22615,7 @@ function validateOrchestrateOptions(opts) {
 		const stage = consistency.stage ?? "draft";
 		if (stage !== "draft" && stage !== "final" && stage !== "both") throw new ConfigError("orchestrate claimConsistency.stage must be 'draft', 'final' or 'both'; got " + JSON.stringify(consistency.stage));
 		if (stage !== "draft" && opts.synthesis === void 0) throw new ConfigError(`orchestrate claimConsistency.stage '${stage}' requires synthesis: without the post-fan-in invocation the coordination draft IS the final artifact, and the default 'draft' already judges it`);
+		if (stage === "final" && onFound === "carry") throw new ConfigError("orchestrate claimConsistency.onFound 'carry' cannot pair with stage 'final': the final pass runs after the synthesis, so there is no prompt left to carry the findings into; use 'report' or 'fail', or keep a carried draft pass with stage 'both'");
 		if (consistency.pattern !== void 0) {
 			if (typeof consistency.pattern !== "string") throw new ConfigError(`orchestrate claimConsistency.pattern must be a string; got ${typeof consistency.pattern}`);
 			let probe;
@@ -24848,7 +24915,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 				reason
 			}));
 			claimFindingsFound = findings;
-			claimConsistencyMeta = finishMeta({ judgeInvoked: true });
+			claimConsistencyMeta = finishMeta({
+				judgeInvoked: true,
+				findings: findings.length
+			});
 			announce();
 			if (onFound !== "fail" || findings.length === 0) return;
 			throw new FailRunError(`the claim-consistency judge found ${String(findings.length)} contradiction${findings.length === 1 ? "" : "s"} between the draft and the settled child pool: ` + findings.map((finding) => `${finding.anchor} (${finding.reason})`).join("; "), { data: {
@@ -28419,6 +28489,7 @@ function createEngine(options) {
 				workflow: wf.name,
 				outcome: outcomeFacts,
 				agentsSpawned: budget.spent().agentsSpawned,
+				...configFingerprint === void 0 ? {} : { configFingerprint },
 				...settlementFailure !== void 0 ? { settlement: {} } : supersededBy !== void 0 ? { settlement: { settledReason: "superseded" } } : {}
 			});
 			const outcome = {

package/package.json

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