mu-agent 0.2.1 → 0.2.3

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";
@@ -154,21 +154,21 @@ function readEnvEntries(text) {
     }
     let body = rest.slice(1);
     let end = closingQuote(body, quote);
-    const startedAt = index;
+    const startedAt2 = index;
     while (end < 0 && index + 1 < lines.length) {
       body += `
 ${lines[++index]}`;
       end = closingQuote(body, quote);
     }
     if (end < 0) {
-      index = startedAt;
+      index = startedAt2;
       continue;
     }
     const value = body.slice(0, end);
     entries.push({
       name,
       value: quote === '"' ? value.replace(/\\(["\\$`])/g, "$1") : value,
-      first: startedAt,
+      first: startedAt2,
       last: index
     });
   }
@@ -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
@@ -503,12 +503,21 @@ function tail(file, lines = 12) {
     return "";
   }
 }
+var StartStopped = class extends Error {
+  /** Whether the server went too: one this call started does, one that was running before does not. */
+  serverStopped;
+  constructor(serverStopped = false) {
+    super("Stopped while the mude 1.0 server was starting");
+    this.name = "StartStopped";
+    this.serverStopped = serverStopped;
+  }
+};
 async function startServer(paths, options) {
   const sleep2 = options.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
   const timeoutMs = options.timeoutMs ?? 18e4;
   const running = readPid(paths);
   if (running && serverAlive(paths, running)) {
-    if (options.wait !== false) await untilReady(paths, running, options.port, timeoutMs, sleep2);
+    if (options.wait !== false) await untilReady(paths, running, options.port, timeoutMs, sleep2, options.signal);
     return { pid: running, port: options.port, already: true };
   }
   if (!await portFree(options.port)) {
@@ -530,7 +539,7 @@ async function startServer(paths, options) {
       "--port",
       String(options.port),
       "--name",
-      MUDE_MODEL,
+      options.name ?? MUDE_MODEL,
       "--verify",
       "fast"
     ],
@@ -557,12 +566,21 @@ async function startServer(paths, options) {
   child.unref();
   writeFileSync2(paths.pid, `${pid}
 `, { mode: 384 });
-  if (options.wait !== false) await untilReady(paths, pid, options.port, timeoutMs, sleep2);
+  if (options.wait !== false) {
+    try {
+      await untilReady(paths, pid, options.port, timeoutMs, sleep2, options.signal);
+    } catch (error) {
+      if (!(error instanceof StartStopped)) throw error;
+      await stopServer(paths);
+      throw new StartStopped(true);
+    }
+  }
   return { pid, port: options.port, already: false };
 }
-async function untilReady(paths, pid, port2, timeoutMs, sleep2) {
+async function untilReady(paths, pid, port2, timeoutMs, sleep2, signal) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
+    if (signal?.aborted) throw new StartStopped();
     if ((await health(port2))?.status === "ready") return;
     if (!serverAlive(paths, pid)) {
       rmSync(paths.pid, { force: true });
@@ -602,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"));
@@ -614,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);
@@ -659,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);
@@ -686,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,
@@ -700,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);
@@ -748,6 +780,7 @@ import { open } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname2, join as join4 } from "node:path";
 import { pipeline } from "node:stream/promises";
+import { setTimeout as wait } from "node:timers/promises";
 var CHECKPOINT_BYTES = 32 * 1024 * 1024;
 var RETRY_WAITS = [2e3, 5e3, 1e4, 2e4, 3e4];
 function huggingFaceToken(env = process.env, home2 = homedir2()) {
@@ -773,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"));
@@ -783,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;
@@ -793,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)}
 `);
 }
@@ -844,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;
@@ -855,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"
       );
     }
@@ -899,7 +940,8 @@ function writeSaved(part, bytes) {
 }
 async function fetchFile(options, file, part, onBytes) {
   const attempts = options.attempts ?? 8;
-  const sleep2 = options.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const sleep2 = options.sleep ?? ((ms) => wait(ms, void 0, { signal: options.signal }).catch(() => {
+  }));
   let resumed = false;
   let failures = 0;
   let lastError;
@@ -911,6 +953,12 @@ async function fetchFile(options, file, part, onBytes) {
       return resumed;
     } catch (error) {
       if (error instanceof DownloadError && error.kind !== "network") throw error;
+      const code = error.code;
+      if (code === "ENOSPC" || code === "EDQUOT") {
+        throw new Error(
+          `The disk is full: couldn't write ${file.path}. Free up some space, then run mu judge mude install to resume`
+        );
+      }
       lastError = error;
       failures = resumeFrom(part, file.size, options.checkpointBytes) > before ? 1 : failures + 1;
       if (failures >= attempts) break;
