mu-agent 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-10-24
+
+**0.2.2 makes `mu judge mude install` cope with a full disk, a stop at any step and two installs at once.**
+
+### Changed
+
+- English pass on the strings added since 0.1.10, against `docs/writing-style.md`: `mu judge mude` messages say how to resume ("Run mu judge mude install to resume"); errors say what happened and what to do next ("Couldn't create the Python environment (uv venv)", "Hugging Face returned 404 for …", the disk-space error); the kernel's settings descriptions read naturally (their translations kept); `mu --help` describes `mu judge mude install` as "install mude 1.0, mu's own decision model for coding, and make it the judge on this Mac".
+
+### Fixed
+
+- `mu judge mude install`: Ctrl-C (or SIGTERM) during the wait between tries after a dropped connection now stops the download at once. It prints "Stopped with X of 1.8 GB downloaded. Run mu judge mude install to resume". Before, the wait (up to 30 s) ran on, and the command ended 5 s later with no message. What was downloaded was kept either way.
+- `mu judge mude install`, disk space and stops:
+  - A full disk (ENOSPC or EDQUOT) during the download now ends the install at once with "The disk is full: couldn't write <file>. Free up some space, then run mu judge mude install to resume". Before, it was retried as a network error for about two minutes, and the desktop app said it couldn't reach Hugging Face.
+  - The free-space check before a download counts only the bytes still to come. Before, it counted the whole of every unfinished file, even when most of it was on the disk already.
+  - Ctrl-C (or SIGTERM) while the Python environment is being set up now says "Stopped while setting up the Python environment. Run mu judge mude install to resume", instead of "mude's Python packages could not be installed".
+- `mu judge mude install` on a Mac without uv: downloading the pinned uv (about 20 MB, from GitHub) had no time limit and ignored a stop. It now ends after 5 minutes with "uv could not be downloaded from GitHub (no answer in 300 s): run mu judge mude install again", and Ctrl-C or the app's Cancel ends it at once ("Stopped while setting up the Python environment").
+- `mu judge mude install` (also from `mu setup` and the desktop app) takes `local-judge/mude/install.lock`. A second install while one runs now stops at once with "Another mude 1.0 install is running (process N). Wait for it to finish, or stop it, then run mu judge mude install again". Before, both downloaded into the same `.part` files, and the second failed with `ENOENT … .part` when the first renamed a finished file. The lock records the process's pid and start time, so a lock left by a power cut or a kill is taken over, even if the pid has since been reused.
+- `mu judge mude install`, `enable` and `start`: a stop (Ctrl-C, or SIGTERM from the app's Cancel) while waiting for the server's `/health` now ends the wait at once. It also stops the server if this command started it, with "Stopped while the mude 1.0 server was starting, and stopped the server too. Run mu judge mude install again to finish". Before, the wait ran on until the CLI's 5 s exit timer, with no message. The server is started `detached`, so it survived both that exit and the app's process-group kill, and kept about 4 GB of memory while mude was not the judge. A server that was already running before the command is left running: "Stopped waiting for the mude 1.0 server, which is still starting…".
+
+## [0.2.1] - 2026-10-24
+
+**0.2.1 makes mude 1.0 the recommended judge on a Mac, set up from `mu setup`, and its install survives a power cut.**
+
+### Added
+
+- `mu setup` offers mude 1.0 in its judge step on a Mac that can run it (Apple silicon, macOS 14 or later, 8 GB of memory or more). It is the first choice and the recommended one, so pressing Enter picks it; the Jev that was recommended before follows it and stays a choice. Picking it writes Jev as the judge, then installs mude 1.0 in front of it in the same terminal, with its progress. If the install doesn't finish, Jev stays the judge and `mu judge mude install` goes on from where it stopped. Scripts use `--judge mude`. On other machines the judge step is as before: free Jev is first and recommended.
+
+### Fixed
+
+- `mu judge mude install` survives a power cut in the middle of the download. Every 32 MiB the partly downloaded file is synced to the disk and the amount on disk is recorded in `<file>.part.saved`. The next install goes on from there, so it never builds on an end the disk didn't keep. A part left by mu 0.2.0, which has no record, goes on from 32 MiB before its end.
+- A resumed file that fails its sha256 check is downloaded once more from the start, instead of ending the install.
+- The download rides out a lost connection: a try that gets some of the file starts the count of failed tries again. Tries that get nothing wait 2, 5, 10, 20 and then 30 s, about two minutes in all, before the install stops.
+- Ctrl-C, or the desktop app ending an install, stops the download where it is, keeps what it got and says how much: "Stopped with 0.9 of 1.8 GB downloaded: mu judge mude install goes on from there". An install that goes on says how much is already there.
+- An install that goes on from one that stopped keeps that one's `--local-only`: it is recorded in `install.json` until the install finishes. Before, running it again without the flag left the hosted judges behind mude.
+
 ## [0.2.0] - 2026-10-23
 
 **0.2.0 starts the era of mu's own models: `mu judge mude install` turns on mude 1.0 in one command.**

package/judge/dist/mude.js

@@ -92,21 +92,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
     });
   }
