mu-agent 0.2.4 → 0.2.6

package/kyrn/bin/kyrn-doctor

@@ -14,7 +14,6 @@ import {
 	findOnPath,
 	layoutOf,
 	linkState,
-	localJudgeSupport,
 	packageEntries,
 	parseEnvFile,
 	platformName,
@@ -143,31 +142,18 @@ if (overrides.length > 0) row("--", "modes", overrides.map(([id, value]) => `${i
 const ladder = config?.features?.swarm?.models ?? [];
 row("--", "subagents", ladder.length > 0 ? `model ladder ${ladder.join(" < ")}` : "use the session's model (no ladder configured)");
 
-const judgeSupport = localJudgeSupport({ platform: process.platform, env: process.env, wsl });
-if (!asksJudge) {
-	// Nothing asks the local judge either: whether it is up does not matter.
-} else if (tiers.some((tier) => tier.startsWith("laya")) && !judgeSupport.runs && !judgeSupport.url) {
-	// Not a failure of this installation: the sidecar is Core ML, and there is none for this platform.
-	row("--", "local judge", `not available on ${platformName({ platform: process.platform, wsl })}: the Laya sidecar needs Core ML (macOS on Apple silicon)`);
-	row("--", "", "Laya's decision points use the next judge or their fallbacks. Use Jev, an LLM judge or MU_LOCAL_JUDGE_URL=<a server with the same API>");
-} else if (tiers.some((tier) => tier.startsWith("laya"))) {
-	const base = env("LOCAL_JUDGE_URL") ?? `http://127.0.0.1:${env("LOCAL_JUDGE_PORT") ?? 47823}`;
-	const startedAt = performance.now();
-	try {
-		const response = await fetch(`${base}/health`, { signal: AbortSignal.timeout(2000) });
-		const health = await response.json();
-		const ms = Math.round(performance.now() - startedAt);
-		row(health.status === "ok" ? "ok" : "--", "local judge", `${base} · ${health.status} · ${health.model ?? "laya"} · ${ms} ms`);
-	} catch {
-		row(
-			"fix",
-			"local judge",
-			judgeSupport.runs
-				? `${base} isn't answering: run mu judge start   (first time: mu judge setup)`
-				: `${base} (MU_LOCAL_JUDGE_URL) isn't answering`,
-		);
-	}
+// Laya, the local judge mu had until 0.2.4, is no longer built in. The next session takes it out of mu.json (mude 1.0 in
+// its place when it is set up), and skips it in MU_JUDGE (packages/kyrn-judge/src/laya-migration.ts).
+if (tiers.includes("laya") || Object.values(config?.judges ?? {}).some((judge) => judge?.type === "local")) {
+	row(
+		"--",
+		"laya",
+		env("JUDGE")
+			? "no longer built into mu: mu skips it in MU_JUDGE. Other decision models: mu judge model add <link>"
+			: "no longer built into mu: the next session takes it out of mu.json. Other decision models: mu judge model add <link>",
+	);
 }
+
 // The built-in ways to Jev, as packages/kyrn-judge/src/config.ts has them; mu.json may name others.
 const JEV_ROUTES = {
 	jev: { type: "jev" },
@@ -359,10 +345,13 @@ const { browserAdvice, findBrowser, thisBrowserHost } = await import(
 const browserHost = thisBrowserHost();
 const chrome = findBrowser(browserHost);
 const [advice, ...moreAdvice] = chrome ? [] : browserAdvice(browserHost).split("\n");
+// Only mu's browser needs one: without it the rest of mu works, so it is not something to fix.
 row(
-	chrome ? "ok" : "fix",
+	chrome ? "ok" : "--",
 	"browser",
-	chrome ? `${chrome.executable}${chrome.side === "windows" ? "  (on the Windows side, reached over mirrored networking)" : ""}` : advice,
+	chrome
+		? `${chrome.executable}${chrome.side === "windows" ? "  (on the Windows side, reached over mirrored networking)" : ""}`
+		: `optional, for mu's browser. ${advice}`,
 );
 for (const line of moreAdvice) row("--", "", line);
 const canRelate = (tier) =>

package/kyrn/bin/mu.mjs

@@ -22,8 +22,9 @@
 // - mu's name on the agent: PI_PACKAGE_DIR points at ~/.mu/app, a view of packages/coding-agent whose
 //   package.json carries piConfig {name: mu, configDir: .mu}. No upstream file is edited.
 // - the judgment layer (packages/kyrn-judge), with judges from ~/.mu/agent/mu.json or MU_JUDGE
-//   (e.g. "laya", "laya,luna", "laya,jev", "off"). When "laya" is among them the sidecar is started (macOS only).
-//   kyrn.json and every KYRN_* variable are still read when the mu spelling is absent.
+//   (e.g. "jev", "mude,jev", "off"). When mude 1.0 or a decision model added from Hugging Face is among them, its
+//   server is started in the background (macOS only). kyrn.json and every KYRN_* variable are still read when the
+//   mu spelling is absent.
 // - the repo-root .env (the Jev key), read as data and handed to the agent without ever being printed.
 //   The npm package reads ~/.mu/.env instead: there is no repository around it.
 import { spawn, spawnSync } from "node:child_process";
@@ -100,13 +101,16 @@ export function usage(platform) {
 		'  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 (mu setup --help)",
-		"  mu judge mude install    install mude 1.0, mu's own decision model for coding, and make it the judge on this Mac (Apple silicon, 1.8 GB)",
+		"  mu setup                 connect a model (paste an API key or pick a service) and choose",
+		"                           a judge (mu setup --help)",
+		"  mu judge mude install    install mude 1.0, mu's own decision model for coding, and make it",
+		"                           the judge on this Mac (Apple silicon, 1.8 GB)",
 		"                           enable | disable | start | stop | status | uninstall (mu judge mude help)",
-		"  mu judge model <cmd>     other decision models from Hugging Face: add <link> | list | use | remove (mu judge model help)",
-		"  mu judge <cmd>           manage the local judge, Laya (macOS on Apple silicon): setup | start | stop | status | run",
+		"  mu judge model <cmd>     other decision models from Hugging Face:",
+		"                           add <link> | list | use | remove (mu judge model help)",
 		"  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 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>",
@@ -422,28 +426,9 @@ export function agentDirFor({ env, muDir, platform }) {
 	);
 }
 
-/** Whether the configuration asks for the local judge. */
-export function wantsLaya({ env, agentDir, platform, readFile }) {
-	const judges = muEnv("JUDGE", env);
-	if (judges) return `,${judges},`.includes(",laya");
-	const path = pathFor(platform);
-	for (const name of ["mu.json", "kyrn.json"]) {
-		let text;
-		try {
-			text = readFile(path.join(agentDir, name));
-		} catch {
-			continue;
-		}
-		// Like the file itself: kyrn.json is only looked at when there is no mu.json.
-		return text.includes('"laya');
-	}
-	return false;
-}
-
-/** The Core ML sidecar exists for macOS only. Anything else needs a server of its own behind MU_LOCAL_JUDGE_URL. */
 /**
  * Whether the configuration asks for mude (mu judge mude): MU_JUDGE naming it, else `tiers` or a route in mu.json (or
- * kyrn.json when there is no mu.json). Its server is then started when a session starts, as Laya's is.
+ * kyrn.json when there is no mu.json). Its server is then started when a session starts.
  */
 export function wantsMude({ env, agentDir, platform, readFile }) {
 	const judges = muEnv("JUDGE", env);
@@ -487,30 +472,47 @@ export function wantedModel({ env, agentDir, muDir, platform, readFile, exists }
 	return undefined;
 }
 
+/**
+ * Whether mu.json (or kyrn.json when there is no mu.json) still names Laya, which mu no longer has: `laya` in `tiers`
+ * or a route (and no judge of that name of a type mu knows), or a judge of Laya's type, `local`. The judgment layer
+ * then puts mude 1.0 in its place when it is set up on this Mac (packages/kyrn-judge/src/laya-migration.ts), so mude's
+ * server is started for that session too. MU_JUDGE naming Laya is only skipped.
+ */
+export function namesLaya({ env, agentDir, platform, readFile }) {
+	if (muEnv("JUDGE", env)) return false;
+	const path = pathFor(platform);
+	for (const name of ["mu.json", "kyrn.json"]) {
+		let config;
+		try {
+			config = JSON.parse(readFile(path.join(agentDir, name)));
+		} catch (error) {
+			if (error instanceof SyntaxError) return false;
+			continue;
+		}
+		const judges = config?.judges && typeof config.judges === "object" ? config.judges : {};
+		const known = ["jev", "typesafe", "clm", "gateway", "http", "llm", "classifier", "mock"];
+		const retired = (tier) =>
+			typeof tier === "string" &&
+			(judges[tier.trim()]?.type === "local" || (tier.trim() === "laya" && !known.includes(judges.laya?.type)));
+		const lists = [config?.tiers, ...Object.values(config?.routes ?? {})];
+		return lists.some((tiers) => (Array.isArray(tiers) ? tiers : typeof tiers === "string" ? tiers.split(",") : []).some(retired));
+	}
+	return false;
+}
+
+/** What mude 1.0 needs to answer: its environment, made by `mu judge mude install`, and the key `enable` writes to the .env. */
+export function mudeSetUp({ env, muDir, platform, exists }) {
+	return Boolean(env.MU_JUDGE_MUDE_KEY) && exists(pathFor(platform).join(muDir, "local-judge", "mude", "venv", "bin", "python"));
+}
+
 /** What starts the server of the decision model the configuration asks for: `mu judge mude start`, or a model's. */
 export function localModelStart({ env, agentDir, muDir, platform, readFile, exists }) {
 	if (wantsMude({ env, agentDir, platform, readFile })) return ["start", "--no-wait"];
+	if (namesLaya({ env, agentDir, platform, readFile }) && mudeSetUp({ env, muDir, platform, exists })) return ["start", "--no-wait"];
 	const model = wantedModel({ env, agentDir, muDir, platform, readFile, exists });
 	return model ? ["model", "start", model, "--no-wait"] : undefined;
 }
 
-export function localJudgeSupport({ platform, env, wsl = false }) {
-	if (platform === "darwin") return { runs: true };
-	const url = muEnv("LOCAL_JUDGE_URL", env);
-	const where = platformName({ platform, wsl });
-	return {
-		runs: false,
-		url,
-		message: [
-			`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"),
-	};
-}
-
 /** exec replaces this process, as the bash launcher did; spawn is what Windows has. MU_LAUNCH forces either. */
 export function launchStrategy({ platform, env, canExec }) {
 	const forced = muEnv("LAUNCH", env);
@@ -623,17 +625,6 @@ export function planLaunch({
 	// pi reports a fresh install to pi.dev with its version. mu-agent is not a pi install; asked for, it still can be.
 	if (layout === "package" && childEnv.PI_TELEMETRY === undefined) childEnv.PI_TELEMETRY = "0";
 
-	let startJudge = false;
-	if (wantsLaya({ env: childEnv, agentDir, platform, readFile: fs.readFile })) {
-		const support = localJudgeSupport({ platform, env: childEnv, wsl });
-		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 })}, the decision points it would answer use the next judge or their fallbacks (mu judge status)`,
-			);
-		}
-	}
-
 	// mude's server, or an added model's, when the configuration asks for it: started without waiting, so a session
 	// never waits for the model to load (what it cannot answer yet goes to the judges behind it). Only a Mac runs it.
 	let startMude;
@@ -652,7 +643,6 @@ export function planLaunch({
 		muDir,
 		appDir,
 		agentDir,
-		startJudge,
 		startMude,
 		notes,
 		preface: argv[0] === "-h" || argv[0] === "--help" ? `${usage(platform)}\n\npi's help (mu passes all of this through):\n` : undefined,
@@ -688,7 +678,6 @@ export function planHost({ platform, env, argv, root, home, fs, wsl = false, str
 		muDir: launch.muDir,
 		appDir: launch.appDir,
 		agentDir: launch.agentDir,
-		startJudge: launch.startJudge,
 		startMude,
 		notes: launch.notes,
 	};
@@ -712,10 +701,6 @@ export function planHost({ platform, env, argv, root, home, fs, wsl = false, str
 	};
 }
 
-/** What mu says when the local judge does not come up. */
-const LOCAL_JUDGE_NOT_STARTED =
-	"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 }) {
 	const path = pathFor(platform);
@@ -728,26 +713,19 @@ function prepareFiles({ plan, platform, root, err }) {
 
 /**
  * What is done before pi starts, for the command line and the desktop app's runtime host alike: the app view that
- * names a checkout mu, mu's agent folder, the configuration's notes (to `err`), and the local judge when the
- * configuration asks for it. `bin` is this launcher's folder. The local judge is one shared sidecar: starting it is
- * idempotent and never blocks pi.
+ * names a checkout mu, mu's agent folder, the configuration's notes (to `err`), and the server of the decision model
+ * the configuration asks for (mude 1.0, or one added from Hugging Face), started in the background. Nothing here waits
+ * for a judge. `bin` (this launcher's folder) is still taken, for the hosts that pass it.
  */
-export function prepareLaunch({ plan, platform, root, bin, err }) {
+export function prepareLaunch({ plan, platform, root, err }) {
 	prepareFiles({ plan, platform, root, err });
 	startMudeServer(plan);
-	if (plan.startJudge) {
-		const started = spawnSync(pathFor(platform).join(bin, "kyrn-judge-local"), ["start"], {
-			stdio: "ignore",
-			env: plan.env,
-		});
-		if (started.status !== 0) err(LOCAL_JUDGE_NOT_STARTED);
-	}
 }
 
 /**
  * mude's server, or an added model's, started in the background (`mu judge mude start --no-wait`): nothing waits for
- * it, and it outlives this process, shared by every mu session like Laya. When it is not installed it does nothing (the
- * doctor says so).
+ * it, and it outlives this process, shared by every mu session. When it is not installed it does nothing (the doctor
+ * says so). Until it answers, the judges behind it do: its address refuses the connection at once.
  */
 function startMudeServer(plan) {
 	if (!plan.startMude) return;
@@ -765,22 +743,11 @@ function startMudeServer(plan) {
 }
 
 /**
- * prepareLaunch for a program that must not stop while the local judge starts, such as the desktop app's main process:
- * the same steps and notes, with the local judge started through a child process it waits for without blocking.
+ * prepareLaunch for a program that must not stop, such as the desktop app's main process. It is prepareLaunch: it
+ * starts nothing it waits for. It stays a promise for the hosts that await it.
  */
-export async function prepareLaunchAsync({ plan, platform, root, bin, err }) {
-	prepareFiles({ plan, platform, root, err });
-	startMudeServer(plan);
-	if (!plan.startJudge) return;
-	const status = await new Promise((resolve) => {
-		const child = spawn(pathFor(platform).join(bin, "kyrn-judge-local"), ["start"], {
-			stdio: "ignore",
-			env: plan.env,
-		});
-		child.once("error", () => resolve(null));
-		child.once("close", (code) => resolve(code));
-	});
-	if (status !== 0) err(LOCAL_JUDGE_NOT_STARTED);
+export async function prepareLaunchAsync(input) {
+	prepareLaunch(input);
 }
 
 // ---------------------------------------------------------------------------------------------------------
@@ -808,8 +775,8 @@ export const AUTH_USAGE = [
 	"  mu auth status",
 	"  mu auth login <provider> [--paste]",
 	"  mu auth logout <provider>",
-	"In a terminal, /login inside mu signs in the same way. With --paste, the sign-in takes the address the browser",
-	"ends on as pasted instead of listening for it: for when another program (the Codex CLI) holds the callback port.",
+	"In a terminal, /login inside mu signs in the same way. With --paste, you paste the address the browser ends on",
+	"instead of mu listening for it. Use it when another program, such as the Codex CLI, holds the callback port.",
 	"",
 	"pi's auth commands:",
 ].join("\n");
@@ -847,13 +814,38 @@ export function planAuth({ platform, env, argv, root, home, execPath, fs, canExe
 // mu judge
 // ---------------------------------------------------------------------------------------------------------
 
-/** What `mu judge <cmd>` does here: the macOS script, a look at a server of one's own, or a plain explanation. */
-export function planJudge({ platform, env, argv, bin, wsl = false }) {
-	const args = argv.length > 0 ? argv : ["status"];
-	const support = localJudgeSupport({ platform, env, wsl });
-	if (support.runs) return { kind: "script", command: pathFor(platform).join(bin, "kyrn-judge-local"), args };
-	if (args[0] === "status" && support.url) return { kind: "health", url: `${support.url.replace(/\/+$/, "")}/health` };
-	return { kind: "unsupported", message: support.message };
+/** `mu judge help`. `mu judge mude …` and `mu judge model …` have their own (packages/kyrn-judge/src/mude). */
+export const JUDGE_USAGE = [
+	"mu judge: the decision model that answers mu's judgment calls on this machine.",
+	"",
+	"  mu judge mude <cmd>     mude 1.0, mu's own decision model for coding (a Mac with Apple silicon):",
+	"                          install | enable | disable | start | stop | status | uninstall (mu judge mude help)",
+	"  mu judge model <cmd>    other decision models from Hugging Face: add <link> | list | use | remove (mu judge model help)",
+	"",
+	"Hosted judges (Jev and others) are set with mu setup, or in ~/.mu/agent/mu.json.",
+].join("\n");
+
+/** The commands that ran Laya's sidecar until mu 0.2.4. */
+const LAYA_COMMANDS = ["setup", "start", "stop", "status", "run"];
+
+/**
+ * What `mu judge <cmd>` does, besides `mude` and `model`: its usage, or a plain explanation. Laya, which `mu judge
+ * setup | start | stop | status | run` ran, is no longer built into mu.
+ */
+export function planJudge({ argv }) {
+	const [command] = argv;
+	if (command === undefined || command === "help" || command === "--help" || command === "-h") return { kind: "usage", code: 0, text: JUDGE_USAGE };
+	if (LAYA_COMMANDS.includes(command)) {
+		return {
+			kind: "removed",
+			code: 1,
+			text: [
+				`mu judge ${command} used to manage Laya, which is no longer built into mu.`,
+				"For a decision model on this machine, install mude 1.0 (mu judge mude install), or add one from Hugging Face (mu judge model add <link>).",
+			].join("\n"),
+		};
+	}
+	return { kind: "unknown", code: 2, text: `Unknown command: mu judge ${command}\n\n${JUDGE_USAGE}` };
 }
 
 // ---------------------------------------------------------------------------------------------------------
@@ -1661,20 +1653,10 @@ export async function main(argv = process.argv.slice(2)) {
 		return handOver({ command: plan.command, args: plan.args, env: plan.env, strategy: "spawn" });
 	}
 	if (command === "judge") {
-		const plan = planJudge({ platform, env, argv: rest, bin, wsl });
-		if (plan.kind === "script") return handOver({ command: plan.command, args: plan.args, env, strategy });
-		if (plan.kind === "unsupported") {
-			err(plan.message);
-			return 1;
-		}
-		try {
-			const response = await fetch(plan.url, { signal: AbortSignal.timeout(2000) });
-			out(await response.text());
-			return 0;
-		} catch {
-			out(`The local judge server isn't answering at ${plan.url}. Check that it's running.`);
-			return 1;
-		}
+		const plan = planJudge({ argv: rest });
+		if (plan.code === 0) out(plan.text);
+		else err(plan.text);
+		return plan.code;
 	}
 	if (command === "ledger") {
 		return handOver({ command: process.execPath, args: [path.join(bin, "kyrn-ledger"), ...rest], env, strategy });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mu-agent",
-	"version": "0.2.4",
+	"version": "0.2.6",
 	"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": {
@@ -42,6 +42,6 @@
 	"muBuild": {
 		"pi": "1.3.0",
 		"judge": "0.1.0",
-		"commit": "86b54d6d8"
+		"commit": "bd42ca6ba"
 	}
 }

package/kyrn/bin/kyrn-judge-local

@@ -1,160 +0,0 @@
-#!/usr/bin/env bash
-# Manage the mu local judge sidecar (Laya on Core ML, Apple silicon only).
-#
-#   kyrn/bin/kyrn-judge-local setup    create the venv, install pinned deps, download the weights (~680 MB)
-#   kyrn/bin/kyrn-judge-local start    start in the background if it is not already running
-#   kyrn/bin/kyrn-judge-local stop
-#   kyrn/bin/kyrn-judge-local status
-#   kyrn/bin/kyrn-judge-local run      run in the foreground
-#
-# One sidecar serves every mu session on this machine. State lives in ~/.mu/local-judge
-# (~/.kyrn/local-judge on a machine whose home has not been moved yet).
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
-HOME_DIR="$ROOT/kyrn/local-judge"
-MODEL_REPO="aac6fef/laya-multilingual-coreml"
-if [[ -d "$HOME/.mu" || ! -d "$HOME/.kyrn" ]]; then MU_DIR="$HOME/.mu"; else MU_DIR="$HOME/.kyrn"; fi
-RUN_DIR="${MU_LOCAL_JUDGE_RUN_DIR:-${KYRN_LOCAL_JUDGE_RUN_DIR:-$MU_DIR/local-judge}}"
-# A checkout keeps the venv and the weights beside server.py. The npm package (mu-agent) keeps them in mu's
-# home instead: npm replaces the whole package folder on every update.
-if [[ -d "$ROOT/packages/kyrn-judge" ]]; then STATE_DIR="$HOME_DIR"; else STATE_DIR="$RUN_DIR"; fi
-PYTHON="$STATE_DIR/.venv/bin/python"
-MODEL_DIR="${MU_LOCAL_JUDGE_MODEL:-${KYRN_LOCAL_JUDGE_MODEL:-$STATE_DIR/models/laya-multilingual-coreml}}"
-PORT="${MU_LOCAL_JUDGE_PORT:-${KYRN_LOCAL_JUDGE_PORT:-47823}}"
-PID_FILE="$RUN_DIR/judge.pid"
-LOG_FILE="$RUN_DIR/judge.log"
-URL="http://127.0.0.1:$PORT"
-
-health() { curl -s --max-time 2 "$URL/health" 2>/dev/null || true; }
-
-is_ready() { [[ "$(health)" == *'"status": "ok"'* ]]; }
-
-is_up() { [[ "$(health)" == *'"status"'* ]]; }
-
-require_setup() {
-  if [[ ! -x "$PYTHON" || ! -f "$MODEL_DIR/coreml_config.json" ]]; then
-    echo "The local judge isn't installed yet. Run: mu judge setup" >&2
-    exit 1
-  fi
-}
-
-cmd_setup() {
-  if [[ "$(uname -s)-$(uname -m)" != "Darwin-arm64" ]]; then
-    echo "The local judge needs a Mac with Apple silicon and macOS 15 or later." >&2
-    exit 1
-  fi
-  command -v uv >/dev/null || { echo "mu judge setup needs uv: https://docs.astral.sh/uv/" >&2; exit 1; }
-  mkdir -p "$STATE_DIR"
-  [[ -x "$PYTHON" ]] || uv venv --python 3.12 "$STATE_DIR/.venv"
-  # The official index on purpose: mirrors lag behind new releases.
-  uv pip install --python "$PYTHON" --index-url https://pypi.org/simple -r "$HOME_DIR/requirements.lock.txt"
-  if [[ ! -f "$MODEL_DIR/coreml_config.json" ]]; then
-    "$PYTHON" - "$MODEL_REPO" "$MODEL_DIR" <<'PY'
-import sys
-from huggingface_hub import snapshot_download
-
-snapshot_download(
-    sys.argv[1],
-    local_dir=sys.argv[2],
-    allow_patterns=[
-        "coreml_config.json", "rl_agent_config.json", "encoder/config.json", "tokenizer/*",
-        "model.mlpackage/**", "host_weights.safetensors", "README.md", "LICENSE*", "NOTICE*",
-    ],
-)
-PY
-  fi
-  "$PYTHON" - "$MODEL_DIR" <<'PY'
-import json, sys
-from pathlib import Path
-from laya_coreml.artifacts import verify_files
-
-directory = Path(sys.argv[1])
-manifest = json.loads((directory / "coreml_config.json").read_text())
-verify_files(directory, manifest["files"])
-print(f"Weights checked against the bundle's manifest ({len(manifest['files'])} files).")
-PY
-}
-
-cmd_run() {
-  require_setup
-  exec "$PYTHON" "$HOME_DIR/server.py" --model-dir "$MODEL_DIR" --port "$PORT" "$@"
-}
-
-cmd_start() {
-  require_setup
-  if is_up; then
-    echo "The local judge is already running at $URL."
-    return 0
-  fi
-  mkdir -p "$RUN_DIR"
-  nohup "$PYTHON" "$HOME_DIR/server.py" --model-dir "$MODEL_DIR" --port "$PORT" >>"$LOG_FILE" 2>&1 &
-  echo $! >"$PID_FILE"
-  for _ in $(seq 1 120); do
-    if is_ready; then
-      echo "The local judge is ready at $URL (pid $(cat "$PID_FILE"), log $LOG_FILE)."
-      return 0
-    fi
-    if ! kill -0 "$(cat "$PID_FILE")" 2>/dev/null; then
-      echo "The local judge stopped while starting; see $LOG_FILE" >&2
-      tail -5 "$LOG_FILE" >&2 || true
-      return 1
-    fi
-    sleep 0.5
-  done
-  echo "The local judge is still warming up; see $LOG_FILE" >&2
-}
-
-cmd_stop() {
-  if [[ -f "$PID_FILE" ]] && kill -0 "$(cat "$PID_FILE")" 2>/dev/null; then
-    kill "$(cat "$PID_FILE")"
-    echo "Stopped the local judge (pid $(cat "$PID_FILE"))."
-  else
-    echo "The local judge isn't running."
-  fi
-  rm -f "$PID_FILE"
-}
-
-cmd_status() {
-  local body
-  body="$(health)"
-  if [[ -z "$body" ]]; then echo "The local judge isn't running at $URL."; return 1; fi
-  # --json: the server's own answer, for scripts.
-  if [[ "${1:-}" == "--json" ]]; then echo "$body"; return 0; fi
-  URL="$URL" node -e '
-    let text = "";
-    process.stdin.on("data", (chunk) => (text += chunk)).on("end", () => {
-      let health;
-      try { health = JSON.parse(text); } catch { console.log(text.trim()); return; }
-      const up = Math.round((health.uptimeSeconds ?? 0) / 60);
-      const uptime = up < 60 ? `${up} min` : `${Math.floor(up / 60)} h ${up % 60} min`;
-      const state = health.status === "ok" ? "running" : `starting (${health.status})`;
-      const model = String(health.model ?? "").split("/").pop();
-      console.log(`The local judge is ${state} at ${process.env.URL}: ${model} on ${health.computeUnits}, pid ${health.pid}, up ${uptime}, ${health.requests} requests.`);
-    });' <<<"$body"
-}
-
-usage() {
-  cat <<'USAGE'
-mu judge: the local judge, Laya, on Core ML (macOS on Apple silicon).
-
-  mu judge setup           install it: a Python environment and the weights (about 680 MB)
-  mu judge start           start it in the background, unless it's already running
-  mu judge stop            stop it
-  mu judge status [--json] whether it's running, and what it serves
-  mu judge run             run it in the foreground
-
-One local judge serves every mu session on this machine. To have mu ask it, add "laya" to "tiers" in
-mu.json, or start mu with MU_JUDGE=laya.
-USAGE
-}
-
-case "${1:-status}" in
-  setup) cmd_setup ;;
-  run) shift; cmd_run "$@" ;;
-  start) cmd_start ;;
-  stop) cmd_stop ;;
-  status) shift; cmd_status "$@" ;;
-  help | -h | --help) usage ;;
-  *) usage >&2; exit 2 ;;
-esac

package/kyrn/local-judge/requirements.lock.txt

@@ -1,26 +0,0 @@
-anyio==4.15.1
-attrs==26.1.0
-cattrs==26.2.0
-certifi==2026.7.22
-click==8.5.0
-coremltools==9.0
-filelock==4.0.1
-fsspec==2026.9.0
-h11==0.16.0
-hf-xet==1.6.0
-httpcore==1.0.9
-httpx==0.28.1
-huggingface-hub==1.32.0
-idna==3.20
-laya-coreml==0.1.0
-mpmath==1.3.0
-numpy==2.1.3
-packaging==26.3
-protobuf==7.36.2
-pyaml==26.7.0
-pyyaml==6.0.3
-safetensors==0.8.0
-sympy==1.14.0
-tokenizers==0.23.2
-tqdm==4.70.1
-typing-extensions==4.16.0