mu-agent 0.2.0 → 0.2.2

package/judge/dist/setup.js

@@ -1,8 +1,8 @@
 import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
 
 // packages/kyrn-judge/src/setup/main.ts
-import { constants } from "node:os";
-import { join as join4 } from "node:path";
+import { constants as constants2 } from "node:os";
+import { join as join9 } from "node:path";
 import {
   applyHttpProxySettings,
   configureHttpDispatcher,
@@ -51,6 +51,16 @@ 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 { homedir as homedir4, release, totalmem as totalmem2 } from "node:os";
+import { join as join7 } from "node:path";
+
+// packages/kyrn-judge/src/mude/config.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
+
 // packages/kyrn-judge/src/naming.ts
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";
@@ -66,42 +76,58 @@ function muHome(home2 = homedir()) {
   return existsSync(current) || !existsSync(legacy) ? current : legacy;
 }
 
-// packages/kyrn-judge/src/redact.ts
-var REDACTED = "[redacted]";
-var SHAPES = [
-  // A private key, the whole block, or to the end when the text was cut inside it.
-  /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY-----|$)/g,
-  // OpenAI, Anthropic, OpenRouter, DeepSeek and the like.
-  /\bsk-[A-Za-z0-9_-]{20,}/g,
-  /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{22,})/g,
-  /\bglpat-[A-Za-z0-9_-]{20,}/g,
-  /\bxox[abposr]-[A-Za-z0-9-]{10,}/g,
-  /\bAIza[0-9A-Za-z_-]{35}/g,
-  /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
-  /\b[rs]k_(?:live|test)_[0-9A-Za-z]{16,}/g,
-  /\bnpm_[A-Za-z0-9]{36}\b/g,
-  /\bhf_[A-Za-z0-9]{30,}/g,
-  // A JSON web token.
-  /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g
-];
-var BEARER = /\b(Bearer|Basic)(\s+)(?=[A-Za-z._~+/=-]*[0-9])[A-Za-z0-9._~+/=-]{12,}/g;
-var URL_PASSWORD = /\b([a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:)[^\s@/]+(@)/gi;
-var KEY_WORD = "(?:SECRET|TOKEN|PASSWD|PASSWORD|API_?KEY|ACCESS_?KEY|PRIVATE_?KEY)";
-var ENV_VALUE = new RegExp(`\\b([A-Z0-9_]*${KEY_WORD}[A-Z0-9_]*=)("[^"\\n]{8,}"|'[^'\\n]{8,}'|[^\\s"';&|]{8,})`, "g");
-var QUOTED_VALUE = new RegExp(
-  `(["']?[A-Za-z0-9_-]*${KEY_WORD.replaceAll("_?", "[_-]?")}[A-Za-z0-9_-]*["']?\\s*[:=]\\s*)(["'])[^"'\\s]{8,}\\2`,
-  "gi"
-);
-var LINE_VALUE = new RegExp(
-  `^(\\s*[A-Za-z0-9_.-]*${KEY_WORD.replaceAll("_?", "[_.-]?")}[A-Za-z0-9_.-]*\\s*[:=][ \\t]*)[^\\s#"']{8,}[ \\t]*$`,
-  "gim"
-);
-function redactSecrets(text, known = []) {
-  let clean = text;
-  for (const secret of known) if (clean.includes(secret)) clean = clean.split(secret).join(REDACTED);
-  for (const shape of SHAPES) clean = clean.replace(shape, REDACTED);
-  return clean.replace(BEARER, `$1$2${REDACTED}`).replace(URL_PASSWORD, `$1${REDACTED}$2`).replace(ENV_VALUE, `$1${REDACTED}`).replace(QUOTED_VALUE, `$1$2${REDACTED}$2`).replace(LINE_VALUE, `$1${REDACTED}`);
-}
+// packages/kyrn-judge/src/config.ts
+var BUILT_IN_JUDGES = {
+  jev: { type: "jev" },
+  "jev-direct": { type: "typesafe" },
+  // OpenRouter serves Jev over the same System One protocol. The key is Jev's own, not the one for OpenRouter's
+  // chat models, so setting one never changes the other.
+  "jev-openrouter": {
+    type: "typesafe",
+    baseUrl: "https://openrouter.ai/api/v1/systemone",
+    model: "~typesafe/jev-latest",
+    apiKeyEnv: "MU_JUDGE_OPENROUTER_API_KEY"
+  },
+  "jev-gateway": { type: "gateway", model: "typesafe-ai/jev" },
+  // Jev on OpenCode Zen, with the key of OpenCode's models (OPENCODE_API_KEY, or `mu auth`). The free one is a
+  // limited-time offer of OpenCode's and needs no key at all. OpenCode does not train on what Jev is sent.
+  "jev-opencode": { type: "classifier", model: "opencode/jev-1.13" },
+  "jev-opencode-free": { type: "classifier", model: "opencode/jev-1.13-free" },
+  // Jev on Cloudflare Workers AI, with Cloudflare's key and account (CLOUDFLARE_API_KEY, CLOUDFLARE_ACCOUNT_ID).
+  "jev-cloudflare": { type: "classifier", model: "cloudflare-workers-ai/typesafe/jev" },
+  // Cloudflare's own System One classifiers. Not measured on mu's questions yet.
+  clef: { type: "classifier", model: "cloudflare-workers-ai/@cf/cloudflare/clef" },
+  "clef-flash": { type: "classifier", model: "cloudflare-workers-ai/@cf/cloudflare/clef-flash" },
+  // CLM-8B on this machine, where `clm-serve` listens by default. Its profile is not measured on mu's questions yet.
+  clm: { type: "clm" },
+  // Measured in kyrn/docs/03-local-judge.md: the base checkpoint classifies one text well, says "yes" to
+  // nearly every relational question, and cannot use a rubric or judge the request itself. Measured on
+  // Terminal-Bench 2.1 (Oct 2026): on tool output it is wrong or late. All 15 passages it withheld as injections were
+  // clean (directory listings, href lists, headers, JSON), its one admission drop was a makefile, and most of its
+  // calls on both failed or came too late. So screening tool output (`screen`) goes to the next tier, or to the
+  // rules. It also read a finished "Done. Created /app/meeting_scheduled.ics …" as a promise of more work, twice in one
+  // run (constraints-scheduling): 4 extra requests and the model searching / for test files. So whether a closing
+  // message promised more (`intent`, turn.continue) goes to the next tier too; `continuation.localPromised` asks it.
+  laya: {
+    type: "local",
+    profile: { capabilities: { relate: false, rate: false, meta: false, screen: false, intent: false } }
+  },
+  // mude, the decision model trained for mu's judgment layer, on this Mac (`mu judge mude install`, Apple silicon):
+  // the System One server that comes in its package, on 127.0.0.1:8790, with the key the install wrote to the .env.
+  // Trusted on every capability: on mu's own dev scenarios (an internal benchmark, not public yet) it did as well as Jev
+  // or better on relate, rate, meta, screening tool output (`tool.admission`) and promises (`turn.continue`), and on
+  // classify but for one check: a tool's description screened for injected instructions (`tool.description`), where
+  // Jev did better. Nothing measured it on injections in fetched content (`tool.injection`). So with a judge behind it,
+  // `mu judge mude` routes those two checks to that judge (`routes` in mu.json). It answers in about 0.1 s here.
+  mude: {
+    type: "typesafe",
+    baseUrl: "http://127.0.0.1:8790/v1/systemone",
+    model: "mude",
+    apiKeyEnv: "MU_JUDGE_MUDE_KEY",
+    timeoutMs: 4e3
+  },
+  mock: { type: "mock" }
+};
 
 // packages/kyrn-judge/src/setup/env-file.ts
 var DEFINITION = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/;
@@ -128,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
     });
   }
@@ -360,6 +386,1259 @@ function writeEnvValue(path, name, value) {
   writeFileAtomic(path, setEnvValue(readTextFile(path) ?? "", name, value));
 }
 
