mu-agent 0.2.2 → 0.2.4

package/judge/dist/setup.js

@@ -2,7 +2,7 @@ import { createRequire as __muCreateRequire } from "node:module"; const require
 
 // packages/kyrn-judge/src/setup/main.ts
 import { constants as constants2 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import {
   applyHttpProxySettings,
   configureHttpDispatcher,
@@ -54,9 +54,9 @@ function drop(lock) {
 // packages/kyrn-judge/src/mude/command.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { randomBytes } from "node:crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, rmSync as rmSync4, statfsSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync4, statfsSync, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir4, release, totalmem as totalmem2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // packages/kyrn-judge/src/mude/config.ts
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
@@ -432,8 +432,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
@@ -539,7 +539,7 @@ async function startServer(paths, options) {
       "--port",
       String(options.port),
       "--name",
-      MUDE_MODEL,
+      options.name ?? MUDE_MODEL,
       "--verify",
       "fast"
     ],
@@ -620,6 +620,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"));
@@ -632,18 +637,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);
@@ -677,18 +686,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);
@@ -704,9 +715,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,
@@ -718,15 +729,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);
@@ -792,6 +806,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(join4(dir, ".mu-verified.json"), "utf8"));
@@ -802,7 +824,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(join4(dir, file.path));
     return stats.size === file.size && stats.mtimeMs === seen.mtimeMs;
