@rulvar/core 1.78.0 → 1.80.0

package/dist/index.d.ts

@@ -3476,6 +3476,16 @@ type CoreEvents = {
   * nonnegative integers. Absent otherwise.
   */
   childStatusCounts?: Record<string, number>;
+  /**
+  * Per-child degradation notes, lifted from the same envelope (or
+  * typed error data) when it carries a valid string array (the
+  * fifth experiment, cycle 75). An empty array is the workflow's
+  * claim of zero degradation; absence means no claim. The outcome
+  * mirror spreads the SAME lift, so the surfaces cannot disagree.
+  */
+  degradedReasons?: string[]; /** Children accepted by acceptPartialChildren; same lift. */
+  salvagedPartialChildren?: string[]; /** Children accepted through validated terminal output salvage on 'limit'; same lift. */
+  salvagedTerminalOutputChildren?: string[];
 } | {
   type: "phase:start";
   phase: string;
@@ -4915,6 +4925,8 @@ interface BudgetAccountView {
   spentUsd: number;
   committedReserveUsd: number;
   finalizeReserveUsd: number;
+  /** The synthesis payload hold (cycle 76); zero when none is committed. */
+  synthesisReserveUsd: number;
   parentScope?: string;
 }
 /**
@@ -5071,6 +5083,21 @@ declare class RunBudget {
   * frozen past the cap, so nothing else can take it.
   */
   releaseFinalizeReserve(scope: string): void;
+  /**
+  * Registers the synthesis payload reserve (the sixth comparison
+  * experiment, cycle 76): absolute dollars held on the orchestrator
+  * account AND the run root, so neither spawn admission nor the
+  * per-turn output clamp lets the coordination prefix eat the money
+  * the synthesis finish needs. Unlike the finalize reserve it is
+  * released BEFORE the synthesis invocation dispatches (the held
+  * money is exactly what that invocation is meant to spend), and it
+  * never joins the severing check: a coordination running against the
+  * hold is clamped smaller, never aborted. Idempotent per account:
+  * re-registering adjusts the root by the delta.
+  */
+  commitSynthesisReserve(scope: string, reserveUsd: number): void;
+  /** The synthesis dispatch consumes its reserve; see commitSynthesisReserve. */
+  releaseSynthesisReserve(scope: string): void;
   /** The reserve is replaced by real spend when the spawn settles. */
   releaseReserve(reserveUsd: number, accountScope?: string): void;
   /** Layer 2: the per-turn guard. A turn that would cross any ceiling in the chain is not dispatched. */
@@ -5682,7 +5709,23 @@ type RunOutcome<R> = {
   * nonnegative integers; the mirror of the `run:end` field. Absent
   * otherwise.
   */
-  childStatusCounts?: Record<string, number>; /** Pipeline drops and onError:'null' losses; silent losses are forbidden. */
+  childStatusCounts?: Record<string, number>;
+  /**
+  * Per-child degradation notes, lifted from the same envelope (or
+  * typed error data) when it carries a valid string array (the fifth
+  * experiment, cycle 75): the facts the orchestrator acceptance path
+  * has always emitted beside completion, now on the outcome itself so
+  * a host stops digging error.data on the rejected path. An empty
+  * array is the workflow's claim of zero degradation; absence means no
+  * claim was made.
+  */
+  degradedReasons?: string[]; /** Children accepted by acceptPartialChildren; same lift and posture. */
+  salvagedPartialChildren?: string[];
+  /**
+  * Children accepted through validated terminal output salvage on
+  * 'limit'; same lift and posture.
+  */
+  salvagedTerminalOutputChildren?: string[]; /** Pipeline drops and onError:'null' losses; silent losses are forbidden. */
   dropped: DroppedItem[]; /** Suspensions open at settle time (M2). */
   pending: PendingExternal[];
   usage: Usage;
@@ -7098,6 +7141,21 @@ interface OrchestratorBudgetSpec {
   */
   finalizeReserveUsd?: number;
   /**
+  * The synthesis payload reserve (the sixth comparison experiment,
+  * cycle 76): absolute USD held out of the orchestrator sub account
+  * while the coordination loop runs, released to the synthesis
+  * invocation just before it dispatches. Without it a pricey
+  * coordination can leave the synthesis turns a remainder the budget
+  * clamp shrinks below the contract's minimal accepting payload: the
+  * finish is then cut at the output allowance before any tool call,
+  * the invocation dies at maxTurns, and a validator-bound run fails
+  * closed (the rematch run 1 lost an entire paid run exactly there).
+  * Requires the `synthesis` option (single mode); must stay below the
+  * effective cap. Declaring it changes budget arithmetic only; absent
+  * keeps every account byte identical.
+  */
+  synthesisReserveUsd?: number;
+  /**
   * A positive integer, validated before any journal entry or dispatch:
   * the turn limit of the reserved final wake.
   */
@@ -9112,6 +9170,19 @@ interface PreflightInput {
     * the repair-reserve-unfunded warning stays silent.
     */
     maxRepairs?: number;
+    /**
+    * Mirrors FinishValidationSpec.draftPolicy (the fifth experiment,
+    * cycle 75): declaring it lets the estimator compare the draft
+    * gate's word floor against the contract's own word minimum. The
+    * experiment gated drafts at 3200 words under a 4500 word contract,
+    * so the gate admitted a draft the final validators had to reject
+    * and the synthesis started from an underlength base; the
+    * draft-gate-below-contract warning names exactly that shape.
+    */
+    draftPolicy?: {
+      minWords?: number;
+      requireSections?: string[];
+    };
   };
 }
 /** One linter verdict; `spawn` names the wave entry it is about. */

package/dist/index.js

@@ -10740,24 +10740,35 @@ async function runAgent(options) {
 				skipped: true
 			}));
 		};