+// packages/kyrn-judge/src/mude/server.ts
+import { execFileSync, spawn } from "node:child_process";
+import { closeSync, existsSync as existsSync3, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync2, rmSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { createServer } from "node:net";
+import { totalmem } from "node:os";
+import { join as join3 } from "node:path";
+
+// packages/kyrn-judge/src/mude/manifest.ts
+var MUDE_REPO = "qybaihe/mude-1.0-mlx-8bit";
+var MUDE_REVISION = "269b71dbc4276770b5a021d7adbad100010473c8";
+var MUDE_MODEL = "mude";
+var FILES = [
+  [".gitattributes", 1570, "34448b82c17d60fec9b65b1f093c115ddbaadc04beb1b0140b6bfed2e012a930"],
+  ["LICENSE", 1482, "793a9f63a9cdfd3436ca19a4a70e54d1acf9d639d84ba27129918284765f3a05"],
+  ["LICENSES/Apache-2.0.txt", 11357, "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4"],
+  ["MODEL_MANIFEST.json", 19177, "2d197005a61e693566e75946e034937ed13b192a150df583cfe2dde4f9f6ebcd"],
+  ["NOTICE", 1899, "d57889a1687573fb059329fde16fc6d1feeadc683fc50aa592370b6a727bf42b"],
+  ["README.md", 2356, "f86e44bd8573b306daafa86a3a4a261b430d99d5cd0df6bda223f187c5f56756"],
+  ["chat_template.jinja", 7755, "273d8e0e683b885071fb17e08d71e5f2a5ddfb5309756181681de4f5a1822d80"],
+  ["config.json", 2783, "4fba61002dea71507b2ea7d9910a70bb7df8f0a0639e2b2ffae2b978ddb9874b"],
+  ["d3_engine.py", 4413, "086238942762df45047a32cd9a8e2bedd9b63167eb40be260c776de567979f53"],
+  ["d3_fast.py", 22331, "68a1fb9a2c3bde9ac2763bf504decae592ca12722698fbde1b39a31262955535"],
+  ["d3_format.py", 7008, "3badfbc70561bb3f5b8ec16a11d2c455b96ddb32caace0a8a54ca102eae1f3fa"],
+  ["d3_kernels.py", 16129, "8f7534ca1e1846ebf7c4c73058002f3be4dbf0d5d426f0815150ae0cbe7677bd"],
+  ["d3_mac.py", 10824, "5ab4f773a7361656a765b5be351e2cde519b3094c0b4a66123d01b2ac2f40372"],
+  ["d3_mlx.py", 15876, "04890d713a240f7ff7d53ebb250b88ef85f9c04948f322a46006506f1e33e48d"],
+  ["d3_runtime.py", 98229, "a77a0b84c1732a0fd6296e0daa44cd86130f67bfea5e9c87eee8c5a1df293def"],
+  ["d3_server.py", 17705, "766a20a69101e36ab0535a1ec683379db422380a83091f0eccd7e82edb6a02de"],
+  ["d3_server_mac.py", 1216, "0e351b255fac166d71489e95b68d761d1d91d10297dbcfc16a1c42a659b7b396"],
+  ["decision_config.json", 5509, "19c62c4a8b0ff7bd1f82c05ef0d7af8df4b2ce7af2cfe19e3989e7d9f6c1c1cc"],
+  ["merges.txt", 3353259, "a9d356d7bdf1ef4949e3e748e95b8e10ad9d4e2e838eddc38a0a7b6b94d1db8d"],
+  ["mlx-q8.safetensors", 1756751774, "9757238f601c7b2eea997069add5856ba5ed8370786bfffae0b9ac550c33f697"],
+  ["mlx_weights.json", 293, "747ece4d690e493dda9637917b3d8b9c1296ccfa4a258f51c0ae0ad716a1d698"],
+  ["modeling_d3.py", 12079, "f8f8db23ff58f1a990ffa24977d744a50e1b4446d02a64c22070967705b6dbef"],
+  ["pipeline_d3.py", 2936, "4f9297c7c74e596e9b67df91a1e6823cfada48bf781336f141974ff6a2f1038e"],
+  ["preprocessor_config.json", 390, "27225450ac9c6529872ee1924fcb0962ff5634834f817040f444118116f4e516"],
+  ["readout.safetensors", 2089040, "aeb18e2f9289aab0012e2059264326fb850aa8c5d8537975a891cf9655811674"],
+  ["requirements-mac.txt", 289, "ed16543a58d7ffd2f19e17b38f8b9e46775548700d9d3eaca7a592309a8741b5"],
+  ["requirements.txt", 723, "de9defd71ae4e559a7f5bdcc935b23716f9788e8755f2ba6db1ab6862bcda12e"],
+  ["tokenizer.json", 12807982, "5f9e4d4901a92b997e463c1f46055088b6cca5ca61a6522d1b9f64c4bb81cb42"],
+  ["tokenizer_config.json", 16709, "49e2b6e395f959f077f1e992b338919c0d4a9732fc6e613995e06557f843500c"],
+  ["video_preprocessor_config.json", 385, "7768af27c1fafa9cc9011c1dc20067e03f8915e03b63504550e11d5066986d13"],
+  ["vocab.json", 6722759, "ce99b4cb2983d118806ce0a8b777a35b093e2000a503ebde25853284c9dfa003"]
+];
+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("/")}`;
+}
+
+// packages/kyrn-judge/src/mude/server.ts
+var DEFAULT_PORT = 8790;
+function mudeBaseUrl(port2) {
+  return `http://127.0.0.1:${port2}/v1/systemone`;
+}
+async function health(port2, timeoutMs = 2e3, fetcher = fetch) {
+  try {
+    const response = await fetcher(`http://127.0.0.1:${port2}/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    return { status: String(body.status ?? ""), model: typeof body.model === "string" ? body.model : void 0 };
+  } catch {
+    return void 0;
+  }
+}
+function portFree(port2) {
+  return new Promise((resolve2) => {
+    const probe = createServer();
+    probe.once("error", () => resolve2(false));
+    probe.listen({ port: port2, host: "127.0.0.1", exclusive: true }, () => probe.close(() => resolve2(true)));
+  });
+}
+async function choosePort(preferred = DEFAULT_PORT) {
+  if (await portFree(preferred)) return preferred;
+  return new Promise((resolve2, reject) => {
+    const probe = createServer();
+    probe.once("error", reject);
+    probe.listen({ port: 0, host: "127.0.0.1" }, () => {
+      const address = probe.address();
+      const port2 = typeof address === "object" && address ? address.port : 0;
+      probe.close(() => resolve2(port2));
+    });
+  });
+}
+function readPid(paths) {
+  try {
+    const pid = Number.parseInt(readFileSync2(paths.pid, "utf8").trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function serverAlive(paths, pid = readPid(paths)) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return false;
+  }
+  try {
+    const command = execFileSync("/bin/ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8" });
+    return command.includes("d3_server_mac.py") && command.includes(paths.model);
+  } catch {
+    return false;
+  }
+}
+function cacheGb(memoryBytes = totalmem()) {
+  return memoryBytes >= 16 * 1024 ** 3 ? "1" : "0.25";
+}
+function tail(file, lines = 12) {
+  try {
+    const text = readFileSync2(file, "utf8");
+    return text.split(/\r?\n/).filter(Boolean).slice(-lines).join("\n");
+  } catch {
+    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, options.signal);
+    return { pid: running, port: options.port, already: true };
+  }
+  if (!await portFree(options.port)) {
+    throw new Error(
+      `Port ${options.port} on 127.0.0.1 is taken by another program; mu judge mude enable picks a free one`
+    );
+  }
+  mkdirSync3(paths.root, { recursive: true });
+  rmSync(paths.log, { force: true });
+  const log = openSync(paths.log, "a", 384);
+  const child = spawn(
+    paths.python,
+    [
+      join3(paths.model, "d3_server_mac.py"),
+      "--model",
+      paths.model,
+      "--host",
+      "127.0.0.1",
+      "--port",
+      String(options.port),
+      "--name",
+      MUDE_MODEL,
+      "--verify",
+      "fast"
+    ],
+    {
+      cwd: paths.model,
+      detached: true,
+      stdio: ["ignore", log, log],
+      env: {
+        PATH: "/usr/bin:/bin:/usr/sbin:/sbin",
+        HOME: process.env.HOME,
+        LANG: process.env.LANG ?? "en_US.UTF-8",
+        DECISION_API_KEY: options.key,
+        D3_MLX_CACHE_GB: cacheGb(),
+        // Everything it needs is in the package: nothing is fetched from the Hub at run time.
+        HF_HUB_OFFLINE: "1",
+        TRANSFORMERS_OFFLINE: "1",
+        PYTHONUNBUFFERED: "1"
+      }
+    }
+  );
+  closeSync(log);
+  const pid = child.pid;
+  if (!pid) throw new Error("mude's server could not be started");
+  child.unref();
+  writeFileSync2(paths.pid, `${pid}
+`, { mode: 384 });
+  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, 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 });
+      throw new Error(`mude's server stopped while starting. Its log (${paths.log}) ends with:
+${tail(paths.log)}`);
+    }
+    await sleep2(500);
+  }
+  throw new Error(`mude's server did not answer within ${Math.round(timeoutMs / 1e3)} s; see ${paths.log}`);
+}
+async function stopServer(paths, sleep2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms))) {
+  const pid = readPid(paths);
+  if (!pid || !serverAlive(paths, pid)) {
+    rmSync(paths.pid, { force: true });
+    return false;
+  }
+  process.kill(pid, "SIGTERM");
+  for (let waited = 0; waited < 5e3 && serverAlive(paths, pid); waited += 200) await sleep2(200);
+  if (serverAlive(paths, pid)) process.kill(pid, "SIGKILL");
+  rmSync(paths.pid, { force: true });
+  return true;
+}
+function serverMemory(pid) {
+  if (!pid) return void 0;
+  try {
+    const kb = Number.parseInt(
+      execFileSync("/bin/ps", ["-p", String(pid), "-o", "rss="], { encoding: "utf8" }).trim(),
+      10
+    );
+    return Number.isFinite(kb) ? kb * 1024 : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// packages/kyrn-judge/src/mude/config.ts
+var ROUTED_AWAY = ["tool.description", "tool.injection"];
+var MUDE = "mude";
+var KEY_VARIABLE = "MU_JUDGE_MUDE_KEY";
+function readState(paths) {
+  try {
+    const value = JSON.parse(readFileSync3(paths.state, "utf8"));
+    return Number.isInteger(value.port) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeState(paths, state) {
+  writeFileSync3(paths.state, `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+}
+function judgeSetting(files) {
+  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);
+  return { enabled, localOnly: enabled && fallback.length === 0, fallback };
+}
+function mudeInTiers(files) {
+  const file = readJsonFile(judgeConfigPath(files.agentDir));
+  return file.state === "ok" && tiersOf(file.value).includes(MUDE);
+}
+function readConfig(files) {
+  const path = judgeConfigPath(files.agentDir);
+  const file = readJsonFile(path);
+  if (file.state === "unreadable") {
+    throw new Error(
+      `${path} is not plain JSON (comments, or a typo), so mu leaves it alone. Fix it, then run this again.`
+    );
+  }
+  return { path, config: file.state === "ok" ? file.value : {} };
+}
+function recordOf(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? { ...value } : {};
+}
+function judgesOf(config) {
+  return recordOf(config.judges);
+}
+function withSection(config, key2, value) {
+  if (Object.keys(value).length > 0) return { ...config, [key2]: value };
+  const { [key2]: _gone, ...rest } = config;
+  return rest;
+}
+var sameTiers = (a, b) => Array.isArray(a) && a.length === b.length && a.every((tier, index) => tier === b[index]);
+function withoutOwnRoutes(config, state) {
+  const routes = recordOf(config.routes);
+  for (const [spec, tiers] of Object.entries(state?.wroteRoutes ?? {})) {
+    if (sameTiers(routes[spec], tiers)) delete routes[spec];
+  }
+  return withSection(config, "routes", routes);
+}
+function entryFor(port2) {
+  return { ...BUILT_IN_JUDGES[MUDE], baseUrl: mudeBaseUrl(port2) };
+}
+function enableMude(paths, files, options) {
+  const { path, config } = readConfig(files);
+  const state = readState(paths);
+  const current = tiersOf(config).filter((tier) => tier !== MUDE);
+  const before = current.length > 0 ? current : [...state?.previousTiers ?? ["jev"]];
+  const tiers = options.localOnly ? [MUDE] : [MUDE, ...before.filter((tier) => tier !== MUDE)];
+  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];
+  next = withSection(next, "judges", judges);
+  const fallback = tiers.slice(1);
+  const routes = recordOf(next.routes);
+  const wroteRoutes = {};
+  if (fallback.length > 0) {
+    for (const spec of ROUTED_AWAY) {
+      if (routes[spec] !== void 0) continue;
+      routes[spec] = [...fallback];
+      wroteRoutes[spec] = fallback;
+    }
+  }
+  next = withSection(next, "routes", routes);
+  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) {
+    backups.save(files.envFile);
+    writeEnvValue(files.envFile, KEY_VARIABLE, options.key);
+  }
+  writeState(paths, {
+    port: options.port,
+    previousTiers: before,
+    judgeWasOff,
+    wroteEntry: entry || void 0,
+    wroteRoutes: Object.keys(wroteRoutes).length > 0 ? wroteRoutes : void 0
+  });
+  return tiers;
+}
+function disableMude(paths, files, options = {}) {
+  const { path, config } = readConfig(files);
+  const state = readState(paths);
+  const rest = tiersOf(config).filter((tier) => tier !== MUDE);
+  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];
+    next = withSection(next, "judges", judges);
+  }
+  new Backups(files.home, files.now ?? /* @__PURE__ */ new Date()).save(path);
+  writeJsonFile(path, next);
+  if (state) {
+    writeState(paths, {
+      ...state,
+      judgeWasOff: void 0,
+      wroteRoutes: void 0,
+      wroteEntry: options.removeEntry ? void 0 : state.wroteEntry
+    });
+  }
+  return tiers;
+}
+function readText(path) {
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+// packages/kyrn-judge/src/mude/download.ts
+import { createHash } from "node:crypto";
+import {
+  createReadStream,
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync3,
+  truncateSync,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+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()) {
+  const direct = env.HF_TOKEN?.trim();
+  if (direct) return direct;
+  const files = [
+    env.HF_TOKEN_PATH,
+    env.HF_HOME ? join4(env.HF_HOME, "token") : void 0,
+    join4(env.XDG_CACHE_HOME || join4(home2, ".cache"), "huggingface", "token")
+  ];
+  for (const file of files) {
+    if (!file) continue;
+    try {
+      const token = readFileSync4(file, "utf8").trim();
+      if (token) return token;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function sha256File(path) {
+  const hash = createHash("sha256");
+  await pipeline(createReadStream(path), hash);
+  return hash.digest("hex");
+}
+function readVerified(dir) {
+  try {
+    const value = JSON.parse(readFileSync4(join4(dir, ".mu-verified.json"), "utf8"));
+    return typeof value === "object" && value !== null ? value : {};
+  } catch {
+    return {};
+  }
+}
+function knownGood(dir, file, verified) {
+  const seen = verified[file.path];
+  if (!seen || seen.sha256 !== file.sha256) return false;
+  try {
+    const stats = statSync3(join4(dir, file.path));
+    return stats.size === file.size && stats.mtimeMs === seen.mtimeMs;
+  } catch {
+    return false;
+  }
+}
+function remember(dir, verified, file) {
+  const stats = statSync3(join4(dir, file.path));
+  verified[file.path] = { size: stats.size, mtimeMs: stats.mtimeMs, sha256: file.sha256 };
+  writeFileSync4(join4(dir, ".mu-verified.json"), `${JSON.stringify(verified, null, 1)}
+`);
+}
+function missingFiles(dir, files) {
+  const verified = readVerified(dir);
+  return files.filter((file) => !knownGood(dir, file, verified));
+}
+function downloadedBytes(dir, files) {
+  const verified = readVerified(dir);
+  let bytes = 0;
+  for (const file of files) {
+    if (knownGood(dir, file, verified)) {
+      bytes += file.size;
+      continue;
+    }
+    const target = join4(dir, file.path);
+    bytes += Math.min(file.size, Math.max(sizeOf(target), sizeOf(`${target}.part`)));
+  }
+  return bytes;
+}
+function sizeOf(path) {
+  try {
+    return statSync3(path).size;
+  } catch {
+    return 0;
+  }
+}
+var DownloadError = class extends Error {
+  kind;
+  constructor(message, kind) {
+    super(message);
+    this.name = "DownloadError";
+    this.kind = kind;
+  }
+};
+async function downloadFiles(options) {
+  const { dir, files } = options;
+  const total = files.reduce((sum, file) => sum + file.size, 0);
+  mkdirSync4(dir, { recursive: true });
+  const verified = readVerified(dir);
+  let settled = 0;
+  for (const file of files) {
+    if (knownGood(dir, file, verified)) {
+      settled += file.size;
+      continue;
+    }
+    const target = join4(dir, file.path);
+    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) {
+        remember(dir, verified, file);
+        settled += file.size;
+        continue;
+      }
+      rmSync2(target, { force: true });
+    }
+    const part = `${target}.part`;
+    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) {
+      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);
+    }
+    if (actual !== file.sha256) {
+      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`,
+        "integrity"
+      );
+    }
+    renameSync2(part, target);
+    rmSync2(savedPath(part), { force: true });
+    remember(dir, verified, file);
+    settled += file.size;
+  }
+  options.onProgress?.({ file: "", checking: false, done: total, total });
+}
+var savedPath = (part) => `${part}.saved`;
+function dropPart(part) {
+  rmSync2(part, { force: true });
+  rmSync2(savedPath(part), { force: true });
+}
+function resumeFrom(part, size, checkpointBytes = CHECKPOINT_BYTES) {
+  const have = Math.min(sizeOf(part), size);
+  let saved;
+  try {
+    const value = Number.parseInt(readFileSync4(savedPath(part), "utf8").trim(), 10);
+    if (Number.isSafeInteger(value) && value >= 0) saved = value;
+  } catch {
+  }
+  return saved === void 0 ? Math.max(0, have - checkpointBytes) : Math.min(saved, have);
+}
+function writeSaved(part, bytes) {
+  const path = savedPath(part);
+  writeFileSync4(`${path}.tmp`, `${bytes}
+`);
+  renameSync2(`${path}.tmp`, path);
+}
+async function fetchFile(options, file, part, onBytes) {
+  const attempts = options.attempts ?? 8;
+  const sleep2 = options.sleep ?? ((ms) => wait(ms, void 0, { signal: options.signal }).catch(() => {
+  }));
+  let resumed = false;
+  let failures = 0;
+  let lastError;
+  for (; ; ) {
+    if (options.signal?.aborted) throw new DownloadError("The download was stopped", "aborted");
+    const before = resumeFrom(part, file.size, options.checkpointBytes);
+    try {
+      resumed = await fetchOnce(options, file, part, onBytes) || resumed;
+      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;
+      await sleep2(RETRY_WAITS[Math.min(failures, RETRY_WAITS.length) - 1]);
+    }
+  }
+  const reason = lastError instanceof Error ? lastError.message : String(lastError);
+  throw new DownloadError(
+    `${file.path} could not be downloaded (${reason}). Run mu judge mude install again to resume`,
+    "network"
+  );
+}
+async function fetchOnce(options, file, part, onBytes) {
+  const checkpointBytes = options.checkpointBytes ?? CHECKPOINT_BYTES;
+  let have = resumeFrom(part, file.size, checkpointBytes);
+  if (have === file.size) {
+    if (sizeOf(part) > file.size) truncateSync(part, file.size);
+    return true;
+  }
+  const controller = new AbortController();
+  const stallMs = options.stallMs ?? 6e4;
+  let stall = setTimeout(() => controller.abort(new Error(`no data for ${stallMs / 1e3} s`)), stallMs);
+  const onAbort = () => controller.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  let handle;
+  let written = 0;
+  let synced = 0;
+  try {
+    const headers = {};
+    if (have > 0) headers.Range = `bytes=${have}-`;
+    if (options.token) headers.Authorization = `Bearer ${options.token}`;
+    const response = await (options.fetch ?? fetch)(options.url(file.path), {
+      headers,
+      redirect: "follow",
+      signal: controller.signal
+    });
+    if (response.status === 401 || response.status === 403 || response.status === 404) {
+      throw new DownloadError(
+        `Hugging Face returned ${response.status} for ${file.path}: the model isn't public yet, or this machine's token can't access it`,
+        "access"
+      );
+    }
+    if (response.status === 416) {
+      dropPart(part);
+      throw new Error("HTTP 416");
+    }
+    if (!response.ok || !response.body) throw new Error(`HTTP ${response.status}`);
+    const resumed = response.status === 206 && have > 0;
+    if (!resumed) have = 0;
+    mkdirSync4(dirname2(part), { recursive: true });
+    handle = await open(part, existsSync4(part) ? "r+" : "w");
+    await handle.truncate(have);
+    writeSaved(part, have);
+    written = have;
+    synced = have;
+    onBytes(written);
+    const reader = response.body.getReader();
+    for (; ; ) {
+      const { done, value: chunk } = await reader.read();
+      if (done) break;
+      clearTimeout(stall);
+      stall = setTimeout(() => controller.abort(new Error(`no data for ${stallMs / 1e3} s`)), stallMs);
+      if (written + chunk.length > file.size) throw new Error(`got more than the ${file.size} bytes of the file`);
+      await handle.write(chunk, 0, chunk.length, written);
+      written += chunk.length;
+      if (written - synced >= checkpointBytes) {
+        await handle.sync();
+        synced = written;
+        writeSaved(part, synced);
+      }
+      onBytes(written);
+    }
+    if (written !== file.size) throw new Error(`got ${written} of ${file.size} bytes`);
+    return resumed;
+  } catch (error) {
+    if (options.signal?.aborted) throw new DownloadError("The download was stopped", "aborted");
+    throw error;
+  } finally {
+    clearTimeout(stall);
+    options.signal?.removeEventListener("abort", onAbort);
+    if (handle) {
+      try {
+        await handle.sync();
+        if (written > synced) writeSaved(part, written);
+      } catch {
+      }
+      await handle.close();
+    }
+  }
+}
+
+// packages/kyrn-judge/src/mude/paths.ts
+import { join as join5 } from "node:path";
+function mudePaths(muHome2) {
+  const root = join5(muHome2, "local-judge", "mude");
+  const model = join5(root, "model", MUDE_REVISION);
+  const venv = join5(root, "venv");
+  return {
+    root,
+    model,
+    verified: join5(model, ".mu-verified.json"),
+    venv,
+    python: join5(venv, "bin", "python"),
+    venvLock: join5(venv, ".mu-lock-sha256"),
+    tools: join5(root, "tools"),
+    key: join5(root, "key"),
+    pid: join5(root, "server.pid"),
+    log: join5(root, "server.log"),
+    state: join5(root, "state.json"),
+    install: join5(root, "install.json"),
+    installLock: join5(root, "install.lock")
+  };
+}
+
+// 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 { homedir as homedir3 } from "node:os";
+import { delimiter, join as join6 } from "node:path";
+var PYTHON_VERSION = "3.13";
+var UV_RELEASE = {
+  version: "0.13.1",
+  url: "https://github.com/astral-sh/uv/releases/download/0.13.1/uv-aarch64-apple-darwin.tar.gz",
+  sha256: "cfe454573412ff7380d15fc7dae5997ab53ffce72fce0a78e91ddbc84001acd2"
+};
+function executable(path) {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findUv(paths, env = process.env, home2 = homedir3()) {
+  const dirs = [
+    ...(env.PATH ?? "").split(delimiter),
+    join6(home2, ".local", "bin"),
+    join6(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");
+  }
+  return void 0;
+}
+function run(command, args, options = {}) {
+  return new Promise((resolve2) => {
+    const child = spawn2(command, args, { env: options.env ?? process.env, stdio: ["ignore", "pipe", "pipe"] });
+    const lines = [];
+    let pending = "";
+    const take = (chunk) => {
+      pending += chunk.toString("utf8");
+      const parts = pending.split(/\r?\n/);
+      pending = parts.pop() ?? "";
+      for (const line of parts) {
+        if (!line.trim()) continue;
+        lines.push(line);
+        if (lines.length > 40) lines.shift();
+        options.onLine?.(line);
+      }
+    };
+    child.stdout.on("data", take);
+    child.stderr.on("data", take);
+    child.once("error", (error) => resolve2({ code: null, output: error.message }));
+    child.once("close", (code) => {
+      if (pending.trim()) lines.push(pending);
+      resolve2({ code, output: lines.slice(-12).join("\n") });
+    });
+  });
+}
+async function downloadUv(paths, options = {}) {
+  mkdirSync5(paths.tools, { recursive: true });
+  const archive = "uv.tar.gz";
+  options.onLine?.(`Downloading uv ${UV_RELEASE.version}`);
+  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);
+  const unpacked = await run("/usr/bin/tar", [
+    "-xzf",
+    join6(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(`Couldn't unpack uv: ${unpacked.output}`);
+  return join6(paths.tools, "uv");
+}
+function lockDigest(lockFile) {
+  return createHash2("sha256").update(readFileSync5(lockFile)).digest("hex");
+}
+function venvReady(paths, lockFile) {
+  if (!existsSync5(paths.python)) return false;
+  try {
+    return readFileSync5(paths.venvLock, "utf8").trim() === lockDigest(lockFile);
+  } catch {
+    return false;
+  }
+}
+async function ensureVenv(paths, lockFile, uv, options = {}) {
+  if (venvReady(paths, lockFile)) return;
+  rmSync3(paths.venv, { recursive: true, force: true });
+  const env = { ...options.env ?? process.env, UV_NO_CONFIG: "1", VIRTUAL_ENV: void 0 };
+  const made = await run(uv, ["venv", "--python", PYTHON_VERSION, "--no-project", "--quiet", paths.venv], {
+    env,
+    onLine: options.onLine
+  });
+  if (made.code !== 0) throw new Error(`Couldn't create the Python environment (uv venv):
+${made.output}`);
+  const installed2 = await run(
+    uv,
+    [
+      "pip",
+      "install",
+      "--python",
+      paths.python,
+      "--require-hashes",
+      "--no-deps",
+      "--index-url",
+      "https://pypi.org/simple",
+      "-r",
+      lockFile
+    ],
+    { env, onLine: options.onLine }
+  );
+  if (installed2.code !== 0)
+    throw new Error(`Couldn't install mude's Python packages (uv pip install):
+${installed2.output}`);
+  writeFileSync5(paths.venvLock, `${lockDigest(lockFile)}
+`);
+}
+
+// packages/kyrn-judge/src/mude/command.ts
+var USAGE = `mu judge mude: mude 1.0, mu's own decision model optimized for coding, as the judge on this Mac
+(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 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
+  mu judge mude start | stop             start or stop its server (about 4 GB of memory while it runs)
+  mu judge mude status                   what is installed, running and enabled
+  mu judge mude uninstall                disable it and delete the model and its Python environment
+
+What mude 1.0 cannot answer, because its server is not running or it is unsure, goes to the judges that were there
+before it (Jev by default): those are hosted, so what they read leaves this machine. With --local-only, it is the
+only judge, and such a decision takes its fallback instead. Add --json for one JSON object per line.
+`;
+function jsonOut(write) {
+  const emit = (value) => write(`${JSON.stringify(value)}
+`);
+  let last = 0;
+  return {
+    step: (step, message) => emit({ type: "step", step, message }),
+    progress: (event) => {
+      const now = Date.now();
+      if (now - last < 250 && event.done < event.total && !event.checking) return;
+      last = now;
+      emit({ type: "progress", ...event });
+    },
+    line: (text) => emit({ type: "log", line: text }),
+    status: (status2) => emit({ type: "status", ...status2 }),
+    error: (message, kind) => emit({ type: "error", message, kind })
+  };
+}
+function humanOut(write, tty) {
+  let shown = -1;
+  return {
+    step: (_step, message) => {
+      if (shown >= 0 && tty) write("\n");
+      shown = -1;
+      write(`${message}
+`);
+    },
+    progress: ({ done, total, checking }) => {
+      const percent = total > 0 ? Math.floor(done / total * 100) : 100;
+      if (tty) {
+        write(
+          `\r  ${percent}%  ${(done / 1e9).toFixed(2)} of ${(total / 1e9).toFixed(2)} GB${checking ? "  (checking)" : ""}   `
+        );
+        shown = percent;
+      } else if (percent >= shown + 10 || percent === 100) {
+        shown = percent - percent % 10;
+        write(`  ${percent}%
+`);
+      }
+    },
+    line: (text) => write(`  ${text}
+`),
+    status: (status2) => write(describe(status2)),
+    error: (message) => {
+      if (shown >= 0 && tty) write("\n");
+      shown = -1;
+      write(`${message}
+`);
+    }
+  };
+}
+function describe(status2) {
+  const lines = [];
+  if (!status2.supported) {
+    lines.push(`mude 1.0 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"}`
+  );
+  if (status2.installed && !status2.pythonReady) lines.push("python    not set up: mu judge mude 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)`
+    );
+  } else {
+    lines.push(`judge     ${status2.installed ? "not enabled: mu judge mude enable" : "not enabled"}`);
+  }
+  lines.push(`folder    ${status2.folder}`);
+  return `${lines.join("\n")}
+`;
+}
+function problems(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "darwin") return ["it needs a Mac with Apple silicon (an M1 or newer)"];
+  const out = [];
+  const arm64 = options.arm64 ?? appleSilicon();
+  if (!arm64) out.push("it needs Apple silicon (an M1 or newer); this Mac has an Intel processor");
+  const darwinMajor = options.darwinMajor ?? Number.parseInt(release().split(".")[0] ?? "0", 10);
+  if (darwinMajor < 23) out.push("it needs macOS 14 or later");
+  const memory = options.memoryBytes ?? totalmem2();
+  if (memory < 8 * 1024 ** 3)
+    out.push(
+      `it needs 8 GB of memory or more (it uses about 4 GB); this Mac has ${Math.round(memory / 1024 ** 3)} GB`
+    );
+  return out;
+}
+function appleSilicon() {
+  if (process.arch === "arm64") return true;
+  try {
+    return execFileSync2("/usr/sbin/sysctl", ["-n", "hw.optional.arm64"], { encoding: "utf8" }).trim() === "1";
+  } catch {
+    return false;
+  }
+}
+function freeBytes(path) {
+  let dir = path;
+  while (!existsSync6(dir)) {
+    const parent = join7(dir, "..");
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+  try {
+    const stats = statfsSync(dir);
+    return stats.bavail * stats.bsize;
+  } catch {
+    return void 0;
+  }
+}
+var gb = (bytes) => (bytes / 1e9).toFixed(1);
+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"));
+    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) {
+  mkdirSync6(paths.root, { recursive: true });
+  const mine = `${JSON.stringify({ pid: process.pid, started: startedAt(process.pid) ?? "" })}
+`;
+  try {
+    writeFileSync6(paths.installLock, mine, { flag: "wx" });
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    let holder = {};
+    try {
+      holder = JSON.parse(readFileSync6(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`
+      );
+    }
+    writeFileSync6(paths.installLock, mine);
+  }
+  return () => {
+    try {
+      if (readFileSync6(paths.installLock, "utf8") === mine) rmSync4(paths.installLock, { force: true });
+    } catch {
+    }
+  };
+}
+function installed(ctx) {
+  return missingFiles(ctx.paths.model, MUDE_FILES).length === 0;
+}
+function key(ctx) {
+  try {
+    const existing = readFileSync6(ctx.paths.key, "utf8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  mkdirSync6(ctx.paths.root, { recursive: true });
+  const made = randomBytes(32).toString("hex");
+  writeFileSync6(ctx.paths.key, `${made}
+`, { mode: 384 });
+  return made;
+}
+async function port(ctx) {
+  const previous = readState(ctx.paths)?.port;
+  if (previous && (serverAlive(ctx.paths) || await portFree(previous))) return previous;
+  return choosePort(DEFAULT_PORT);
+}
+async function status(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);
+  return {
+    supported: found.length === 0,
+    problems: found,
+    installed: installed(ctx),
+    downloadedBytes: downloadedBytes(ctx.paths.model, MUDE_FILES),
+    pythonReady: venvReady(ctx.paths, ctx.lockFile),
+    running,
+    ready,
+    port: at,
+    pid: running ? pid : void 0,
+    memoryBytes: running ? serverMemory(pid) : void 0,
+    enabled: setting.enabled,
+    localOnly: setting.localOnly,
+    fallback: setting.fallback,
+    model: `${MUDE_REPO}@${MUDE_REVISION}`,
+    folder: ctx.paths.root,
+    log: ctx.paths.log
+  };
+}
+async function ensureInstalled(ctx, out) {
+  const missing = missingFiles(ctx.paths.model, MUDE_FILES);
+  if (missing.length > 0) {
+    const need = missing.reduce((sum, file) => sum + file.size, 0);
+    const already = downloadedBytes(ctx.paths.model, MUDE_FILES);
+    const free = freeBytes(ctx.paths.root);
+    const room = MUDE_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`
+      );
+    }
+    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`
+    );
+    try {
+      await downloadFiles({
+        dir: ctx.paths.model,
+        files: MUDE_FILES,
+        url: (path) => mudeFileUrl(path, ctx.env.HF_ENDPOINT || void 0),
+        token: huggingFaceToken(ctx.env),
+        onProgress: (event) => out.progress(event),
+        signal: ctx.signal
+      });
+    } 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`,
+          "aborted"
+        );
+      }
+      throw error;
+    }
+  }
+  if (!venvReady(ctx.paths, ctx.lockFile)) {
+    out.step("python", "Setting up the Python environment for mude 1.0 (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 mu judge mude 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");
+  }
+}
+async function start(ctx, out, command, wait2 = true) {
+  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)`
+  );
+  try {
+    await startServer(ctx.paths, { port: at, key: key(ctx), wait: wait2, signal: ctx.signal });
+  } 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`,
+        "aborted"
+      );
+    }
+    throw error;
+  }
+  return at;
+}
+function enable(ctx, out, at, localOnly) {
+  const tiers = enableMude(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.`
+  );
+}
+async function main(argv, ctx, write, tty = false) {
+  const json = argv.includes("--json");
+  const args = argv.filter((arg) => arg !== "--json");
+  const out = json ? jsonOut(write) : humanOut(write, tty);
+  const command = args[0] ?? "status";
+  const flag = (name) => args.includes(name);
+  try {
+    if (command === "help" || command === "--help" || command === "-h") {
+      write(USAGE);
+      return 0;
+    }
+    const unknown = args.slice(1).find((arg) => !["--local-only", "--with-fallback", "--no-wait", "--yes"].includes(arg));
+    if (unknown) {
+      out.error(`Unknown option for mu judge mude ${command}: ${unknown} (mu judge mude help)`, "usage");
+      return 2;
+    }
+    if (command === "status") {
+      out.status(await status(ctx));
+      return 0;
+    }
+    const found = problems();
+    if (found.length > 0 && command !== "stop" && command !== "disable" && command !== "uninstall") {
+      out.error(`mude 1.0 can't run on this machine: ${found.join("; ")}.`, "unsupported");
+      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();
+        }
+        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);
+        break;
+      }
+      case "disable": {
+        if (!mudeInTiers(ctx.files)) {
+          const stopped2 = await stopServer(ctx.paths);
+          out.step("disable", `mude 1.0 was not the judge${stopped2 ? "; its server is stopped" : ""}.`);
+          break;
+        }
+        const tiers = disableMude(ctx.paths, ctx.files);
+        const stopped = await stopServer(ctx.paths);
+        out.step(
+          "disable",
+          `mude 1.0 is no longer the judge: ${tiers.join(" > ")} again${stopped ? ", and its server is stopped" : ""}.`
+        );
+        break;
+      }
+      case "start": {
+        requireInstalled(ctx);
+        await start(ctx, out, "start", !flag("--no-wait"));
+        break;
+      }
+      case "stop": {
+        const stopped = await stopServer(ctx.paths);
+        out.step("stop", stopped ? "The mude 1.0 server is stopped." : "The mude 1.0 server was not running.");
+        break;
+      }
+      case "uninstall": {
+        if (mudeInTiers(ctx.files) || readState(ctx.paths)?.wroteEntry) {
+          const tiers = disableMude(ctx.paths, ctx.files, { removeEntry: true });
+          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.`);
+        break;
+      }
+      default:
+        out.error(`Unknown command: mu judge mude ${command}
+
+${USAGE}`, "usage");
+        return 2;
+    }
+    out.status(await status(ctx));
+    return 0;
+  } catch (error) {
+    const kind = error instanceof DownloadError ? error.kind : void 0;
+    out.error(error instanceof Error ? error.message : String(error), kind);
+    return 1;
+  }
+}
+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");
+  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"),
+    env
+  };
+}
+
+// packages/kyrn-judge/src/redact.ts
+var REDACTED = "[redacted]";
+var SHAPES = [
+  // A private key, the whole block, or to the end when the text was cut inside it.
+  /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?(?:-----END [A-Z0-9 ]*PRIVATE KEY-----|$)/g,
+  // OpenAI, Anthropic, OpenRouter, DeepSeek and the like.
+  /\bsk-[A-Za-z0-9_-]{20,}/g,
+  /\b(?:gh[pousr]_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{22,})/g,
+  /\bglpat-[A-Za-z0-9_-]{20,}/g,
+  /\bxox[abposr]-[A-Za-z0-9-]{10,}/g,
+  /\bAIza[0-9A-Za-z_-]{35}/g,
+  /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g,
+  /\b[rs]k_(?:live|test)_[0-9A-Za-z]{16,}/g,
+  /\bnpm_[A-Za-z0-9]{36}\b/g,
+  /\bhf_[A-Za-z0-9]{30,}/g,
+  // A JSON web token.
+  /\beyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g
+];
+var BEARER = /\b(Bearer|Basic)(\s+)(?=[A-Za-z._~+/=-]*[0-9])[A-Za-z0-9._~+/=-]{12,}/g;
+var URL_PASSWORD = /\b([a-z][a-z0-9+.-]*:\/\/[^\s:@/]+:)[^\s@/]+(@)/gi;
+var KEY_WORD = "(?:SECRET|TOKEN|PASSWD|PASSWORD|API_?KEY|ACCESS_?KEY|PRIVATE_?KEY)";
+var ENV_VALUE = new RegExp(`\\b([A-Z0-9_]*${KEY_WORD}[A-Z0-9_]*=)("[^"\\n]{8,}"|'[^'\\n]{8,}'|[^\\s"';&|]{8,})`, "g");
+var QUOTED_VALUE = new RegExp(
+  `(["']?[A-Za-z0-9_-]*${KEY_WORD.replaceAll("_?", "[_-]?")}[A-Za-z0-9_-]*["']?\\s*[:=]\\s*)(["'])[^"'\\s]{8,}\\2`,
+  "gi"
+);
+var LINE_VALUE = new RegExp(
+  `^(\\s*[A-Za-z0-9_.-]*${KEY_WORD.replaceAll("_?", "[_.-]?")}[A-Za-z0-9_.-]*\\s*[:=][ \\t]*)[^\\s#"']{8,}[ \\t]*$`,
+  "gim"
+);
+function redactSecrets(text, known = []) {
+  let clean = text;
+  for (const secret of known) if (clean.includes(secret)) clean = clean.split(secret).join(REDACTED);
+  for (const shape of SHAPES) clean = clean.replace(shape, REDACTED);
+  return clean.replace(BEARER, `$1$2${REDACTED}`).replace(URL_PASSWORD, `$1${REDACTED}$2`).replace(ENV_VALUE, `$1${REDACTED}`).replace(QUOTED_VALUE, `$1$2${REDACTED}$2`).replace(LINE_VALUE, `$1${REDACTED}`);
+}
+
 // packages/kyrn-judge/src/setup/language.ts
 function languageOf(value) {
   const tag = value?.trim().split(/[.@]/)[0];
@@ -396,7 +1675,7 @@ function piAccess(runtime, agentDir2) {
       if (!found) return void 0;
       return found.type === "oauth" ? "oauth" : "api_key";
     },
-    storeKey: async (provider, key) => {
+    storeKey: async (provider, key2) => {
       await runtime.refresh({ allowNetwork: false, providers: [provider] });
       if (!runtime.getProvider(provider)) {
         throw new Error(
@@ -411,7 +1690,7 @@ function piAccess(runtime, agentDir2) {
             if (asked || prompt.type !== "secret")
               throw new Error(`the sign-in for ${provider} asked for more than a key`);
             asked = true;
-            return key;
+            return key2;
           },
           notify: () => {
           }
@@ -520,30 +1799,30 @@ async function readAll(input = process.stdin) {
 }
 
 // packages/kyrn-judge/src/setup/wizard.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join3 } from "node:path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
 
 // packages/kyrn-judge/src/setup/check.ts
 var CHECK_TIMEOUT_MS = 1e4;
-function checkRequest(kind, baseUrl, key) {
+function checkRequest(kind, baseUrl, key2) {
   const base = baseUrl.replace(/\/+$/, "");
   const headers = { accept: "application/json" };
   switch (kind) {
     case "anthropic-models":
       headers["anthropic-version"] = "2023-06-01";
-      if (key?.includes("sk-ant-oat")) {
-        headers.authorization = `Bearer ${key}`;
+      if (key2?.includes("sk-ant-oat")) {
+        headers.authorization = `Bearer ${key2}`;
         headers["anthropic-beta"] = "oauth-2025-04-20";
-      } else if (key) headers["x-api-key"] = key;
+      } else if (key2) headers["x-api-key"] = key2;
       return { url: `${base}/v1/models?limit=1000`, headers };
     case "google-models":
-      if (key) headers["x-goog-api-key"] = key;
+      if (key2) headers["x-goog-api-key"] = key2;
       return { url: `${base}/models?pageSize=1000`, headers };
     case "openrouter-key":
-      if (key) headers.authorization = `Bearer ${key}`;
+      if (key2) headers.authorization = `Bearer ${key2}`;
       return { url: `${base}/key`, headers };
     default:
-      if (key) headers.authorization = `Bearer ${key}`;
+      if (key2) headers.authorization = `Bearer ${key2}`;
       return { url: `${base}/models`, headers };
   }
 }
@@ -568,23 +1847,23 @@ function messageOf(body) {
   }
   return body.trimStart().startsWith("<") ? "" : body;
 }
-function safeMessage(text, key) {
-  const known = key ? [key] : [];
+function safeMessage(text, key2) {
+  const known = key2 ? [key2] : [];
   const clean = redactSecrets(text, known).replace(/\*{2,}[A-Za-z0-9_-]{0,12}/g, "\u2026").replace(/\s+/g, " ").trim();
   return clean.length > 160 ? `${clean.slice(0, 157)}...` : clean;
 }
-function classifyAnswer(status, body) {
+function classifyAnswer(status2, body) {
   const text = `${messageOf(body)} ${body}`;
-  if (status === 401) return "key";
-  if (status === 402) return "balance";
-  if (status === 404) return "address";
-  if (status >= 500) return "server";
-  if (status === 400 || status === 403 || status === 429) {
+  if (status2 === 401) return "key";
+  if (status2 === 402) return "balance";
+  if (status2 === 404) return "address";
+  if (status2 >= 500) return "server";
+  if (status2 === 400 || status2 === 403 || status2 === 429) {
     if (BALANCE.test(text)) return "balance";
     if (REGION.test(text)) return "region";
     if (WRONG_KEY.test(text)) return "key";
-    if (status === 429) return "rate";
-    if (status === 403) return PERMISSION.test(text) ? "permission" : "refused";
+    if (status2 === 429) return "rate";
+    if (status2 === 403) return PERMISSION.test(text) ? "permission" : "refused";
   }
   return "other";
 }
@@ -630,19 +1909,19 @@ function listedModels(kind, body) {
 async function checkKey({
   kind,
   baseUrl,
-  key,
-  fetch,
+  key: key2,
+  fetch: fetch2,
   timeoutMs = CHECK_TIMEOUT_MS
 }) {
   if (kind === "opencode-key") {
-    const refused = await opencodeRefuses(baseUrl, key, fetch, timeoutMs);
+    const refused = await opencodeRefuses(baseUrl, key2, fetch2, timeoutMs);
     if (refused) return { ok: false, problem: refused };
   }
-  const request = checkRequest(kind, baseUrl, key);
+  const request = checkRequest(kind, baseUrl, key2);
   const url = request.url.split("?")[0];
   let response;
   try {
-    response = await fetch(request.url, { headers: request.headers, signal: AbortSignal.timeout(timeoutMs) });
+    response = await fetch2(request.url, { headers: request.headers, signal: AbortSignal.timeout(timeoutMs) });
   } catch (error) {
     return { ok: false, problem: { kind: classifyFailure(error), url } };
   }
@@ -658,7 +1937,7 @@ async function checkKey({
         kind: classifyAnswer(response.status, text),
         url,
         status: response.status,
-        said: safeMessage(messageOf(text), key) || void 0
+        said: safeMessage(messageOf(text), key2) || void 0
       }
     };
   }
@@ -722,13 +2001,13 @@ function explainProblem(problem, context, language) {
       return zh ? `${service} \u62D2\u7EDD\u4E86\u8FD9\u6B21\u68C0\u67E5\uFF08HTTP ${problem.status ?? "?"}\uFF09\u3002${said}` : `${service} rejected the check (HTTP ${problem.status ?? "?"}).${said}`;
   }
 }
-async function opencodeRefuses(baseUrl, key, fetch, timeoutMs) {
+async function opencodeRefuses(baseUrl, key2, fetch2, timeoutMs) {
   const url = `${baseUrl.replace(/\/+$/, "")}/systemone`;
   let response;
   try {
-    response = await fetch(url, {
+    response = await fetch2(url, {
       method: "POST",
-      headers: { "content-type": "application/json", ...key ? { authorization: `Bearer ${key}` } : {} },
+      headers: { "content-type": "application/json", ...key2 ? { authorization: `Bearer ${key2}` } : {} },
       body: JSON.stringify({
         model: "jev-1.13-free",
         state: "mu setup is checking a key.",
@@ -745,7 +2024,7 @@ async function opencodeRefuses(baseUrl, key, fetch, timeoutMs) {
     kind: classifyAnswer(response.status, text),
     url,
     status: response.status,
-    said: safeMessage(messageOf(text), key) || void 0
+    said: safeMessage(messageOf(text), key2) || void 0
   };
 }
 
@@ -939,15 +2218,15 @@ function serviceById(id) {
   return SETUP_SERVICES.find((service) => service.id === id);
 }
 function cleanKey(raw) {
-  let key = raw.trim();
-  if (key.length >= 2 && (key[0] === '"' || key[0] === "'") && key.at(-1) === key[0]) key = key.slice(1, -1).trim();
-  return key;
+  let key2 = raw.trim();
+  if (key2.length >= 2 && (key2[0] === '"' || key2[0] === "'") && key2.at(-1) === key2[0]) key2 = key2.slice(1, -1).trim();
+  return key2;
 }
-function isClaudeSubscriptionToken(key) {
-  return cleanKey(key).startsWith("sk-ant-oat");
+function isClaudeSubscriptionToken(key2) {
+  return cleanKey(key2).startsWith("sk-ant-oat");
 }
-function servicesForKey(key) {
-  const clean = cleanKey(key);
+function servicesForKey(key2) {
+  const clean = cleanKey(key2);
   return clean ? SETUP_SERVICES.filter((service) => service.keyShape?.test(clean)) : [];
 }
 function checkKindOf(service, api) {
@@ -1060,11 +2339,11 @@ function parseSetupArgs(argv) {
     return { error: { zh: "--api \u53EA\u80FD\u662F openai \u6216 anthropic", en: "--api must be openai or anthropic" } };
   }
   const judge = values.get("--judge");
-  if (judge !== void 0 && !["jev", "opencode", "free", "model", "off", "none"].includes(judge)) {
+  if (judge !== void 0 && !["jev", "opencode", "free", "model", "mude", "off", "none"].includes(judge)) {
     return {
       error: {
-        zh: "--judge \u53EA\u80FD\u662F jev\u3001opencode\u3001free\u3001model\u3001off \u6216 none",
-        en: "--judge must be jev, opencode, free, model, off or none"
+        zh: "--judge \u53EA\u80FD\u662F jev\u3001opencode\u3001free\u3001model\u3001mude\u3001off \u6216 none",
+        en: "--judge must be jev, opencode, free, model, mude, off or none"
       }
     };
   }
@@ -1111,6 +2390,7 @@ function setupUsage(language) {
       "  --judge opencode  OpenCode Zen \u4E0A\u7684 Jev\uFF0C\u7528 OpenCode \u7684\u5BC6\u94A5\uFF08--service opencode \u6216 OPENCODE_API_KEY\uFF09",
       "  --judge free      OpenCode Zen \u4E0A\u9650\u65F6\u514D\u8D39\u7684 Jev\uFF0C\u4E0D\u7528\u5BC6\u94A5\uFF08\u6CA1\u6709\u5BC6\u94A5\u65F6\u672C\u6765\u5C31\u7528\u5B83\uFF09",
       "  --judge model     \u7528\u521A\u8BBE\u7F6E\u7684\u6A21\u578B\u5F53\u5224\u5B9A\u5668\uFF08\u66F4\u6162\uFF0C\u6BCF\u6B21\u5224\u65AD\u90FD\u82B1 token\uFF09",
+      "  --judge mude      \u5728\u8FD9\u53F0 Mac \u4E0A\u88C5\u597D mude 1.0\uFF08mu \u81EA\u5DF1\u7684\u51B3\u7B56\u6A21\u578B\uFF0C\u4E0B\u8F7D 1.8 GB\uFF09\u5F53\u5224\u5B9A\u5668\uFF0CJev \u5728\u5B83\u540E\u9762",
       "  --judge off       \u4E0D\u7528\u5224\u5B9A\u5668\uFF1A\u6240\u6709\u5224\u5B9A\u70B9\u5173\u95ED\uFF0C\u4EC0\u4E48\u90FD\u4E0D\u53D1\u7ED9\u5224\u5B9A\u5668",
       "  --judge none      \u4E0D\u6539\u5224\u5B9A\u5668\uFF1B\u4E0D\u5199 --judge \u65F6\u4E5F\u4E0D\u6539",
       "  --api, --name     \u670D\u52A1 other \u7684\u63A5\u53E3\uFF08openai \u6216 anthropic\uFF09\u548C\u5B83\u5728 mu \u91CC\u7684\u540D\u5B57",
@@ -1137,6 +2417,8 @@ function setupUsage(language) {
     "  --judge opencode  use Jev on OpenCode Zen with an OpenCode key (--service opencode or OPENCODE_API_KEY)",
     "  --judge free      use the free Jev on OpenCode Zen (limited time, no key; the default while no key is set)",
     "  --judge model     use the model you just set up as the judge (slower, and every verdict costs tokens)",
+    "  --judge mude      install mude 1.0, mu's own decision model, on this Mac (a 1.8 GB download) as the judge,",
+    "                    with Jev behind it",
     "  --judge off       no judge: every decision point is off, and nothing is sent to a judge",
     "  --judge none      leave the judge unchanged (the same as omitting --judge)",
     "  --api, --name     for the service `other`: its API (openai or anthropic) and its name in mu",
@@ -1161,13 +2443,13 @@ function providerIdFor(baseUrl) {
   } catch {
     return "custom";
   }
-  const [name, port] = host.split(/:(?=\d+$)/);
+  const [name, port2] = host.split(/:(?=\d+$)/);
   if (name === "localhost" || /^\d+(\.\d+){3}$/.test(name) || name.startsWith("[")) {
-    return port ? `local-${port}` : "local";
+    return port2 ? `local-${port2}` : "local";
   }
   const parts = name.split(".").filter((part) => part !== "api" && part !== "www");
-  const main2 = parts.length >= 2 ? parts[parts.length - 2] : parts[0] ?? "";
-  return main2.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "custom";
+  const main3 = parts.length >= 2 ? parts[parts.length - 2] : parts[0] ?? "";
+  return main3.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "") || "custom";
 }
 function hostOf2(url) {
   try {
@@ -1257,16 +2539,16 @@ var Setup = class {
     for (; ; ) {
       const answer = await this.io.secret(question);
       if (answer === void 0) throw this.cancelled();
-      const key = cleanKey(answer);
-      if (key || allowEmpty) return key;
+      const key2 = cleanKey(answer);
+      if (key2 || allowEmpty) return key2;
     }
   }
   async pasteKey() {
     for (; ; ) {
-      const key = await this.secret(
+      const key2 = await this.secret(
         this.t({ zh: "\u7C98\u8D34 API \u5BC6\u94A5\uFF08\u4E0D\u4F1A\u663E\u793A\u51FA\u6765\uFF09\uFF1A", en: "Paste the API key (it won't be shown): " })
       );
-      if (!isClaudeSubscriptionToken(key)) return key;
+      if (!isClaudeSubscriptionToken(key2)) return key2;
       this.io.warn(this.t(CLAUDE_TOKEN));
     }
   }
@@ -1293,7 +2575,7 @@ var Setup = class {
   async steps() {
     const { args, deps } = this;
     if (args.firstRun && !await this.firstStart()) return SETUP_EXIT.done;
-    let key = deps.givenKey ?? args.words[0];
+    let key2 = deps.givenKey ?? args.words[0];
     if (args.keyStdin) {
       if (deps.stdinTerminal) {
         throw this.fail(
@@ -1305,11 +2587,11 @@ var Setup = class {
         );
       }
       const [modelKey, jevKey] = (await deps.readStdin()).split(/\r?\n/).map((line) => cleanKey(line)).filter(Boolean);
-      key = modelKey;
+      key2 = modelKey;
       this.jevFromStdin = jevKey;
     }
-    if (key !== void 0 && isClaudeSubscriptionToken(key)) throw this.fail(CLAUDE_TOKEN, SETUP_EXIT.usage);
-    if (this.scripted && key === void 0 && args.service === void 0) {
+    if (key2 !== void 0 && isClaudeSubscriptionToken(key2)) throw this.fail(CLAUDE_TOKEN, SETUP_EXIT.usage);
+    if (this.scripted && key2 === void 0 && args.service === void 0) {
       throw this.fail(
         deps.interactive ? { zh: "\u6CA1\u6709\u5BC6\u94A5\uFF0C\u4E5F\u6CA1\u6709 --service", en: "no key or --service given" } : {
           zh: "\u95EE\u9898\u8981\u5728\u7EC8\u7AEF\u91CC\u56DE\u7B54\u3002\u811A\u672C\u91CC\u7528\uFF1Amu setup --service <id> --key-stdin\uFF08\u89C1 mu setup --help\uFF09",
@@ -1326,18 +2608,41 @@ var Setup = class {
         })
       );
     }
-    const start = await this.start(key === void 0 ? void 0 : cleanKey(key));
-    if (start === "subscription") {
-      const code2 = await this.write(void 0, void 0, await this.judge(void 0));
-      return code2 === SETUP_EXIT.done ? this.offerSession(true) : code2;
+    const start2 = await this.start(key2 === void 0 ? void 0 : cleanKey(key2));
+    if (start2 === "subscription") {
+      const judge2 = await this.judge(void 0);
+      const code2 = await this.write(void 0, void 0, judge2);
+      if (code2 !== SETUP_EXIT.done) return code2;
+      const installed3 = await this.installMude(judge2);
+      return installed3 === SETUP_EXIT.done ? this.offerSession(true) : installed3;
     }
-    const target = await this.checked(start.service, start.key);
+    const target = await this.checked(start2.service, start2.key);
     this.modelKey = target.key;
     const model = await this.model(target);
     await this.conflicts(target);
     const judge = await this.judge({ provider: target.reach.provider, model });
     const code = await this.write(target, model, judge);
-    return code === SETUP_EXIT.done ? this.offerSession() : code;
+    if (code !== SETUP_EXIT.done) return code;
+    const installed2 = await this.installMude(judge);
+    return installed2 === SETUP_EXIT.done ? this.offerSession() : installed2;
+  }
+  /**
+   * mude, when it was picked: installed now that the files name Jev, which it goes in front of. One that does not get
+   * installed (no connection, stopped) leaves Jev as the judge, and `mu judge mude install` goes on from where it got.
+   */
+  async installMude(judge) {
+    const mude = this.deps.mude;
+    if (judge?.kind !== "mude" || !mude) return SETUP_EXIT.done;
+    this.io.say("");
+    const code = await mude.install();
+    if (code === 0) return SETUP_EXIT.done;
+    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 resume it."
+      })
+    );
+    return this.scripted ? SETUP_EXIT.failed : SETUP_EXIT.done;
   }
   /** The launcher's question on a first start. A no is remembered: the question is never asked again. */
   async firstStart() {
@@ -1350,9 +2655,9 @@ var Setup = class {
     );
     if (yes) return true;
     try {
-      mkdirSync3(this.deps.paths.agentDir, { recursive: true });
-      writeFileSync2(
-        join3(this.deps.paths.agentDir, SETUP_DECLINED_FILE),
+      mkdirSync7(this.deps.paths.agentDir, { recursive: true });
+      writeFileSync7(
+        join8(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 {
@@ -1368,10 +2673,10 @@ var Setup = class {
   // -----------------------------------------------------------------------------------------------------------
   // Steps 1 and 2: how a model is reached, and which service a key belongs to
   // -----------------------------------------------------------------------------------------------------------
-  async start(key) {
+  async start(key2) {
     const named2 = this.args.service === void 0 ? void 0 : serviceById(this.args.service);
-    if (named2) return this.keyFor(named2, key);
-    if (key !== void 0) return { service: await this.serviceOf(key), key };
+    if (named2) return this.keyFor(named2, key2);
+    if (key2 !== void 0) return { service: await this.serviceOf(key2), key: key2 };
     const route = await this.choose(
       this.t({ zh: "mu \u7528\u4EC0\u4E48\u65B9\u5F0F\u8FDE\u63A5\u6A21\u578B\uFF1F", en: "How should mu connect to a model?" }),
       [
@@ -1393,11 +2698,11 @@ var Setup = class {
       ]
     );
     if (route === "subscription") {
-      const auth = this.path(join3(this.deps.paths.agentDir, "auth.json"));
+      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}.`
+          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}.`
         })
       );
       return "subscription";
@@ -1416,8 +2721,8 @@ var Setup = class {
    * The service a key belongs to, by its shape. When the shape fits several, or none, the person says which: a key is
    * never tried on one vendor after another.
    */
-  async serviceOf(key) {
-    const matches = servicesForKey(key);
+  async serviceOf(key2) {
+    const matches = servicesForKey(key2);
     if (matches.length === 1) {
       this.io.say(
         this.t({
@@ -1460,23 +2765,23 @@ var Setup = class {
   async keyFor(service, given) {
     if (service.keyless) return { service };
     if (service.keyOptional && given === void 0) return { service };
-    let key = given;
-    if (key === void 0 && !this.scripted) {
+    let key2 = given;
+    if (key2 === void 0 && !this.scripted) {
       if (service.keyPage) {
         this.io.say(this.t({ zh: `\u5BC6\u94A5\u5728\u8FD9\u91CC\u521B\u5EFA\uFF1A${service.keyPage}`, en: `Create a key at ${service.keyPage}` }));
       }
-      key = await this.pasteKey();
+      key2 = await this.pasteKey();
     }
-    if (!key) {
+    if (!key2) {
       if (service.keyOptional) return { service };
       throw this.fail(
         { zh: `${this.name(service)} \u9700\u8981\u4E00\u4E2A API \u5BC6\u94A5`, en: `${this.name(service)} needs an API key` },
         SETUP_EXIT.usage
       );
     }
-    const matches = servicesForKey(key);
+    const matches = servicesForKey(key2);
     const ownAddress = service.id === "other" || this.args.baseUrl !== void 0;
-    if (matches.length === 0 || matches.includes(service) || ownAddress) return { service, key };
+    if (matches.length === 0 || matches.includes(service) || ownAddress) return { service, key: key2 };
     if (this.scripted) {
       this.io.warn(
         this.t({
@@ -1484,7 +2789,7 @@ var Setup = class {
           en: `Note: this key looks like ${article(this.names(matches))} key; sending it to ${this.name(service)}, as --service says.`
         })
       );
-      return { service, key };
+      return { service, key: key2 };
     }
     const chosen = await this.pickService(
       [service, ...matches],
@@ -1493,7 +2798,7 @@ var Setup = class {
         en: `This key looks like ${article(this.names(matches))} key, not ${article(this.name(service))} one. Which service is it for?`
       })
     );
-    return { service: chosen, key };
+    return { service: chosen, key: key2 };
   }
   // -----------------------------------------------------------------------------------------------------------
   // Step 3: one request to the service
@@ -1566,7 +2871,7 @@ var Setup = class {
     return [{ provider, builtIn: false, baseUrl: base, api }];
   }
   inModelsFile(provider) {
-    const models = readJsonFile(join3(this.deps.paths.agentDir, "models.json"));
+    const models = readJsonFile(join8(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. */
@@ -1580,10 +2885,10 @@ var Setup = class {
   }
   /** The key, checked: asked again, retried, or taken unchecked until the person has one that works, or stops. */
   async checked(service, firstKey) {
-    let key = firstKey;
+    let key2 = firstKey;
     const reaches = await this.reaches(service);
-    if (service.keyOptional && key === void 0 && !this.scripted) {
-      key = await this.secret(
+    if (service.keyOptional && key2 === void 0 && !this.scripted) {
+      key2 = await this.secret(
         this.t({
           zh: "\u7C98\u8D34\u5B83\u7684 API \u5BC6\u94A5\uFF1B\u4E0D\u9700\u8981\u5BC6\u94A5\u5C31\u76F4\u63A5\u56DE\u8F66\uFF08\u4E0D\u4F1A\u663E\u793A\uFF09\uFF1A",
           en: "Paste its API key, or press Enter if it doesn't need one (it won't be shown): "
@@ -1594,8 +2899,8 @@ var Setup = class {
     if (!reaches[0].builtIn || this.args.baseUrl) this.modelsFileWritable();
     await this.oauthConflict(service, reaches);
     for (; ; ) {
-      const result = await this.tryReaches(service, reaches, key);
-      if (result.ok) return { service, reach: result.reach, key, listed: result.listed };
+      const result = await this.tryReaches(service, reaches, key2);
+      if (result.ok) return { service, reach: result.reach, key: key2, listed: result.listed };
       const said = this.explain(service, result.problem);
       if (this.scripted) throw this.fail({ zh: said, en: said });
       this.io.say(said);
@@ -1615,19 +2920,19 @@ var Setup = class {
       });
       const next = await this.choose(this.t({ zh: "\u63A5\u4E0B\u6765\u600E\u4E48\u529E\uFF1F", en: "What next?" }), choices);
       if (next === "stop") throw this.cancelled();
-      if (next === "unchecked") return { service, reach: reaches[0], key };
-      if (next === "key") key = await this.pasteKey();
+      if (next === "unchecked") return { service, reach: reaches[0], key: key2 };
+      if (next === "key") key2 = await this.pasteKey();
     }
   }
   /** Each address of the service in turn: Kimi's .cn, then .ai; an address of one's own, then with /v1 added. */
-  async tryReaches(service, reaches, key) {
+  async tryReaches(service, reaches, key2) {
     let first;
     const candidates = [...reaches];
     for (let index = 0; index < candidates.length; index++) {
       const reach = candidates[index];
       const where = `${this.name(service)}\uFF08${hostOf2(reach.baseUrl)}\uFF09`;
       this.io.say(
-        key ? this.t({
+        key2 ? this.t({
           zh: `\u6B63\u5728\u7528 ${where}\u68C0\u67E5\u5BC6\u94A5\u2026\u2026`,
           en: `Checking the key with ${this.name(service)} (${hostOf2(reach.baseUrl)})\u2026`
         }) : this.t({
@@ -1638,7 +2943,7 @@ var Setup = class {
       const result = await checkKey({
         kind: checkKindOf(service, reach.api),
         baseUrl: reach.baseUrl,
-        key,
+        key: key2,
         fetch: this.deps.fetch,
         timeoutMs: this.deps.timeoutMs ?? CHECK_TIMEOUT_MS
       });
@@ -1686,7 +2991,7 @@ var Setup = class {
     }
   }
   modelsFileWritable() {
-    const path = join3(this.deps.paths.agentDir, "models.json");
+    const path = join8(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`,
@@ -1768,7 +3073,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(join3(this.deps.paths.agentDir, "models.json"));
+    const models = readJsonFile(join8(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;
@@ -1802,10 +3107,23 @@ var Setup = class {
       en: `${existing.name} in ${this.path(paths.envFile)}`
     }) : void 0;
     const choices = [];
+    const mude = this.deps.mude !== void 0;
+    if (mude) {
+      choices.push({
+        label: this.t({
+          zh: "mude 1.0\uFF08\u63A8\u8350\uFF09\uFF0C\u5728\u8FD9\u53F0 Mac \u4E0A\u8FD0\u884C\uFF1Amu \u81EA\u5DF1\u7684\u51B3\u7B56\u6A21\u578B\uFF0C\u5224\u5B9A\u4E0D\u51FA\u672C\u673A\u3002\u4E0B\u8F7D\u4E00\u6B21 1.8 GB\uFF0C\u8FD0\u884C\u65F6\u7EA6\u5360 4 GB \u5185\u5B58\uFF1B\u5B83\u7B54\u4E0D\u4E86\u7684\u4EA4\u7ED9 Jev",
+          en: "mude 1.0 on this Mac (recommended): mu's own decision model, and its verdicts stay on this Mac. A one-time 1.8 GB download; it uses about 4 GB of memory while it runs, and Jev takes what it can't answer"
+        }),
+        value: "mude"
+      });
+    }
     const keyless = !opencode && !where;
     if (keyless) {
       choices.push({
-        label: this.t({
+        label: mude ? this.t({
+          zh: "Jev \u514D\u8D39\u7248\uFF0C\u5728 OpenCode Zen \u4E0A\uFF1A\u4E0D\u7528\u5BC6\u94A5\uFF0C\u9650\u65F6\u514D\u8D39\uFF1B\u4EE5\u540E\u52A0\u4E86\u5BC6\u94A5\u81EA\u52A8\u6362\u7528",
+          en: "Free Jev on OpenCode Zen: no key needed, free for a limited time; a key you add later takes over"
+        }) : this.t({
           zh: "Jev \u514D\u8D39\u7248\uFF08\u63A8\u8350\uFF09\uFF0C\u5728 OpenCode Zen \u4E0A\uFF1A\u4E0D\u7528\u5BC6\u94A5\uFF0C\u9650\u65F6\u514D\u8D39\uFF1B\u4EE5\u540E\u52A0\u4E86\u5BC6\u94A5\u81EA\u52A8\u6362\u7528",
           en: "Free Jev on OpenCode Zen (recommended): no key needed, free for a limited time; a key you add later takes over"
         }),
@@ -1814,7 +3132,10 @@ var Setup = class {
     }
     if (opencode && !where) {
       choices.push({
-        label: this.t({
+        label: mude ? this.t({
+          zh: "Jev\uFF0C\u5728 OpenCode Zen \u4E0A\uFF0C\u7528\u4F60\u7684 OpenCode \u5BC6\u94A5\uFF0C\u6309\u6B21\u8BA1\u8D39",
+          en: "Jev on OpenCode Zen with your OpenCode key, billed per call"
+        }) : this.t({
           zh: "Jev\uFF08\u63A8\u8350\uFF09\uFF0C\u5728 OpenCode Zen \u4E0A\uFF0C\u7528\u4F60\u7684 OpenCode \u5BC6\u94A5\uFF0C\u6309\u6B21\u8BA1\u8D39",
           en: "Jev on OpenCode Zen with your OpenCode key (recommended), billed per call"
         }),
@@ -1823,7 +3144,10 @@ var Setup = class {
     }
     if (where) {
       choices.push({
-        label: this.t({
+        label: mude ? this.t({
+          zh: `Jev\uFF0C\u7528\u5DF2\u7ECF\u8BBE\u7F6E\u7684\u5BC6\u94A5\uFF08${where}\uFF09`,
+          en: `Jev with the key that's already set: ${where}`
+        }) : this.t({
           zh: `Jev\uFF08\u63A8\u8350\uFF09\uFF0C\u7528\u5DF2\u7ECF\u8BBE\u7F6E\u7684\u5BC6\u94A5\uFF08${where}\uFF09`,
           en: `Jev with the key that's already set (recommended): ${where}`
         }),
@@ -1890,11 +3214,22 @@ var Setup = class {
         return { kind: "opencode" };
       case "free":
         return { kind: "free" };
+      case "mude":
+        if (!this.deps.mude) {
+          throw this.fail(
+            {
+              zh: "--judge mude \u9700\u8981 Apple \u82AF\u7247\u7684 Mac\uFF08macOS 14 \u53CA\u4EE5\u4E0A\uFF0C\u5185\u5B58 8 GB \u53CA\u4EE5\u4E0A\uFF09",
+              en: "--judge mude needs a Mac with Apple silicon (macOS 14 or later, 8 GB of memory or more)"
+            },
+            SETUP_EXIT.usage
+          );
+        }
+        return { kind: "mude" };
       case "off":
         return { kind: "none" };
       case "jev": {
-        const key = this.jevFromStdin;
-        if (!key) {
+        const key2 = this.jevFromStdin;
+        if (!key2) {
           if (keySet) return { kind: "keep" };
           throw this.fail(
             {
@@ -1904,20 +3239,20 @@ var Setup = class {
             SETUP_EXIT.usage
           );
         }
-        if (key === this.modelKey) {
+        if (key2 === this.modelKey) {
           throw this.fail(
             { zh: "Jev \u5BC6\u94A5\u548C\u6A21\u578B\u7684\u5BC6\u94A5\u662F\u540C\u4E00\u4E2A", en: "the Jev key is the same as the model key" },
             SETUP_EXIT.usage
           );
         }
         const current = envText === void 0 ? void 0 : envFileValue(envText, "TYPESAFE_API_KEY");
-        if (current && current !== key && !this.args.yes) {
+        if (current && current !== key2 && !this.args.yes) {
           throw this.fail({
             zh: `${this.path(this.deps.paths.envFile)} \u91CC\u5DF2\u7ECF\u6709 TYPESAFE_API_KEY\u3002\u8981\u66FF\u6362\u5B83\uFF0C\u52A0\u4E0A --yes`,
             en: `${this.path(this.deps.paths.envFile)} already has a TYPESAFE_API_KEY. To replace it, add --yes`
           });
         }
-        return { kind: "jev", key };
+        return { kind: "jev", key: key2 };
       }
       case "model":
         return model ? { kind: "model" } : void 0;
@@ -1927,13 +3262,13 @@ var Setup = class {
   }
   async jevKey() {
     for (; ; ) {
-      const key = await this.secret(
+      const key2 = await this.secret(
         this.t({
           zh: "\u7C98\u8D34 Jev \u5BC6\u94A5\uFF08TYPESAFE_API_KEY\uFF0C\u4E0D\u4F1A\u663E\u793A\uFF09\uFF1A",
           en: "Paste the Jev key (TYPESAFE_API_KEY; it won't be shown): "
         })
       );
-      if (key === this.modelKey) {
+      if (key2 === this.modelKey) {
         this.io.say(
           this.t({
             zh: `\u8FD9\u662F\u521A\u624D\u7ED9\u6A21\u578B\u7684\u5BC6\u94A5\u3002Jev \u7684\u5BC6\u94A5\u5728 TypeSafe \u7533\u8BF7\uFF1A${JEV_PAGE}`,
@@ -1942,8 +3277,8 @@ var Setup = class {
         );
         continue;
       }
-      const branded = servicesForKey(key).find((service) => BRANDED.has(service.id));
-      if (!branded) return key;
+      const branded = servicesForKey(key2).find((service) => BRANDED.has(service.id));
+      if (!branded) return key2;
       const anyway = await this.confirm(
         this.t({
           zh: `\u8FD9\u770B\u8D77\u6765\u662F ${this.name(branded)} \u7684\u5BC6\u94A5\uFF0C\u4E0D\u662F Jev \u7684\uFF0C\u5B83\u4F1A\u88AB\u53D1\u7ED9 TypeSafe\u3002\u4ECD\u7136\u4F7F\u7528\u5417\uFF1F[y/N] `,
@@ -1951,7 +3286,7 @@ var Setup = class {
         }),
         false
       );
-      if (anyway) return key;
+      if (anyway) return key2;
     }
   }
   // -----------------------------------------------------------------------------------------------------------
@@ -1963,12 +3298,12 @@ var Setup = class {
     const backups = new Backups(deps.paths.home, deps.now());
     const saved = [];
     const notes = [];
-    const modelsPath = join3(agentDir2, "models.json");
-    const authPath2 = join3(agentDir2, "auth.json");
-    const settingsPath = join3(agentDir2, "settings.json");
+    const modelsPath = join8(agentDir2, "models.json");
+    const authPath2 = join8(agentDir2, "auth.json");
+    const settingsPath = join8(agentDir2, "settings.json");
     try {
       if (target && model) {
-        const { service, reach, key } = target;
+        const { service, reach, key: key2 } = target;
         const provider = reach.provider;
         const custom = !reach.builtIn;
         const moved = reach.builtIn && this.args.baseUrl !== void 0;
@@ -1983,7 +3318,7 @@ var Setup = class {
               baseUrl: reach.baseUrl,
               api: reach.api,
               // pi counts a provider without a key as unusable: a keyless service gets a placeholder, never a real key.
-              apiKey: service.keyless ? "ollama" : key ? void 0 : "none",
+              apiKey: service.keyless ? "ollama" : key2 ? void 0 : "none",
               compat: service.compat,
               // What the service lists goes into /model, the one to start with first.
               models: [model, ...chatModels(target.listed ?? []).filter((id) => id !== model)].map((id) => ({
@@ -2009,9 +3344,9 @@ var Setup = class {
             )
           );
         }
-        if (key) {
+        if (key2) {
           backups.save(authPath2);
-          await deps.pi.storeKey(provider, key);
+          await deps.pi.storeKey(provider, key2);
           saved.push(
             this.savedLine(
               authPath2,
@@ -2107,7 +3442,7 @@ var Setup = class {
     if (judge.kind === "model") {
       if (target && model) tiers = [`llm:${target.reach.provider}/${model}`];
     } else if (judge.kind === "opencode") tiers = ["jev-opencode"];
-    else if (judge.kind === "free") {
+    else if (judge.kind === "free" || judge.kind === "mude") {
       if (!tiersOf(current).some((tier) => tier === "jev" || tier === "jev-opencode-free")) tiers = ["jev"];
     } else if (!tiersOf(current).some((tier) => JEV_TIERS.has(tier))) tiers = ["jev"];
     const turnOn = judgeOff(current);
@@ -2160,7 +3495,10 @@ var Setup = class {
       zh: `\u5B8C\u6210\u3002mu \u4F1A\u7528 ${this.name(target.service)} \xB7 ${model} \u5F00\u59CB\u5DE5\u4F5C\u3002`,
       en: `Done. mu will start on ${this.name(target.service)} \xB7 ${model}.`
     }) : this.t({ zh: "\u5B8C\u6210\u3002", en: "Done." });
-    const judged = judge === void 0 ? "" : judge.kind === "model" ? this.t({ zh: "\u5224\u5B9A\u5668\uFF1A\u540C\u4E00\u4E2A\u6A21\u578B\u3002", en: " Judge: the same model." }) : judge.kind === "none" ? this.t({ zh: "\u5224\u5B9A\u5668\uFF1A\u6682\u65F6\u6CA1\u6709\u3002", en: " Judge: none for now." }) : judge.kind === "opencode" ? this.t({ zh: "\u5224\u5B9A\u5668\uFF1AOpenCode Zen \u4E0A\u7684 Jev\u3002", en: " Judge: Jev on OpenCode Zen." }) : judge.kind === "free" ? this.t({
+    const judged = judge === void 0 ? "" : judge.kind === "model" ? this.t({ zh: "\u5224\u5B9A\u5668\uFF1A\u540C\u4E00\u4E2A\u6A21\u578B\u3002", en: " Judge: the same model." }) : judge.kind === "none" ? this.t({ zh: "\u5224\u5B9A\u5668\uFF1A\u6682\u65F6\u6CA1\u6709\u3002", en: " Judge: none for now." }) : judge.kind === "opencode" ? this.t({ zh: "\u5224\u5B9A\u5668\uFF1AOpenCode Zen \u4E0A\u7684 Jev\u3002", en: " Judge: Jev on OpenCode Zen." }) : judge.kind === "mude" ? this.t({
+      zh: "\u5224\u5B9A\u5668\uFF1Amude 1.0\uFF0C\u4E0B\u9762\u63A5\u7740\u5B89\u88C5\uFF1B\u5B83\u7B54\u4E0D\u4E86\u7684\u4EA4\u7ED9 Jev\u3002",
+      en: " Judge: mude 1.0, installed next, with Jev for what it can't answer."
+    }) : judge.kind === "free" ? this.t({
       zh: "\u5224\u5B9A\u5668\uFF1AJev\uFF0C\u52A0\u5BC6\u94A5\u4E4B\u524D\u7528 OpenCode Zen \u4E0A\u9650\u65F6\u514D\u8D39\u7684\u7248\u672C\u3002",
       en: " Judge: Jev, using the free version on OpenCode Zen until you add a key."
     }) : this.t({ zh: "\u5224\u5B9A\u5668\uFF1AJev\u3002", en: " Judge: Jev." });
@@ -2180,8 +3518,8 @@ var Setup = class {
   async offerSession(signIn = false) {
     if (this.scripted) return SETUP_EXIT.done;
     if (this.args.firstRun) return signIn ? SETUP_EXIT.signIn : SETUP_EXIT.done;
-    const start = await this.confirm(this.t({ zh: "\u73B0\u5728\u542F\u52A8 mu \u5417\uFF1F[Y/n] ", en: "Start mu now? [Y/n] " }), true);
-    if (!start) return SETUP_EXIT.done;
+    const start2 = await this.confirm(this.t({ zh: "\u73B0\u5728\u542F\u52A8 mu \u5417\uFF1F[Y/n] ", en: "Start mu now? [Y/n] " }), true);
+    if (!start2) return SETUP_EXIT.done;
     return signIn ? SETUP_EXIT.signIn : SETUP_EXIT.start;
   }
 };
@@ -2211,10 +3549,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") || join4(home, "agent");
-var envFile = process.env.MU_SETUP_ENV_FILE || join4(home, ".env");
-var authPath = join4(agentDir, "auth.json");
-var modelsStorePath = join4(agentDir, "models-store.json");
+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 givenEnv = { ...process.env };
 var PROXY_VARIABLES = ["HTTPS_PROXY", "https_proxy", "HTTP_PROXY", "http_proxy"];
 function useSessionProxy() {
@@ -2234,11 +3572,11 @@ function useSessionProxy() {
   if (named2) return named2 in givenEnv ? named2 : `${named2}, .env`;
   return fromSettings ? "httpProxy, settings.json" : void 0;
 }
-async function main() {
+async function main2() {
   const proxy = useSessionProxy();
   const runtime = await ModelRuntime.create({
     authPath,
-    modelsPath: join4(agentDir, "models.json"),
+    modelsPath: join9(agentDir, "models.json"),
     modelsStorePath,
     refreshOnCreate: false
   });
@@ -2255,7 +3593,16 @@ async function main() {
     stdinTerminal: process.stdin.isTTY === true,
     readStdin: () => readAll(),
     givenKey,
-    proxy
+    proxy,
+    // mude 1.0 where this Mac can run it: `mu judge mude install`, here, its progress in this terminal.
+    mude: problems().length === 0 ? {
+      install: () => main(
+        ["install"],
+        contextFromEnv(process.env),
+        (text) => process.stdout.write(text),
+        process.stdout.isTTY === true
+      )
+    } : void 0
   });
 }
 var leaving = false;
@@ -2266,8 +3613,8 @@ var leave = (code) => {
   void exitWhenUnlocked(code, [authPath, modelsStorePath], (exitCode) => process.exit(exitCode));
 };
 for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"])
-  process.on(signal, () => leave(128 + constants.signals[signal]));
-main().then(leave, (error) => {
+  process.on(signal, () => leave(128 + constants2.signals[signal]));
+main2().then(leave, (error) => {
   const message = error instanceof Error ? error.message : String(error);
   process.stderr.write(`mu setup: ${redactSecrets(message, givenKey ? [givenKey] : [])}
 `);