@@ -812,7 +834,7 @@ function knownGood(dir, file, verified) {
 }
 function remember(dir, verified, file) {
   const stats = statSync3(join4(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(join4(dir, ".mu-verified.json"), `${JSON.stringify(verified, null, 1)}
 `);
 }
@@ -863,7 +885,7 @@ async function downloadFiles(options) {
     mkdirSync4(dirname2(target), { recursive: true });
     if (existsSync4(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;
@@ -874,17 +896,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"
       );
     }
@@ -1028,6 +1050,10 @@ async function fetchOnce(options, file, part, onBytes) {
   }
 }
 
+// packages/kyrn-judge/src/mude/models.ts
+import { mkdirSync as mkdirSync5, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join6 } from "node:path";
+
 // packages/kyrn-judge/src/mude/paths.ts
 import { join as join5 } from "node:path";
 function mudePaths(muHome2) {
@@ -1051,12 +1077,72 @@ function mudePaths(muHome2) {
   };
 }
 
+// packages/kyrn-judge/src/mude/models.ts
+function modelsDir(muHome2) {
+  return join6(muHome2, "local-judge", "models");
+}
+function modelPaths(muHome2, record) {
+  const shared = mudePaths(muHome2);
+  const root = join6(modelsDir(muHome2), record.id);
+  const model = join6(root, "model", record.revision);
+  return {
+    ...shared,
+    root,
+    model,
+    verified: join6(model, ".mu-verified.json"),
+    key: join6(root, "key"),
+    pid: join6(root, "server.pid"),
+    log: join6(root, "server.log"),
+    state: join6(root, "state.json"),
+    install: join6(root, "install.json"),
+    installLock: join6(root, "install.lock")
+  };
+}
+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(muHome2) {
+  let names;
+  try {
+    names = readdirSync(modelsDir(muHome2));
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const name of names.sort()) {
+    try {
+      const value = JSON.parse(readFileSync5(join6(modelsDir(muHome2), name, "model.json"), "utf8"));
+      if (isRecord2(value) && value.id === name) records.push(value);
+    } catch {
+    }
+  }
+  return records;
+}
+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 existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { accessSync, constants, existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { delimiter, join as join6 } from "node:path";
+import { delimiter, join as join7 } from "node:path";
 var PYTHON_VERSION = "3.13";
 var UV_RELEASE = {
   version: "0.13.1",
@@ -1074,14 +1160,14 @@ function executable(path) {
 function findUv(paths, env = process.env, home2 = homedir3()) {
   const dirs = [
     ...(env.PATH ?? "").split(delimiter),
-    join6(home2, ".local", "bin"),
-    join6(home2, ".cargo", "bin"),
+    join7(home2, ".local", "bin"),
+    join7(home2, ".cargo", "bin"),
     "/opt/homebrew/bin",
     "/usr/local/bin",
     paths.tools
   ];
   for (const dir of dirs) {
-    if (dir && executable(join6(dir, "uv"))) return join6(dir, "uv");
+    if (dir && executable(join7(dir, "uv"))) return join7(dir, "uv");
   }
   return void 0;
 }
@@ -1111,7 +1197,7 @@ function run(command, args, options = {}) {
   });
 }
 async function downloadUv(paths, options = {}) {
-  mkdirSync5(paths.tools, { recursive: true });
+  mkdirSync6(paths.tools, { recursive: true });
   const archive = "uv.tar.gz";
   options.onLine?.(`Downloading uv ${UV_RELEASE.version}`);
   const timeoutMs = options.timeoutMs ?? 3e5;
@@ -1131,27 +1217,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(join6(paths.tools, archive), bytes);
+  writeFileSync6(join7(paths.tools, archive), bytes);
   const unpacked = await run("/usr/bin/tar", [
     "-xzf",
-    join6(paths.tools, archive),
+    join7(paths.tools, archive),
     "-C",
     paths.tools,
     "--strip-components",
     "1"
   ]);
-  rmSync3(join6(paths.tools, archive), { force: true });
-  if (unpacked.code !== 0 || !executable(join6(paths.tools, "uv")))
+  rmSync3(join7(paths.tools, archive), { force: true });
+  if (unpacked.code !== 0 || !executable(join7(paths.tools, "uv")))
     throw new Error(`Couldn't unpack uv: ${unpacked.output}`);
-  return join6(paths.tools, "uv");
+  return join7(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 (!existsSync5(paths.python)) return false;
   try {
-    return readFileSync5(paths.venvLock, "utf8").trim() === lockDigest(lockFile);
+    return readFileSync6(paths.venvLock, "utf8").trim() === lockDigest(lockFile);
   } catch {
     return false;
   }
@@ -1185,7 +1271,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)}
 `);
 }
 
@@ -1223,7 +1309,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) => {
@@ -1247,7 +1333,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;
@@ -1256,31 +1342,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)"];
@@ -1307,7 +1405,7 @@ function appleSilicon() {
 function freeBytes(path) {
   let dir = path;
   while (!existsSync6(dir)) {
-    const parent = join7(dir, "..");
+    const parent = join8(dir, "..");
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -1323,7 +1421,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;
@@ -1336,46 +1434,46 @@ function startedAt(pid) {
     return void 0;
   }
 }
-function holdInstall(paths) {
-  mkdirSync6(paths.root, { recursive: true });
+function holdInstall(paths, pkg = MUDE_PACKAGE) {
+  mkdirSync7(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 {
   }
-  mkdirSync6(ctx.paths.root, { recursive: true });
+  mkdirSync7(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;
 }
@@ -1385,18 +1483,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,
@@ -1406,32 +1506,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
@@ -1439,7 +1540,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"
         );
       }
@@ -1447,7 +1548,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 });
@@ -1455,7 +1556,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"
         );
       }
@@ -1465,21 +1566,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"
       );
     }
@@ -1487,13 +1590,57 @@ 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 home2 = ctx.files.home;
+  const found = [];
+  if (name !== MUDE) found.push({ judge: MUDE_JUDGE, paths: mudePaths(home2) });
+  for (const record of listRecords(home2)) {
+    if (record.id !== name) found.push({ judge: localJudgeOf(record.id), paths: modelPaths(home2, 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 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(argv, ctx, write, tty = false) {
   const json = argv.includes("--json");
   const args = argv.filter((arg) => arg !== "--json");
@@ -1520,29 +1667,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);
@@ -1573,8 +1703,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 existsSync6(ctx.paths.root) ? readdirSync2(ctx.paths.root) : []) {
+            const path = join8(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:
@@ -1592,12 +1734,12 @@ ${USAGE}`, "usage");
   }
 }
 function contextFromEnv(env = process.env, home2 = homedir4()) {
-  const muHome2 = env.MU_MUDE_HOME || join7(home2, ".mu");
-  const agentDir2 = env.MU_AGENT_DIR || join7(muHome2, "agent");
+  const muHome2 = env.MU_MUDE_HOME || join8(home2, ".mu");
+  const agentDir2 = env.MU_AGENT_DIR || join8(muHome2, "agent");
   return {
     paths: mudePaths(muHome2),
-    files: { agentDir: agentDir2, home: muHome2, envFile: env.MU_MUDE_ENV_FILE || join7(muHome2, ".env") },
-    lockFile: env.MU_MUDE_LOCK || join7(import.meta.dirname, "..", "..", "..", "..", "kyrn", "local-judge", "mude-requirements.lock.txt"),
+    files: { agentDir: agentDir2, home: muHome2, envFile: env.MU_MUDE_ENV_FILE || join8(muHome2, ".env") },
+    lockFile: env.MU_MUDE_LOCK || join8(import.meta.dirname, "..", "..", "..", "..", "kyrn", "local-judge", "mude-requirements.lock.txt"),
     env
   };
 }