@@ -409,12 +409,21 @@ function tail(file, lines = 12) {
     return "";
   }
 }
+var StartStopped = class extends Error {
+  /** Whether the server went too: one this call started does, one that was running before does not. */
+  serverStopped;
+  constructor(serverStopped = false) {
+    super("Stopped while the mude 1.0 server was starting");
+    this.name = "StartStopped";
+    this.serverStopped = serverStopped;
+  }
+};
 async function startServer(paths, options) {
   const 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);
+    if (options.wait !== false) await untilReady(paths, running, options.port, timeoutMs, sleep, options.signal);
     return { pid: running, port: options.port, already: true };
   }
   if (!await portFree(options.port)) {
@@ -463,12 +472,21 @@ async function startServer(paths, options) {
   child.unref();
   writeFileSync2(paths.pid, `${pid}
 `, { mode: 384 });
-  if (options.wait !== false) await untilReady(paths, pid, options.port, timeoutMs, sleep);
+  if (options.wait !== false) {
+    try {
+      await untilReady(paths, pid, options.port, timeoutMs, sleep, 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, sleep) {
+async function untilReady(paths, pid, port2, timeoutMs, sleep, 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 });
@@ -641,19 +659,22 @@ function readText(path) {
 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,
+  truncateSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
+import { open } from "node:fs/promises";
 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";
+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, home = homedir()) {
   const direct = env.HF_TOKEN?.trim();
   if (direct) return direct;
@@ -755,66 +776,100 @@ async function downloadFiles(options) {
       }
       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);
+    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) {
-      rmSync2(part, { force: true });
+      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 });
 }
-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)));
+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 sleep = options.sleep ?? ((ms) => wait(ms, void 0, { signal: options.signal }).catch(() => {
+  }));
+  let resumed = false;
+  let failures = 0;
   let lastError;
-  for (let attempt = 1; attempt <= attempts; attempt++) {
+  for (; ; ) {
     if (options.signal?.aborted) throw new DownloadError("The download was stopped", "aborted");
+    const before = resumeFrom(part, file.size, options.checkpointBytes);
     try {
-      await fetchOnce(options, file, part, onBytes);
-      return;
+      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;
-      if (attempt < attempts) await sleep([2e3, 5e3, 1e4][attempt - 1] ?? 1e4);
+      failures = resumeFrom(part, file.size, options.checkpointBytes) > before ? 1 : failures + 1;
+      if (failures >= attempts) break;
+      await sleep(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 the install again to go on from here`,
+    `${file.path} could not be downloaded (${reason}). Run mu judge mude install again to resume`,
     "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;
+  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;
   }
-  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 });
+  let handle;
+  let written = 0;
+  let synced = 0;
   try {
     const headers = {};
     if (have > 0) headers.Range = `bytes=${have}-`;
@@ -826,34 +881,56 @@ async function fetchOnce(options, file, part, onBytes) {
     });
     if (response.status === 401 || response.status === 403 || response.status === 404) {
       throw new DownloadError(
-        `Hugging Face answered ${response.status} for ${file.path}: the model is not public yet, or this machine's token cannot read it`,
+        `Hugging Face returned ${response.status} for ${file.path}: the model isn't public yet, or this machine's token can't access it`,
         "access"
       );
     }
-    if (response.status === 416 && have > 0) {
-      return;
+    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;
+    const resumed = response.status === 206 && have > 0;
     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;
+    mkdirSync3(dirname2(part), { recursive: true });
+    handle = await open(part, existsSync3(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);
-      onBytes(received);
-    });
-    await pipeline(body, out);
-    if (received !== file.size) throw new Error(`got ${received} of ${file.size} bytes`);
+      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();
+    }
   }
 }
 
@@ -874,7 +951,9 @@ function mudePaths(muHome) {
     key: join4(root, "key"),
     pid: join4(root, "server.pid"),
     log: join4(root, "server.log"),
-    state: join4(root, "state.json")
+    state: join4(root, "state.json"),
+    install: join4(root, "install.json"),
+    installLock: join4(root, "install.lock")
   };
 }
 
@@ -941,9 +1020,20 @@ 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 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");
@@ -958,7 +1048,7 @@ async function downloadUv(paths, options = {}) {
   ]);
   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}`);
+    throw new Error(`Couldn't unpack uv: ${unpacked.output}`);
   return join5(paths.tools, "uv");
 }
 function lockDigest(lockFile) {
@@ -980,7 +1070,7 @@ async function ensureVenv(paths, lockFile, uv, options = {}) {
     env,
     onLine: options.onLine
   });
