@rulvar/core 1.78.0 → 1.79.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;
@@ -5682,7 +5692,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;
@@ -9112,6 +9138,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({
@@ -18254,6 +18265,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",
@@ -18505,6 +18526,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 +19356,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 +19827,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.79.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",