@rulvar/cli 1.24.0 → 1.25.0

package/dist/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { r as runCli, t as processIo } from "./io-CL4wldEQ.js";
+import { r as runCli, t as processIo } from "./io-CAXfPWq7.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

package/dist/index.js

@@ -1,4 +1,4 @@
-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-CL4wldEQ.js";
+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-CAXfPWq7.js";
 import { ConfigError, InvalidResolutionError, JournalCompatibilityError, LeaseHeldError, Replayer, RulvarError, buildDeriverRegistry, costReportFromJournal, maskSecrets, normalizeEntry, scanJournalCompatibility, validateSchemaSpec } from "@rulvar/core";
 //#region src/server.ts
 /**

package/dist/{io-CL4wldEQ.js → io-CAXfPWq7.js}

@@ -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;
@@ -641,14 +655,39 @@ async function loadCompanion(loading, specifier, command, missingMessage) {
 		throw new Error(`${command}: ${specifier} is installed but failed to load; the cause below is a defect in the installed package or its dependencies, not a missing install`, { cause: error });
 	}
 }
-/** Parses --args JSON into workflow arguments; undefined when absent. */
+/**
+* Parses --args JSON into workflow arguments; undefined when absent.
+*
+* CLI args must be representable in canonical JCS, i.e. finite JSON. A
+* numeric literal that overflows JavaScript's finite range parses to
+* Infinity, which `hashRunArgs` cannot canonicalize, so genesis would
+* record `argsProvided` WITHOUT a hash and the resume gate would soften
+* to an unverifiable warning that lets changed args through (v1.24.0
+* review P2-1). A CLI value always arrives as JSON text, so it can
+* always be canonicalized; reject the non-finite case here, before any
+* config, store, or adapter loads, instead of letting it defeat the gate
+* 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;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		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 {
-		return JSON.parse(raw);
+		hashRunArgs(parsed);
 	} catch {
-		throw new ConfigError(`--args is not valid JSON: ${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;
 }
 async function runCommand(argv, context) {
 	const parsed = parseCommand(GRAMMAR.run, argv);
@@ -690,31 +729,38 @@ 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) {
-			io.err(`warning: run '${meta.runId}' recorded args presence but no hash (the genesis args were not JCS-serializable); the supplied --args cannot be verified`);
+			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 '${runRef}' recorded args presence but no hash (genesis args not JCS-serializable); the supplied --args cannot be verified (--allow-args-change)`);
 			return;
 		}
-		const supplied = hashRunArgs(args);
+		let supplied;
+		try {
+			supplied = hashRunArgs(args);
+		} catch {
+			throw new ConfigError(`--args cannot be canonicalized to compare against run '${meta.runId}' (a numeric value overflows the finite range, or the value is otherwise not canonical JSON); supply finite JSON, or force the resume with --allow-args-change; ${usageOf(GRAMMAR.resume)}`);
+		}
 		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) {
@@ -845,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;
@@ -1312,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.0",
+  "version": "1.25.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.0"
+    "@rulvar/core": "1.25.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.0",
     "tsdown": "^0.22.3",
     "typescript": "~6.0.3",
-    "@rulvar/testing": "1.24.0",
-    "@rulvar/store-sqlite": "1.24.0",
-    "@rulvar/planner": "1.24.0",
-    "@rulvar/evals": "1.24.0",
-    "@rulvar/plan": "1.24.0"
+    "@rulvar/planner": "1.25.0",
+    "@rulvar/testing": "1.25.0",
+    "@rulvar/plan": "1.25.0",
+    "@rulvar/store-sqlite": "1.25.0",
+    "@rulvar/evals": "1.25.0"
   },
   "bin": {
     "rulvar": "./dist/cli.js"