@rulvar/plan 1.234.0 → 1.236.0

package/dist/index.d.ts

@@ -984,6 +984,32 @@ interface PlanRunnerOptions {
   * enabling it changes toolsetHash by design. Default false.
   */
   kbPropose?: boolean;
+  /**
+  * Disarms the finish gate (RV3202). By default the coordination
+  * finish REFUSES while any plan node is ready or running, naming the
+  * stragglers, because the plan is the extension's authority: a root
+  * that finishes over a running node used to settle a bare ok while
+  * the exit barrier cancelled the node (the 2026-08-11 experiment's
+  * blocker). Opting out restores that pre-RV3202 behavior for hosts
+  * whose acceptance policy already owns the boundary. Default false.
+  */
+  allowEarlyFinish?: boolean;
+  /**
+  * The resume posture toward a drifted profile registry (RV3203, the
+  * 2026-08-11 experiment's resume blocker). The registry identity
+  * frozen in `termination.init` (profile names mapped to ladder
+  * lengths) is recomputed from the LIVE profiles on every resume:
+  * under `'refuse'` (the default) a mismatch terminates the resumed
+  * run typed BEFORE any model call, because ladders are live values
+  * the journal cannot rebuild and "the journal wins" is not honorable
+  * for them; `'warn'` downgrades the mismatch to the
+  * `termination:config-drift` event and proceeds under the live
+  * registry. Either way the mismatch is reported; a journal recorded
+  * before the hash shipped skips the check (absence means NOT
+  * RECORDED). The projection covers profile names and ladder lengths,
+  * not the models inside same-length rungs.
+  */
+  profileDrift?: "refuse" | "warn";
 }
 /**
 * Builds the PlanRunner orchestrator extension.

package/dist/index.js

@@ -1996,6 +1996,7 @@ const TERMINATION_DENIED_KEY_KIND = "termination.denied";
 * the `orchestratePlanned` convenience surface.
 */
 function planRunner(options) {
+	if (options?.profileDrift !== void 0 && options.profileDrift !== "refuse" && options.profileDrift !== "warn") throw new ConfigError(`PlanRunnerOptions.profileDrift must be 'refuse' or 'warn'; got ` + JSON.stringify(options.profileDrift));
 	let io;
 	let planScope = "plan";
 	let rootScope = "";
@@ -3684,6 +3685,11 @@ function planRunner(options) {
 			"plan_revise (add_task, amend_task, park_task, unpark_task, cancel_task,",
 			"reprioritize, rewire_deps, waive_dep), inspect it with plan_view, and sleep",
 			"with wait_for_events; the ENGINE schedules ready plan nodes for you.",
+			...options?.allowEarlyFinish === true ? [] : [
+				"finish is refused while any plan node is ready or running: wait for them",
+				"with wait_for_events, or close them deliberately with plan_revise",
+				"(cancel_task or park_task) before finishing."
+			],
 			...options?.kbPropose === true ? ["kb_propose records ONE quarantined model observation about a ladder tier of a", "journaled lineage; it renders into no prompt and commits nothing during the run."] : []
 		],
 		boot: async (bound) => {
@@ -3711,6 +3717,36 @@ function planRunner(options) {
 						liveValue
 					});
 				}
+				const liveUsd = {
+					runBudgetUsdCeiling: io.runCeilingUsd ?? 0,
+					orchestratorCapUsd: io.orchestratorCapUsd ?? 0,
+					finalizeReserveUsd: io.finalizeReserveUsd ?? 0
+				};
+				for (const [field, liveValue] of Object.entries(liveUsd)) {
+					const frozenValue = frozen[field];
+					if (typeof frozenValue === "number" && frozenValue !== 0 && frozenValue !== liveValue) io.emit({
+						type: "termination:config-drift",
+						field,
+						frozenValue,
+						liveValue
+					});
+				}
+				const frozenRegistryHash = folded.init.profileRegistrySnapshotHash;
+				if (typeof frozenRegistryHash === "string") {
+					const liveRegistryHash = profileRegistrySnapshotHash(io.profiles);
+					if (frozenRegistryHash !== liveRegistryHash) {
+						io.emit({
+							type: "termination:config-drift",
+							field: "profileRegistrySnapshotHash",
+							frozenValue: frozenRegistryHash,
+							liveValue: liveRegistryHash
+						});
+						if (options?.profileDrift !== "warn") {
+							io.terminate?.(new ConfigError(`resume: the profile registry drifted since run '${io.runId}' started (frozen ${frozenRegistryHash.slice(0, 12)}, live ${liveRegistryHash.slice(0, 12)}): profile names or ladder lengths changed, and the journaled plan cannot be honored under a different registry. Resume with the original profiles, or pass PlanRunnerOptions.profileDrift: 'warn' to proceed under the live registry deliberately`));
+							return;
+						}
+					}
+				}
 			} else {
 				const limits = validateTerminationLimits({
 					maxRevisionsPerRun: options?.maxRevisionsPerRun ?? 32,
@@ -3787,6 +3823,17 @@ function planRunner(options) {
 			absorbPlan();
 			return !Object.values(fold.plan.nodes).some((node) => node.status === "ready" || node.status === "running");
 		},
+		finishGate: () => {
+			if (options?.allowEarlyFinish === true) return { ok: true };
+			absorbPlan();
+			const live = Object.values(fold.plan.nodes).filter((node) => node.status === "ready" || node.status === "running").sort((a, b) => a.nodeId.localeCompare(b.nodeId));
+			if (live.length === 0) return { ok: true };
+			const named = live.slice(0, 8).map((node) => `${node.nodeId} (${node.logicalTaskId}, ${node.status})`).join(", ");
+			return {
+				ok: false,
+				reason: `finish refused: the plan still has ${String(live.length)} node(s) ready or running: ${named}${live.length > 8 ? ", ..." : ""}. Wait for them with wait_for_events, or close them deliberately with plan_revise (cancel_task or park_task), then call finish again`
+			};
+		},
 		digestExtras: () => {
 			absorbPlan();
 			const spend = DedupIndex.fold(io.snapshot(), { priceUsd: (servedBy, usage) => io.priceUsd(servedBy, usage) }).abandonedSpend();
@@ -4172,6 +4219,15 @@ async function runOscillationFreeze(options) {
 				prompt: "flip flop"
 			}
 		}], `oscillation ${String(phase)}`);
+		if (phase === 7) return { toolCall: {
+			name: "finish",
+			args: { result: "frozen" }
+		} };
+		if (phase === 8) return revise([{
+			op: "cancel_task",
+			nodeId: liveNode ?? "MISSING",
+			reason: "frozen: close out"
+		}], "close the straggler");
 		return { toolCall: {
 			name: "finish",
 			args: { result: "frozen" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/plan",
-  "version": "1.234.0",
+  "version": "1.236.0",
   "description": "Rulvar adaptive orchestration extension: PlanRunner, RunLedger, escalation extensions, ModelLadder configuration. Replans during the run; not the plan-writing hybrid mode, which is @rulvar/planner.",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,13 +22,13 @@
     "access": "public"
   },
   "dependencies": {
-    "@rulvar/core": "1.234.0"
+    "@rulvar/core": "1.236.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.1",
     "tsdown": "^0.22.14",
     "typescript": "~6.0.3",
-    "@rulvar/store-sqlite": "1.234.0"
+    "@rulvar/store-sqlite": "1.236.0"
   },
   "repository": {
     "type": "git",