-  if (made.code !== 0) throw new Error(`The Python environment could not be made (uv venv):
+  if (made.code !== 0) throw new Error(`Couldn't create the Python environment (uv venv):
 ${made.output}`);
   const installed2 = await run(
     uv,
@@ -999,7 +1089,7 @@ ${made.output}`);
     { env, onLine: options.onLine }
   );
   if (installed2.code !== 0)
-    throw new Error(`mude's Python packages could not be installed (uv pip install):
+    throw new Error(`Couldn't install mude's Python packages (uv pip install):
 ${installed2.output}`);
   writeFileSync5(paths.venvLock, `${lockDigest(lockFile)}
 `);
@@ -1009,7 +1099,8 @@ ${installed2.output}`);
 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 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
@@ -1063,8 +1154,12 @@ function humanOut(write, tty) {
     line: (text) => write(`  ${text}
 `),
     status: (status2) => write(describe(status2)),
-    error: (message) => write(`${message}
-`)
+    error: (message) => {
+      if (shown >= 0 && tty) write("\n");
+      shown = -1;
+      write(`${message}
+`);
+    }
   };
 }
 function describe(status2) {
@@ -1075,7 +1170,7 @@ function describe(status2) {
 `;
   }
   lines.push(
-    `model     ${status2.installed ? `installed (${MUDE_REPO} @ ${MUDE_REVISION.slice(0, 7)})` : status2.downloadedBytes > 0 ? `partly downloaded (${(status2.downloadedBytes / 1e9).toFixed(1)} of ${(MUDE_BYTES / 1e9).toFixed(1)} GB): mu judge mude install goes on from there` : "not installed: mu judge mude install"}`
+    `model     ${status2.installed ? `installed (${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(
@@ -1129,6 +1224,52 @@ function freeBytes(path) {
     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) {
+  mkdirSync5(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;
 }
@@ -1180,29 +1321,52 @@ 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);
-    if (free !== void 0 && free < need + 2e9) {
+    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 ${((need + 2e9) / 1e9).toFixed(1)} GB, and ${(free / 1e9).toFixed(1)} GB are free`
+        `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",
-      `Downloading mude 1.0 (${MUDE_REPO}, ${(need / 1e9).toFixed(1)} GB) and checking every file`
+      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`
     );
-    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)
-    });
+    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)");
-    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 });
+    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) {
@@ -1210,13 +1374,23 @@ function requireInstalled(ctx) {
     throw new Error("mude 1.0 is not installed here yet: mu judge mude install");
   }
 }
-async function start(ctx, out, wait = true) {
+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)`
   );
-  await startServer(ctx.paths, { port: at, key: key(ctx), wait });
+  try {
+    await startServer(ctx.paths, { port: at, key: key(ctx), wait: wait2, signal: ctx.signal });
+  } 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) {
@@ -1253,16 +1427,25 @@ async function main(argv, ctx, write, tty = false) {
     }
     switch (command) {
       case "install": {
-        await ensureInstalled(ctx, out);
-        const at = await start(ctx, out);
-        enable(ctx, out, at, flag("--local-only"));
+        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);
+        const at = await start(ctx, out, "enable");
         enable(ctx, out, at, localOnly);
         break;
       }
@@ -1282,7 +1465,7 @@ async function main(argv, ctx, write, tty = false) {
       }
       case "start": {
         requireInstalled(ctx);
-        await start(ctx, out, !flag("--no-wait"));
+        await start(ctx, out, "start", !flag("--no-wait"));
         break;
       }
       case "stop": {
@@ -1326,7 +1509,20 @@ function contextFromEnv(env = process.env, home = homedir3()) {
 }
 
 // packages/kyrn-judge/src/mude/cli.ts
-main(process.argv.slice(2), contextFromEnv(), (text) => process.stdout.write(text), Boolean(process.stdout.isTTY)).then(
+var stop = new AbortController();
+var onSignal = (signal) => {
+  if (stop.signal.aborted) process.exit(signal === "SIGINT" ? 130 : 143);
+  stop.abort();
+  setTimeout(() => process.exit(signal === "SIGINT" ? 130 : 143), 5e3).unref();
+};
+process.on("SIGINT", onSignal);
+process.on("SIGTERM", onSignal);
+main(
+  process.argv.slice(2),
+  { ...contextFromEnv(), signal: stop.signal },
+  (text) => process.stdout.write(text),
+  Boolean(process.stdout.isTTY)
+).then(
   (code) => {
     process.exitCode = code;
   },