mu-agent 0.1.8 → 0.1.13

package/kyrn/bin/mu.mjs

@@ -94,26 +94,28 @@ export function platformName({ platform, wsl }) {
 export function usage(platform) {
 	const linkDir = platform === "win32" ? "%USERPROFILE%\\.local\\bin" : "~/.local/bin";
 	return [
-		"mu command line. (The project was called KYRN until 2026-09-21; the old spellings below still work.)",
+		"mu: a coding agent with a judgment kernel, built on pi.",
 		"",
-		"  mu                       interactive session in the current directory",
-		'  mu "prompt"              interactive, starting with this prompt',
-		'  mu -p "prompt"           one-shot: print the answer and exit',
-		"  mu -c | -r               continue the last session | pick one to resume",
-		"  mu setup                 connect a model (an API key, or a service from a list) and choose the judge",
-		"                           (mu setup --help: scripts, a key from stdin, the services it knows)",
-		"  mu judge <cmd>           the local judge (Laya): setup | start | stop | status | run",
-		"  mu ledger [n] [--json]   what the judge decided in the last n sessions",
-		"  mu import --list | <file>...   bring Claude Code and Codex conversations into mu (mu import --help)",
-		"  mu doctor                check the installation",
-		"  mu auth <cmd>            subscription sign-in for the desktop app, as JSON lines:",
+		"  mu                       start a session in the current directory",
+		'  mu "prompt"              start a session with this prompt',
+		'  mu -p "prompt"           run one prompt, print the answer and exit',
+		"  mu -c | -r               continue the last session | pick a session to resume",
+		"  mu setup                 connect a model (paste an API key or pick a service) and choose a judge",
+		"                           (see mu setup --help for scripting, reading a key from stdin and the supported services)",
+		"  mu judge <cmd>           manage the local judge, Laya (macOS on Apple silicon): setup | start | stop | status | run",
+		"  mu ledger [n] [--json]   print the judge's verdicts from the last n sessions",
+		"  mu import <file>...      import Claude Code, Codex and ZCode conversations; --list shows them (mu import --help)",
+		"  mu doctor                check the installation, the judges and the connections",
+		"  mu auth <cmd>            sign-in helper for the desktop app (JSON lines):",
 		"                           status | login <provider> | logout <provider>",
-		`  mu link | unlink         put the \`mu\` command on your PATH (${linkDir}) | remove it`,
-		"  mu migrate [--dry-run]   once: move the home from before the rename, ~/.kyrn, to ~/.mu",
-		"  mu help | version",
+		`  mu link | unlink         put the mu command on your PATH (${linkDir}) | remove it`,
+		"  mu migrate [--dry-run]   move the old home folder, ~/.kyrn, to ~/.mu (once)",
+		"  mu help | version        show this help | print the version",
 		"",
-		"Everything else goes to the agent unchanged: `mu --help` lists every flag,",
-		"and `mu install|remove|update|list|config` manage pi packages.",
+		"Everything else goes to pi unchanged: mu --help also shows pi's options,",
+		"and mu install|remove|update|list|config manage pi packages.",
+		"",
+		"Formerly KYRN: the kyrn commands still work.",
 	].join("\n");
 }
 
@@ -310,7 +312,7 @@ export function ensureAppView({ platform, app, upstream, fs = realFs }) {
 /**
  * Where this mu comes from: "repo", a checkout that runs the TypeScript sources (sourceRuntime), or "package", the
  * npm package mu-agent, which carries pi's bundle (dist/bundle/cli.js) and the judgment layer built to
- * JavaScript (judge/dist/kyrn-judge.js). A checkout without its dependencies is still a checkout.
+ * JavaScript (judge/mu/index.js). A checkout without its dependencies is still a checkout.
  */
 export function layoutOf({ root, platform, exists }) {
 	const path = pathFor(platform);
@@ -326,7 +328,7 @@ export function packageEntries({ root, platform }) {
 	const path = pathFor(platform);
 	return {
 		cli: path.join(root, "dist", "bundle", "cli.js"),
-		extension: path.join(root, "judge", "dist", "kyrn-judge.js"),
+		extension: path.join(root, "judge", "mu", "index.js"),
 		auth: path.join(root, "judge", "dist", "auth.js"),
 		import: path.join(root, "judge", "dist", "import.js"),
 		setup: path.join(root, "judge", "dist", "setup.js"),
@@ -356,13 +358,13 @@ export function installHint({ root, platform }) {
 	const steps = [`cd ${root}`, "npm ci --ignore-scripts", "npm run hydrate:model-data"];
 	// Windows PowerShell 5 has no `&&`.
 	return platform === "win32"
-		? `mu's dependencies are not installed. Run:\n${steps.map((step) => `  ${step}`).join("\n")}`
-		: `mu's dependencies are not installed. Run:  ${steps.join(" && ")}`;
+		? `mu's dependencies aren't installed. Run:\n${steps.map((step) => `  ${step}`).join("\n")}`
+		: `mu's dependencies aren't installed. Run:  ${steps.join(" && ")}`;
 }
 
 /** What mu says on a Node that does not strip TypeScript types, which a checkout cannot run on. */
 const NO_TYPE_STRIPPING =
-	"mu runs a checkout's TypeScript with Node's own type stripping (on by default from Node 22.18), and this Node does not strip types";
+	"mu runs a source checkout's TypeScript with Node's built-in type stripping (on by default since Node 22.18), but this Node doesn't strip types. Use Node 22.19 or newer.";
 
 /**
  * Node's arguments for running a checkout's TypeScript, up to the entry file. Node strips the types itself (on by
@@ -428,10 +430,10 @@ export function localJudgeSupport({ platform, env, wsl = false }) {
 		runs: false,
 		url,
 		message: [
-			`The local judge (Laya) is a Core ML sidecar: it runs on macOS with Apple Silicon only, not on ${where}.`,
-			"mu works without it: use Jev (TYPESAFE_API_KEY or AI_GATEWAY_API_KEY) or an llm judge in mu.json;",
-			"the desktop app's own local judge is being built. Decisions without a judge fall back to pi's behaviour.",
-			"A server that speaks the same contract (GET /health, POST /evaluate) can be used from here:",
+			`The local judge (Laya) is a Core ML sidecar that runs only on macOS on Apple silicon, not on ${where}.`,
+			"mu works without it: Jev, the default hosted judge, answers instead (free on OpenCode Zen, or with your own key via mu setup); you can also set an LLM judge in mu.json.",
+			"A local judge for the desktop app is in progress. Without a judge, decision points use their fallbacks.",
+			"To use a server that implements the same API (GET /health, POST /evaluate), set:",
 			"  MU_LOCAL_JUDGE_URL=http://host:port",
 		].join("\n"),
 	};
@@ -447,12 +449,39 @@ export function launchStrategy({ platform, env, canExec }) {
 /** How the judgment layer's extension joins pi's arguments: in front for a session, never in front of pi's own
  *  commands (PI_COMMANDS), which pi reads as its first argument — an -e before them would turn them into a prompt.
  *  The judgment layer never runs for them, so its extension stays out of their way. */
-function judgeArgs({ argv, layout, root, platform }) {
+function judgeArgs({ argv, layout, root, platform, agentDir, readFile }) {
 	if (PI_COMMANDS.has(argv[0])) return [];
-	const path = pathFor(platform);
+	return ["-e", judgeExtension({ layout, root, platform }), ...themeArgs({ argv, layout, root, platform, agentDir, readFile })];
+}
+
+/** The judgment layer's extension file: the package's build, or a checkout's source. */
+function judgeExtension({ layout, root, platform }) {
 	return layout === "package"
-		? ["-e", packageEntries({ root, platform }).extension]
-		: ["-e", path.join(root, "packages", "kyrn-judge", "src", "extension", "kyrn-judge.ts")];
+		? packageEntries({ root, platform }).extension
+		: pathFor(platform).join(root, "packages", "kyrn-judge", "src", "extension", "kyrn-judge.ts");
+}
+
+/** mu's own terminal themes, beside the judgment layer's files. */
+export function themesDir({ layout, root, platform }) {
+	const path = pathFor(platform);
+	return layout === "package" ? path.join(root, "judge", "themes") : path.join(root, "packages", "kyrn-judge", "themes");
+}
+
+/**
+ * An interactive session gets mu's themes (mu-light and mu-dark, which /settings then lists beside pi's) and, while the
+ * person has chosen no theme of their own, starts in them: light or dark as the terminal is. A theme chosen in
+ * /settings is saved in settings.json and wins; so does --use-theme. Print and RPC modes draw nothing and get neither.
+ */
+function themeArgs({ argv, layout, root, platform, agentDir, readFile }) {
+	if (argv.includes("--mode") || argv.includes("-p") || argv.includes("--print")) return [];
+	const args = ["--theme", themesDir({ layout, root, platform })];
+	if (argv.includes("--use-theme") || !agentDir || !readFile) return args;
+	let chosen = false;
+	try {
+		const settings = JSON.parse(readFile(pathFor(platform).join(agentDir, "settings.json")));
+		chosen = typeof settings?.theme === "string" && settings.theme !== "";
+	} catch {}
+	return chosen ? args : [...args, "--use-theme", "mu-light/mu-dark"];
 }
 
 /**
@@ -485,7 +514,7 @@ export function planLaunch({
 	} else {
 		const runtime = sourceRuntime({ root, platform, stripsTypes, exists: fs.exists });
 		if (runtime.error) return { error: runtime.error };
-		entry = [...runtime.args, path.join(root, "packages", "coding-agent", "src", "experimental", "cli.ts")];
+		entry = [...runtime.args, path.join(root, "packages", "coding-agent", "src", "cli.ts")];
 	}
 
 	const muDir = muHome({ home, platform, isDir: fs.isDir });
@@ -503,7 +532,7 @@ export function planLaunch({
 		const parsed = parseEnvFile(envText);
 		fromFile = envFileAdditions({ env, entries: parsed.entries, platform });
 		// Line numbers only: the text of a line that did not parse may well be a secret.
-		if (parsed.problems.length > 0) notes.push(`mu: .env: skipped line ${parsed.problems.join(", ")} (not KEY=VALUE)`);
+		if (parsed.problems.length > 0) notes.push(`mu: .env: skipped ${parsed.problems.length === 1 ? "line" : "lines"} ${parsed.problems.join(", ")} (expected KEY=VALUE)`);
 	}
 
 	const childEnv = {};
@@ -511,6 +540,8 @@ export function planLaunch({
 		if (typeof value === "string") childEnv[key] = value;
 	}
 	childEnv.PI_PACKAGE_DIR = appDir;
+	// The judgment layer is part of mu, not an extension loaded for this run: pi shows its commands without [t].
+	childEnv.PI_APP_EXTENSIONS = judgeExtension({ layout, root, platform });
 	childEnv.MU_CODING_AGENT_DIR = agentDir;
 	childEnv.KYRN_CODING_AGENT_DIR = agentDir;
 	childEnv.PI_CODING_AGENT_DIR = agentDir;
@@ -526,14 +557,14 @@ export function planLaunch({
 		if (support.runs) startJudge = true;
 		else if (!support.url) {
 			notes.push(
-				`mu: the configuration asks for the local judge (laya), which runs on macOS only; on ${platformName({ platform, wsl })} its decisions fall back to the next judge or to pi's behaviour (mu judge status)`,
+				`mu: the configuration asks for the local judge (Laya), which runs on macOS only; on ${platformName({ platform, wsl })}, the decision points it would answer use the next judge or their fallbacks (mu judge status)`,
 			);
 		}
 	}
 
 	return {
 		command: execPath,
-		args: [...entry, ...judgeArgs({ argv, layout, root, platform }), ...argv],
+		args: [...entry, ...judgeArgs({ argv, layout, root, platform, agentDir, readFile: fs.readFile }), ...argv],
 		env: childEnv,
 		strategy: launchStrategy({ platform, env, canExec }),
 		layout,
@@ -542,7 +573,7 @@ export function planLaunch({
 		agentDir,
 		startJudge,
 		notes,
-		preface: argv[0] === "-h" || argv[0] === "--help" ? `${usage(platform)}\n\nAgent flags:\n` : undefined,
+		preface: argv[0] === "-h" || argv[0] === "--help" ? `${usage(platform)}\n\npi's help (mu passes all of this through):\n` : undefined,
 	};
 }
 
@@ -552,6 +583,9 @@ export function planLaunch({
  * Node flags that process starts with, pi's arguments (the judgment layer, then `argv`) and its whole environment.
  * The app's pi and the command line's are then one: the same files, settings, sign-ins and keys.
  *
+ * `cli` is the script the command line runs pi with. pi starts its sub-agents (swarm, hive, delegate) by running
+ * `process.argv[1]` again, which inside the host is the host's own file: the host hands pi this script there instead.
+ *
  * A checkout runs there as it runs on the command line (sourceRuntime). Returns { error } when pi cannot run.
  */
 export function planHost({ platform, env, argv, root, home, fs, wsl = false, stripsTypes = true }) {
@@ -571,8 +605,9 @@ export function planHost({ platform, env, argv, root, home, fs, wsl = false, str
 		return {
 			...common,
 			module: path.join(root, "dist", "bundle", "index.js"),
+			cli: packageEntries({ root, platform }).cli,
 			execArgv: [],
-			args: [...judgeArgs({ argv, layout: launch.layout, root, platform }), ...argv],
+			args: [...judgeArgs({ argv, layout: launch.layout, root, platform, agentDir: launch.agentDir, readFile: fs.readFile }), ...argv],
 		};
 	}
 	const runtime = sourceRuntime({ root, platform, stripsTypes, exists: fs.exists });
@@ -580,14 +615,15 @@ export function planHost({ platform, env, argv, root, home, fs, wsl = false, str
 	return {
 		...common,
 		module: path.join(root, "packages", "coding-agent", "src", "index.ts"),
+		cli: path.join(root, "packages", "coding-agent", "src", "cli.ts"),
 		execArgv: runtime.args,
-		args: [...judgeArgs({ argv, layout: launch.layout, root, platform }), ...argv],
+		args: [...judgeArgs({ argv, layout: launch.layout, root, platform, agentDir: launch.agentDir, readFile: fs.readFile }), ...argv],
 	};
 }
 
 /** What mu says when the local judge does not come up. */
 const LOCAL_JUDGE_NOT_STARTED =
-	"mu: the local judge did not start (mu judge status); decisions fall back to pi's behaviour";
+	"mu: the local judge (Laya) didn't start; decision points use the next judge or their fallbacks. Run mu judge status for details.";
 
 /** The part of the preparation that is files: the app view of a checkout, mu's agent folder, the configuration's notes. */
 function prepareFiles({ plan, platform, root, err }) {
@@ -641,6 +677,29 @@ export async function prepareLaunchAsync({ plan, platform, root, bin, err }) {
 /** What `mu auth` answers itself. Every other `auth` command (check, print-api-key, ...) is pi's own. */
 export const AUTH_COMMANDS = ["status", "login", "logout"];
 
+/** `mu link --help` and `mu unlink --help`. */
+export const LINK_USAGE = [
+	"mu link: put this mu on your PATH, as a link in ~/.local/bin (on Windows, a small mu.cmd there). MU_LINK_DIR",
+	"names another folder.",
+	"",
+	"  mu link            link this mu, unless another mu is already on your PATH",
+	"  mu link --force    link it anyway (it comes first only if its folder comes first on your PATH)",
+	"  mu unlink          remove the link mu link made",
+	"",
+	"A mu installed with npm is already on your PATH and needs neither.",
+].join("\n");
+
+/** What `mu auth --help` (or a bare `mu auth`) says before pi's own auth commands. */
+export const AUTH_USAGE = [
+	"mu's sign-in, which the desktop app runs (JSON lines on stdout):",
+	"  mu auth status",
+	"  mu auth login <provider>",
+	"  mu auth logout <provider>",
+	"In a terminal, /login inside mu signs in the same way.",
+	"",
+	"pi's auth commands:",
+].join("\n");
+
 /**
  * `mu auth status | login <provider> | logout <provider>`: the sign-in the desktop app runs, with pi's own OAuth
  * flows and credential store (packages/kyrn-judge/src/auth). It is pi's code, so it runs the way pi does here:
@@ -688,7 +747,7 @@ export function planJudge({ platform, env, argv, bin, wsl = false }) {
 // ---------------------------------------------------------------------------------------------------------
 
 /**
- * `mu import`: Claude Code and Codex conversations into mu's sessions (packages/kyrn-judge/src/import). The importer
+ * `mu import`: Claude Code, Codex and ZCode conversations into mu's sessions (packages/kyrn-judge/src/import). The importer
  * needs nothing but Node: the npm package runs its build, judge/dist/import.js, and a checkout its TypeScript with
  * Node's own type stripping (on by default from 22.18).
  */
@@ -726,6 +785,17 @@ export const SETUP_DECLINED_FILE = "setup-declined";
 /** How `mu setup` says: set up, and start a session now. */
 export const SETUP_EXIT_START = 3;
 
+/** How `mu setup` says: a subscription was chosen, so start a session that opens on /login. */
+export const SETUP_EXIT_SIGN_IN = 4;
+
+/**
+ * What the session is started with after the wizard ended with `code`: /login after a subscription was chosen, unless
+ * the command line already says what to do.
+ */
+export function afterSetup(code, argv) {
+	return code === SETUP_EXIT_SIGN_IN && argv.length === 0 ? ["/login"] : argv;
+}
+
 /** How `mu setup` says it was cancelled (ctrl+c): a first start then goes no further. */
 export const SETUP_EXIT_CANCELLED = 130;
 
@@ -1003,7 +1073,7 @@ export function planLink({ platform, env, home, bin, argv, fs }) {
 		return {
 			action: "refuse",
 			errors: [
-				`${link} already exists and is not this mu; it was left alone. Choose another folder: MU_LINK_DIR=<dir> mu link`,
+				`${link} already exists and is not this mu, so it was left alone. To use another folder: MU_LINK_DIR=<dir> mu link`,
 			],
 		};
 	}
@@ -1031,7 +1101,7 @@ export function planLink({ platform, env, home, bin, argv, fs }) {
 	if (windows && /[^\x00-\x7f]/.test(content)) {
 		notes.push(
 			"Note: the path from that folder to this repository has non-ASCII characters in it, and cmd reads a batch file in the",
-			"console's code page. If `mu` then cannot find its target, choose a folder on the same drive (MU_LINK_DIR), or put",
+			"console's code page. If mu then can't find its target, choose a folder on the same drive (MU_LINK_DIR), or put",
 			`${bin} on your PATH instead.`,
 		);
 	}
@@ -1046,12 +1116,12 @@ export function planUnlink({ platform, env, home, fs }) {
 			text = fs.readFile(link);
 		} catch {}
 		return text?.includes(SHIM_MARK)
-			? { remove: link, message: `removed ${link}` }
-			: { message: `${link} is not a shim written by mu link; nothing removed` };
+			? { remove: link, message: `Removed ${link}.` }
+			: { message: `${link} is not a shim written by mu link; nothing removed.` };
 	}
 	return fs.isLink(link)
-		? { remove: link, message: `removed ${link}` }
-		: { message: `${link} is not a link; nothing removed` };
+		? { remove: link, message: `Removed ${link}.` }
+		: { message: `${link} is not a link; nothing removed.` };
 }
 
 /** What `mu doctor` says about the command. */
@@ -1200,8 +1270,8 @@ export function migrate({ platform, home, argv, fs, run, alive, self, out, err }
 		return 0;
 	}
 	if (fs.exists(next) || fs.isLink(next)) {
-		err(`${next} already exists, so nothing was moved. Two homes are never merged or overwritten here:`);
-		err("look at both folders and decide which one is the real one.");
+		err(`${next} already exists, so nothing was moved. mu never merges or overwrites two home folders:`);
+		err("look at both and decide which one to keep.");
 		return 1;
 	}
 	// Whatever is running would write into the gap between the rename and the link, and split the home in two.
@@ -1210,10 +1280,10 @@ export function migrate({ platform, home, argv, fs, run, alive, self, out, err }
 	try {
 		pid = Number.parseInt(fs.readFile(path.join(old, "local-judge", "judge.pid")).trim(), 10);
 	} catch {}
-	if (pid > 0 && alive(pid)) busy.push(`  the local judge (pid ${pid}). Stop it: mu judge stop`);
+	if (pid > 0 && alive(pid)) busy.push(`  the local judge (pid ${pid}). Stop it with mu judge stop`);
 	const found = findBusy({ platform, old, run, self });
 	if (!found) {
-		err("Nothing was moved: the list of running processes could not be read (tasklist, powershell), so it is not known whether mu is still running.");
+		err("Nothing was moved: mu couldn't read the list of running processes (tasklist, powershell), so it can't tell whether mu is still running.");
 		return 1;
 	}
 	const list = (pids) => pids.join(" ");
@@ -1222,7 +1292,7 @@ export function migrate({ platform, home, argv, fs, run, alive, self, out, err }
 	}
 	if (found.browser.length > 0) busy.push(`  the mu browser (pid ${list(found.browser)}). Close it.`);
 	if (found.desktop.length > 0) {
-		busy.push(`  the desktop app's backend (pid ${list(found.desktop)}). Quit the desktop app.`);
+		busy.push(`  the desktop app's local service (pid ${list(found.desktop)}). Quit the desktop app.`);
 	}
 	if (busy.length > 0) {
 		err(`Nothing was moved, because these are still using ${old}:`);
@@ -1247,7 +1317,7 @@ export function migrate({ platform, home, argv, fs, run, alive, self, out, err }
 		out(`renamed  ${path.join(next, config)} -> mu.json`);
 	}
 	out(`linked   ${old} -> ${next} (paths stored from before the rename keep working)`);
-	out("Check it: mu doctor");
+	out("To check it, run mu doctor");
 	return 0;
 }
 
@@ -1329,7 +1399,7 @@ function handOver({ command, args, env, strategy }) {
 		for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.on(signal, () => relay(signal));
 		if (process.platform === "win32") process.on("SIGBREAK", () => {});
 		child.on("error", (error) => {
-			err(`mu: could not start ${command}: ${error.message}`);
+			err(`mu: couldn't start ${command}: ${error.message}`);
 			resolve(1);
 		});
 		child.on("exit", (code, signal) => resolve(code ?? 128 + (osConstants.signals[signal] ?? 0)));
@@ -1363,6 +1433,8 @@ export async function main(argv = process.argv.slice(2)) {
 		out(usage(platform));
 		return 0;
 	}
+	// mu's own auth commands first; pi prints its own after them.
+	if (command === "auth" && (rest.length === 0 || rest[0] === "--help" || rest[0] === "-h")) out(AUTH_USAGE);
 	if (command === "auth" && AUTH_COMMANDS.includes(rest[0])) {
 		const plan = planAuth({
 			platform,
@@ -1426,7 +1498,7 @@ export async function main(argv = process.argv.slice(2)) {
 			out(await response.text());
 			return 0;
 		} catch {
-			out(`the judge server does not answer at ${plan.url}`);
+			out(`The local judge server isn't answering at ${plan.url}. Check that it's running.`);
 			return 1;
 		}
 	}
@@ -1471,8 +1543,8 @@ export async function main(argv = process.argv.slice(2)) {
 		if (plan.keyGiven) process.title = "mu setup";
 		mkdirSync(plan.agentDir, { recursive: true });
 		const code = await handOver(plan);
-		if (code !== SETUP_EXIT_START) return code;
-		sessionArgv = [];
+		if (code !== SETUP_EXIT_START && code !== SETUP_EXIT_SIGN_IN) return code;
+		sessionArgv = afterSetup(code, []);
 	}
 	if (command === "doctor") {
 		const link = linkPath({ platform, env, home });
@@ -1483,8 +1555,12 @@ export async function main(argv = process.argv.slice(2)) {
 			strategy,
 		});
 	}
+	if ((command === "link" || command === "unlink") && (rest[0] === "--help" || rest[0] === "-h")) {
+		out(LINK_USAGE);
+		return 0;
+	}
 	if ((command === "link" || command === "unlink") && layout === "package") {
-		out("This mu was installed with npm, which already put `mu` on your PATH (npm i -g mu-agent); nothing to link.");
+		out("This mu was installed with npm, which already put `mu` on your PATH (npm i -g mu-agent); nothing to do.");
 		return 0;
 	}
 	if (command === "link") {
@@ -1517,9 +1593,10 @@ export async function main(argv = process.argv.slice(2)) {
 		return 0;
 	}
 
-	if (layout === "package" && command === "version") {
+	// --version is the bare number, in the npm package as in a checkout (below).
+	if (layout === "package" && (command === "version" || command === "--version" || command === "-v")) {
 		const pkg = JSON.parse(readText(path.join(root, "package.json")));
-		out(`mu ${pkg.version} (pi ${pkg.muBuild?.pi ?? "?"}, npm package ${pkg.name})`);
+		out(command === "version" ? `mu ${pkg.version} (pi ${pkg.muBuild?.pi ?? "?"}, npm package ${pkg.name})` : pkg.version);
 		return 0;
 	}
 	// Asked before `version` too, as it always was: a checkout without its dependencies says so at the first command.
@@ -1527,10 +1604,12 @@ export async function main(argv = process.argv.slice(2)) {
 		err(installHint({ root, platform }));
 		return 1;
 	}
-	if (command === "version") {
+	if (command === "version" || command === "--version" || command === "-v") {
 		// mu's version is the one this tree is released as; the judgment layer's own package.json is never released.
 		const version = (file) => JSON.parse(readText(path.join(root, ...file.split("/")))).version;
-		out(`mu ${version("kyrn/npm/package.template.json")} (pi ${version("packages/coding-agent/package.json")})`);
+		const mu = version("kyrn/npm/package.template.json");
+		// --version is the bare number, as the npm package's pi bundle prints it; pi's own here would be pi's version.
+		out(command === "version" ? `mu ${mu} (pi ${version("packages/coding-agent/package.json")})` : mu);
 		return 0;
 	}
 
@@ -1564,7 +1643,9 @@ export async function main(argv = process.argv.slice(2)) {
 		if (!setup.error) {
 			mkdirSync(setup.agentDir, { recursive: true });
 			// Whatever the wizard ends with, the session follows (pi says itself when there is no model), unless it was cancelled.
-			if ((await handOver(setup)) === SETUP_EXIT_CANCELLED) return SETUP_EXIT_CANCELLED;
+			const code = await handOver(setup);
+			if (code === SETUP_EXIT_CANCELLED) return SETUP_EXIT_CANCELLED;
+			sessionArgv = afterSetup(code, sessionArgv);
 		}
 	}
 

package/kyrn/local-judge/server.py

@@ -3,7 +3,7 @@
 
 Serves a Laya Core ML checkpoint (https://github.com/mizorewww/laya-coreml) over
 the same wire contract as the AI Gateway `evaluation-model` endpoint, so the
-mu kernel can swap Jev for a local model without translating anything:
+mu kernel can swap the hosted judge model for a local one without translating anything:
 
     POST /evaluate  {"state": ..., "questions": {id: {type, instructions, criteria?}}}
                  -> {"answers": {...}, "usage": {...}, "warnings": [...], "providerMetadata": {"laya": {...}}}
@@ -27,9 +27,16 @@ from pathlib import Path
 DEFAULT_HOST = "127.0.0.1"
 DEFAULT_PORT = 47823
 MAX_BODY_BYTES = 1024 * 1024
-# Measured on an M3 Max with 10-question preflights: no floor p50 411 ms (one shape switch per request),
-# 256 -> 124 ms, 384 -> 155 ms. Requests longer than the floor still work; they just pay the switch.
-DEFAULT_MIN_LENGTH = 256
+# Every request is padded to at least this many tokens; by default (None) to the checkpoint's whole window, so that
+# after warm-up the input length never changes. A change of length is what crashed the sidecar: Core ML re-specializes
+# the GPU program from its compiled copy of the model in ~/Library/Caches/<process>/com.apple.e5rt.e5bundlecache,
+# which it marks APFS-purgeable, and macOS deletes those files whenever the disk runs low. The next change of length
+# then recompiles the model (3-36 s, 644 MB written again) or, when the purge lands mid-load, aborts the process with
+# "MPSGraphTensorData.mm: failed assertion `shape.count = 0 != strides.count = 2'". Measured on an M6 under load:
+# 1024 tokens cost ~34 ms a question at a steady length against ~23-32 ms for 384-768, while a change of length
+# cost 0.4-1.1 s at p50 and up to 18 s at p90. A lower floor (MU_LOCAL_JUDGE_MIN_LENGTH=256) is faster for short
+# requests and brings the changes of length back.
+DEFAULT_MIN_LENGTH = None
 DEFAULT_MODEL_DIR = Path(__file__).resolve().parent / "models" / "laya-multilingual-coreml"
 
 
@@ -88,11 +95,10 @@ def from_laya_answer(answer):
 
 
 class LocalJudge:
-    def __init__(self, model_dir, compute_units=None, min_length=0):
+    def __init__(self, model_dir, compute_units=None, min_length=DEFAULT_MIN_LENGTH):
         import laya_coreml as laya
 
         self.model_dir = Path(model_dir)
-        self.min_length = min_length
         started = time.perf_counter()
         self.agent = laya.load(str(self.model_dir), local_files_only=True, compute_units=compute_units)
         self.load_seconds = time.perf_counter() - started
@@ -103,15 +109,19 @@ class LocalJudge:
         manifest = getattr(self.agent, "manifest", {})
         self.model_id = "laya:" + str(manifest.get("repository") or self.model_dir.name)
         self.shape = getattr(self.agent, "shape", {})
+        if min_length is None:
+            min_length = getattr(self.agent, "cfg", {}).get("max_len") or self.shape.get("max_length") or 0
+        self.min_length = int(min_length)
 
     def uniform_shape(self, state, laya_questions):
         """Pad every question of a request to one input length.
 
         Core ML re-specializes the GPU program whenever the enumerated length
-        changes (about 350 ms on an M3 Max, against 40 ms for a steady shape),
-        and the questions of one request differ in length because their
-        options do. One bucket per request removes those switches; the floor
-        keeps consecutive requests on the same bucket too.
+        changes (0.3-1 s, against ~30 ms for a steady shape), reading the
+        compiled model back from a cache macOS may have purged (see
+        DEFAULT_MIN_LENGTH). The questions of one request differ in length
+        because their options do, so one bucket per request removes the
+        changes within it; the floor keeps every request in the same bucket.
         """
         lengths = self.agent.shape.get("lengths")
         if not lengths:
@@ -199,9 +209,10 @@ class LocalJudge:
     def warm_up(self):
         """Core ML compiles each enumerated input length on first use (seconds). Pay that before real traffic."""
         lengths = list(self.shape.get("lengths") or [self.shape.get("default_length", 128)])
-        # Finish on the bucket real traffic starts in, so the first request does not pay a shape switch.
+        # Requests are padded to at least the floor's bucket, so no request uses a shorter one: warm only the lengths
+        # traffic can reach, and finish on the floor's bucket, so the first request does not pay a shape switch.
         resting = next((n for n in lengths if n >= self.min_length), lengths[-1])
-        lengths = [n for n in lengths if n != resting] + [resting]
+        lengths = [n for n in lengths if n > resting] + [resting]
         question = {"warm": {"type": "noul", "instructions": "Is this a warm-up request?"}}
         started = time.perf_counter()
         for length in lengths:
@@ -299,8 +310,9 @@ def main():
     parser.add_argument(
         "--min-length",
         type=int,
-        default=int(setting("LOCAL_JUDGE_MIN_LENGTH", DEFAULT_MIN_LENGTH)),
-        help="Smallest input length to pad to. A floor above the usual request size avoids shape switches between requests.",
+        default=setting("LOCAL_JUDGE_MIN_LENGTH", DEFAULT_MIN_LENGTH),
+        help="Smallest input length to pad to. Default: the checkpoint's window, so the length never changes after "
+        "warm-up; a change of length is slow and, when macOS has purged Core ML's cache, can crash the sidecar.",
     )
     args = parser.parse_args()
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "mu-agent",
-	"version": "0.1.8",
-	"description": "mu: a coding agent that thinks before it acts. A small, fast judge makes the routine calls; the big model keeps its attention for the work. Built on pi.",
+	"version": "0.1.13",
+	"description": "mu: a coding agent that hands its routine decisions to a small, fast judge model, so the main model can keep its attention on the work. Built on pi.",
 	"type": "module",
 	"bin": {
 		"mu": "kyrn/bin/mu.mjs"
@@ -12,13 +12,16 @@
 	},
 	"keywords": [
 		"coding-agent",
+		"pi-coding-agent",
 		"ai",
 		"llm",
 		"cli",
 		"terminal",
 		"agent",
 		"judge",
-		"pi"
+		"pi",
+		"mcp",
+		"prompt-injection"
 	],
 	"homepage": "https://github.com/qybaihe/mu",
 	"repository": {
@@ -33,13 +36,12 @@
 		"node": ">=22.19.0"
 	},
 	"dependencies": {
-		"@earendil-works/chord": "1.0.2",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"jiti": "2.7.0"
 	},
 	"muBuild": {
-		"pi": "1.0.2",
+		"pi": "1.3.0",
 		"judge": "0.1.0",
-		"commit": "a63b81be9"
+		"commit": "47bdfac19"
 	}
 }