+		let terminalAdmitted = false;
 		for (const [index, call] of calls.entries()) {
-			if (limits.maxToolCalls !== void 0 && toolCallsUsed >= limits.maxToolCalls) {
-				closeSkippedTail(calls.slice(index), "maxToolCalls");
-				return {
-					parts,
-					limitHit: true,
-					limiter: "maxToolCalls",
-					skipped: calls.length - index
-				};
-			}
-			if (guard !== void 0 && guard.unitsExhausted()) {
-				closeSkippedTail(calls.slice(index), "toolUnits");
-				return {
-					parts,
-					limitHit: true,
-					limiter: "toolUnits",
-					skipped: calls.length - index
-				};
+			const expiredLimiter = limits.maxToolCalls !== void 0 && toolCallsUsed >= limits.maxToolCalls ? "maxToolCalls" : guard !== void 0 && guard.unitsExhausted() ? "toolUnits" : void 0;
+			if (expiredLimiter !== void 0) {
+				const tail = calls.slice(index);
+				const terminalName = options.terminalTool?.name;
+				if (!(terminalName !== void 0 && (terminalAdmitted || tail.some((candidate) => candidate.name === terminalName)))) {
+					closeSkippedTail(tail, expiredLimiter);
+					return {
+						parts,
+						limitHit: true,
+						limiter: expiredLimiter,
+						skipped: calls.length - index
+					};
+				}
+				if (call.name !== terminalName) {
+					parts.push(errorPart(call, {
+						error: "skipped: the tool budget is exhausted; the call was not executed",
+						limiter: expiredLimiter,
+						skipped: true
+					}));
+					continue;
+				}
+				terminalAdmitted = true;
+				events?.emit({
+					type: "log",
+					level: "warn",
+					msg: `terminal tool '${call.name}' admitted at the exhausted tool budget (${expiredLimiter}): terminal calls do not consume the budget`
+				});
 			}
 			const def = runtime.defs.find((candidate) => candidate.name === call.name);
 			events?.emit({
@@ -12130,6 +12141,7 @@ var RunBudget = class {
 			spentUsd: 0,
 			committedReserveUsd: 0,
 			finalizeReserveUsd: 0,
+			synthesisReserveUsd: 0,
 			controller: new AbortController()
 		};
 		if (options.ceilingUsd !== void 0) root.ceilingUsd = options.ceilingUsd;
@@ -12174,6 +12186,7 @@ var RunBudget = class {
 			spentUsd: 0,
 			committedReserveUsd: 0,
 			finalizeReserveUsd: options.finalizeReserveUsd ?? 0,
+			synthesisReserveUsd: 0,
 			parentScope,
 			controller: new AbortController()
 		};
@@ -12225,7 +12238,8 @@ var RunBudget = class {
 			scope: account.scope,
 			spentUsd: account.spentUsd,
 			committedReserveUsd: account.committedReserveUsd,
-			finalizeReserveUsd: account.finalizeReserveUsd
+			finalizeReserveUsd: account.finalizeReserveUsd,
+			synthesisReserveUsd: account.synthesisReserveUsd
 		};
 		if (account.ceilingUsd !== void 0) view.ceilingUsd = account.ceilingUsd;
 		if (account.parentScope !== void 0) view.parentScope = account.parentScope;
@@ -12239,7 +12253,7 @@ var RunBudget = class {
 	remainderOf(scope) {
 		const account = this.accounts.get(scope);
 		if (account?.ceilingUsd === void 0) return;
-		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd);
+		return Math.max(0, account.ceilingUsd - account.spentUsd - account.committedReserveUsd - account.finalizeReserveUsd - account.synthesisReserveUsd);
 	}
 	/**
 	* The tightest allowance headroom on the chain of `scope`: the minimum
@@ -12309,7 +12323,7 @@ var RunBudget = class {
 		const chain = this.chainOf(accountScope);
 		for (const account of chain) {
 			if (account.ceilingUsd === void 0) continue;
-			const committed = account.spentUsd + account.committedReserveUsd + account.finalizeReserveUsd;
+			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: {
@@ -12364,6 +12378,34 @@ var RunBudget = class {
 		this.root.finalizeReserveUsd = 0;
 		this.emitUpdate();
 	}
+	/**
+	* Registers the synthesis payload reserve (the sixth comparison
+	* experiment, cycle 76): absolute dollars held on the orchestrator
+	* account AND the run root, so neither spawn admission nor the
+	* per-turn output clamp lets the coordination prefix eat the money
+	* the synthesis finish needs. Unlike the finalize reserve it is
+	* released BEFORE the synthesis invocation dispatches (the held
+	* money is exactly what that invocation is meant to spend), and it
+	* never joins the severing check: a coordination running against the
+	* hold is clamped smaller, never aborted. Idempotent per account:
+	* re-registering adjusts the root by the delta.
+	*/
+	commitSynthesisReserve(scope, reserveUsd) {
+		const account = this.accounts.get(scope);
+		if (account === void 0) throw new ConfigError(`unknown budget account '${scope}' for the synthesis reserve`);
+		const previous = account.synthesisReserveUsd;
+		account.synthesisReserveUsd = reserveUsd;
+		if (account.scope !== "run") this.root.synthesisReserveUsd = Math.max(0, this.root.synthesisReserveUsd + reserveUsd - previous);
+		this.emitUpdate();
+	}
+	/** The synthesis dispatch consumes its reserve; see commitSynthesisReserve. */
+	releaseSynthesisReserve(scope) {
+		const account = this.accounts.get(scope);
+		if (account === void 0 || account.synthesisReserveUsd === 0) return;
+		if (account.scope !== "run") this.root.synthesisReserveUsd = Math.max(0, this.root.synthesisReserveUsd - account.synthesisReserveUsd);
+		account.synthesisReserveUsd = 0;
+		this.emitUpdate();
+	}
 	/** The reserve is replaced by real spend when the spawn settles. */
 	releaseReserve(reserveUsd, accountScope = "run") {
 		for (const account of this.chainOf(accountScope)) account.committedReserveUsd = Math.max(0, account.committedReserveUsd - reserveUsd);
@@ -12396,7 +12438,7 @@ var RunBudget = class {
 		let remainingUsd;
 		for (const account of this.chainOf(accountScope)) {
 			if (account.ceilingUsd === void 0) continue;
-			const headroom = account.ceilingUsd - account.spentUsd;
+			const headroom = account.ceilingUsd - account.spentUsd - account.synthesisReserveUsd;
 			remainingUsd = remainingUsd === void 0 ? headroom : Math.min(remainingUsd, headroom);
 		}
 		if (remainingUsd === void 0) return;
@@ -16148,6 +16190,11 @@ function validateOrchestrateOptions(opts) {
 	if (spec.capUsd !== void 0) requireNonNegativeNumber(spec.capUsd, "orchestrate budget.capUsd");
 	if (spec.capFraction !== void 0) requireFraction(spec.capFraction, "orchestrate budget.capFraction");
 	if (spec.finalizeReserveUsd !== void 0) requireNonNegativeNumber(spec.finalizeReserveUsd, "orchestrate budget.finalizeReserveUsd");
+	if (spec.synthesisReserveUsd !== void 0) {
+		requireNonNegativeNumber(spec.synthesisReserveUsd, "orchestrate budget.synthesisReserveUsd");
+		if (opts.synthesis === void 0) throw new ConfigError("orchestrate budget.synthesisReserveUsd requires the synthesis option: the reserve holds sub account money for the separate synthesis invocation");
+		if (opts.synthesis.mode === "incremental") throw new ConfigError("orchestrate budget.synthesisReserveUsd is incompatible with synthesis.mode 'incremental': the reserve protects the single post-fan-in invocation");
+	}
 	if (spec.finalizeTurns !== void 0) requirePositiveInteger(spec.finalizeTurns, "orchestrate budget.finalizeTurns");
 	if (spec.atCap !== void 0 && spec.atCap !== "finish-with-partial" && spec.atCap !== "fail-run") throw new ConfigError(`orchestrate budget.atCap must be 'finish-with-partial' or 'fail-run'; got ${String(spec.atCap)}`);
 }
@@ -16297,12 +16344,14 @@ function makeOrchestratorWorkflow(goal, opts) {
 					liveValue: internals.pricingVersion ?? "unpriced"
 				}] : []);
 				orchestratorAccount = callingState.scope === "" ? "orchestrator" : `${callingState.scope}/orchestrator`;
+				if (spec?.synthesisReserveUsd !== void 0 && frozen.capUsd <= spec.synthesisReserveUsd) throw new OrchestratorCapConfigError(`effectiveCap ${frozen.capUsd.toFixed(4)} USD is not above the synthesis reserve ${spec.synthesisReserveUsd.toFixed(4)} USD`);
 				internals.budget.openAccount(orchestratorAccount, {
 					parentScope: callingState.budgetScope ?? "run",
 					ceilingUsd: frozen.capUsd,
 					kind: "orchestrator-cap"
 				});
 				if (extension !== void 0) internals.budget.commitFinalizeReserve(orchestratorAccount, frozen.finalizeReserveUsd);
+				if (spec?.synthesisReserveUsd !== void 0 && spec.synthesisReserveUsd > 0) internals.budget.commitSynthesisReserve(orchestratorAccount, spec.synthesisReserveUsd);
 				capState = {
 					effectiveCapUsd: frozen.capUsd,
 					finalizeReserveUsd: frozen.finalizeReserveUsd,
@@ -16324,6 +16373,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					level: "warn",
 					msg: `orchestrator budget.capUsd ${spec.capUsd.toFixed(4)} USD is bounded to ${effectiveCapUsd.toFixed(4)} USD by the default capFraction 0.2 of the run ceiling (effectiveCap = min(capUsd, capFraction * ceiling)); pass capFraction: 1.0 to make capUsd the sole bound`
 				}, callingState.spanId);
+				if (spec?.synthesisReserveUsd !== void 0 && effectiveCapUsd <= spec.synthesisReserveUsd) throw new OrchestratorCapConfigError(`effectiveCap ${effectiveCapUsd.toFixed(4)} USD is not above the synthesis reserve ${spec.synthesisReserveUsd.toFixed(4)} USD: the coordination loop would have no money at all`);
 				orchestratorAccount = callingState.scope === "" ? "orchestrator" : `${callingState.scope}/orchestrator`;
 				internals.budget.openAccount(orchestratorAccount, {
 					parentScope: callingState.budgetScope ?? "run",
@@ -16331,6 +16381,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 					kind: "orchestrator-cap"
 				});
 				if (extension !== void 0) internals.budget.commitFinalizeReserve(orchestratorAccount, finalizeReserveUsd);
+				if (spec?.synthesisReserveUsd !== void 0 && spec.synthesisReserveUsd > 0) internals.budget.commitSynthesisReserve(orchestratorAccount, spec.synthesisReserveUsd);
 				capState = {
 					effectiveCapUsd,
 					finalizeReserveUsd,
@@ -17257,7 +17308,7 @@ function makeOrchestratorWorkflow(goal, opts) {
 			role: "orchestrate",
 			result: "full",
 			tools,
-			...capState === void 0 ? {} : { estCost: orchestratorAdmissionEstCostUsd(capState.effectiveCapUsd, orchestratorAccount === void 0 ? 0 : internals.budget.accountView(orchestratorAccount)?.finalizeReserveUsd ?? 0) },
+			...capState === void 0 ? {} : { estCost: orchestratorAdmissionEstCostUsd(capState.effectiveCapUsd, orchestratorAccount === void 0 ? 0 : (internals.budget.accountView(orchestratorAccount)?.finalizeReserveUsd ?? 0) + (internals.budget.accountView(orchestratorAccount)?.synthesisReserveUsd ?? 0)) },
 			...opts?.model === void 0 ? {} : { model: opts.model },
 			...opts?.limits === void 0 ? {} : { limits: opts.limits },
 			[kOnRunning]: (seq) => {
@@ -17573,7 +17624,10 @@ function makeOrchestratorWorkflow(goal, opts) {
 				}
 			}, callingState.spanId);
 			const synthesisState = { ...callingState };
-			if (orchestratorAccount !== void 0) synthesisState.budgetScope = orchestratorAccount;
+			if (orchestratorAccount !== void 0) {
+				synthesisState.budgetScope = orchestratorAccount;
+				internals.budget.releaseSynthesisReserve(orchestratorAccount);
+			}
 			const synthesisBreak = validationSpec === void 0 ? void 0 : validationAbort.signal;
 			if (synthesisBreak !== void 0) synthesisState.signal = callingState.signal === void 0 ? synthesisBreak : AbortSignal.any([callingState.signal, synthesisBreak]);
 			const synthesisOpts = {
@@ -18226,7 +18280,7 @@ function preflightEstimate(input) {
 				turns: projectedProviderTurnsOf(orchLimits, overallExecutedCeiling(orchLimits, toolCeilingsOf(orchLimits))) + coordinationRepairReserve,
 				count: 1
 			});
-			if (effectiveCapUsd !== void 0) orchestratorReserveUsd = Math.max(0, orchestratorAdmissionEstCostUsd(effectiveCapUsd, reservedForFinalizationUsd));
+			if (effectiveCapUsd !== void 0) orchestratorReserveUsd = Math.max(0, orchestratorAdmissionEstCostUsd(effectiveCapUsd, reservedForFinalizationUsd + (input.orchestrator.budget?.synthesisReserveUsd ?? 0)));
 			else if (pricing === void 0) orchestratorReserveUsd = 0;
 			else orchestratorReserveUsd = admissionReserveUsd({
 				...input.orchestrator.estInputTokens === void 0 ? {} : { inputTokens: input.orchestrator.estInputTokens },
@@ -18254,6 +18308,16 @@ function preflightEstimate(input) {
 					spawn: "synthesis"
 				});
 			}
+			{
+				const synthesisToolCap = synthesis.limits?.maxToolCalls;
+				const expectedReads = input.orchestrator?.maxSpawns ?? 1;
+				if (synthesis.exposeChildResultTools === true && synthesisToolCap !== void 0 && synthesisToolCap < expectedReads) say({
+					severity: "warning",
+					code: "synthesis-terminal-tool-headroom",
+					message: `synthesis.limits.maxToolCalls ${String(synthesisToolCap)} cannot cover one get_child_result read per child (${input.orchestrator?.maxSpawns === void 0 ? "at least 1 read" : `maxSpawns ${String(expectedReads)}`}): the reads exhaust the tool budget and the synthesis loses evidence access (the terminal finish is admitted budget free and needs no slot); raise the cap to at least the child count plus paging margin, or use context 'full' without the read tools`,
+					spawn: "synthesis"
+				});
+			}
 			const servedBy = resolveServing(synthesis.model) ?? resolveServing(defaults.routing?.synthesize);
 			if (servedBy === void 0) say({
 				severity: "error",
@@ -18272,6 +18336,21 @@ function preflightEstimate(input) {
 					spawn: "synthesis"
 				});
 				contractFeasibilityFindings(outputBound, "synthesis", servedBy);
+				{
+					const contract = input.finishValidation?.contract;
+					const pricing = pricingOf(servedBy);
+					if (contract !== void 0 && pricing !== void 0 && pricing.outputUsdPerMTok > 0) {
+						const minTokens = Math.ceil(JSON.stringify({ result: contract.goldenAccept.text }).length / 4);
+						const payloadUsd = minTokens / 1e6 * pricing.outputUsdPerMTok;
+						const declared = input.orchestrator?.budget?.synthesisReserveUsd;
+						if (declared === void 0 || declared < payloadUsd) say({
+							severity: "warning",
+							code: "synthesis-reserve-unfunded",
+							message: `the contract's minimal accepting payload is about ${String(minTokens)} output tokens, about ${payloadUsd.toFixed(4)} USD at the output rate of '${servedBy}', and the orchestrator sub account holds ${declared === void 0 ? "no synthesis reserve" : `only ${declared.toFixed(4)} USD`} for it: a pricey coordination prefix can leave the synthesis turns a remainder the budget clamp shrinks below the payload, cutting the finish before any tool call; declare budget.synthesisReserveUsd at or above the payload price`,
+							spawn: "synthesis"
+						});
+					}
+				}
 				const projected = projectedProviderTurnsOf(merged, overallExecutedCeiling(merged, toolCeilingsOf(merged))) + finishRepairReserve;
 				if (orchestratorEcho !== void 0) orchestratorEcho.synthesis = {
 					projectedProviderTurns: projected,
@@ -18294,10 +18373,12 @@ function preflightEstimate(input) {
 	let committed = 0;
 	let spawned = 0;
 	let children = 0;
-	const admitAgainstRoot = (reserveUsd) => {
+	const admitAgainstRoot = (reserveUsd, strictAtFill = false) => {
 		if (ceilingUsd === void 0) return true;
 		const held = committed + reservedForFinalizationUsd;
-		return !(held >= ceilingUsd || held + reserveUsd > ceilingUsd);
+		if (held >= ceilingUsd) return false;
+		const fill = held + reserveUsd;
+		return strictAtFill ? fill < ceilingUsd : fill <= ceilingUsd;
 	};
 	if (input.orchestrator !== void 0) {
 		const reserveUsd = orchestratorReserveUsd ?? flatReserveUsd;
@@ -18329,9 +18410,9 @@ function preflightEstimate(input) {
 				if (orchestrateWave && ceilingUsd !== void 0) {
 					const remainder = ceilingUsd - committed - reservedForFinalizationUsd;
 					const projection = dispatchProjectionReserveUsd(gate, flatReserveUsd);
-					if (remainder <= 0 || remainder < projection) deniedBy = "budget";
+					if (remainder <= 0 || remainder <= projection) deniedBy = "budget";
 				}
-				if (deniedBy === void 0 && !admitAgainstRoot(reserveUsd)) deniedBy = "budget";
+				if (deniedBy === void 0 && !admitAgainstRoot(reserveUsd, orchestrateWave)) deniedBy = "budget";
 			}
 			wave.push({
 				label,
@@ -18505,6 +18586,16 @@ function preflightEstimate(input) {
 				message: `finishValidation grants up to ${String(grantedRepairs)} repair exchange(s) but declares no repairTurnReserve: a rejected finish burns an ordinary turn and a window at maxTurns settles 'limit' with the repair unspent; set finishValidation.repairTurnReserve to fund the repair exchanges`
 			});
 		}
+		{
+			const draftMinWords = fv.draftPolicy?.minWords;
+			if (draftMinWords !== void 0) requireNonNegativeInteger(draftMinWords, "preflight finishValidation.draftPolicy.minWords");
+			const contractMinWords = fv.contract?.manifest.words?.min;
+			if (draftMinWords !== void 0 && contractMinWords !== void 0 && draftMinWords < contractMinWords) findings.push({
+				severity: "warning",
+				code: "draft-gate-below-contract",
+				message: `draftPolicy.minWords ${String(draftMinWords)} sits below the contract word minimum ${String(contractMinWords)}: the draft gate admits drafts the final validators must reject, so the synthesis starts from an underlength base; raise draftPolicy.minWords to the contract minimum or above`
+			});
+		}
 		if (fv.contract !== void 0) {
 			for (const contractValidator of fv.contract.validators) if (!names.has(contractValidator.name)) findings.push({
 				severity: "error",
@@ -19325,15 +19416,23 @@ function liftRunCompletion(candidate) {
 	if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) return;
 	const completion = candidate.completion;
 	if (completion !== "complete" && completion !== "partial" && completion !== "rejected") return;
+	const lifted = { completion };
 	const counts = candidate.childStatusCounts;
 	if (typeof counts === "object" && counts !== null && !Array.isArray(counts)) {
 		const entries = Object.entries(counts);
-		if (entries.every(([, value]) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) return {
-			completion,
-			childStatusCounts: Object.fromEntries(entries)
-		};
+		if (entries.every(([, value]) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0)) lifted.childStatusCounts = Object.fromEntries(entries);
 	}
-	return { completion };
+	const liftStringList = (key) => {
+		const value = candidate[key];
+		return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? [...value] : void 0;
+	};
+	const degradedReasons = liftStringList("degradedReasons");
+	if (degradedReasons !== void 0) lifted.degradedReasons = degradedReasons;
+	const salvagedPartialChildren = liftStringList("salvagedPartialChildren");
+	if (salvagedPartialChildren !== void 0) lifted.salvagedPartialChildren = salvagedPartialChildren;
+	const salvagedTerminalOutputChildren = liftStringList("salvagedTerminalOutputChildren");
+	if (salvagedTerminalOutputChildren !== void 0) lifted.salvagedTerminalOutputChildren = salvagedTerminalOutputChildren;
+	return lifted;
 }
 /**
 * sha256 hex over the JCS canonical serialization of a run's args: the
@@ -19788,6 +19887,9 @@ function createEngine(options) {
 			if (lifted !== void 0) {
 				outcome.completion = lifted.completion;
 				if (lifted.childStatusCounts !== void 0) outcome.childStatusCounts = lifted.childStatusCounts;
+				if (lifted.degradedReasons !== void 0) outcome.degradedReasons = lifted.degradedReasons;
+				if (lifted.salvagedPartialChildren !== void 0) outcome.salvagedPartialChildren = lifted.salvagedPartialChildren;
+				if (lifted.salvagedTerminalOutputChildren !== void 0) outcome.salvagedTerminalOutputChildren = lifted.salvagedTerminalOutputChildren;
 			}
 			let settlementFailure;
 			if (resumeCtx?.strict !== true) {

package/package.json

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