mu-agent 0.1.13 → 0.2.0

package/judge/dist/mude.js

@@ -0,0 +1,1338 @@
+import { createRequire as __muCreateRequire } from "node:module"; const require = __muCreateRequire(import.meta.url);
+
+// packages/kyrn-judge/src/mude/command.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync4, statfsSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { homedir as homedir3, release, totalmem as totalmem2 } from "node:os";
+import { join as join6 } 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
+var CONFIG_FILE = "mu.json";
+var LEGACY_CONFIG_FILE = "kyrn.json";
+
+// 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*(.*)$/;
+function closingQuote(text, quote) {
+  for (let index = 0; index < text.length; index++) {
+    if (quote === '"' && text[index] === "\\") index++;
+    else if (text[index] === quote) return index;
+  }
+  return -1;
+}
+function readEnvEntries(text) {
+  const entries = [];
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index].trim();
+    if (!line || line.startsWith("#")) continue;
+    const match = DEFINITION.exec(line);
+    if (!match) continue;
+    const [, name, rest] = match;
+    const quote = rest[0];
+    if (quote !== '"' && quote !== "'") {
+      entries.push({ name, value: rest.replace(/\s+#.*$/, "").trim(), first: index, last: index });
+      continue;
+    }
+    let body = rest.slice(1);
+    let end = closingQuote(body, quote);
+    const startedAt = index;
+    while (end < 0 && index + 1 < lines.length) {
+      body += `
+${lines[++index]}`;
+      end = closingQuote(body, quote);
+    }
+    if (end < 0) {
+      index = startedAt;
+      continue;
+    }
+    const value = body.slice(0, end);
+    entries.push({
+      name,
+      value: quote === '"' ? value.replace(/\\(["\\$`])/g, "$1") : value,
+      first: startedAt,
+      last: index
+    });
+  }
+  return entries;
+}
+function envFileValue(text, name) {
+  return readEnvEntries(text).find((entry) => entry.name === name)?.value;
+}
+function formatEnvValue(value) {
+  if (/^[A-Za-z0-9_./:@+-]*$/.test(value)) return value;
+  if (!value.includes("'")) return `'${value}'`;
+  return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function setEnvValue(text, name, value) {
+  const newline = text.includes("\r\n") ? "\r\n" : "\n";
+  const bom = text.startsWith("\uFEFF") ? "\uFEFF" : "";
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
+  const found = readEnvEntries(text).filter((entry) => entry.name === name);
+  const assignment = (exported2) => `${exported2 ? "export " : ""}${name}=${formatEnvValue(value)}`;
+  if (found.length === 0) {
+    const body = lines.join(newline);
+    const separator = body === "" || body.endsWith(newline) ? "" : newline;
+    return `${bom}${body}${separator}${assignment(false)}${newline}`;
+  }
+  const drop = /* @__PURE__ */ new Set();
+  for (const entry of found.slice(1)) for (let line = entry.first; line <= entry.last; line++) drop.add(line);
+  const [first] = found;
+  const exported = /^\s*export\s/.test(lines[first.first]);
+  const next = [];
+  for (let index = 0; index < lines.length; index++) {
+    if (drop.has(index)) continue;
+    if (index === first.first) next.push(assignment(exported));
+    else if (index > first.first && index <= first.last) continue;
+    else next.push(lines[index]);
+  }
+  return `${bom}${next.join(newline)}`;
+}
+
+// packages/kyrn-judge/src/setup/files.ts
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
+var PRIVATE_FILE = 384;
+var PRIVATE_FOLDER = 448;
+function backupStamp(now) {
+  const two = (value) => String(value).padStart(2, "0");
+  return `${now.getFullYear()}-${two(now.getMonth() + 1)}-${two(now.getDate())}T${two(now.getHours())}-${two(now.getMinutes())}-${two(now.getSeconds())}`;
+}
+var holdsNothing = (file) => {
+  try {
+    return /^\s*(\{\s*\})?\s*$/.test(readFileSync(file, "utf8"));
+  } catch {
+    return false;
+  }
+};
+var Backups = class {
+  root;
+  stamp;
+  made;
+  saved = /* @__PURE__ */ new Set();
+  constructor(home, now) {
+    this.root = join(home, "backups");
+    this.stamp = backupStamp(now);
+  }
+  /**
+   * Copies `file` the first time it is about to change in this run. A file that does not exist, or holds nothing (empty,
+   * or the `{}` pi writes to auth.json when it first starts), has nothing to keep: a first setup makes no backup folder
+   * and does not say it kept the previous files.
+   */
+  save(file) {
+    if (this.saved.has(file) || !existsSync(file) || holdsNothing(file)) return;
+    const folder = this.folder();
+    const copy = join(folder, basename(file));
+    copyFileSync(file, copy);
+    try {
+      chmodSync(copy, PRIVATE_FILE);
+    } catch {
+    }
+    this.saved.add(file);
+  }
+  /** Where this run's copies are, once one was made. */
+  get path() {
+    return this.made;
+  }
+  folder() {
+    if (this.made) return this.made;
+    mkdirSync(this.root, { recursive: true, mode: PRIVATE_FOLDER });
+    for (let attempt = 1; ; attempt++) {
+      const candidate = join(this.root, attempt === 1 ? this.stamp : `${this.stamp}-${attempt}`);
+      try {
+        mkdirSync(candidate, { mode: PRIVATE_FOLDER });
+        this.made = candidate;
+        return candidate;
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+      }
+    }
+  }
+};
+function readJsonFile(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return { state: "absent" };
+    return { state: "unreadable" };
+  }
+  if (!text.trim()) return { state: "ok", value: {} };
+  try {
+    const value = JSON.parse(text.replace(/^/, ""));
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? { state: "ok", value } : { state: "unreadable" };
+  } catch {
+    return { state: "unreadable" };
+  }
+}
+function writeFileAtomic(path, text) {
+  mkdirSync(dirname(path), { recursive: true });
+  let mode = PRIVATE_FILE;
+  try {
+    mode = statSync(path).mode & 511;
+  } catch {
+  }
+  const temporary = `${path}.mu-setup-${process.pid}`;
+  writeFileSync(temporary, text, { mode });
+  try {
+    chmodSync(temporary, mode);
+    renameSync(temporary, path);
+  } catch (error) {
+    try {
+      unlinkSync(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+function writeJsonFile(path, value) {
+  writeFileAtomic(path, `${JSON.stringify(value, null, 2)}
+`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function judgeConfigPath(agentDir, exists = existsSync) {
+  const current = join(agentDir, CONFIG_FILE);
+  const legacy = join(agentDir, LEGACY_CONFIG_FILE);
+  return !exists(current) && exists(legacy) ? legacy : current;
+}
+function tiersOf(config) {
+  const tiers = config?.tiers;
+  const named = Array.isArray(tiers) ? tiers.filter((tier) => typeof tier === "string") : [];
+  return named.length > 0 ? named : ["jev"];
+}
+function withTiers(config, tiers) {
+  return { ...config, tiers: [...tiers] };
+}
+function judgeOff(config) {
+  return isRecord(config?.modes) && config.modes.default === "off";
+}
+function withJudge(config, on) {
+  const { default: _default, ...modes } = isRecord(config.modes) ? config.modes : {};
+  if (!on) return { ...config, modes: { default: "off", ...modes } };
+  if (!judgeOff(config)) return config;
+  const { modes: _modes, ...rest } = config;
+  return Object.keys(modes).length > 0 ? { ...rest, modes } : rest;
+}
+function readTextFile(path) {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+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 existsSync2, mkdirSync as mkdirSync2, 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 join2 } 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((resolve) => {
+    const probe = createServer();
+    probe.once("error", () => resolve(false));
+    probe.listen({ port: port2, host: "127.0.0.1", exclusive: true }, () => probe.close(() => resolve(true)));
+  });
+}
+async function choosePort(preferred = DEFAULT_PORT) {
+  if (await portFree(preferred)) return preferred;
+  return new Promise((resolve, 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(() => resolve(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 "";
+  }
+}
+async function startServer(paths, options) {
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, 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, sleep);
+    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`
+    );
+  }
+  mkdirSync2(paths.root, { recursive: true });
+  rmSync(paths.log, { force: true });
+  const log = openSync(paths.log, "a", 384);
+  const child = spawn(
+    paths.python,
+    [
+      join2(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) await untilReady(paths, pid, options.port, timeoutMs, sleep);
+  return { pid, port: options.port, already: false };
+}
+async function untilReady(paths, pid, port2, timeoutMs, sleep) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    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 sleep(500);
+  }
+  throw new Error(`mude's server did not answer within ${Math.round(timeoutMs / 1e3)} s; see ${paths.log}`);
+}
+async function stopServer(paths, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, 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 sleep(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,
+  createWriteStream,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync4,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync3,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+function huggingFaceToken(env = process.env, home = homedir()) {
+  const direct = env.HF_TOKEN?.trim();
+  if (direct) return direct;
+  const files = [
+    env.HF_TOKEN_PATH,
+    env.HF_HOME ? join3(env.HF_HOME, "token") : void 0,
+    join3(env.XDG_CACHE_HOME || join3(home, ".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(join3(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(join3(dir, file.path));
+    return stats.size === file.size && stats.mtimeMs === seen.mtimeMs;
+  } catch {
+    return false;
+  }
+}
+function remember(dir, verified, file) {
+  const stats = statSync3(join3(dir, file.path));
+  verified[file.path] = { size: stats.size, mtimeMs: stats.mtimeMs, sha256: file.sha256 };
+  writeFileSync4(join3(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 = join3(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);
+  mkdirSync3(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 = join3(dir, file.path);
+    mkdirSync3(dirname2(target), { recursive: true });
+    if (existsSync3(target) && statSync3(target).size === file.size) {
+      options.onProgress?.({ file: file.path, checking: true, done: settled, total });
+      if (await sha256File(target) === file.sha256) {
+        remember(dir, verified, file);
+        settled += file.size;
+        continue;
+      }
+      rmSync2(target, { force: true });
+    }
+    await fetchFile(
+      options,
+      file,
+      target,
+      (bytes) => options.onProgress?.({ file: file.path, checking: false, done: settled + bytes, total })
+    );
+    options.onProgress?.({ file: file.path, checking: true, done: settled + file.size, total });
+    const part = `${target}.part`;
+    const actual = await sha256File(part);
+    if (actual !== file.sha256) {
+      rmSync2(part, { force: true });
+      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);
+    remember(dir, verified, file);
+    settled += file.size;
+  }
+  options.onProgress?.({ file: "", checking: false, done: total, total });
+}
+async function fetchFile(options, file, target, onBytes) {
+  const part = `${target}.part`;
+  const attempts = options.attempts ?? 4;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    if (options.signal?.aborted) throw new DownloadError("The download was stopped", "aborted");
+    try {
+      await fetchOnce(options, file, part, onBytes);
+      return;
+    } catch (error) {
+      if (error instanceof DownloadError && error.kind !== "network") throw error;
+      lastError = error;
+      if (attempt < attempts) await sleep([2e3, 5e3, 1e4][attempt - 1] ?? 1e4);
+    }
+  }
+  const reason = lastError instanceof Error ? lastError.message : String(lastError);
+  throw new DownloadError(
+    `${file.path} could not be downloaded (${reason}); run the install again to go on from here`,
+    "network"
+  );
+}
+async function fetchOnce(options, file, part, onBytes) {
+  let have = 0;
+  try {
+    have = statSync3(part).size;
+  } catch {
+  }
+  if (have > file.size) {
+    rmSync2(part, { force: true });
+    have = 0;
+  }
+  if (have === file.size) return;
+  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 });
+  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 answered ${response.status} for ${file.path}: the model is not public yet, or this machine's token cannot read it`,
+        "access"
+      );
+    }
+    if (response.status === 416 && have > 0) {
+      return;
+    }
+    if (!response.ok || !response.body) throw new Error(`HTTP ${response.status}`);
+    const resumed = response.status === 206;
+    if (!resumed) have = 0;
+    const out = createWriteStream(part, { flags: resumed ? "a" : "w" });
+    let received = have;
+    onBytes(received);
+    const body = Readable.fromWeb(response.body);
+    body.on("data", (chunk) => {
+      received += chunk.length;
+      clearTimeout(stall);
+      stall = setTimeout(() => controller.abort(new Error(`no data for ${stallMs / 1e3} s`)), stallMs);
+      onBytes(received);
+    });
+    await pipeline(body, out);
+    if (received !== file.size) throw new Error(`got ${received} of ${file.size} bytes`);
+  } catch (error) {
+    if (options.signal?.aborted) throw new DownloadError("The download was stopped", "aborted");
+    throw error;
+  } finally {
+    clearTimeout(stall);
+    options.signal?.removeEventListener("abort", onAbort);
+  }
+}
+
+// packages/kyrn-judge/src/mude/paths.ts
+import { join as join4 } from "node:path";
+function mudePaths(muHome) {
+  const root = join4(muHome, "local-judge", "mude");
+  const model = join4(root, "model", MUDE_REVISION);
+  const venv = join4(root, "venv");
+  return {
+    root,
+    model,
+    verified: join4(model, ".mu-verified.json"),
+    venv,
+    python: join4(venv, "bin", "python"),
+    venvLock: join4(venv, ".mu-lock-sha256"),
+    tools: join4(root, "tools"),
+    key: join4(root, "key"),
+    pid: join4(root, "server.pid"),
+    log: join4(root, "server.log"),
+    state: join4(root, "state.json")
+  };
+}
+
+// packages/kyrn-judge/src/mude/python.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { accessSync, constants, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { delimiter, join as join5 } 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, home = homedir2()) {
+  const dirs = [
+    ...(env.PATH ?? "").split(delimiter),
+    join5(home, ".local", "bin"),
+    join5(home, ".cargo", "bin"),
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    paths.tools
+  ];
+  for (const dir of dirs) {
+    if (dir && executable(join5(dir, "uv"))) return join5(dir, "uv");
+  }
+  return void 0;
+}
+function run(command, args, options = {}) {
+  return new Promise((resolve) => {
+    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) => resolve({ code: null, output: error.message }));
+    child.once("close", (code) => {
+      if (pending.trim()) lines.push(pending);
+      resolve({ code, output: lines.slice(-12).join("\n") });
+    });
+  });
+}
+async function downloadUv(paths, options = {}) {
+  mkdirSync4(paths.tools, { recursive: true });
+  const archive = "uv.tar.gz";
+  options.onLine?.(`Downloading uv ${UV_RELEASE.version}`);
+  const response = await (options.fetch ?? fetch)(UV_RELEASE.url, { redirect: "follow" });
+  if (!response.ok) throw new Error(`uv could not be downloaded: HTTP ${response.status}`);
+  const bytes = Buffer.from(await response.arrayBuffer());
+  const actual = createHash2("sha256").update(bytes).digest("hex");
+  if (actual !== UV_RELEASE.sha256)
+    throw new Error("The downloaded uv does not match its pinned sha256; nothing was installed");
+  writeFileSync5(join5(paths.tools, archive), bytes);
+  const unpacked = await run("/usr/bin/tar", [
+    "-xzf",
+    join5(paths.tools, archive),
+    "-C",
+    paths.tools,
+    "--strip-components",
+    "1"
+  ]);
+  rmSync3(join5(paths.tools, archive), { force: true });
+  if (unpacked.code !== 0 || !executable(join5(paths.tools, "uv")))
+    throw new Error(`uv could not be unpacked: ${unpacked.output}`);
+  return join5(paths.tools, "uv");
+}
+function lockDigest(lockFile) {
+  return createHash2("sha256").update(readFileSync5(lockFile)).digest("hex");
+}
+function venvReady(paths, lockFile) {
+  if (!existsSync4(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(`The Python environment could not be made (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(`mude's Python packages could not be installed (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
+  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) => 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 goes on from there` : "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 (!existsSync5(dir)) {
+    const parent = join6(dir, "..");
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+  try {
+    const stats = statfsSync(dir);
+    return stats.bavail * stats.bsize;
+  } catch {
+    return void 0;
+  }
+}
+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 {
+  }
+  mkdirSync5(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 free = freeBytes(ctx.paths.root);
+    if (free !== void 0 && free < need + 2e9) {
+      throw new Error(
+        `Not enough free disk space: mude 1.0 needs about ${((need + 2e9) / 1e9).toFixed(1)} GB, and ${(free / 1e9).toFixed(1)} GB are free`
+      );
+    }
+    out.step(
+      "download",
+      `Downloading mude 1.0 (${MUDE_REPO}, ${(need / 1e9).toFixed(1)} GB) and checking every file`
+    );
+    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)
+    });
+  }
+  if (!venvReady(ctx.paths, ctx.lockFile)) {
+    out.step("python", "Setting up the Python environment for mude 1.0 (MLX, transformers; about 1 GB, once)");
+    let uv = findUv(ctx.paths, ctx.env);
+    if (!uv) uv = await downloadUv(ctx.paths, { onLine: (line) => out.line(line) });
+    await ensureVenv(ctx.paths, ctx.lockFile, uv, { onLine: (line) => out.line(line), env: ctx.env });
+  }
+}
+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, wait = 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)`
+  );
+  await startServer(ctx.paths, { port: at, key: key(ctx), wait });
+  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": {
+        await ensureInstalled(ctx, out);
+        const at = await start(ctx, out);
+        enable(ctx, out, at, flag("--local-only"));
+        break;
+      }
+      case "enable": {
+        requireInstalled(ctx);
+        const current = judgeSetting(ctx.files);
+        const localOnly = flag("--local-only") ? true : flag("--with-fallback") ? false : current.enabled && current.localOnly;
+        const at = await start(ctx, out);
+        enable(ctx, out, at, localOnly);
+        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, !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, home = homedir3()) {
+  const muHome = env.MU_MUDE_HOME || join6(home, ".mu");
+  const agentDir = env.MU_AGENT_DIR || join6(muHome, "agent");
+  return {
+    paths: mudePaths(muHome),
+    files: { agentDir, home: muHome, envFile: env.MU_MUDE_ENV_FILE || join6(muHome, ".env") },
+    lockFile: env.MU_MUDE_LOCK || join6(import.meta.dirname, "..", "..", "..", "..", "kyrn", "local-judge", "mude-requirements.lock.txt"),
+    env
+  };
+}
+
+// packages/kyrn-judge/src/mude/cli.ts
+main(process.argv.slice(2), contextFromEnv(), (text) => process.stdout.write(text), Boolean(process.stdout.isTTY)).then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (error) => {
+    process.stderr.write(`mu judge mude: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  }
+);