@rulvar/cli 1.24.1 → 1.26.0

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { r as runCli, t as processIo } from "./io-CV_G44A2.js";
+import { r as runCli, t as processIo } from "./io-C3T5nbNg.js";
+import { sanitizeTerminalText } from "@rulvar/core";
 import { inspect } from "node:util";
 //#region src/cli.ts
 /**
@@ -11,7 +12,8 @@ runCli(process.argv.slice(2), {
 }).then((code) => {
 	process.exitCode = code;
 }, (thrown) => {
-	process.stderr.write(`${inspect(thrown)}\n`);
+	const rendered = inspect(thrown).split("\n").map(sanitizeTerminalText).join("\n");
+	process.stderr.write(`${rendered}\n`);
 	process.exitCode = 1;
 });
 //#endregion

package/dist/index.d.ts

@@ -142,7 +142,13 @@ declare function driveRun(options: {
   io: CliIo; /** Original run arguments: not journaled in v1, the host re-supplies them. */
   args?: unknown;
 }): Promise<RunOutcome<unknown>>;
-/** Renders the settled outcome; returns the process exit code. */
+/**
+* Renders the settled outcome; returns the process exit code. Error
+* messages, suspension keys, model refs, and phase names originate from
+* providers, tools, and workflow authors, so each is sanitized before
+* it reaches a terminal line, matching the TUI renderer (v1.24.1 review
+* P2-1). Values print as JSON, which escapes control bytes on its own.
+*/
 declare function reportOutcome(outcome: RunOutcome<unknown>, io: CliIo): number;
 //#endregion
 //#region src/server.d.ts