@@ -919,7 +967,7 @@ async function fetchFile(options, file, part, onBytes) {
   }
   const reason = lastError instanceof Error ? lastError.message : String(lastError);
   throw new DownloadError(
-    `${file.path} could not be downloaded (${reason}); run the install again to go on from here`,
+    `${file.path} could not be downloaded (${reason}). Run mu judge mude install again to resume`,
     "network"
   );
 }
@@ -949,7 +997,7 @@ async function fetchOnce(options, file, part, onBytes) {
     });
     if (response.status === 401 || response.status === 403 || response.status === 404) {
       throw new DownloadError(
-        `Hugging Face answered ${response.status} for ${file.path}: the model is not public yet, or this machine's token cannot read it`,
+        `Hugging Face returned ${response.status} for ${file.path}: the model isn't public yet, or this machine's token can't access it`,
         "access"
       );
     }
@@ -1002,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) {
@@ -1020,16 +1072,77 @@ function mudePaths(muHome2) {
     pid: join5(root, "server.pid"),
     log: join5(root, "server.log"),
     state: join5(root, "state.json"),
-    install: join5(root, "install.json")
+    install: join5(root, "install.json"),
+    installLock: join5(root, "install.lock")
+  };
+}
+
+// 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",
@@ -1047,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;
 }
@@ -1084,36 +1197,47 @@ 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 response = await (options.fetch ?? fetch)(UV_RELEASE.url, { redirect: "follow" });
-  if (!response.ok) throw new Error(`uv could not be downloaded: HTTP ${response.status}`);
-  const bytes = Buffer.from(await response.arrayBuffer());
+  const timeoutMs = options.timeoutMs ?? 3e5;
+  const timeout = AbortSignal.timeout(timeoutMs);
+  let bytes;
+  try {
+    const response = await (options.fetch ?? fetch)(UV_RELEASE.url, {
+      redirect: "follow",
+      signal: options.signal ? AbortSignal.any([options.signal, timeout]) : timeout
+    });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    bytes = Buffer.from(await response.arrayBuffer());
+  } catch (error) {
+    const reason = timeout.aborted ? `no answer in ${timeoutMs / 1e3} s` : error instanceof Error ? error.message : String(error);
+    throw new Error(`uv could not be downloaded from GitHub (${reason}): run mu judge mude install again`);
+  }
   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")))
-    throw new Error(`uv could not be unpacked: ${unpacked.output}`);
-  return 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 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;
   }
@@ -1126,7 +1250,7 @@ async function ensureVenv(paths, lockFile, uv, options = {}) {
     env,
     onLine: options.onLine
   });
-  if (made.code !== 0) throw new Error(`The Python environment could not be made (uv venv):
+  if (made.code !== 0) throw new Error(`Couldn't create the Python environment (uv venv):
 ${made.output}`);
   const installed2 = await run(
     uv,
@@ -1145,9 +1269,9 @@ ${made.output}`);
     { env, onLine: options.onLine }
   );
   if (installed2.code !== 0)
-    throw new Error(`mude's Python packages could not be installed (uv pip install):
+    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)}
 `);
 }
 
@@ -1156,7 +1280,7 @@ var USAGE = `mu judge mude: mude 1.0, mu's own decision model optimized for codi
 (Apple silicon, macOS 14 or later)
 
   mu judge mude install [--local-only]   download it (${(MUDE_BYTES / 1e9).toFixed(1)} GB), set it up, start it and make it the judge;
-                                         after a stop (Ctrl-C, a lost connection, a power cut), it goes on from there
+                                         after a stop (Ctrl-C, a lost connection, a power cut), it picks up where it left off
   mu judge mude enable [--local-only | --with-fallback]
                                          make it the judge again, or change what happens when it can't answer
   mu judge mude disable                  back to the judges from before, and stop its server
@@ -1185,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) => {
@@ -1209,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;
@@ -1218,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 goes on from there` : "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)"];
@@ -1269,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;
   }
@@ -1285,24 +1421,59 @@ 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;
   }
 }