@@ -1799,8 +1941,8 @@ async function readAll(input = process.stdin) {
 }
 
 // packages/kyrn-judge/src/setup/wizard.ts
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join8 } from "node:path";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join9 } from "node:path";
 
 // packages/kyrn-judge/src/setup/check.ts
 var CHECK_TIMEOUT_MS = 1e4;
@@ -2600,14 +2742,6 @@ var Setup = class {
         SETUP_EXIT.usage
       );
     }
-    if (!args.firstRun) {
-      this.io.say(
-        this.t({
-          zh: "mu setup\uFF1A\u7ED9 mu \u63A5\u4E0A\u4E00\u4E2A\u5E72\u6D3B\u7684\u6A21\u578B\uFF0C\u518D\u9009\u4E00\u4E2A\u5224\u5B9A\u5668\u3002",
-          en: "mu setup: connect a model for mu to work with, and choose a judge."
-        })
-      );
-    }
     const start2 = await this.start(key2 === void 0 ? void 0 : cleanKey(key2));
     if (start2 === "subscription") {
       const judge2 = await this.judge(void 0);
@@ -2655,9 +2789,9 @@ var Setup = class {
     );
     if (yes) return true;
     try {
-      mkdirSync7(this.deps.paths.agentDir, { recursive: true });
-      writeFileSync7(
-        join8(this.deps.paths.agentDir, SETUP_DECLINED_FILE),
+      mkdirSync8(this.deps.paths.agentDir, { recursive: true });
+      writeFileSync8(
+        join9(this.deps.paths.agentDir, SETUP_DECLINED_FILE),
         "mu asked on its first start whether to set up a model, and the answer was no.\nDelete this file to be asked again; run mu setup any time.\n"
       );
     } catch {
@@ -2698,11 +2832,10 @@ var Setup = class {
       ]
     );
     if (route === "subscription") {
-      const auth = this.path(join8(this.deps.paths.agentDir, "auth.json"));
       this.io.say(
         this.t({
-          zh: `\u8BA2\u9605\u8D26\u53F7\u5728 mu \u91CC\u7528 /login \u767B\u5F55\uFF1A\u9009 Sign in with an account\uFF0C\u518D\u9009 OpenAI\uFF08ChatGPT\uFF09\u3001xAI\uFF08Grok\uFF09\u6216 Google \u7684\u4E00\u9879\uFF0C\u6309\u63D0\u793A\u5728\u6D4F\u89C8\u5668\u91CC\u5B8C\u6210\u3002setup \u63A5\u7740\u542F\u52A8 mu \u65F6\uFF0C/login \u5DF2\u7ECF\u6253\u5F00\u3002\u767B\u5F55\u4FE1\u606F\u4FDD\u5B58\u5728 ${auth}\u3002`,
-          en: `Sign in to your subscription from inside mu with /login: choose Sign in with an account, then OpenAI for ChatGPT, xAI for Grok or one of the Google sign-ins, and finish in the browser. When setup starts mu, /login is already open. The sign-in is saved in ${auth}.`
+          zh: "\u8BA2\u9605\u8D26\u53F7\u5728 mu \u91CC\u7528 /login \u767B\u5F55\uFF1A\u9009 Sign in with an account\uFF0C\u518D\u9009 OpenAI\uFF08ChatGPT\uFF09\u3001xAI\uFF08Grok\uFF09\u6216 Google \u7684\u4E00\u9879\uFF0C\u6309\u63D0\u793A\u5728\u6D4F\u89C8\u5668\u91CC\u5B8C\u6210\u3002setup \u63A5\u7740\u542F\u52A8 mu \u65F6\uFF0C/login \u5DF2\u7ECF\u6253\u5F00\u3002",
+          en: "Sign in to your subscription from inside mu with /login: choose Sign in with an account, then OpenAI for ChatGPT, xAI for Grok or one of the Google sign-ins, and finish in the browser. When setup starts mu, /login is already open."
         })
       );
       return "subscription";
@@ -2871,7 +3004,7 @@ var Setup = class {
     return [{ provider, builtIn: false, baseUrl: base, api }];
   }
   inModelsFile(provider) {
-    const models = readJsonFile(join8(this.deps.paths.agentDir, "models.json"));
+    const models = readJsonFile(join9(this.deps.paths.agentDir, "models.json"));
     return models.state === "ok" && existingProvider(models.value, provider) !== void 0;
   }
   /** A failure as the person can act on it: a local service that is silent is not ready yet, whatever the key. */
@@ -2991,7 +3124,7 @@ var Setup = class {
     }
   }
   modelsFileWritable() {
-    const path = join8(this.deps.paths.agentDir, "models.json");
+    const path = join9(this.deps.paths.agentDir, "models.json");
     if (readJsonFile(path).state !== "unreadable") return;
     throw this.fail({
       zh: `${this.path(path)} \u4E0D\u662F\u7EAF JSON\uFF08\u4E5F\u8BB8\u6709\u6CE8\u91CA\u6216\u5199\u9519\u4E86\uFF09\uFF0Cmu setup \u4E0D\u6539\u5199\u5B83\u3002\u5148\u4FEE\u597D\u5B83\uFF0C\u6216\u624B\u52A8\u628A\u670D\u52A1\u52A0\u8FDB\u53BB\u3002`,
@@ -3073,7 +3206,7 @@ var Setup = class {
   /** A provider models.json has at another address is moved only with a yes. */
   async conflicts(target) {
     if (target.reach.builtIn && !this.args.baseUrl) return;
-    const models = readJsonFile(join8(this.deps.paths.agentDir, "models.json"));
+    const models = readJsonFile(join9(this.deps.paths.agentDir, "models.json"));
     if (models.state !== "ok") return;
     const current = existingProvider(models.value, target.reach.provider)?.baseUrl;
     const old = typeof current === "string" ? current.replace(/\/+$/, "") : void 0;
@@ -3191,8 +3324,8 @@ var Setup = class {
     });
     const picked = await this.choose(
       this.t({
-        zh: "mu \u5DE5\u4F5C\u65F6\u8981\u505A\u5F88\u591A\u5C0F\u5224\u65AD\uFF1A\u8FD9\u6761\u6D88\u606F\u8BE5\u600E\u4E48\u5904\u7406\u3001\u8FD9\u4E00\u6B65\u4F1A\u4E0D\u4F1A\u8FDD\u53CD\u4F60\u5B9A\u7684\u89C4\u5219\u2026\u2026\u5224\u5B9A\u5668\u8D1F\u8D23\u56DE\u7B54\u3002\u9009\u54EA\u4E2A\u5224\u5B9A\u5668\uFF1F",
-        en: "As it works, mu faces many small decisions: how to handle a message, whether a step breaks your rules. A judge answers them. Which judge do you want?"
+        zh: "mu \u5DE5\u4F5C\u4E2D\u7684\u5C0F\u5224\u65AD\u4EA4\u7ED9\u54EA\u4E2A\u5224\u5B9A\u5668\uFF1F",
+        en: "Which judge should answer mu's small decisions?"
       }),
       choices
     );
@@ -3298,9 +3431,9 @@ var Setup = class {
     const backups = new Backups(deps.paths.home, deps.now());
     const saved = [];
     const notes = [];
-    const modelsPath = join8(agentDir2, "models.json");
-    const authPath2 = join8(agentDir2, "auth.json");
-    const settingsPath = join8(agentDir2, "settings.json");
+    const modelsPath = join9(agentDir2, "models.json");
+    const authPath2 = join9(agentDir2, "auth.json");
+    const settingsPath = join9(agentDir2, "settings.json");
     try {
       if (target && model) {
         const { service, reach, key: key2 } = target;
@@ -3504,12 +3637,8 @@ var Setup = class {
     }) : this.t({ zh: "\u5224\u5B9A\u5668\uFF1AJev\u3002", en: " Judge: Jev." });
     this.io.say("");
     this.io.say(`${done}${judged}`);
-    this.io.say(
-      target ? this.t({
-        zh: "\u5728 mu \u91CC\u7528 /model \u6362\u6A21\u578B\uFF1B\u968F\u65F6\u53EF\u4EE5\u518D\u8FD0\u884C mu setup\u3002",
-        en: "Switch models inside mu with /model, and run mu setup again any time."
-      }) : this.t({ zh: "\u63A5\u4E0B\u6765\u5728 mu \u91CC\u7528 /login \u767B\u5F55\u3002", en: "Next, sign in with /login in mu." })
-    );
+    if (!target)
+      this.io.say(this.t({ zh: "\u63A5\u4E0B\u6765\u5728 mu \u91CC\u7528 /login \u767B\u5F55\u3002", en: "Next, sign in with /login in mu." }));
   }
   /**
    * On its own, a finished setup offers a session; on a first start the launcher goes on into one anyway. After a
@@ -3549,10 +3678,10 @@ async function runSetup(argv, deps) {
 var givenKey = process.env.MU_SETUP_KEY || void 0;
 delete process.env.MU_SETUP_KEY;
 var home = process.env.MU_SETUP_HOME || muHome();
-var agentDir = muEnv("AGENT_DIR") || join9(home, "agent");
-var envFile = process.env.MU_SETUP_ENV_FILE || join9(home, ".env");
-var authPath = join9(agentDir, "auth.json");
-var modelsStorePath = join9(agentDir, "models-store.json");
+var agentDir = muEnv("AGENT_DIR") || join10(home, "agent");
+var envFile = process.env.MU_SETUP_ENV_FILE || join10(home, ".env");
+var authPath = join10(agentDir, "auth.json");
+var modelsStorePath = join10(agentDir, "models-store.json");
 var givenEnv = { ...process.env };
 var PROXY_VARIABLES = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"];
 function useSessionProxy() {
@@ -3576,7 +3705,7 @@ async function main2() {
   const proxy = useSessionProxy();
   const runtime = await ModelRuntime.create({
     authPath,
-    modelsPath: join9(agentDir, "models.json"),
+    modelsPath: join10(agentDir, "models.json"),
     modelsStorePath,
     refreshOnCreate: false
   });