mu-agent 0.2.2 → 0.2.3

package/judge/dist/mude.js

@@ -3,9 +3,9 @@ import { createRequire as __muCreateRequire } from "node:module"; const require
 // packages/kyrn-judge/src/mude/command.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync4, statfsSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync4, statfsSync, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir3, release, totalmem as totalmem2 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 
 // packages/kyrn-judge/src/mude/config.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
@@ -338,8 +338,8 @@ var FILES = [
 ];
 var MUDE_FILES = FILES.map(([path, size, sha256]) => ({ path, size, sha256 }));
 var MUDE_BYTES = MUDE_FILES.reduce((sum, file) => sum + file.size, 0);
-function mudeFileUrl(path, endpoint = "https://huggingface.co") {
-  return `${endpoint.replace(/\/+$/, "")}/${MUDE_REPO}/resolve/${MUDE_REVISION}/${path.split("/").map(encodeURIComponent).join("/")}`;
+function fileUrl(repo, revision, path, endpoint = "https://huggingface.co") {
+  return `${endpoint.replace(/\/+$/, "")}/${repo}/resolve/${revision}/${path.split("/").map(encodeURIComponent).join("/")}`;
 }
 
 // packages/kyrn-judge/src/mude/server.ts
@@ -445,7 +445,7 @@ async function startServer(paths, options) {
       "--port",
       String(options.port),
       "--name",
-      MUDE_MODEL,
+      options.name ?? MUDE_MODEL,
       "--verify",
       "fast"
     ],
@@ -526,6 +526,11 @@ function serverMemory(pid) {
 var ROUTED_AWAY = ["tool.description", "tool.injection"];
 var MUDE = "mude";
 var KEY_VARIABLE = "MU_JUDGE_MUDE_KEY";
+var MUDE_JUDGE = {
+  name: MUDE,
+  keyVariable: KEY_VARIABLE,
+  entry: (port2) => port2 === DEFAULT_PORT ? void 0 : entryFor(port2)
+};
 function readState(paths) {
   try {
     const value = JSON.parse(readFileSync3(paths.state, "utf8"));
@@ -538,18 +543,22 @@ function writeState(paths, state) {
   writeFileSync3(paths.state, `${JSON.stringify(state, null, 2)}
 `, { mode: 384 });
 }
-function judgeSetting(files) {
+function judgeSetting(files, name = MUDE) {
   const file = readJsonFile(judgeConfigPath(files.agentDir));
   if (file.state === "unreadable") return { enabled: false, localOnly: false, fallback: [], unreadable: true };
   const config = file.state === "ok" ? file.value : {};
   const tiers = tiersOf(config);
-  const enabled = tiers[0] === MUDE && !judgeOff(config);
-  const fallback = tiers.filter((tier) => tier !== MUDE);
+  const enabled = tiers[0] === name && !judgeOff(config);
+  const fallback = tiers.filter((tier) => tier !== name);
   return { enabled, localOnly: enabled && fallback.length === 0, fallback };
 }
-function mudeInTiers(files) {
+function mudeInTiers(files, name = MUDE) {
+  const file = readJsonFile(judgeConfigPath(files.agentDir));
+  return file.state === "ok" && tiersOf(file.value).includes(name);
+}
+function currentTiers(files) {
   const file = readJsonFile(judgeConfigPath(files.agentDir));
-  return file.state === "ok" && tiersOf(file.value).includes(MUDE);
+  return file.state === "ok" ? tiersOf(file.value) : [];
 }
 function readConfig(files) {
   const path = judgeConfigPath(files.agentDir);
@@ -583,18 +592,20 @@ function withoutOwnRoutes(config, state) {
 function entryFor(port2) {
   return { ...BUILT_IN_JUDGES[MUDE], baseUrl: mudeBaseUrl(port2) };
 }
-function enableMude(paths, files, options) {
+function enableLocal(judge, paths, files, options) {
+  const name = judge.name;
   const { path, config } = readConfig(files);
   const state = readState(paths);
-  const current = tiersOf(config).filter((tier) => tier !== MUDE);
+  const current = tiersOf(config).filter((tier) => tier !== name);
   const before = current.length > 0 ? current : [...state?.previousTiers ?? ["jev"]];
-  const tiers = options.localOnly ? [MUDE] : [MUDE, ...before.filter((tier) => tier !== MUDE)];
+  const tiers = options.localOnly ? [name] : [name, ...before.filter((tier) => tier !== name)];
   const judgeWasOff = state?.judgeWasOff ?? judgeOff(config);
   let next = withJudge(withTiers(withoutOwnRoutes(config, state), tiers), true);
   const judges = judgesOf(next);
-  const entry = options.port !== DEFAULT_PORT;
-  if (entry) judges[MUDE] = entryFor(options.port);
-  else if (state?.wroteEntry) delete judges[MUDE];
+  const written = judge.entry(options.port);
+  if (written) judges[name] = written;
+  else if (state?.wroteEntry) delete judges[name];
+  const entry = written !== void 0;
   next = withSection(next, "judges", judges);
   const fallback = tiers.slice(1);
   const routes = recordOf(next.routes);
@@ -610,9 +621,9 @@ function enableMude(paths, files, options) {
   const backups = new Backups(files.home, files.now ?? /* @__PURE__ */ new Date());
   backups.save(path);
   writeJsonFile(path, next);
-  if (envFileValue(readText(files.envFile), KEY_VARIABLE) !== options.key) {
+  if (envFileValue(readText(files.envFile), judge.keyVariable) !== options.key) {
     backups.save(files.envFile);
-    writeEnvValue(files.envFile, KEY_VARIABLE, options.key);
+    writeEnvValue(files.envFile, judge.keyVariable, options.key);
   }
   writeState(paths, {
     port: options.port,
@@ -624,15 +635,18 @@ function enableMude(paths, files, options) {
   return tiers;
 }
 function disableMude(paths, files, options = {}) {
+  return disableLocal(MUDE_JUDGE, paths, files, options);
+}
+function disableLocal(judge, paths, files, options = {}) {
   const { path, config } = readConfig(files);
   const state = readState(paths);
-  const rest = tiersOf(config).filter((tier) => tier !== MUDE);
+  const rest = tiersOf(config).filter((tier) => tier !== judge.name);
   const tiers = rest.length > 0 ? rest : [...state?.previousTiers ?? ["jev"]];
   let next = withTiers(withoutOwnRoutes(config, state), tiers);
   if (state?.judgeWasOff) next = withJudge(next, false);
   if (options.removeEntry && state?.wroteEntry) {
     const judges = judgesOf(next);
-    delete judges[MUDE];
+    delete judges[judge.name];
     next = withSection(next, "judges", judges);
   }
   new Backups(files.home, files.now ?? /* @__PURE__ */ new Date()).save(path);
@@ -698,6 +712,14 @@ async function sha256File(path) {
   await pipeline(createReadStream(path), hash);
   return hash.digest("hex");
 }
+var pinnedHash = (file) => file.sha256 ?? file.gitSha1 ?? "";
+async function hashOf(path, file) {
+  if (file.sha256 || !file.gitSha1) return sha256File(path);
+  const hash = createHash("sha1");
+  hash.update(`blob ${statSync3(path).size}\0`);
+  await pipeline(createReadStream(path), hash);
+  return hash.digest("hex");
+}
 function readVerified(dir) {
   try {
     const value = JSON.parse(readFileSync4(join3(dir, ".mu-verified.json"), "utf8"));
@@ -708,7 +730,7 @@ function readVerified(dir) {
 }
 function knownGood(dir, file, verified) {
   const seen = verified[file.path];
-  if (!seen || seen.sha256 !== file.sha256) return false;
+  if (!seen || seen.sha256 !== pinnedHash(file)) return false;
   try {
     const stats = statSync3(join3(dir, file.path));
     return stats.size === file.size && stats.mtimeMs === seen.mtimeMs;
@@ -718,7 +740,7 @@ function knownGood(dir, file, verified) {
 }
 function remember(dir, verified, file) {
   const stats = statSync3(join3(dir, file.path));
-  verified[file.path] = { size: stats.size, mtimeMs: stats.mtimeMs, sha256: file.sha256 };
+  verified[file.path] = { size: stats.size, mtimeMs: stats.mtimeMs, sha256: pinnedHash(file) };
   writeFileSync4(join3(dir, ".mu-verified.json"), `${JSON.stringify(verified, null, 1)}
 `);
 }
@@ -769,7 +791,7 @@ async function downloadFiles(options) {
     mkdirSync3(dirname2(target), { recursive: true });
     if (existsSync3(target) && statSync3(target).size === file.size) {
       options.onProgress?.({ file: file.path, checking: true, done: settled, total });
-      if (await sha256File(target) === file.sha256) {
+      if (await hashOf(target, file) === pinnedHash(file)) {
         remember(dir, verified, file);
         settled += file.size;
         continue;
@@ -780,17 +802,17 @@ async function downloadFiles(options) {
     const onBytes = (bytes) => options.onProgress?.({ file: file.path, checking: false, done: settled + bytes, total });
     let resumed = await fetchFile(options, file, part, onBytes);
     options.onProgress?.({ file: file.path, checking: true, done: settled + file.size, total });
-    let actual = await sha256File(part);
-    if (actual !== file.sha256 && resumed) {
+    let actual = await hashOf(part, file);
+    if (actual !== pinnedHash(file) && resumed) {
       dropPart(part);
       resumed = await fetchFile(options, file, part, onBytes);
       options.onProgress?.({ file: file.path, checking: true, done: settled + file.size, total });
-      actual = await sha256File(part);
+      actual = await hashOf(part, file);
     }
-    if (actual !== file.sha256) {
+    if (actual !== pinnedHash(file)) {
       dropPart(part);
       throw new DownloadError(
-        `${file.path} does not match its pinned sha256 (got ${actual.slice(0, 12)}\u2026, want ${file.sha256.slice(0, 12)}\u2026); it was removed`,
+        `${file.path} does not match its pinned ${file.sha256 ? "sha256" : "git hash"} (got ${actual.slice(0, 12)}\u2026, want ${pinnedHash(file).slice(0, 12)}\u2026); it was removed`,
         "integrity"
       );
     }
@@ -934,6 +956,10 @@ async function fetchOnce(options, file, part, onBytes) {
   }
 }
 
+// packages/kyrn-judge/src/mude/models.ts
+import { mkdirSync as mkdirSync4, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join5 } from "node:path";
+
 // packages/kyrn-judge/src/mude/paths.ts
 import { join as join4 } from "node:path";
 function mudePaths(muHome) {
@@ -957,12 +983,204 @@ function mudePaths(muHome) {
   };
 }
 
+// packages/kyrn-judge/src/mude/models.ts
+var ModelError = class extends Error {
+  kind;
+  constructor(message, kind) {
+    super(message);
+    this.name = "ModelError";
+    this.kind = kind;
+  }
+};
+var PART = /^[A-Za-z0-9][A-Za-z0-9._-]{0,95}$/;
+function parseModelRef(input) {
+  const text = input.trim();
+  let repo;
+  let revision;
+  if (/^https?:\/\//i.test(text) || /^(www\.)?(huggingface\.co|hf\.co)\//i.test(text)) {
+    let url;
+    try {
+      url = new URL(/^https?:\/\//i.test(text) ? text : `https://${text}`);
+    } catch {
+      throw new ModelError(`${text} isn't a Hugging Face link`, "usage");
+    }
+    if (!/^(www\.)?(huggingface\.co|hf\.co)$/i.test(url.hostname))
+      throw new ModelError(`${text} isn't a Hugging Face link`, "usage");
+    const parts = url.pathname.split("/").filter(Boolean).map(decodeURIComponent);
+    if (parts[0] === "datasets" || parts[0] === "spaces") {
+      throw new ModelError(
+        `${text} is a Hugging Face ${parts[0] === "datasets" ? "dataset" : "Space"}, not a model`,
+        "usage"
+      );
+    }
+    if (parts.length < 2)
+      throw new ModelError(
+        `${text} doesn't name a model: use a link like https://huggingface.co/owner/name`,
+        "usage"
+      );
+    repo = `${parts[0]}/${parts[1]}`;
+    if (["tree", "blob", "resolve"].includes(parts[2] ?? "") && parts[3]) revision = parts[3];
+  } else {
+    const at = text.lastIndexOf("@");
+    repo = at > 0 ? text.slice(0, at) : text;
+    revision = at > 0 ? text.slice(at + 1) : void 0;
+  }
+  const [owner, name, extra] = repo.split("/");
+  if (!owner || !name || extra !== void 0 || !PART.test(owner) || !PART.test(name)) {
+    throw new ModelError(
+      `${text} isn't a Hugging Face model: give its link or owner/name (for example qybaihe/mude-1.0-mlx-8bit)`,
+      "usage"
+    );
+  }
+  if (revision !== void 0 && !/^[A-Za-z0-9][A-Za-z0-9._/-]{0,199}$/.test(revision)) {
+    throw new ModelError(`${revision} isn't a branch, tag or commit`, "usage");
+  }
+  return { repo, revision };
+}
+var SERVER_FILE = "d3_server_mac.py";
+async function resolveModel(ref, options = {}) {
+  const endpoint = (options.endpoint ?? "https://huggingface.co").replace(/\/+$/, "");
+  const get = options.fetch ?? fetch;
+  const headers = options.token ? { Authorization: `Bearer ${options.token}` } : {};
+  const request = async (url) => {
+    let response;
+    try {
+      response = await get(url, { headers, signal: AbortSignal.timeout(3e4) });
+    } catch (error) {
+      throw new ModelError(
+        `Couldn't reach Hugging Face (${error instanceof Error ? error.message : String(error)}): check the connection, then add it again`,
+        "network"
+      );
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new ModelError(
+        `Hugging Face won't show ${ref.repo} (${response.status}): it's private or gated. Accept its terms on huggingface.co, set HF_TOKEN, then add it again`,
+        "access"
+      );
+    }
+    if (response.status === 404) {
+      throw new ModelError(
+        `Hugging Face has no model ${ref.repo}${ref.revision ? ` at ${ref.revision}` : ""}`,
+        "notFound"
+      );
+    }
+    if (!response.ok) throw new ModelError(`Hugging Face returned ${response.status} for ${ref.repo}`, "network");
+    return response;
+  };
+  const info = await (await request(`${endpoint}/api/models/${ref.repo}/revision/${encodeURIComponent(ref.revision ?? "main")}`)).json();
+  const revision = typeof info.sha === "string" ? info.sha : "";
+  if (!/^[0-9a-f]{40}$/.test(revision)) throw new Error(`Hugging Face didn't say which commit ${ref.repo} is at`);
+  const files = [];
+  let next = `${endpoint}/api/models/${ref.repo}/tree/${revision}?recursive=true`;
+  while (next) {
+    const response = await request(next);
+    for (const entry of await response.json()) {
+      if (entry.type !== "file" || typeof entry.path !== "string" || typeof entry.size !== "number") continue;
+      if (entry.path.split("/").some((part) => part === ".." || part === "")) continue;
+      const sha256 = entry.lfs?.oid;
+      if (sha256 && /^[0-9a-f]{64}$/.test(sha256)) files.push({ path: entry.path, size: entry.size, sha256 });
+      else if (entry.oid && /^[0-9a-f]{40}$/.test(entry.oid))
+        files.push({ path: entry.path, size: entry.size, gitSha1: entry.oid });
+      else throw new Error(`Hugging Face listed ${entry.path} of ${ref.repo} without a hash, so mu can't check it`);
+    }
+    next = /<([^>]+)>;\s*rel="next"/.exec(response.headers.get("link") ?? "")?.[1];
+  }
+  if (!files.some((file) => file.path === SERVER_FILE)) {
+    throw new ModelError(
+      `${ref.repo} isn't packaged as a decision model mu can run: it has no ${SERVER_FILE}. mu runs models packaged like mude 1.0's MLX edition, with their own System One server`,
+      "notRunnable"
+    );
+  }
+  return { revision, files };
+}
+function reserved(name) {
+  return name in BUILT_IN_JUDGES || name === "off" || name.startsWith("jev") || name.includes(":");
+}
+var slug = (text) => text.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+function modelId(repo, taken) {
+  const [owner = "", name = ""] = repo.split("/");
+  const short = slug(name);
+  if (short && !reserved(short) && !taken.has(short)) return short;
+  const long = slug(`${owner}-${name}`);
+  if (!reserved(long) && !taken.has(long)) return long;
+  for (let n = 2; ; n++) if (!taken.has(`${long}-${n}`)) return `${long}-${n}`;
+}
+function modelsDir(muHome) {
+  return join5(muHome, "local-judge", "models");
+}
+function modelPaths(muHome, record) {
+  const shared = mudePaths(muHome);
+  const root = join5(modelsDir(muHome), record.id);
+  const model = join5(root, "model", record.revision);
+  return {
+    ...shared,
+    root,
+    model,
+    verified: join5(model, ".mu-verified.json"),
+    key: join5(root, "key"),
+    pid: join5(root, "server.pid"),
+    log: join5(root, "server.log"),
+    state: join5(root, "state.json"),
+    install: join5(root, "install.json"),
+    installLock: join5(root, "install.lock")
+  };
+}
+function writeRecord(muHome, record) {
+  const root = join5(modelsDir(muHome), record.id);
+  mkdirSync4(root, { recursive: true });
+  writeFileSync5(join5(root, "model.json"), `${JSON.stringify(record, null, 1)}
+`);
+}
+function isRecord2(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return typeof record.id === "string" && typeof record.repo === "string" && typeof record.revision === "string" && typeof record.bytes === "number" && Array.isArray(record.files);
+}
+function listRecords(muHome) {
+  let names;
+  try {
+    names = readdirSync(modelsDir(muHome));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const name of names.sort()) {
+    try {
+      const value = JSON.parse(readFileSync5(join5(modelsDir(muHome), name, "model.json"), "utf8"));
+      if (isRecord2(value) && value.id === name) records.push(value);
+    } catch {
+    }
+  }
+  return records;
+}
+function findRecord(muHome, name) {
+  const records = listRecords(muHome);
+  const lower = name.toLowerCase();
+  return records.find((record) => record.id === lower) ?? records.find((record) => record.repo.toLowerCase() === lower);
+}
+function keyVariable(id) {
+  return `MU_JUDGE_${id.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_KEY`;
+}
+function localJudgeOf(id) {
+  return {
+    name: id,
+    keyVariable: keyVariable(id),
+    entry: (port2) => ({
+      type: "typesafe",
+      baseUrl: mudeBaseUrl(port2),
+      model: id,
+      apiKeyEnv: keyVariable(id),
+      timeoutMs: 4e3
+    })
+  };
+}
+
 // packages/kyrn-judge/src/mude/python.ts
 import { spawn as spawn2 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { accessSync, constants, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { delimiter, join as join5 } from "node:path";
+import { delimiter, join as join6 } from "node:path";
 var PYTHON_VERSION = "3.13";
 var UV_RELEASE = {
   version: "0.13.1",
@@ -980,14 +1198,14 @@ function executable(path) {
 function findUv(paths, env = process.env, home = homedir2()) {
   const dirs = [
     ...(env.PATH ?? "").split(delimiter),
-    join5(home, ".local", "bin"),
-    join5(home, ".cargo", "bin"),
+    join6(home, ".local", "bin"),
+    join6(home, ".cargo", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     paths.tools
   ];
   for (const dir of dirs) {
-    if (dir && executable(join5(dir, "uv"))) return join5(dir, "uv");
+    if (dir && executable(join6(dir, "uv"))) return join6(dir, "uv");
   }
   return void 0;
 }
@@ -1017,7 +1235,7 @@ function run(command, args, options = {}) {
   });
 }
 async function downloadUv(paths, options = {}) {
-  mkdirSync4(paths.tools, { recursive: true });
+  mkdirSync5(paths.tools, { recursive: true });
   const archive = "uv.tar.gz";
   options.onLine?.(`Downloading uv ${UV_RELEASE.version}`);
   const timeoutMs = options.timeoutMs ?? 3e5;
@@ -1037,27 +1255,27 @@ async function downloadUv(paths, options = {}) {
   const actual = createHash2("sha256").update(bytes).digest("hex");
   if (actual !== UV_RELEASE.sha256)
     throw new Error("The downloaded uv does not match its pinned sha256; nothing was installed");
-  writeFileSync5(join5(paths.tools, archive), bytes);
+  writeFileSync6(join6(paths.tools, archive), bytes);
   const unpacked = await run("/usr/bin/tar", [
     "-xzf",
-    join5(paths.tools, archive),
+    join6(paths.tools, archive),
     "-C",
     paths.tools,
     "--strip-components",
     "1"
   ]);
-  rmSync3(join5(paths.tools, archive), { force: true });
-  if (unpacked.code !== 0 || !executable(join5(paths.tools, "uv")))
+  rmSync3(join6(paths.tools, archive), { force: true });
+  if (unpacked.code !== 0 || !executable(join6(paths.tools, "uv")))
     throw new Error(`Couldn't unpack uv: ${unpacked.output}`);
-  return join5(paths.tools, "uv");
+  return join6(paths.tools, "uv");
 }
 function lockDigest(lockFile) {
-  return createHash2("sha256").update(readFileSync5(lockFile)).digest("hex");
+  return createHash2("sha256").update(readFileSync6(lockFile)).digest("hex");
 }
 function venvReady(paths, lockFile) {
   if (!existsSync4(paths.python)) return false;
   try {
-    return readFileSync5(paths.venvLock, "utf8").trim() === lockDigest(lockFile);
+    return readFileSync6(paths.venvLock, "utf8").trim() === lockDigest(lockFile);
   } catch {
     return false;
   }
@@ -1091,7 +1309,7 @@ ${made.output}`);
   if (installed2.code !== 0)
     throw new Error(`Couldn't install mude's Python packages (uv pip install):
 ${installed2.output}`);
-  writeFileSync5(paths.venvLock, `${lockDigest(lockFile)}
+  writeFileSync6(paths.venvLock, `${lockDigest(lockFile)}
 `);
 }
 
@@ -1129,7 +1347,7 @@ function jsonOut(write) {
     error: (message, kind) => emit({ type: "error", message, kind })
   };
 }
-function humanOut(write, tty) {
+function humanOut(write, tty, pkg = MUDE_PACKAGE) {
   let shown = -1;
   return {
     step: (_step, message) => {
@@ -1153,7 +1371,7 @@ function humanOut(write, tty) {
     },
     line: (text) => write(`  ${text}
 `),
-    status: (status2) => write(describe(status2)),
+    status: (status2) => write(describe(status2, pkg)),
     error: (message) => {
       if (shown >= 0 && tty) write("\n");
       shown = -1;
@@ -1162,31 +1380,43 @@ function humanOut(write, tty) {
     }
   };
 }
-function describe(status2) {
+function describe(status2, pkg) {
   const lines = [];
   if (!status2.supported) {
-    lines.push(`mude 1.0 can't run here: ${status2.problems.join("; ")}`);
+    lines.push(`${pkg.label} can't run here: ${status2.problems.join("; ")}`);
     return `${lines.join("\n")}
 `;
   }
   lines.push(
-    `model     ${status2.installed ? `installed (${MUDE_REPO} @ ${MUDE_REVISION.slice(0, 7)})` : status2.downloadedBytes > 0 ? `partly downloaded (${(status2.downloadedBytes / 1e9).toFixed(1)} of ${(MUDE_BYTES / 1e9).toFixed(1)} GB): mu judge mude install resumes it` : "not installed: mu judge mude install"}`
+    `model     ${status2.installed ? `installed (${pkg.repo} @ ${pkg.revision.slice(0, 7)})` : status2.downloadedBytes > 0 ? `partly downloaded (${(status2.downloadedBytes / 1e9).toFixed(1)} of ${(pkg.bytes / 1e9).toFixed(1)} GB): ${pkg.install} resumes it` : `not installed: ${pkg.install}`}`
   );
-  if (status2.installed && !status2.pythonReady) lines.push("python    not set up: mu judge mude install");
+  if (status2.installed && !status2.pythonReady) lines.push(`python    not set up: ${pkg.install}`);
   lines.push(
     `server    ${status2.ready ? `running on 127.0.0.1:${status2.port}${status2.memoryBytes ? ` \xB7 ${(status2.memoryBytes / 1e9).toFixed(1)} GB of memory` : ""}` : status2.running ? `starting on 127.0.0.1:${status2.port}` : "stopped"}`
   );
   if (status2.enabled) {
     lines.push(
-      status2.localOnly ? "judge     mude 1.0 only: a decision it cannot answer takes its fallback, and nothing goes to a hosted judge" : `judge     mude 1.0, then ${status2.fallback.join(" > ")} for what it cannot answer (what those read leaves this machine)`
+      status2.localOnly ? `judge     ${pkg.label} only: a decision it cannot answer takes its fallback, and nothing goes to a hosted judge` : `judge     ${pkg.label}, then ${status2.fallback.join(" > ")} for what it cannot answer (what those read leaves this machine)`
     );
   } else {
-    lines.push(`judge     ${status2.installed ? "not enabled: mu judge mude enable" : "not enabled"}`);
+    lines.push(`judge     ${status2.installed ? `not enabled: ${pkg.again("enable")}` : "not enabled"}`);
   }
   lines.push(`folder    ${status2.folder}`);
   return `${lines.join("\n")}
 `;
 }
+var MUDE_PACKAGE = {
+  label: "mude 1.0",
+  repo: MUDE_REPO,
+  revision: MUDE_REVISION,
+  files: MUDE_FILES,
+  bytes: MUDE_BYTES,
+  judge: MUDE_JUDGE,
+  served: MUDE_MODEL,
+  install: "mu judge mude install",
+  again: (what) => `mu judge mude ${what}`
+};
+var pkgOf = (ctx) => ctx.pkg ?? MUDE_PACKAGE;
 function problems(options = {}) {
   const platform = options.platform ?? process.platform;
   if (platform !== "darwin") return ["it needs a Mac with Apple silicon (an M1 or newer)"];
@@ -1213,7 +1443,7 @@ function appleSilicon() {
 function freeBytes(path) {
   let dir = path;
   while (!existsSync5(dir)) {
-    const parent = join6(dir, "..");
+    const parent = join7(dir, "..");
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -1229,7 +1459,7 @@ function installLocalOnly(ctx, args) {
   if (args.includes("--local-only")) return true;
   if (args.includes("--with-fallback")) return false;
   try {
-    const value = JSON.parse(readFileSync6(ctx.paths.install, "utf8"));
+    const value = JSON.parse(readFileSync7(ctx.paths.install, "utf8"));
     return typeof value === "object" && value !== null && "localOnly" in value && value.localOnly === true;
   } catch {
     return false;
@@ -1242,46 +1472,46 @@ function startedAt(pid) {
     return void 0;
   }
 }
-function holdInstall(paths) {
-  mkdirSync5(paths.root, { recursive: true });
+function holdInstall(paths, pkg = MUDE_PACKAGE) {
+  mkdirSync6(paths.root, { recursive: true });
   const mine = `${JSON.stringify({ pid: process.pid, started: startedAt(process.pid) ?? "" })}
 `;
   try {
-    writeFileSync6(paths.installLock, mine, { flag: "wx" });
+    writeFileSync7(paths.installLock, mine, { flag: "wx" });
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
     let holder = {};
     try {
-      holder = JSON.parse(readFileSync6(paths.installLock, "utf8"));
+      holder = JSON.parse(readFileSync7(paths.installLock, "utf8"));
     } catch {
     }
     const pid = typeof holder.pid === "number" ? holder.pid : 0;
     if (pid > 0 && pid !== process.pid && holder.started && startedAt(pid) === holder.started) {
       throw new Error(
-        `Another mude 1.0 install is running (process ${pid}). Wait for it to finish, or stop it, then run mu judge mude install again`
+        `Another ${pkg.label} install is running (process ${pid}). Wait for it to finish, or stop it, then run ${pkg.install} again`
       );
     }
-    writeFileSync6(paths.installLock, mine);
+    writeFileSync7(paths.installLock, mine);
   }
   return () => {
     try {
-      if (readFileSync6(paths.installLock, "utf8") === mine) rmSync4(paths.installLock, { force: true });
+      if (readFileSync7(paths.installLock, "utf8") === mine) rmSync4(paths.installLock, { force: true });
     } catch {
     }
   };
 }
 function installed(ctx) {
-  return missingFiles(ctx.paths.model, MUDE_FILES).length === 0;
+  return missingFiles(ctx.paths.model, pkgOf(ctx).files).length === 0;
 }
 function key(ctx) {
   try {
-    const existing = readFileSync6(ctx.paths.key, "utf8").trim();
+    const existing = readFileSync7(ctx.paths.key, "utf8").trim();
     if (existing) return existing;
   } catch {
   }
-  mkdirSync5(ctx.paths.root, { recursive: true });
+  mkdirSync6(ctx.paths.root, { recursive: true });
   const made = randomBytes(32).toString("hex");
-  writeFileSync6(ctx.paths.key, `${made}
+  writeFileSync7(ctx.paths.key, `${made}
 `, { mode: 384 });
   return made;
 }
@@ -1291,18 +1521,20 @@ async function port(ctx) {
   return choosePort(DEFAULT_PORT);
 }
 async function status(ctx) {
+  const pkg = pkgOf(ctx);
   const found = problems();
   const state = readState(ctx.paths);
   const at = state?.port ?? DEFAULT_PORT;
   const pid = readPid(ctx.paths);
   const running = serverAlive(ctx.paths, pid);
   const ready = running && (await health(at))?.status === "ready";
-  const setting = judgeSetting(ctx.files);
+  const setting = judgeSetting(ctx.files, pkg.judge.name);
   return {
+    name: pkg.judge.name,
     supported: found.length === 0,
     problems: found,
     installed: installed(ctx),
-    downloadedBytes: downloadedBytes(ctx.paths.model, MUDE_FILES),
+    downloadedBytes: downloadedBytes(ctx.paths.model, pkg.files),
     pythonReady: venvReady(ctx.paths, ctx.lockFile),
     running,
     ready,
@@ -1312,32 +1544,33 @@ async function status(ctx) {
     enabled: setting.enabled,
     localOnly: setting.localOnly,
     fallback: setting.fallback,
-    model: `${MUDE_REPO}@${MUDE_REVISION}`,
+    model: `${pkg.repo}@${pkg.revision}`,
     folder: ctx.paths.root,
     log: ctx.paths.log
   };
 }
 async function ensureInstalled(ctx, out) {
-  const missing = missingFiles(ctx.paths.model, MUDE_FILES);
+  const pkg = pkgOf(ctx);
+  const missing = missingFiles(ctx.paths.model, pkg.files);
   if (missing.length > 0) {
     const need = missing.reduce((sum, file) => sum + file.size, 0);
-    const already = downloadedBytes(ctx.paths.model, MUDE_FILES);
+    const already = downloadedBytes(ctx.paths.model, pkg.files);
     const free = freeBytes(ctx.paths.root);
-    const room = MUDE_BYTES - already + 2e9;
+    const room = pkg.bytes - already + 2e9;
     if (free !== void 0 && free < room) {
       throw new Error(
-        `Not enough free disk space: mude 1.0 needs about ${gb(room)} GB, and only ${gb(free)} GB are free. Free up some space, then run mu judge mude install again`
+        `Not enough free disk space: ${pkg.label} needs about ${gb(room)} GB, and only ${gb(free)} GB are free. Free up some space, then run ${pkg.install} again`
       );
     }
     out.step(
       "download",
-      already > 0 ? `Resuming the mude 1.0 download (${MUDE_REPO}): ${gb(already)} of ${gb(MUDE_BYTES)} GB already downloaded` : `Downloading mude 1.0 (${MUDE_REPO}, ${gb(need)} GB) and checking every file`
+      already > 0 ? `Resuming the ${pkg.label} download (${pkg.repo}): ${gb(already)} of ${gb(pkg.bytes)} GB already downloaded` : `Downloading ${pkg.label} (${pkg.repo}, ${gb(need)} GB) and checking every file`
     );
     try {
       await downloadFiles({
         dir: ctx.paths.model,
-        files: MUDE_FILES,
-        url: (path) => mudeFileUrl(path, ctx.env.HF_ENDPOINT || void 0),
+        files: pkg.files,
+        url: (path) => fileUrl(pkg.repo, pkg.revision, path, ctx.env.HF_ENDPOINT || void 0),
         token: huggingFaceToken(ctx.env),
         onProgress: (event) => out.progress(event),
         signal: ctx.signal
@@ -1345,7 +1578,7 @@ async function ensureInstalled(ctx, out) {
     } catch (error) {
       if (error instanceof DownloadError && error.kind === "aborted") {
         throw new DownloadError(
-          `Stopped with ${gb(downloadedBytes(ctx.paths.model, MUDE_FILES))} of ${gb(MUDE_BYTES)} GB downloaded. Run mu judge mude install to resume`,
+          `Stopped with ${gb(downloadedBytes(ctx.paths.model, pkg.files))} of ${gb(pkg.bytes)} GB downloaded. Run ${pkg.install} to resume`,
           "aborted"
         );
       }
@@ -1353,7 +1586,7 @@ async function ensureInstalled(ctx, out) {
     }
   }
   if (!venvReady(ctx.paths, ctx.lockFile)) {
-    out.step("python", "Setting up the Python environment for mude 1.0 (MLX, transformers; about 1 GB, once)");
+    out.step("python", `Setting up the Python environment for ${pkg.label} (MLX, transformers; about 1 GB, once)`);
     try {
       let uv = findUv(ctx.paths, ctx.env);
       if (!uv) uv = await downloadUv(ctx.paths, { onLine: (line) => out.line(line), signal: ctx.signal });
@@ -1361,7 +1594,7 @@ async function ensureInstalled(ctx, out) {
     } catch (error) {
       if (ctx.signal?.aborted) {
         throw new DownloadError(
-          "Stopped while setting up the Python environment. Run mu judge mude install to resume",
+          `Stopped while setting up the Python environment. Run ${pkg.install} to resume`,
           "aborted"
         );
       }
@@ -1371,21 +1604,23 @@ async function ensureInstalled(ctx, out) {
 }
 function requireInstalled(ctx) {
   if (!installed(ctx) || !venvReady(ctx.paths, ctx.lockFile)) {
-    throw new Error("mude 1.0 is not installed here yet: mu judge mude install");
+    const pkg = pkgOf(ctx);
+    throw new Error(`${pkg.label} is not installed here yet: ${pkg.install}`);
   }
 }
 async function start(ctx, out, command, wait2 = true) {
+  const pkg = pkgOf(ctx);
   const at = await port(ctx);
   out.step(
     "start",
-    serverAlive(ctx.paths) ? `The mude 1.0 server is running on 127.0.0.1:${at}` : `Starting the mude 1.0 server on 127.0.0.1:${at} (loading the model takes a few seconds)`
+    serverAlive(ctx.paths) ? `The ${pkg.label} server is running on 127.0.0.1:${at}` : `Starting the ${pkg.label} server on 127.0.0.1:${at} (loading the model takes a few seconds)`
   );
   try {
-    await startServer(ctx.paths, { port: at, key: key(ctx), wait: wait2, signal: ctx.signal });
+    await startServer(ctx.paths, { port: at, key: key(ctx), wait: wait2, signal: ctx.signal, name: pkg.served });
   } catch (error) {
     if (error instanceof StartStopped) {
       throw new DownloadError(
-        error.serverStopped ? `Stopped while the mude 1.0 server was starting, and stopped the server too. Run mu judge mude ${command} again to finish` : `Stopped waiting for the mude 1.0 server, which is still starting. Run mu judge mude ${command} again to finish`,
+        error.serverStopped ? `Stopped while the ${pkg.label} server was starting, and stopped the server too. Run ${pkg.again(command)} again to finish` : `Stopped waiting for the ${pkg.label} server, which is still starting. Run ${pkg.again(command)} again to finish`,
         "aborted"
       );
     }
@@ -1393,16 +1628,60 @@ async function start(ctx, out, command, wait2 = true) {
   }
   return at;
 }
-function enable(ctx, out, at, localOnly) {
-  const tiers = enableMude(ctx.paths, ctx.files, { port: at, key: key(ctx), localOnly });
+function others(ctx) {
+  const name = pkgOf(ctx).judge.name;
+  const home = ctx.files.home;
+  const found = [];
+  if (name !== MUDE) found.push({ judge: MUDE_JUDGE, paths: mudePaths(home) });
+  for (const record of listRecords(home)) {
+    if (record.id !== name) found.push({ judge: localJudgeOf(record.id), paths: modelPaths(home, record) });
+  }
+  return found;
+}
+async function stopOthers(ctx) {
+  for (const other of others(ctx)) await stopServer(other.paths);
+}
+async function enable(ctx, out, at, localOnly) {
+  const pkg = pkgOf(ctx);
+  const tiers = currentTiers(ctx.files);
+  for (const other of others(ctx)) {
+    if (tiers.includes(other.judge.name)) disableLocal(other.judge, other.paths, ctx.files);
+  }
+  const order = enableLocal(pkg.judge, ctx.paths, ctx.files, { port: at, key: key(ctx), localOnly });
   out.step(
     "enable",
-    localOnly ? "mude 1.0 is the judge, on its own. New mu sessions use it; one that is open now picks it up when it starts again." : `mude 1.0 is the judge, with ${tiers.slice(1).join(" > ")} behind it for what it cannot answer. New mu sessions use it.`
+    localOnly ? `${pkg.label} is the judge, on its own. New mu sessions use it; one that is open now picks it up when it starts again.` : `${pkg.label} is the judge, with ${order.slice(1).join(" > ")} behind it for what it cannot answer. New mu sessions use it.`
   );
 }
-async function main(argv, ctx, write, tty = false) {
-  const json = argv.includes("--json");
-  const args = argv.filter((arg) => arg !== "--json");
+async function install(ctx, out, args, holdAlso) {
+  const localOnly = installLocalOnly(ctx, args);
+  const release2 = holdInstall(ctx.paths, pkgOf(ctx));
+  let releaseAlso;
+  try {
+    if (holdAlso && !venvReady(ctx.paths, ctx.lockFile)) releaseAlso = holdInstall(holdAlso);
+    writeFileSync7(ctx.paths.install, `${JSON.stringify({ localOnly })}
+`);
+    await ensureInstalled(ctx, out);
+    await stopOthers(ctx);
+    const at = await start(ctx, out, "install");
+    await enable(ctx, out, at, localOnly);
+    rmSync4(ctx.paths.install, { force: true });
+  } finally {
+    releaseAlso?.();
+    release2();
+  }
+}
+async function enableCommand(ctx, out, args) {
+  requireInstalled(ctx);
+  const current = judgeSetting(ctx.files, pkgOf(ctx).judge.name);
+  const localOnly = args.includes("--local-only") ? true : args.includes("--with-fallback") ? false : current.enabled && current.localOnly;
+  await stopOthers(ctx);
+  const at = await start(ctx, out, "enable");
+  await enable(ctx, out, at, localOnly);
+}
+async function main(argv2, ctx, write, tty = false) {
+  const json = argv2.includes("--json");
+  const args = argv2.filter((arg) => arg !== "--json");
   const out = json ? jsonOut(write) : humanOut(write, tty);
   const command = args[0] ?? "status";
   const flag = (name) => args.includes(name);
@@ -1426,29 +1705,12 @@ async function main(argv, ctx, write, tty = false) {
       return 1;
     }
     switch (command) {
-      case "install": {
-        const localOnly = installLocalOnly(ctx, args);
-        const release2 = holdInstall(ctx.paths);
-        try {
-          writeFileSync6(ctx.paths.install, `${JSON.stringify({ localOnly })}
-`);
-          await ensureInstalled(ctx, out);
-          const at = await start(ctx, out, "install");
-          enable(ctx, out, at, localOnly);
-          rmSync4(ctx.paths.install, { force: true });
-        } finally {
-          release2();
-        }
+      case "install":
+        await install(ctx, out, args);
         break;
-      }
-      case "enable": {
-        requireInstalled(ctx);
-        const current = judgeSetting(ctx.files);
-        const localOnly = flag("--local-only") ? true : flag("--with-fallback") ? false : current.enabled && current.localOnly;
-        const at = await start(ctx, out, "enable");
-        enable(ctx, out, at, localOnly);
+      case "enable":
+        await enableCommand(ctx, out, args);
         break;
-      }
       case "disable": {
         if (!mudeInTiers(ctx.files)) {
           const stopped2 = await stopServer(ctx.paths);
@@ -1479,8 +1741,20 @@ async function main(argv, ctx, write, tty = false) {
           out.step("disable", `mude 1.0 is no longer the judge: ${tiers.join(" > ")} again.`);
         }
         await stopServer(ctx.paths);
-        rmSync4(ctx.paths.root, { recursive: true, force: true });
-        out.step("uninstall", `Deleted ${ctx.paths.root}: the model, its Python environment and its key.`);
+        if (listRecords(ctx.files.home).length > 0) {
+          for (const name of existsSync5(ctx.paths.root) ? readdirSync2(ctx.paths.root) : []) {
+            const path = join7(ctx.paths.root, name);
+            if (path !== ctx.paths.venv && path !== ctx.paths.tools)
+              rmSync4(path, { recursive: true, force: true });
+          }
+          out.step(
+            "uninstall",
+            `Deleted mude 1.0 and its key from ${ctx.paths.root}. Its Python environment stays there for the other decision models.`
+          );
+        } else {
+          rmSync4(ctx.paths.root, { recursive: true, force: true });
+          out.step("uninstall", `Deleted ${ctx.paths.root}: the model, its Python environment and its key.`);
+        }
         break;
       }
       default:
@@ -1498,16 +1772,245 @@ ${USAGE}`, "usage");
   }
 }
 function contextFromEnv(env = process.env, home = homedir3()) {
-  const muHome = env.MU_MUDE_HOME || join6(home, ".mu");
-  const agentDir = env.MU_AGENT_DIR || join6(muHome, "agent");
+  const muHome = env.MU_MUDE_HOME || join7(home, ".mu");
+  const agentDir = env.MU_AGENT_DIR || join7(muHome, "agent");
   return {
     paths: mudePaths(muHome),
-    files: { agentDir, home: muHome, envFile: env.MU_MUDE_ENV_FILE || join6(muHome, ".env") },
-    lockFile: env.MU_MUDE_LOCK || join6(import.meta.dirname, "..", "..", "..", "..", "kyrn", "local-judge", "mude-requirements.lock.txt"),
+    files: { agentDir, home: muHome, envFile: env.MU_MUDE_ENV_FILE || join7(muHome, ".env") },
+    lockFile: env.MU_MUDE_LOCK || join7(import.meta.dirname, "..", "..", "..", "..", "kyrn", "local-judge", "mude-requirements.lock.txt"),
     env
   };
 }
 
+// packages/kyrn-judge/src/mude/models-command.ts
+import { rmSync as rmSync5 } from "node:fs";
+var USAGE2 = `mu judge model: decision models from Hugging Face, run on this Mac like mude 1.0
+
+  mu judge model add <link or owner/name>[@revision] [--local-only]
+                              download it, set it up, start it and make it the judge; run it again to resume
+  mu judge model list         mude 1.0 and the models added here
+  mu judge model use <name> [--local-only | --with-fallback]
+                              make it the judge (mude for mude 1.0)
+  mu judge model start | stop | status | disable <name>
+  mu judge model remove <name>
+                              stop it, take it out of the judge order and delete it
+
+mu runs a repository packaged like mude 1.0's MLX edition, with its own ${SERVER_FILE}. Add --json for one JSON object per line.
+`;
+function packageOf(record) {
+  const command = (what) => what === "install" ? "add" : what === "enable" ? "use" : what;
+  return {
+    label: record.id,
+    repo: record.repo,
+    revision: record.revision,
+    files: record.files,
+    bytes: record.bytes,
+    judge: localJudgeOf(record.id),
+    served: record.id,
+    install: `mu judge model add ${record.id}`,
+    again: (what) => `mu judge model ${command(what)} ${record.id}`
+  };
+}
+function modelContext(ctx, record) {
+  return { ...ctx, paths: modelPaths(ctx.files.home, record), pkg: packageOf(record) };
+}
+function summary(pkg, state, builtIn) {
+  return {
+    name: pkg.judge.name,
+    label: pkg.label,
+    repo: pkg.repo,
+    revision: pkg.revision,
+    bytes: pkg.bytes,
+    builtIn,
+    installed: state.installed && state.pythonReady,
+    downloadedBytes: state.downloadedBytes,
+    running: state.running,
+    ready: state.ready,
+    enabled: state.enabled,
+    localOnly: state.localOnly
+  };
+}
+async function listModels(ctx) {
+  const mude = { ...ctx, paths: mudePaths(ctx.files.home), pkg: void 0 };
+  const models = [summary(MUDE_PACKAGE, await status(mude), true)];
+  for (const record of listRecords(ctx.files.home)) {
+    const each = modelContext(ctx, record);
+    models.push(summary(packageOf(record), await status(each), false));
+  }
+  return models;
+}
+var gb2 = (bytes) => (bytes / 1e9).toFixed(1);
+function describeList(models) {
+  const width = Math.max(...models.map((model) => model.name.length));
+  const lines = models.map((model) => {
+    const state = model.installed ? model.ready ? "running" : model.running ? "starting" : "installed" : model.downloadedBytes > 0 ? `${gb2(model.downloadedBytes)} of ${gb2(model.bytes)} GB downloaded` : model.builtIn ? "not installed" : "not downloaded";
+    const judge = model.enabled ? model.localOnly ? " \xB7 the judge, on its own" : " \xB7 the judge" : "";
+    return `${model.name.padEnd(width)}  ${model.repo} @ ${model.revision.slice(0, 7)} \xB7 ${gb2(model.bytes)} GB \xB7 ${state}${judge}`;
+  });
+  return `${lines.join("\n")}
+`;
+}
+function isMude(name) {
+  if (name.toLowerCase() === MUDE) return true;
+  try {
+    return parseModelRef(name).repo.toLowerCase() === MUDE_REPO.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+async function addRecord(ctx, name, out, options) {
+  const home = ctx.files.home;
+  const known = findRecord(home, name);
+  if (known) return known;
+  const ref = parseModelRef(name);
+  const existing = findRecord(home, ref.repo);
+  if (existing && ref.revision === void 0) return existing;
+  out.step("resolve", `Looking up ${ref.repo}${ref.revision ? ` at ${ref.revision}` : ""} on Hugging Face`);
+  const resolved = await resolveModel(ref, {
+    endpoint: ctx.env.HF_ENDPOINT || void 0,
+    token: huggingFaceToken(ctx.env),
+    fetch: options.fetch
+  });
+  const id = existing?.id ?? modelId(ref.repo, new Set(listRecords(home).map((record2) => record2.id)));
+  if (existing && existing.revision !== resolved.revision) {
+    rmSync5(modelPaths(home, existing).model, { recursive: true, force: true });
+  }
+  const record = {
+    id,
+    repo: ref.repo,
+    revision: resolved.revision,
+    files: resolved.files,
+    bytes: resolved.files.reduce((sum, file) => sum + file.size, 0)
+  };
+  writeRecord(home, record);
+  return record;
+}
+async function modelMain(argv2, ctx, write, tty = false, options = {}) {
+  const json = argv2.includes("--json");
+  const args = argv2.filter((arg) => arg !== "--json");
+  let out = json ? jsonOut(write) : humanOut(write, tty);
+  const command = args[0] ?? "list";
+  const names = args.slice(1).filter((arg) => !arg.startsWith("--"));
+  const flags = args.slice(1).filter((arg) => arg.startsWith("--"));
+  try {
+    if (command === "help" || command === "--help" || command === "-h") {
+      write(USAGE2);
+      return 0;
+    }
+    const unknown = flags.find((flag) => !["--local-only", "--with-fallback", "--no-wait"].includes(flag));
+    if (unknown) {
+      out.error(`Unknown option for mu judge model ${command}: ${unknown} (mu judge model help)`, "usage");
+      return 2;
+    }
+    if (command === "list") {
+      const models = await listModels(ctx);
+      if (json) write(`${JSON.stringify({ type: "models", models })}
+`);
+      else write(describeList(models));
+      return 0;
+    }
+    if (!["add", "use", "start", "stop", "status", "disable", "remove"].includes(command)) {
+      out.error(`Unknown command: mu judge model ${command}
+
+${USAGE2}`, "usage");
+      return 2;
+    }
+    const name = names[0];
+    if (!name || names.length > 1) {
+      out.error(
+        `Name one model: mu judge model ${command} <${command === "add" ? "link or owner/name" : "name"}>`,
+        "usage"
+      );
+      return 2;
+    }
+    if (isMude(name)) {
+      const as = { add: "install", use: "enable", remove: "uninstall" }[command] ?? command;
+      return main([as, ...flags, ...json ? ["--json"] : []], ctx, write, tty);
+    }
+    const home = ctx.files.home;
+    const unsupported = problems();
+    if (command === "add") {
+      if (unsupported.length > 0) {
+        out.error(`Decision models can't run on this machine: ${unsupported.join("; ")}.`, "unsupported");
+        return 1;
+      }
+      const record2 = await addRecord(ctx, name, out, options);
+      const each2 = modelContext(ctx, record2);
+      if (json)
+        write(
+          `${JSON.stringify({ type: "model", name: record2.id, repo: record2.repo, revision: record2.revision, bytes: record2.bytes })}
+`
+        );
+      else out = humanOut(write, tty, each2.pkg);
+      out.step(
+        "model",
+        `${record2.repo} @ ${record2.revision.slice(0, 7)} (${gb2(record2.bytes)} GB) is the decision model ${record2.id}. It runs its own server code (${SERVER_FILE}) on this Mac: add only models you trust.`
+      );
+      await install(each2, out, flags, mudePaths(home));
+      out.status(await status(each2));
+      return 0;
+    }
+    const record = findRecord(home, name);
+    if (!record) {
+      out.error(
+        `No decision model ${name} here (mu judge model list). Add it: mu judge model add <link or owner/name>`,
+        "usage"
+      );
+      return 1;
+    }
+    const each = modelContext(ctx, record);
+    const pkg = packageOf(record);
+    if (!json) out = humanOut(write, tty, pkg);
+    if (unsupported.length > 0 && (command === "use" || command === "start")) {
+      out.error(`${record.id} can't run on this machine: ${unsupported.join("; ")}.`, "unsupported");
+      return 1;
+    }
+    switch (command) {
+      case "use":
+        await enableCommand(each, out, flags);
+        break;
+      case "start":
+        requireInstalled(each);
+        await start(each, out, "start", !flags.includes("--no-wait"));
+        break;
+      case "stop": {
+        const stopped = await stopServer(each.paths);
+        out.step(
+          "stop",
+          stopped ? `The ${record.id} server is stopped.` : `The ${record.id} server was not running.`
+        );
+        break;
+      }
+      case "disable": {
+        const was = mudeInTiers(ctx.files, record.id);
+        const tiers = was ? disableLocal(pkg.judge, each.paths, ctx.files) : [];
+        const stopped = await stopServer(each.paths);
+        out.step(
+          "disable",
+          was ? `${record.id} is no longer the judge: ${tiers.join(" > ")} again${stopped ? ", and its server is stopped" : ""}.` : `${record.id} was not the judge${stopped ? "; its server is stopped" : ""}.`
+        );
+        break;
+      }
+      case "remove": {
+        if (mudeInTiers(ctx.files, record.id) || readState(each.paths)?.wroteEntry) {
+          const tiers = disableLocal(pkg.judge, each.paths, ctx.files, { removeEntry: true });
+          out.step("disable", `${record.id} is no longer the judge: ${tiers.join(" > ")} again.`);
+        }
+        await stopServer(each.paths);
+        rmSync5(each.paths.root, { recursive: true, force: true });
+        out.step("remove", `Deleted ${each.paths.root}: the model and its key.`);
+        return 0;
+      }
+    }
+    out.status(await status(each));
+    return 0;
+  } catch (error) {
+    const kind = error instanceof DownloadError || error instanceof ModelError ? error.kind : void 0;
+    out.error(error instanceof Error ? error.message : String(error), kind);
+    return 1;
+  }
+}
+
 // packages/kyrn-judge/src/mude/cli.ts
 var stop = new AbortController();
 var onSignal = (signal) => {
@@ -1517,8 +2020,10 @@ var onSignal = (signal) => {
 };
 process.on("SIGINT", onSignal);
 process.on("SIGTERM", onSignal);
-main(
-  process.argv.slice(2),
+var argv = process.argv.slice(2);
+var run2 = argv[0] === "model" ? modelMain : main;
+run2(
+  argv[0] === "model" ? argv.slice(1) : argv,
   { ...contextFromEnv(), signal: stop.signal },
   (text) => process.stdout.write(text),
   Boolean(process.stdout.isTTY)
@@ -1527,8 +2032,10 @@ main(
     process.exitCode = code;
   },
   (error) => {
-    process.stderr.write(`mu judge mude: ${error instanceof Error ? error.message : String(error)}
-`);
+    process.stderr.write(
+      `mu judge ${argv[0] === "model" ? "model" : "mude"}: ${error instanceof Error ? error.message : String(error)}
+`
+    );
     process.exitCode = 1;
   }
 );