@@ -158,12 +164,43 @@ interface CreateServerOptions {
   */
   priceUsd?: (servedBy: ModelRef, usage: Usage) => number | undefined;
   /**
-  * Opt-in retention (OQ-20 executed at M8-T04): evaluated
+  * Opt-in DURABLE retention (OQ-20 executed at M8-T04): evaluated
   * when a tracked run settles terminally; a true verdict applies
   * engine.deleteRun (transcript cascade, then the journal) and
-  * untracks the run. Absent means everything persists indefinitely.
+  * untracks the run. This deletes the durable record; to release only
+  * process memory, use `memoryRetention` or `maxTrackedRuns`. Absent
+  * means nothing is deleted.
   */
   retention?: (meta: RunMeta) => boolean;
+  /**
+  * Opt-in retention of PROCESS MEMORY, decoupled from the durable kind
+  * (v1.25.0 scale review P1-2): evaluated when a tracked run settles
+  * terminally, after `retention`; a true verdict releases the tracked
+  * state (args, outcome, handle, SSE buffer) while the journal and
+  * transcripts stay untouched, after which GET status/cost serve from
+  * the store exactly as for a run another process owns, and GET events
+  * answers with the documented empty stream for a run not live here.
+  */
+  memoryRetention?: (meta: RunMeta) => boolean;
+  /**
+  * Cap on SETTLED tracked runs kept in process memory: when a run
+  * settles terminally and neither retention released it, the oldest
+  * settled tracked runs beyond the cap are released exactly like a
+  * `memoryRetention` verdict (durable state untouched). Live runs are
+  * never evicted and do not count toward the cap. Absent means no cap.
+  */
+  maxTrackedRuns?: number;
+  /**
+  * Upper bound on buffered SSE replay events per tracked run: past the
+  * bound the OLDEST buffered events are dropped in chunks (so the
+  * retained replay window stays at least seven eighths of the bound)
+  * and counted. A replay that no longer reaches back to a client's
+  * cursor carries `x-rulvar-events-dropped: <count>` and a leading SSE
+  * comment naming the first retained seq; the journal remains the
+  * durable record of the run itself. Absent means unbounded (the
+  * historical behavior).
+  */
+  maxBufferedEventsPerRun?: number;
 }
 interface RulvarServer {
   fetch(req: Request): Promise<Response>;

package/dist/index.js

@@ -1,5 +1,5 @@
-import { a as resumeCommand, c as driveRun, d as renderEventLine, f as DEFAULT_STORE_DIR, g as looksLikeFile, h as loadWorkflowModule, i as inspectCommand, l as reportOutcome, m as loadCliConfig, n as HELP, o as runCommand, p as assembleEngine, r as runCli, s as runsLsCommand, t as processIo, u as attachProgress } from "./io-CV_G44A2.js";
-import { ConfigError, InvalidResolutionError, JournalCompatibilityError, LeaseHeldError, Replayer, RulvarError, buildDeriverRegistry, costReportFromJournal, maskSecrets, normalizeEntry, scanJournalCompatibility, validateSchemaSpec } from "@rulvar/core";
+import { a as resumeCommand, c as driveRun, d as renderEventLine, f as DEFAULT_STORE_DIR, g as looksLikeFile, h as loadWorkflowModule, i as inspectCommand, l as reportOutcome, m as loadCliConfig, n as HELP, o as runCommand, p as assembleEngine, r as runCli, s as runsLsCommand, t as processIo, u as attachProgress } from "./io-C3T5nbNg.js";
+import { ConfigError, InvalidResolutionError, JournalCompatibilityError, LeaseHeldError, Replayer, RulvarError, buildDeriverRegistry, costReportFromJournal, maskSecrets, normalizeEntry, readRunMeta, scanJournalCompatibility, validateSchemaSpec } from "@rulvar/core";
 //#region src/server.ts
 /**
 * createServer (M8-T01): the HTTP shell over the public engine API
@@ -77,13 +77,39 @@ function createServer(options) {
 	const { engine, workflows } = options;
 	const journal = engine.stores.journal;
 	const runs = /* @__PURE__ */ new Map();
+	/**
+	* Buffers one event under the configured bound. Overflow drops the
+	* oldest chunk (an eighth of the bound) in one splice, so the
+	* amortized cost per event stays O(1) and the retained window never
+	* falls below seven eighths of the bound.
+	*/
+	function pushBuffered(run, event) {
+		run.buffer.push(event);
+		const max = options.maxBufferedEventsPerRun;
+		if (max !== void 0 && run.buffer.length > max) {
+			const chunk = Math.max(1, Math.floor(max / 8));
+			run.buffer.splice(0, chunk);
+			run.dropped += chunk;
+		}
+	}
+	/**
+	* Releases settled tracked runs beyond maxTrackedRuns, oldest first
+	* (Map insertion order), durable state untouched. Live runs never
+	* count and are never evicted.
+	*/
+	function enforceTrackedCap() {
+		const cap = options.maxTrackedRuns;
+		if (cap === void 0) return;
+		const settled = [...runs.values()].filter((run) => run.done);
+		for (const run of settled.slice(0, Math.max(0, settled.length - cap))) runs.delete(run.runId);
+	}
 	/** Pumps one resume segment's events into the buffer and the feeds. */
 	function attach(run, handle) {
 		run.handle = handle;
 		run.outcome = void 0;
 		(async () => {
 			for await (const event of handle.events) {
-				run.buffer.push(event);
+				pushBuffered(run, event);
 				for (const feed of [...run.feeds]) feed(event);
 			}
 		})().catch(() => void 0);
@@ -93,12 +119,18 @@ function createServer(options) {
 				run.done = true;
 				for (const feed of [...run.feeds]) feed(null);
 				run.feeds.clear();
-				if (options.retention !== void 0) (async () => {
-					const meta = await metaOf(run.runId);
+				(async () => {
+					const meta = options.retention === void 0 && options.memoryRetention === void 0 ? void 0 : await metaOf(run.runId);
 					if (meta !== void 0 && options.retention?.(meta) === true) {
 						await engine.deleteRun(run.runId);
 						runs.delete(run.runId);
+						return;
+					}
+					if (meta !== void 0 && options.memoryRetention?.(meta) === true) {
+						runs.delete(run.runId);
+						return;
 					}
+					enforceTrackedCap();
 				})().catch(() => void 0);
 			}
 		}).catch(() => void 0);
@@ -109,6 +141,7 @@ function createServer(options) {
 			workflowName,
 			args,
 			buffer: [],
+			dropped: 0,
 			feeds: /* @__PURE__ */ new Set(),
 			handle,
 			done: false,
@@ -119,7 +152,7 @@ function createServer(options) {
 		return run;
 	}
 	async function metaOf(runId) {
-		return (await journal.listRuns()).find((meta) => meta.runId === runId);
+		return readRunMeta(journal, runId);
 	}
 	async function startRun(req) {
 		let body;
@@ -221,19 +254,35 @@ function createServer(options) {
 		const lastEventId = req.headers.get("last-event-id");
 		const encoder = new TextEncoder();
 		let feed;
+		let cursor;
+		if (lastEventId !== null) {
+			const parsed = Number(lastEventId);
+			if (Number.isFinite(parsed)) cursor = parsed;
+		}
+		let startIndex = 0;
+		if (cursor !== void 0) {
+			let lo = 0;
+			let hi = run.buffer.length;
+			while (lo < hi) {
+				const mid = lo + hi >> 1;
+				if (run.buffer[mid].seq <= cursor) lo = mid + 1;
+				else hi = mid;
+			}
+			startIndex = lo;
+		}
+		const firstRetained = run.buffer.length > 0 ? run.buffer[0].seq : void 0;
+		const gap = run.dropped > 0 && (cursor === void 0 || firstRetained === void 0 || cursor < firstRetained);
+		const headers = {
+			"content-type": "text/event-stream",
+			"cache-control": "no-cache",
+			...run.dropped > 0 ? { "x-rulvar-events-dropped": String(run.dropped) } : {}
+		};
 		const stream = new ReadableStream({
 			start(controller) {
-				let startIndex = 0;
-				if (lastEventId !== null) {
-					const cursor = Number(lastEventId);
-					if (Number.isFinite(cursor)) {
-						for (let i = run.buffer.length - 1; i >= 0; i -= 1) if (run.buffer[i].seq === cursor) {
-							startIndex = i + 1;
-							break;
-						}
-					}
-				}
-				for (const event of run.buffer.slice(startIndex)) controller.enqueue(encoder.encode(sseFrame(event)));
+				if (gap) controller.enqueue(encoder.encode(`: replay window starts at seq ${String(firstRetained ?? "none")}; ${run.dropped} earlier events were dropped from the in-memory buffer (the journal is the durable record)
+
+`));
+				for (let i = startIndex; i < run.buffer.length; i += 1) controller.enqueue(encoder.encode(sseFrame(run.buffer[i])));
 				if (run.done) {
 					controller.close();
 					return;
@@ -257,10 +306,7 @@ function createServer(options) {
 		});
 		return new Response(stream, {
 			status: 200,
-			headers: {
-				"content-type": "text/event-stream",
-				"cache-control": "no-cache"
-			}
+			headers
 		});
 	}
 	/** The tracked path: live (or settled-suspended) in this process. */
@@ -487,14 +533,28 @@ function createWorker(engine, options) {
 	const pollMs = options.pollMs ?? 1e3;
 	const registry = buildDeriverRegistry(options.extraDerivers);
 	const active = /* @__PURE__ */ new Map();
-	/** Runs this worker must not retry (DEF-6 violations, binding errors). */
-	const poisoned = /* @__PURE__ */ new Set();
 	/**
-	* Journal length at our last release of a still-suspended run: nothing
-	* new to consume until it grows (an offline resolution appends).
+	* Runs this worker must not retry (DEF-6 violations, binding errors),
+	* keyed to the run's generation (RunMeta.genesis) at poison time: a
+	* deleteRun and recreate of the same runId is a NEW run and must not
+	* inherit the poison. Entries for runIds that leave the candidate set
+	* are dropped each sweep, so an external delete cannot pin
+	* process-local state forever (v1.25.0 scale review).
+	*/
+	const poisoned = /* @__PURE__ */ new Map();
+	/**
+	* Journal length AND generation at our last release of a
+	* still-suspended run: nothing new to consume until the journal grows
+	* (an offline resolution appends) or the generation changes (the same
+	* runId was deleted and recreated; length alone cannot tell the new
+	* run from the old unchanged one, the v1.25.0 scale review). Runs
+	* whose meta predates the genesis field compare as equal when both
+	* sides are undefined, the historical behavior of length alone.
 	*/
 	const suspendedAt = /* @__PURE__ */ new Map();
 	let pollTimer;
+	/** An interval tick never overlaps a sweep that is still running. */
+	let sweeping = false;
 	let stopping = false;
 	function reportError(runId, error) {
 		try {
@@ -523,10 +583,13 @@ function createWorker(engine, options) {
 		const settled = handle.result.then(async (outcome) => {
 			if (outcome.status === "suspended") {
 				const entries = await store.load(runId);
-				suspendedAt.set(runId, entries.length);
+				suspendedAt.set(runId, {
+					length: entries.length,
+					genesis: meta.genesis
+				});
 			} else suspendedAt.delete(runId);
 		}).catch((thrown) => {
-			if (thrown instanceof ConfigError || thrown instanceof JournalCompatibilityError) poisoned.add(runId);
+			if (thrown instanceof ConfigError || thrown instanceof JournalCompatibilityError) poisoned.set(runId, meta.genesis);
 			reportError(runId, thrown);
 		}).finally(async () => {
 			clearInterval(renewTimer);
@@ -562,45 +625,58 @@ function createWorker(engine, options) {
 		}
 	}
 	async function sweep() {
-		if (stopping) return 0;
-		let picked = 0;
-		const metas = await store.listRuns();
-		for (const meta of metas) {
-			if (active.size >= concurrency) break;
-			if (!CANDIDATE_STATUSES.has(meta.status)) {
-				if (options.retention !== void 0 && !active.has(meta.runId)) await applyRetention(meta).catch((thrown) => {
-					reportError(meta.runId, thrown);
-				});
-				continue;
-			}
-			if (active.has(meta.runId) || poisoned.has(meta.runId)) continue;
-			let lease;
-			try {
-				lease = await store.acquire(meta.runId, owner);
-			} catch (thrown) {
-				if (thrown instanceof LeaseHeldError) continue;
-				throw thrown;
-			}
-			try {
-				const entries = (await store.load(meta.runId)).map((raw) => normalizeEntry(raw));
-				scanJournalCompatibility(meta.runId, entries, registry);
-				if (meta.status === "suspended" && suspendedAt.get(meta.runId) === entries.length) {
-					await releaseQuietly(lease);
+		if (stopping || sweeping) return 0;
+		sweeping = true;
+		try {
+			let picked = 0;
+			const metas = options.retention === void 0 ? await store.listRuns({ statuses: [...CANDIDATE_STATUSES] }) : await store.listRuns();
+			const candidateIds = new Set(metas.filter((meta) => CANDIDATE_STATUSES.has(meta.status)).map((meta) => meta.runId));
+			for (const runId of [...suspendedAt.keys()]) if (!candidateIds.has(runId)) suspendedAt.delete(runId);
+			for (const runId of [...poisoned.keys()]) if (!candidateIds.has(runId)) poisoned.delete(runId);
+			for (const meta of metas) {
+				if (active.size >= concurrency) break;
+				if (!CANDIDATE_STATUSES.has(meta.status)) {
+					if (options.retention !== void 0 && !active.has(meta.runId)) await applyRetention(meta).catch((thrown) => {
+						reportError(meta.runId, thrown);
+					});
 					continue;
 				}
-				picked += 1;
-				drive(meta.runId, meta, lease);
-			} catch (thrown) {
-				await releaseQuietly(lease);
-				if (thrown instanceof JournalCompatibilityError || thrown instanceof ConfigError) {
-					poisoned.add(meta.runId);
+				if (active.has(meta.runId)) continue;
+				if (poisoned.has(meta.runId)) {
+					if (poisoned.get(meta.runId) === meta.genesis) continue;
+					poisoned.delete(meta.runId);
+				}
+				let lease;
+				try {
+					lease = await store.acquire(meta.runId, owner);
+				} catch (thrown) {
+					if (thrown instanceof LeaseHeldError) continue;
+					throw thrown;
+				}
+				try {
+					const entries = (await store.load(meta.runId)).map((raw) => normalizeEntry(raw));
+					scanJournalCompatibility(meta.runId, entries, registry);
+					const cached = suspendedAt.get(meta.runId);
+					if (meta.status === "suspended" && cached !== void 0 && cached.length === entries.length && cached.genesis === meta.genesis) {
+						await releaseQuietly(lease);
+						continue;
+					}
+					picked += 1;
+					drive(meta.runId, meta, lease);
+				} catch (thrown) {
+					await releaseQuietly(lease);
+					if (thrown instanceof JournalCompatibilityError || thrown instanceof ConfigError) {
+						poisoned.set(meta.runId, meta.genesis);
+						reportError(meta.runId, thrown);
+						continue;
+					}
 					reportError(meta.runId, thrown);
-					continue;
 				}
-				reportError(meta.runId, thrown);
 			}
+			return picked;
+		} finally {
+			sweeping = false;
 		}
-		return picked;
 	}
 	return {
 		start: () => {

package/dist/{io-CV_G44A2.js → io-C3T5nbNg.js}

@@ -1,4 +1,4 @@
-import { ConfigError, FileModelKnowledgeStore, INBOX_PROPOSAL_TTL_DAYS, JsonlFileStore, claimExpired, claimExpiry, compilePermissionPreset, costReportFromJournal, createEngine, hashRunArgs, parseModelRef, priceUsdOf, proposalStatement, remeasureQueue, resolvePricing, runProfile, sanitizeTerminalText } from "@rulvar/core";
+import { ConfigError, FileModelKnowledgeStore, INBOX_PROPOSAL_TTL_DAYS, JsonlFileStore, claimExpired, claimExpiry, compilePermissionPreset, costReportFromJournal, createEngine, hashRunArgs, parseModelRef, priceUsdOf, proposalStatement, readRunMeta, remeasureQueue, resolvePricing, runProfile, sanitizeTerminalText } from "@rulvar/core";
 import { join, resolve } from "node:path";
 import { existsSync, statSync } from "node:fs";
 import { pathToFileURL } from "node:url";
@@ -234,6 +234,13 @@ function attachProgress(handle, io) {
 }
 //#endregion
 //#region src/drive.ts
+/**
+* The run/suspend/resolve/resume loop shared by `rulvar run` and
+* `rulvar resume` (the CLI performs interactive resolution of suspended
+* approvals and external inputs). Prompts read
+* one line per pending suspension; EOF leaves the run suspended with a
+* notice, never an error.
+*/
 const APPROVAL_PREFIX = "approval:";
 /** Parses an approval answer; undefined = unusable input. */
 function approvalDecision(answer) {
@@ -259,31 +266,32 @@ function approvalDecision(answer) {
 async function resolvePending(handle, pending, io) {
 	let applied = 0;
 	for (const item of pending) {
+		const keyRef = sanitizeTerminalText(item.key);
 		if (item.key.startsWith(APPROVAL_PREFIX)) {
-			const answer = await io.prompt(`approve '${item.prompt ?? item.key}'? [allow/deny]`);
+			const answer = await io.prompt(`approve '${sanitizeTerminalText(item.prompt ?? item.key)}'? [allow/deny]`);
 			if (answer === void 0) return applied;
 			const decision = approvalDecision(answer);
 			if (decision === void 0) {
-				io.err(`unrecognized answer '${answer.trim()}'; leaving ${item.key} suspended`);
+				io.err(`unrecognized answer '${sanitizeTerminalText(answer.trim())}'; leaving ${keyRef} suspended`);
 				continue;
 			}
 			const outcome = await handle.resolveExternal(item.key, decision);
-			io.err(`approval ${item.key}: ${decision.decision} (${outcome.applied ? "applied" : outcome.reason})`);
+			io.err(`approval ${keyRef}: ${decision.decision} (${outcome.applied ? "applied" : sanitizeTerminalText(outcome.reason)})`);
 			if (outcome.applied) applied += 1;
 			continue;
 		}
-		const label = item.prompt === void 0 ? item.key : `${item.key} (${item.prompt})`;
+		const label = item.prompt === void 0 ? keyRef : `${keyRef} (${sanitizeTerminalText(item.prompt)})`;
 		const answer = await io.prompt(`value for external '${label}' as JSON:`);
 		if (answer === void 0) return applied;
 		let value;
 		try {
 			value = JSON.parse(answer);
 		} catch {
-			io.err(`not valid JSON; leaving '${item.key}' suspended`);
+			io.err(`not valid JSON; leaving '${keyRef}' suspended`);
 			continue;
 		}
 		const outcome = await handle.resolveExternal(item.key, value);
-		io.err(`external '${item.key}': ${outcome.applied ? "applied" : outcome.reason}`);
+		io.err(`external '${keyRef}': ${outcome.applied ? "applied" : sanitizeTerminalText(outcome.reason)}`);
 		if (outcome.applied) applied += 1;
 	}
 	return applied;
@@ -320,29 +328,35 @@ async function reportDryRun(handle, io) {
 	io.err(`  hits: ${preview.hits}  misses: ${preview.misses}  reruns: ${preview.reruns}  skipped: ${preview.skipped}`);
 	io.err(preview.orphaned.length === 0 ? "  orphaned effect roots: none" : `  orphaned effect roots (entryRefs): ${preview.orphaned.join(", ")}`);
 	if (preview.invalidResolutions.length === 0) io.err("  invalid resolutions: none");
-	else for (const invalid of preview.invalidResolutions) io.err(`  invalid resolution at seq ${invalid.seq}: ${invalid.detail}`);
+	else for (const invalid of preview.invalidResolutions) io.err(`  invalid resolution at seq ${invalid.seq}: ${sanitizeTerminalText(invalid.detail)}`);
 	if (outcome.error?.code === "journal_miss") {
-		io.err(`  stopped at the first would-be-live call: ${outcome.error.message}`);
+		io.err(`  stopped at the first would-be-live call: ${sanitizeTerminalText(outcome.error.message)}`);
 		io.err("  a real resume would perform new paid work from this point");
 		return 0;
 	}
 	io.err(`  would settle: ${outcome.status}`);
-	if (outcome.error !== void 0) io.err(`  error: ${outcome.error.message}`);
-	for (const pending of outcome.pending) io.err(`  pending: ${pending.key} (entry ${pending.entryRef})`);
+	if (outcome.error !== void 0) io.err(`  error: ${sanitizeTerminalText(outcome.error.message)}`);
+	for (const pending of outcome.pending) io.err(`  pending: ${sanitizeTerminalText(pending.key)} (entry ${pending.entryRef})`);
 	if (outcome.value !== void 0) io.out(JSON.stringify(outcome.value, null, 2));
 	return 0;
 }
-/** Renders the settled outcome; returns the process exit code. */
+/**
+* Renders the settled outcome; returns the process exit code. Error
+* messages, suspension keys, model refs, and phase names originate from
+* providers, tools, and workflow authors, so each is sanitized before
+* it reaches a terminal line, matching the TUI renderer (v1.24.1 review
+* P2-1). Values print as JSON, which escapes control bytes on its own.
+*/
 function reportOutcome(outcome, io) {
 	io.err(`status: ${outcome.status}`);
 	if (outcome.value !== void 0) io.out(JSON.stringify(outcome.value, null, 2));
-	if (outcome.error !== void 0) io.err(`error: ${outcome.error.message}`);
+	if (outcome.error !== void 0) io.err(`error: ${sanitizeTerminalText(outcome.error.message)}`);
 	if (outcome.dropped.length > 0) io.err(`dropped: ${outcome.dropped.length} item(s)`);
-	for (const pending of outcome.pending) io.err(`pending: ${pending.key} (entry ${pending.entryRef})`);
+	for (const pending of outcome.pending) io.err(`pending: ${sanitizeTerminalText(pending.key)} (entry ${pending.entryRef})`);
 	io.err(`cost: $${outcome.cost.totalUsd.toFixed(4)}`);
-	for (const [model, usd] of Object.entries(outcome.cost.byModel)) io.err(`  by model ${model}: $${usd.toFixed(4)}`);
-	for (const [phase, usd] of Object.entries(outcome.cost.byPhase)) if (phase !== "") io.err(`  by phase ${phase}: $${usd.toFixed(4)}`);
-	if (outcome.cost.unpriced.length > 0) io.err(`unpriced models: ${outcome.cost.unpriced.map((u) => u.model).join(", ")}`);
+	for (const [model, usd] of Object.entries(outcome.cost.byModel)) io.err(`  by model ${sanitizeTerminalText(model)}: $${usd.toFixed(4)}`);
+	for (const [phase, usd] of Object.entries(outcome.cost.byPhase)) if (phase !== "") io.err(`  by phase ${sanitizeTerminalText(phase)}: $${usd.toFixed(4)}`);
+	if (outcome.cost.unpriced.length > 0) io.err(`unpriced models: ${outcome.cost.unpriced.map((u) => sanitizeTerminalText(u.model)).join(", ")}`);
 	switch (outcome.status) {
 		case "ok":
 		case "suspended": return 0;
@@ -655,6 +669,10 @@ async function loadCompanion(loading, specifier, command, missingMessage) {
 * later. In-process hosts keep the wider engine contract (functions,
 * BigInt, cycles record presence without a hash); the CLI does not need
 * it.
+*
+* Diagnostics name the failure class and the way out but never echo the
+* value: workflow args may carry private data, and stderr routinely
+* lands in CI logs (v1.24.1 review P2-1).
 */
 function parseArgsJson(raw) {
 	if (raw === void 0) return;
@@ -662,12 +680,12 @@ function parseArgsJson(raw) {
 	try {
 		parsed = JSON.parse(raw);
 	} catch {
-		throw new ConfigError(`--args is not valid JSON: ${raw}`);
+		throw new ConfigError("--args is not valid JSON; check the JSON syntax and shell quoting (the value is withheld from diagnostics: workflow args may carry private data)");
 	}
 	try {
 		hashRunArgs(parsed);
 	} catch {
-		throw new ConfigError(`--args is not representable as canonical JSON: a numeric value overflows JavaScript's finite range (e.g. 1e400 parses to Infinity). Supply finite JSON so the run's args binding can be hashed and later verified on resume: ${raw}`);
+		throw new ConfigError("--args is not representable as canonical JSON: a numeric value overflows JavaScript's finite range (e.g. 1e400 parses to Infinity). Supply finite JSON so the run's args binding can be hashed and later verified on resume (the value is withheld from diagnostics: workflow args may carry private data)");
 	}
 	return parsed;
 }
@@ -711,20 +729,21 @@ async function runCommand(argv, context) {
 */
 function enforceArgsBinding(input) {
 	const { meta, argsGiven, args, allowChange, io } = input;
+	const runRef = sanitizeTerminalText(meta.runId);
 	if (meta.argsProvided === void 0) {
 		if (!argsGiven && !allowChange) throw new ConfigError(`run '${meta.runId}' predates the args binding (rulvar < 1.24.0), so the CLI cannot tell whether it was started with --args, and resuming without them silently changes the logical run if any were used at start. Re-supply the original --args, or acknowledge explicitly with --allow-args-change; ${usageOf(GRAMMAR.resume)}`);
-		if (argsGiven) io.err(`warning: run '${meta.runId}' predates the args binding; the supplied --args cannot be verified against the original invocation`);
+		if (argsGiven) io.err(`warning: run '${runRef}' predates the args binding; the supplied --args cannot be verified against the original invocation`);
 		return;
 	}
 	if (meta.argsProvided) {
 		if (!argsGiven) {
 			if (!allowChange) throw new ConfigError(`run '${meta.runId}' was started WITH args, but this resume supplies none; the workflow would see undefined and every args-dependent call would become new paid work instead of a replay. Re-supply the original --args, or force the change with --allow-args-change; ${usageOf(GRAMMAR.resume)}`);
-			io.err(`warning: resuming '${meta.runId}' without its genesis args (--allow-args-change)`);
+			io.err(`warning: resuming '${runRef}' without its genesis args (--allow-args-change)`);
 			return;
 		}
 		if (meta.argsHash === void 0) {
 			if (!allowChange) throw new ConfigError(`run '${meta.runId}' started WITH args but recorded no verifiable hash (the genesis args were not JCS-serializable), so the CLI cannot confirm the supplied --args match the original; resuming risks silently changing the logical run and re-paying every args-dependent call. Force deliberately with --allow-args-change; ${usageOf(GRAMMAR.resume)}`);
-			io.err(`warning: run '${meta.runId}' recorded args presence but no hash (genesis args not JCS-serializable); the supplied --args cannot be verified (--allow-args-change)`);
+			io.err(`warning: run '${runRef}' recorded args presence but no hash (genesis args not JCS-serializable); the supplied --args cannot be verified (--allow-args-change)`);
 			return;
 		}
 		let supplied;
@@ -735,13 +754,13 @@ function enforceArgsBinding(input) {
 		}
 		if (supplied !== meta.argsHash) {
 			if (!allowChange) throw new ConfigError(`--args does not match the args run '${meta.runId}' was started with (recorded hash ${meta.argsHash.slice(0, 12)}, supplied ${supplied?.slice(0, 12) ?? "none"}); changed args silently change the logical run and re-pay every args-dependent call. Force deliberately with --allow-args-change; ${usageOf(GRAMMAR.resume)}`);
-			io.err(`warning: resuming '${meta.runId}' with changed args (--allow-args-change)`);
+			io.err(`warning: resuming '${runRef}' with changed args (--allow-args-change)`);
 		}
 		return;
 	}
 	if (argsGiven) {
 		if (!allowChange) throw new ConfigError(`run '${meta.runId}' was started WITHOUT args, but this resume supplies some; added args silently change the logical run. Drop --args, or force the change with --allow-args-change; ${usageOf(GRAMMAR.resume)}`);
-		io.err(`warning: resuming no-args run '${meta.runId}' with args (--allow-args-change)`);
+		io.err(`warning: resuming no-args run '${runRef}' with args (--allow-args-change)`);
 	}
 }
 async function resumeCommand(argv, context) {
@@ -758,7 +777,7 @@ async function resumeCommand(argv, context) {
 		...store === void 0 ? {} : { storePath: store },
 		cwd: context.cwd
 	});
-	const meta = (await assembled.store.listRuns()).find((m) => m.runId === runId);
+	const meta = await readRunMeta(assembled.store, runId);
 	if (meta === void 0) throw new ConfigError(`run '${runId}' not found in the store`);
 	enforceArgsBinding({
 		meta,
@@ -810,7 +829,7 @@ async function inspectCommand(argv, context) {
 		...store === void 0 ? {} : { storePath: store },
 		cwd: context.cwd
 	});
-	const meta = (await assembled.store.listRuns()).find((m) => m.runId === runId);
+	const meta = await readRunMeta(assembled.store, runId);
 	if (meta === void 0) throw new ConfigError(`run '${runId}' not found in the store`);
 	const entries = await assembled.store.load(runId);
 	context.io.out(`run ${meta.runId}: ${meta.status} (updated ${meta.updatedAt})`);
@@ -872,7 +891,7 @@ async function planCommand(argv, context) {
 	});
 	const planned = await plannerModule.plan(assembled.engine, goal, planningBudgetUsd === void 0 ? void 0 : { run: { budgetUsd: planningBudgetUsd } });
 	context.io.err(`plan: accepted with ${String(planned.lint.length)} advisory diagnostic(s)`);
-	for (const diagnostic of planned.lint) context.io.err(`  ${diagnostic.ruleId}: ${diagnostic.message}`);
+	for (const diagnostic of planned.lint) context.io.err(`  ${diagnostic.ruleId}: ${sanitizeTerminalText(diagnostic.message)}`);
 	if (dryRun) {
 		context.io.out(planned.source);
 		return 0;
@@ -1068,7 +1087,7 @@ async function kbGateCommand(argv, context) {
 		...values.store === void 0 ? {} : { storePath: values.store },
 		cwd: context.cwd
 	});
-	const meta = (await assembled.store.listRuns()).find((candidate) => candidate.runId === runId);
+	const meta = await readRunMeta(assembled.store, runId);
 	if (meta === void 0) throw new ConfigError(`run '${runId}' not found in the store`);
 	if (meta.status === "running") throw new ConfigError(`run '${runId}' is still running; proposals gate from finished runs`);
 	if (Date.parse(meta.updatedAt) < Date.now() - INBOX_PROPOSAL_TTL_DAYS * 24 * 60 * 60 * 1e3) throw new ConfigError(`the proposal expired: run '${runId}' finished ${meta.updatedAt}, and inbox entries expire after ${String(INBOX_PROPOSAL_TTL_DAYS)} days`);
@@ -1339,7 +1358,7 @@ async function runCli(argv, options) {
 		}
 	} catch (thrown) {
 		if (thrown instanceof ConfigError) {
-			options.io.err(`error: ${thrown.message}`);
+			options.io.err(`error: ${sanitizeTerminalText(thrown.message)}`);
 			return 1;
 		}
 		throw thrown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulvar/cli",
-  "version": "1.24.1",
+  "version": "1.26.0",
   "description": "Rulvar shell: run/resume/runs/inspect/plan/kb commands, TUI progress, createServer, createWorker, OTel exporter.",
   "type": "module",
   "license": "Apache-2.0",
@@ -22,17 +22,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@rulvar/core": "1.24.1"
+    "@rulvar/core": "1.26.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",
     "tsdown": "^0.22.3",
     "typescript": "~6.0.3",
-    "@rulvar/store-sqlite": "1.24.1",
-    "@rulvar/testing": "1.24.1",
-    "@rulvar/planner": "1.24.1",
-    "@rulvar/plan": "1.24.1",
-    "@rulvar/evals": "1.24.1"
+    "@rulvar/plan": "1.26.0",
+    "@rulvar/testing": "1.26.0",
+    "@rulvar/planner": "1.26.0",
+    "@rulvar/evals": "1.26.0",
+    "@rulvar/store-sqlite": "1.26.0"
   },
   "bin": {
     "rulvar": "./dist/cli.js"