+function startedAt(pid) {
+  try {
+    return execFileSync2("/bin/ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8" }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function holdInstall(paths, pkg = MUDE_PACKAGE) {
+  mkdirSync7(paths.root, { recursive: true });
+  const mine = `${JSON.stringify({ pid: process.pid, started: startedAt(process.pid) ?? "" })}
+`;
+  try {
+    writeFileSync7(paths.installLock, mine, { flag: "wx" });
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    let holder = {};
+    try {
+      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 ${pkg.label} install is running (process ${pid}). Wait for it to finish, or stop it, then run ${pkg.install} again`
+      );
+    }
+    writeFileSync7(paths.installLock, mine);
+  }
+  return () => {
+    try {
+      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;
 }
@@ -1312,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,
@@ -1333,31 +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, pkg.files);
     const free = freeBytes(ctx.paths.root);
-    if (free !== void 0 && free < need + 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 ${((need + 2e9) / 1e9).toFixed(1)} GB, and ${(free / 1e9).toFixed(1)} GB are free`
+        `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`
       );
     }
-    const already = downloadedBytes(ctx.paths.model, MUDE_FILES);
     out.step(
       "download",
-      already > 0 ? `Going on with the mude 1.0 download (${MUDE_REPO}): ${gb(already)} of ${gb(MUDE_BYTES)} GB are here already` : `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
@@ -1365,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: mu judge mude install goes on from there`,
+          `Stopped with ${gb(downloadedBytes(ctx.paths.model, pkg.files))} of ${gb(pkg.bytes)} GB downloaded. Run ${pkg.install} to resume`,
           "aborted"
         );
       }
@@ -1373,33 +1548,99 @@ 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)");
-    let uv = findUv(ctx.paths, ctx.env);
-    if (!uv) uv = await downloadUv(ctx.paths, { onLine: (line) => out.line(line) });
-    await ensureVenv(ctx.paths, ctx.lockFile, uv, { onLine: (line) => out.line(line), env: ctx.env });
+    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 });
+      await ensureVenv(ctx.paths, ctx.lockFile, uv, { onLine: (line) => out.line(line), env: ctx.env });
+    } catch (error) {
+      if (ctx.signal?.aborted) {
+        throw new DownloadError(
+          `Stopped while setting up the Python environment. Run ${pkg.install} to resume`,
+          "aborted"
+        );
+      }
+      throw error;
+    }
   }
 }
 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, wait = true) {
+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)`
   );
-  await startServer(ctx.paths, { port: at, key: key(ctx), wait });
+  try {
+    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 ${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"
+      );
+    }
+    throw error;
+  }
   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");
@@ -1426,25 +1667,12 @@ async function main(argv, ctx, write, tty = false) {
       return 1;
     }
     switch (command) {
-      case "install": {
-        const localOnly = installLocalOnly(ctx, args);
-        mkdirSync6(ctx.paths.root, { recursive: true });
-        writeFileSync6(ctx.paths.install, `${JSON.stringify({ localOnly })}
-`);
-        await ensureInstalled(ctx, out);
-        const at = await start(ctx, out);
-        enable(ctx, out, at, localOnly);
-        rmSync4(ctx.paths.install, { force: true });
+      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(ctx, out, at, localOnly);
+      case "enable":
+        await enableCommand(ctx, out, args);
         break;
-      }
       case "disable": {
         if (!mudeInTiers(ctx.files)) {
           const stopped2 = await stopServer(ctx.paths);
@@ -1461,7 +1689,7 @@ async function main(argv, ctx, write, tty = false) {
       }
       case "start": {
         requireInstalled(ctx);
-        await start(ctx, out, !flag("--no-wait"));
+        await start(ctx, out, "start", !flag("--no-wait"));
         break;
       }
       case "stop": {
@@ -1475,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:
@@ -1494,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
   };
 }
@@ -1701,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;
@@ -2502,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);
@@ -2541,7 +2773,7 @@ var Setup = class {
     this.io.warn(
       this.t({
         zh: "mude 1.0 \u8FD8\u6CA1\u6709\u88C5\u597D\uFF0C\u5728\u90A3\u4E4B\u524D\u7531 Jev \u5224\u5B9A\u3002\u8FD0\u884C mu judge mude install \u4F1A\u4ECE\u4E2D\u65AD\u7684\u5730\u65B9\u63A5\u7740\u88C5\u3002",
-        en: "mude 1.0 isn't installed yet, so Jev is the judge until it is. Run mu judge mude install to go on from where it stopped."
+        en: "mude 1.0 isn't installed yet, so Jev is the judge until it is. Run mu judge mude install to resume it."
       })
     );
     return this.scripted ? SETUP_EXIT.failed : SETUP_EXIT.done;
@@ -2557,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 {
@@ -2600,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: `You sign in to a subscription 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";
@@ -2773,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. */
@@ -2893,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`,
@@ -2975,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;
@@ -3093,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
     );
@@ -3200,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;
@@ -3406,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
@@ -3451,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() {
@@ -3478,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
   });