@lumi.ai/runner 0.5.6 → 0.5.8

package/dist/cli.js

@@ -4,12 +4,12 @@
 import { Command } from "commander";
 
 // src/daemon.ts
-import os3 from "node:os";
+import os4 from "node:os";
 import {
   collection as collection5,
   deleteField as deleteField2,
   doc as doc7,
-  getDoc as getDoc5,
+  getDoc as getDoc6,
   getDocs as getDocs4,
   onSnapshot as onSnapshot2,
   orderBy as orderBy4,
@@ -242,15 +242,18 @@ function clampStepText(text, max) {
 function firstLine(text) {
   return text.split("\n").find((l) => l.trim()) ?? "";
 }
+function step(kind, label, detail) {
+  return detail ? { kind, label, detail } : { kind, label };
+}
 function str(input, key) {
   if (!input || typeof input !== "object")
     return void 0;
   const value = input[key];
   return typeof value === "string" && value.trim() ? value : void 0;
 }
-function basename(path5) {
-  const parts = path5.split(/[\\/]/).filter(Boolean);
-  return parts[parts.length - 1] ?? path5;
+function basename(path8) {
+  const parts = path8.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? path8;
 }
 function hostOf(url) {
   try {
@@ -333,8 +336,8 @@ function builtinDetail(tool, input) {
     case "Write":
     case "Edit":
     case "MultiEdit": {
-      const path5 = str(input, "file_path");
-      return path5 ? basename(path5) : void 0;
+      const path8 = str(input, "file_path");
+      return path8 ? basename(path8) : void 0;
     }
     case "Glob":
     case "Grep":
@@ -354,36 +357,28 @@ function builtinDetail(tool, input) {
 function describeToolUse(name, input, opts) {
   if (name.startsWith(WORKSPACE_PREFIX)) {
     const tool = name.slice(WORKSPACE_PREFIX.length);
-    return {
-      kind: "tool",
-      label: WORKSPACE_LABELS[tool] ?? "Working",
-      detail: workspaceDetail(tool, input)
-    };
+    return step("tool", WORKSPACE_LABELS[tool] ?? "Working", workspaceDetail(tool, input));
   }
   if (name.startsWith(MCP_PREFIX)) {
     const rest = name.slice(MCP_PREFIX.length);
     const split = rest.indexOf("__");
     const key = split < 0 ? rest : rest.slice(0, split);
     const tool = split < 0 ? void 0 : rest.slice(split + 2);
-    return {
-      kind: "tool",
-      label: `Using ${opts?.mcpNames?.[key] ?? key}`,
-      detail: tool || void 0
-    };
+    return step("tool", `Using ${opts?.mcpNames?.[key] ?? key}`, tool);
   }
   const label = BUILTIN_LABELS[name];
   if (label)
-    return { kind: "tool", label, detail: builtinDetail(name, input) };
-  return { kind: "tool", label: "Working" };
+    return step("tool", label, builtinDetail(name, input));
+  return step("tool", "Working");
 }
 function describeAssistantText(text) {
-  return { kind: "saying", label: "Working it out", detail: firstLine(text) || void 0 };
+  return step("saying", "Working it out", firstLine(text));
 }
-function pushJobStep(progress, step, max = MAX_JOB_STEPS) {
-  const steps = [...progress?.steps ?? [], step];
+function pushJobStep(progress, step2, max = MAX_JOB_STEPS) {
+  const steps = [...progress?.steps ?? [], step2];
   return {
     seq: (progress?.seq ?? 0) + 1,
-    updatedAt: step.at,
+    updatedAt: step2.at,
     // Keep the NEWEST `max`, oldest first — a reader renders top to bottom.
     steps: steps.slice(Math.max(0, steps.length - max))
   };
@@ -739,7 +734,7 @@ function mcpUrl(config2) {
 }
 
 // src/version.ts
-var RUNNER_VERSION = true ? "0.5.6" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.5.8" : "0.0.0-dev";
 
 // src/auth.ts
 import { signInWithCustomToken } from "firebase/auth";
@@ -1777,7 +1772,7 @@ async function runSession(input, bin, dirs) {
           if (event.type === "result") resultEvent = event;
           if (event.type === "assistant") input.log("claude: assistant turn");
           if (input.onStep) {
-            for (const step of stepsFromClaudeEvent(event, { mcpNames })) input.onStep(step);
+            for (const step2 of stepsFromClaudeEvent(event, { mcpNames })) input.onStep(step2);
           }
         } catch {
         }
@@ -2054,6 +2049,7 @@ import {
   collection as collection4,
   deleteField,
   doc as doc6,
+  getDoc as getDoc5,
   getDocs as getDocs3,
   limit as fsLimit,
   orderBy as orderBy3,
@@ -2076,11 +2072,11 @@ function redactTranscript(transcript, knownSecrets) {
   return out;
 }
 async function uploadTranscript(storage, shipId, jobId, redacted) {
-  const path5 = `crew/${shipId}/transcripts/${jobId}.jsonl`;
-  await uploadBytes(storageRef(storage, path5), new TextEncoder().encode(redacted), {
+  const path8 = `crew/${shipId}/transcripts/${jobId}.jsonl`;
+  await uploadBytes(storageRef(storage, path8), new TextEncoder().encode(redacted), {
     contentType: "application/x-ndjson"
   });
-  return path5;
+  return path8;
 }
 function utcDay(millis) {
   return new Date(millis).toISOString().slice(0, 10);
@@ -2190,16 +2186,27 @@ ${error.slice(0, 800)}
 }
 async function markTaskStopped(db, shipId, job, stoppedBy) {
   const taskRef = doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.tasks, job.taskId);
+  const who = await actorName(db, shipId, stoppedBy);
   await addDoc(collection4(taskRef, COLLECTIONS.activity), {
     author: { type: "agent", id: job.agentId },
     createdAt: Date.now(),
     kind: "comment",
-    content: `This run was stopped by ${stoppedBy} before it finished. The task is unchanged.`
+    content: `This run was stopped by ${who} before it finished. The task is unchanged.`
   });
 }
+async function actorName(db, shipId, actorId) {
+  try {
+    const snap = await getDoc5(doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.members, actorId));
+    const m = snap.data();
+    return m?.displayName || m?.email || actorId;
+  } catch {
+    return actorId;
+  }
+}
 async function markChatStopped(db, shipId, job, stoppedBy) {
   const chatRef = doc6(db, COLLECTIONS.ships, shipId, COLLECTIONS.chats, job.chatId);
-  const content = `Stopped by ${stoppedBy} before I finished. Write again to start a fresh run.`;
+  const who = await actorName(db, shipId, stoppedBy);
+  const content = `Stopped by ${who} before I finished. Write again to start a fresh run.`;
   await addDoc(collection4(chatRef, COLLECTIONS.chatMessages), {
     author: { type: "agent", id: job.agentId },
     content,
@@ -2264,16 +2271,24 @@ async function ensureChatReply(db, shipId, job, resultText) {
 // src/jobs/progress.ts
 var PROGRESS_FLUSH_MS = 3e3;
 var PROGRESS_DENIALS_BEFORE_PROBE = 2;
-function redactStep(step, secrets) {
-  const label = clampStepText(redactTranscript(step.label, secrets), MAX_STEP_LABEL);
-  if (step.detail === void 0) return { ...step, label };
-  const detail = clampStepText(redactTranscript(step.detail, secrets), MAX_STEP_DETAIL);
-  return detail ? { ...step, label, detail } : { at: step.at, kind: step.kind, label };
+function redactStep(step2, secrets) {
+  const label = clampStepText(redactTranscript(step2.label, secrets), MAX_STEP_LABEL);
+  const base = { at: step2.at, kind: step2.kind, label };
+  if (step2.detail === void 0) return base;
+  const detail = clampStepText(redactTranscript(step2.detail, secrets), MAX_STEP_DETAIL);
+  return detail ? { ...base, detail } : base;
+}
+function errorCode(error) {
+  return error?.code ?? "";
 }
 function isDenied(error) {
-  const code = error?.code ?? "";
+  const code = errorCode(error);
   return code === "permission-denied" || code.endsWith("/permission-denied");
 }
+function isUnwritable(error) {
+  const code = errorCode(error);
+  return code === "invalid-argument" || code.endsWith("/invalid-argument");
+}
 function createProgressWriter(deps) {
   const now = deps.now ?? Date.now;
   const flushMs = deps.flushMs ?? PROGRESS_FLUSH_MS;
@@ -2292,12 +2307,18 @@ function createProgressWriter(deps) {
     }
     if (closed || inFlight || pending.length === 0) return;
     const secrets = deps.secrets();
-    for (const step of pending) progress = pushJobStep(progress, redactStep(step, secrets));
+    for (const step2 of pending) progress = pushJobStep(progress, redactStep(step2, secrets));
     pending = [];
     lastWriteAt = now();
     inFlight = true;
     const snapshot = progress;
-    void deps.write(snapshot).then(() => {
+    let written;
+    try {
+      written = deps.write(snapshot);
+    } catch (e) {
+      written = Promise.reject(e);
+    }
+    void written.then(() => {
       denials = 0;
     }).catch((e) => {
       if (isDenied(e)) {
@@ -2309,9 +2330,12 @@ function createProgressWriter(deps) {
         return;
       }
       denials = 0;
+      if (isUnwritable(e)) closed = true;
       if (!loggedFailure) {
         loggedFailure = true;
-        deps.log(`progress write failed (further ones silent): ${e instanceof Error ? e.message : e}`);
+        deps.log(
+          `progress write failed${closed ? " \u2014 live steps are off for this job" : " (further ones silent)"}: ${e instanceof Error ? e.message : e}`
+        );
       }
     }).finally(() => {
       inFlight = false;
@@ -2329,9 +2353,9 @@ function createProgressWriter(deps) {
     timer.unref?.();
   }
   return {
-    push(step) {
+    push(step2) {
       if (closed) return;
-      pending.push({ ...step, at: now() });
+      pending.push({ ...step2, at: now() });
       schedule();
     },
     stop() {
@@ -2345,188 +2369,809 @@ function createProgressWriter(deps) {
   };
 }
 
-// src/daemon.ts
-var HEARTBEAT_MS = 3e4;
-var JOB_TIMEOUT_MS = 20 * 60 * 1e3;
-var MAX_ATTEMPTS = 2;
-var SHUTDOWN_GRACE_MS = 1e4;
-var STOP_POLL_MS = 5e3;
-async function startDaemon() {
-  const moved = migrateLegacyDir();
-  let config2 = requireConfig();
-  if (config2.ships.length === 0) {
-    console.error("No Ships assigned. Run: lumi-runner ship add <shipId>");
-    process.exit(1);
-  }
-  const { sessions, failures } = await openShipSessions(
-    config2,
-    (shipId) => initFirebase(config2, `ship-${shipId}`)
-  );
-  for (const f of failures) console.error(f.message);
-  const orphanFailures = (await Promise.all(orphanShipKeys(config2).map((shipId) => probeShipKey(config2, shipId)))).filter((f) => f !== null);
-  const pruned = pruneDeadShips(config2, [...failures, ...orphanFailures]);
-  if (pruned.dropped.length > 0) {
-    saveConfig(pruned.config);
-    config2 = pruned.config;
-    console.log(
-      `Forgot ${pruned.dropped.length} Ship(s) this machine can no longer open: ${pruned.dropped.join(", ")}. Deleted, or this machine was revoked \u2014 run \`lumi-runner login\` if that was not expected.`
-    );
-  }
-  if (sessions.length === 0) {
-    console.error("No Ship could be signed in to. Run: lumi-runner login");
-    process.exit(1);
-  }
-  const byShip = new Map(sessions.map((s) => [s.shipId, s]));
-  const sess = (shipId) => {
-    const s = byShip.get(shipId);
-    if (!s) throw new Error(`No session for Ship ${shipId}`);
-    return s;
-  };
-  const serving = new Set(sessions.map((s) => s.shipId));
-  console.log(
-    `Runner ${config2.runnerId} serving ${serving.size} Ship(s): ${[...serving].join(", ")}`
-  );
-  const logLines = [];
-  const log2 = (line) => {
-    const stamped = `${(/* @__PURE__ */ new Date()).toISOString()} ${line}`;
-    console.log(stamped);
-    appendLog(stamped);
-    logLines.push(stamped);
-    if (logLines.length > 20) logLines.shift();
-  };
-  if (moved?.migrated) log2(`Moved runner config from ${moved.from} to ${moved.to}.`);
-  const startedAt = Date.now();
-  const running = /* @__PURE__ */ new Map();
-  const runningByShip = () => {
-    const counts = /* @__PURE__ */ new Map();
-    for (const r of running.values()) counts.set(r.shipId, (counts.get(r.shipId) ?? 0) + 1);
-    return counts;
+// src/service.ts
+import { spawnSync } from "node:child_process";
+import fs4 from "node:fs";
+import os3 from "node:os";
+import path4 from "node:path";
+import { fileURLToPath } from "node:url";
+var SERVICE_LABEL = "com.lumi.runner";
+var LINUX_UNIT = "lumi-runner.service";
+var WINDOWS_TASK = "LumiRunner";
+var LEGACY_SERVICE_LABEL = "com.lumi.crew-runner";
+var LEGACY_LINUX_UNIT = "crew-runner.service";
+var LEGACY_WINDOWS_TASK = "CrewRunner";
+var ServiceError = class extends Error {
+};
+function run(command, args) {
+  const result = spawnSync(command, args, { encoding: "utf8" });
+  return {
+    ok: result.status === 0,
+    out: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
   };
-  const liveJobsOn = (shipId) => [...running.values()].filter((r) => r.shipId === shipId && r.mirror).map((r) => r.mirror).sort((a, b) => a.startedAt - b.startedAt);
-  const approved = /* @__PURE__ */ new Map();
-  const warnedUnapproved = /* @__PURE__ */ new Set();
-  const shipRunnerRef = (shipId) => doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.runners, config2.runnerId);
-  const needsRefill = /* @__PURE__ */ new Set();
-  let beating = false;
-  async function heartbeat() {
-    if (beating) return;
-    beating = true;
-    const now = Date.now();
-    try {
-      for (const shipId of [...serving]) {
-        try {
-          const snap = await getDoc5(shipRunnerRef(shipId));
-          if (!snap.exists()) {
-            forgetShipLocally(shipId, "a captain removed this machine on the Daemons page");
-            continue;
-          }
-          const isApproved = snap.data()?.approved === true;
-          const wasApproved = approved.get(shipId) === true;
-          approved.set(shipId, isApproved);
-          if (!isApproved && !warnedUnapproved.has(shipId)) {
-            warnedUnapproved.add(shipId);
-            log2(
-              `Ship ${shipId}: this machine's approval was withdrawn \u2014 idle here until a captain approves it again on the Daemons page.`
-            );
-          }
-          if (isApproved && !wasApproved) {
-            warnedUnapproved.delete(shipId);
-            needsRefill.add(shipId);
-          }
-          const live = liveJobsOn(shipId);
-          await setDoc2(
-            shipRunnerRef(shipId),
-            {
-              hostname: os3.hostname(),
-              version: RUNNER_VERSION,
-              status: "online",
-              lastSeenAt: now,
-              startedAt,
-              currentJob: live[0] ?? null,
-              currentJobs: live,
-              parallelLimit: shipCap(config2, shipId),
-              lastLogLines: [...logLines]
-            },
-            { merge: true }
-          );
-        } catch (e) {
-          if (isEnrolmentGone(e)) {
-            forgetShipLocally(shipId, "this machine is no longer enrolled on that Ship");
-            continue;
-          }
-          console.error(`heartbeat failed (${shipId}):`, e instanceof Error ? e.message : e);
-        }
-      }
-    } finally {
-      beating = false;
+}
+function cliPath() {
+  return fileURLToPath(import.meta.url);
+}
+function uid() {
+  return String(process.getuid?.() ?? 0);
+}
+function launchAgentPath() {
+  return path4.join(os3.homedir(), "Library/LaunchAgents", `${SERVICE_LABEL}.plist`);
+}
+function systemdUnitPath() {
+  return path4.join(os3.homedir(), ".config/systemd/user", LINUX_UNIT);
+}
+function legacyLaunchAgentPath() {
+  return path4.join(os3.homedir(), "Library/LaunchAgents", `${LEGACY_SERVICE_LABEL}.plist`);
+}
+function legacySystemdUnitPath() {
+  return path4.join(os3.homedir(), ".config/systemd/user", LEGACY_LINUX_UNIT);
+}
+function serviceEnv() {
+  const env = { PATH: process.env.PATH ?? "" };
+  if (process.env.LUMI_RUNNER_HOME || process.env.CREW_RUNNER_HOME) {
+    env.LUMI_RUNNER_HOME = configDir();
+  }
+  return env;
+}
+function removeLegacyService() {
+  const removed = [];
+  if (process.platform === "darwin") {
+    const unitPath = legacyLaunchAgentPath();
+    if (fs4.existsSync(unitPath)) {
+      run("launchctl", ["bootout", `gui/${uid()}/${LEGACY_SERVICE_LABEL}`]);
+      fs4.rmSync(unitPath, { force: true });
+      removed.push(unitPath);
     }
-    for (const shipId of [...needsRefill]) {
-      needsRefill.delete(shipId);
-      if (!serving.has(shipId) || approved.get(shipId) !== true) continue;
-      try {
-        const snap = await getDocs4(
-          query4(
-            collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs),
-            where4("status", "==", "queued"),
-            orderBy4("createdAt", "asc")
-          )
-        );
-        for (const d of snap.docs) {
-          pending.set(`${shipId}/${d.id}`, {
-            shipId,
-            job: { id: d.id, ...d.data() }
-          });
-        }
-        log2(`Ship ${shipId}: approved \u2014 picking up ${snap.size} queued job(s).`);
-      } catch (e) {
-        console.error(`queue refill failed (${shipId}):`, e instanceof Error ? e.message : e);
-      }
-      poke();
+    return removed;
+  }
+  if (process.platform === "linux") {
+    const unitPath = legacySystemdUnitPath();
+    if (fs4.existsSync(unitPath)) {
+      run("systemctl", ["--user", "disable", "--now", LEGACY_LINUX_UNIT]);
+      fs4.rmSync(unitPath, { force: true });
+      run("systemctl", ["--user", "daemon-reload"]);
+      removed.push(unitPath);
     }
+    return removed;
   }
-  const pending = /* @__PURE__ */ new Map();
-  const engineLimits = /* @__PURE__ */ new Map();
-  const agentEngines = /* @__PURE__ */ new Map();
-  const unsubsByShip = /* @__PURE__ */ new Map();
-  const listenerError = (shipId, what) => (e) => {
-    if (isEnrolmentGone(e)) {
-      forgetShipLocally(shipId, "a captain removed this machine on the Daemons page");
-      return;
+  if (process.platform === "win32") {
+    if (run("schtasks", ["/Query", "/TN", LEGACY_WINDOWS_TASK]).ok) {
+      run("schtasks", ["/Delete", "/TN", LEGACY_WINDOWS_TASK, "/F"]);
+      removed.push(LEGACY_WINDOWS_TASK);
     }
-    console.error(`${what} listener error (${shipId}):`, e.message);
-  };
-  for (const shipId of serving) {
-    const q = query4(
-      collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs),
-      where4("status", "==", "queued"),
-      orderBy4("createdAt", "asc")
-    );
-    unsubsByShip.set(shipId, [
-      onSnapshot2(
-        q,
-        (snap) => {
-          for (const key of [...pending.keys()]) {
-            if (pending.get(key)?.shipId === shipId) pending.delete(key);
-          }
-          for (const d of snap.docs) {
-            pending.set(`${shipId}/${d.id}`, {
-              shipId,
-              job: { id: d.id, ...d.data() }
-            });
-          }
-          poke();
-        },
-        listenerError(shipId, "jobs")
-      ),
-      // Agents, purely so the claim gate can resolve a queued job's engine without a read.
-      onSnapshot2(
-        collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.agents),
-        (snap) => {
-          for (const d of snap.docs) {
-            agentEngines.set(`${shipId}/${d.id}`, agentEngine(d.data()));
-          }
-          poke();
-        },
+    return removed;
+  }
+  return removed;
+}
+var BOOTSTRAP_RETRY_DELAYS_MS = [250, 500, 1e3, 2e3, 2e3];
+function isTransientBootstrapError(out) {
+  const text = out.toLowerCase();
+  return (
+    // The observed one: `Bootstrap failed: 5: Input/output error`.
+    text.includes("input/output error") || // Same cause, different report: the old generation is still registered.
+    text.includes("service already loaded") || text.includes("service is already loaded") || text.includes("eexist") || // launchd is mid-teardown and says so.
+    text.includes("operation already in progress") || text.includes("operation now in progress")
+  );
+}
+function retryWhileTransient(attempt, wait, delays = BOOTSTRAP_RETRY_DELAYS_MS) {
+  let result = attempt();
+  for (const delay of delays) {
+    if (result.ok || !isTransientBootstrapError(result.out)) return result;
+    wait(delay);
+    result = attempt();
+  }
+  return result;
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function plistXml() {
+  const env = serviceEnv();
+  const envEntries = Object.entries(env).map(([k, v]) => `      <key>${k}</key>
+      <string>${escapeXml(v)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${escapeXml(process.execPath)}</string>
+    <string>${escapeXml(cliPath())}</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>ExitTimeOut</key>
+  <integer>20</integer>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(path4.join(logDir(), "service.out.log"))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(path4.join(logDir(), "service.err.log"))}</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function unescapeXml(value) {
+  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
+}
+function parsePlistCliPath(plist) {
+  const block = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(plist);
+  if (!block) return void 0;
+  const args = [...block[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => unescapeXml(m[1]));
+  return args.length >= 2 ? args[1] : void 0;
+}
+function parseSystemdCliPath(unit) {
+  const line = /^ExecStart=(.*)$/m.exec(unit);
+  if (!line) return void 0;
+  const command = line[1].trim();
+  if (!command.endsWith(" start")) return void 0;
+  const parts = command.slice(0, -" start".length).split(" ");
+  return parts.length === 2 ? parts[1] : void 0;
+}
+function execFacts(unitPath, parse) {
+  let text;
+  try {
+    text = fs4.readFileSync(unitPath, "utf8");
+  } catch {
+    return {};
+  }
+  const execPath = parse(text);
+  if (!execPath || !path4.isAbsolute(execPath)) return {};
+  return { execPath, execMissing: !fs4.existsSync(execPath) };
+}
+function systemdUnit() {
+  const env = serviceEnv();
+  const envLines = Object.entries(env).map(([k, v]) => `Environment="${k}=${v}"`).join("\n");
+  return `[Unit]
+Description=Lumi Crew runner daemon
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${cliPath()} start
+Restart=always
+RestartSec=5
+# Must exceed the daemon's SHUTDOWN_GRACE_MS: a SIGKILL mid-release is exactly the stranded
+# job the graceful shutdown exists to prevent.
+TimeoutStopSec=20
+${envLines}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function serviceStatus() {
+  if (process.platform === "darwin") {
+    const unitPath = launchAgentPath();
+    if (!fs4.existsSync(unitPath)) return { state: "not-installed", detail: "No LaunchAgent installed." };
+    const exec = execFacts(unitPath, parsePlistCliPath);
+    const printed = run("launchctl", ["print", `gui/${uid()}/${SERVICE_LABEL}`]);
+    if (!printed.ok) {
+      return { state: "installed", detail: "LaunchAgent present but not loaded.", unitPath, ...exec };
+    }
+    const running = /\bpid = \d+/.test(printed.out);
+    return {
+      state: running ? "running" : "installed",
+      detail: running ? "LaunchAgent loaded and running." : "LaunchAgent loaded but not running.",
+      unitPath,
+      ...exec
+    };
+  }
+  if (process.platform === "linux") {
+    const unitPath = systemdUnitPath();
+    if (!fs4.existsSync(unitPath)) return { state: "not-installed", detail: "No systemd user unit installed." };
+    const active = run("systemctl", ["--user", "is-active", LINUX_UNIT]);
+    return {
+      state: active.out === "active" ? "running" : "installed",
+      detail: `systemd user unit is ${active.out || "unknown"}.`,
+      unitPath,
+      ...execFacts(unitPath, parseSystemdCliPath)
+    };
+  }
+  if (process.platform === "win32") {
+    const query6 = run("schtasks", ["/Query", "/TN", WINDOWS_TASK]);
+    if (!query6.ok) return { state: "not-installed", detail: "No scheduled task installed." };
+    return {
+      state: /\bRunning\b/i.test(query6.out) ? "running" : "installed",
+      detail: "Scheduled task installed (runs at logon).",
+      unitPath: WINDOWS_TASK
+    };
+  }
+  return { state: "unsupported", detail: `No service integration for ${process.platform}.` };
+}
+function installService() {
+  const notes = [];
+  fs4.mkdirSync(logDir(), { recursive: true, mode: 448 });
+  for (const unit of removeLegacyService()) {
+    notes.push(`Removed the previous crew-runner service (${unit}).`);
+  }
+  if (process.platform === "darwin") {
+    const unitPath = launchAgentPath();
+    fs4.mkdirSync(path4.dirname(unitPath), { recursive: true });
+    fs4.writeFileSync(unitPath, plistXml());
+    run("launchctl", ["bootout", `gui/${uid()}/${SERVICE_LABEL}`]);
+    const boot = retryWhileTransient(
+      () => run("launchctl", ["bootstrap", `gui/${uid()}`, unitPath]),
+      sleepSync
+    );
+    if (!boot.ok) throw new ServiceError(`launchctl bootstrap failed: ${boot.out}`);
+    return { unitPath, notes };
+  }
+  if (process.platform === "linux") {
+    const unitPath = systemdUnitPath();
+    fs4.mkdirSync(path4.dirname(unitPath), { recursive: true });
+    fs4.writeFileSync(unitPath, systemdUnit());
+    const reload = run("systemctl", ["--user", "daemon-reload"]);
+    if (!reload.ok) throw new ServiceError(`systemctl daemon-reload failed: ${reload.out}`);
+    const enable = run("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
+    if (!enable.ok) throw new ServiceError(`systemctl enable failed: ${enable.out}`);
+    const linger = run("loginctl", ["show-user", os3.userInfo().username, "--property=Linger"]);
+    if (!linger.out.includes("Linger=yes")) {
+      notes.push(
+        `Run \`sudo loginctl enable-linger ${os3.userInfo().username}\` so the daemon survives logout and starts at boot.`
+      );
+    }
+    return { unitPath, notes };
+  }
+  if (process.platform === "win32") {
+    const command = `"${process.execPath}" "${cliPath()}" start`;
+    const create = run("schtasks", [
+      "/Create",
+      "/TN",
+      WINDOWS_TASK,
+      "/TR",
+      command,
+      "/SC",
+      "ONLOGON",
+      "/RL",
+      "LIMITED",
+      "/F"
+    ]);
+    if (!create.ok) throw new ServiceError(`schtasks /Create failed: ${create.out}`);
+    notes.push(
+      "Task Scheduler starts the daemon at logon but does not restart it if it exits. For a true always-on box, run the daemon under pm2 or a Windows service wrapper instead."
+    );
+    return { unitPath: WINDOWS_TASK, notes };
+  }
+  throw new ServiceError(`Service install is not supported on ${process.platform}.`);
+}
+function uninstallService() {
+  removeLegacyService();
+  if (process.platform === "darwin") {
+    run("launchctl", ["bootout", `gui/${uid()}/${SERVICE_LABEL}`]);
+    fs4.rmSync(launchAgentPath(), { force: true });
+    return;
+  }
+  if (process.platform === "linux") {
+    run("systemctl", ["--user", "disable", "--now", LINUX_UNIT]);
+    fs4.rmSync(systemdUnitPath(), { force: true });
+    run("systemctl", ["--user", "daemon-reload"]);
+    return;
+  }
+  if (process.platform === "win32") {
+    run("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
+    return;
+  }
+  throw new ServiceError(`Service uninstall is not supported on ${process.platform}.`);
+}
+function restartService() {
+  if (process.platform === "darwin") {
+    const result = run("launchctl", ["kickstart", "-k", `gui/${uid()}/${SERVICE_LABEL}`]);
+    if (!result.ok) throw new ServiceError(`launchctl kickstart failed: ${result.out}`);
+    return;
+  }
+  if (process.platform === "linux") {
+    const result = run("systemctl", ["--user", "restart", LINUX_UNIT]);
+    if (!result.ok) throw new ServiceError(`systemctl restart failed: ${result.out}`);
+    return;
+  }
+  if (process.platform === "win32") {
+    run("schtasks", ["/End", "/TN", WINDOWS_TASK]);
+    const result = run("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
+    if (!result.ok) throw new ServiceError(`schtasks /Run failed: ${result.out}`);
+    return;
+  }
+  throw new ServiceError(`Service restart is not supported on ${process.platform}.`);
+}
+
+// src/update/plan.ts
+import path5 from "node:path";
+
+// src/update/semver.ts
+var DEV_VERSION = "0.0.0-dev";
+var NUMERIC = /^(0|[1-9]\d*)$/;
+function parseVersion(raw) {
+  if (typeof raw !== "string") return null;
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  const [withoutBuild] = trimmed.split("+", 1);
+  const dash = withoutBuild.indexOf("-");
+  const core = dash < 0 ? withoutBuild : withoutBuild.slice(0, dash);
+  const pre = dash < 0 ? "" : withoutBuild.slice(dash + 1);
+  const parts = core.split(".");
+  if (parts.length !== 3) return null;
+  if (!parts.every((p) => NUMERIC.test(p))) return null;
+  const [major, minor, patch] = parts.map(Number);
+  if (dash >= 0 && pre === "") return null;
+  const prerelease = pre === "" ? [] : pre.split(".");
+  if (prerelease.some((id) => id === "")) return null;
+  return {
+    major,
+    minor,
+    patch,
+    prerelease: prerelease.map((id) => NUMERIC.test(id) ? Number(id) : id)
+  };
+}
+function hasPrerelease(raw) {
+  const parsed = parseVersion(raw);
+  return !!parsed && parsed.prerelease.length > 0;
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0) return b.length === 0 ? 0 : 1;
+  if (b.length === 0) return -1;
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === y) continue;
+    const xNum = typeof x === "number";
+    const yNum = typeof y === "number";
+    if (xNum !== yNum) return xNum ? -1 : 1;
+    if (xNum && yNum) return x < y ? -1 : 1;
+    return x < y ? -1 : 1;
+  }
+  if (a.length === b.length) return 0;
+  return a.length < b.length ? -1 : 1;
+}
+function compareVersions(a, b) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key]) return a[key] < b[key] ? -1 : 1;
+  }
+  return comparePrerelease(a.prerelease, b.prerelease);
+}
+function isNewer(candidate, current) {
+  if (current === DEV_VERSION) return false;
+  const a = parseVersion(candidate);
+  const b = parseVersion(current);
+  if (!a || !b) return false;
+  return compareVersions(a, b) === 1;
+}
+
+// src/update/plan.ts
+var CHANNELS = ["latest", "dev"];
+var PACKAGE_NAME = "@lumi.ai/runner";
+var UPDATE_CHECK_MS = 30 * 6e4;
+var UPDATE_FIRST_CHECK_MS = 2 * 6e4;
+var UPDATE_JITTER_MS = 10 * 6e4;
+var CHECK_MINUTES_MIN = 5;
+var CHECK_MINUTES_MAX = 24 * 60;
+var UPDATE_DRAIN_MAX_MS = 30 * 6e4;
+var MAX_UPDATE_ATTEMPTS = 3;
+var UPDATE_BACKOFF_MS = [15 * 6e4, 2 * 36e5, 12 * 36e5];
+var channelFor = (version) => hasPrerelease(version) ? "dev" : "latest";
+function resolveChannel(current, config2, env = {}) {
+  const fromEnv = env.LUMI_RUNNER_CHANNEL;
+  if (fromEnv && CHANNELS.includes(fromEnv)) return fromEnv;
+  const fromConfig = config2.updateChannel;
+  if (typeof fromConfig === "string" && CHANNELS.includes(fromConfig)) {
+    return fromConfig;
+  }
+  return channelFor(current);
+}
+function checkIntervalMs(config2) {
+  const raw = config2.updateCheckMinutes;
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return UPDATE_CHECK_MS;
+  const clamped = Math.min(CHECK_MINUTES_MAX, Math.max(CHECK_MINUTES_MIN, Math.floor(raw)));
+  return clamped * 6e4;
+}
+function nextAttemptAllowed(state, target, now) {
+  if (!state || typeof state !== "object") return { allowed: true };
+  if (state.target !== target) return { allowed: true };
+  const attempts = typeof state.attempts === "number" && state.attempts > 0 ? state.attempts : 0;
+  if (attempts === 0) return { allowed: true };
+  if (attempts >= MAX_UPDATE_ATTEMPTS) return { allowed: false, reason: "exhausted" };
+  if (typeof state.at !== "number" || !Number.isFinite(state.at)) return { allowed: true };
+  const wait = UPDATE_BACKOFF_MS[Math.min(attempts - 1, UPDATE_BACKOFF_MS.length - 1)];
+  return now - state.at >= wait ? { allowed: true } : { allowed: false, reason: "backoff" };
+}
+function reconcile(state, current) {
+  if (!state || typeof state.target !== "string") return { action: "none" };
+  if (state.target === current) return { action: "clear", target: state.target };
+  return { action: "keep", state };
+}
+function packageRootFrom(cliPath2) {
+  return path5.dirname(path5.dirname(cliPath2));
+}
+function globalPrefixFrom(cliPath2) {
+  const root = packageRootFrom(cliPath2);
+  const parts = root.split(path5.sep);
+  const i = parts.lastIndexOf("node_modules");
+  if (i < 1) return null;
+  const before = parts.slice(0, i);
+  if (before[before.length - 1] === "lib") before.pop();
+  const prefix = before.join(path5.sep);
+  return prefix || null;
+}
+function decideUpdate(f) {
+  if (f.platform === "win32") return { update: false, reason: "windows" };
+  if (f.current === DEV_VERSION) return { update: false, reason: "dev-build" };
+  if (!f.autoUpdate) return { update: false, reason: "disabled" };
+  const service2 = f.service();
+  if (service2.state !== "running") return { update: false, reason: "service-not-running" };
+  if (!service2.execPath || service2.execPath !== f.cliPath) {
+    return { update: false, reason: "foreign-unit" };
+  }
+  if (!f.npmPresent()) return { update: false, reason: "no-npm" };
+  if (f.distTags === null) return { update: false, reason: "registry-unreachable" };
+  const target = f.distTags[f.channel];
+  if (!target) return { update: false, reason: "no-such-tag" };
+  if (!isNewer(target, f.current)) return { update: false, reason: "up-to-date" };
+  const attempt = nextAttemptAllowed(f.state, target, f.now);
+  if (!attempt.allowed) return { update: false, reason: attempt.reason };
+  return { update: true, target, channel: f.channel };
+}
+function describeRefusal(reason, f) {
+  switch (reason) {
+    case "windows":
+      return "Auto-update is not available on Windows \u2014 run `lumi-runner update` to upgrade.";
+    case "dev-build":
+      return "Development build \u2014 auto-update is off.";
+    case "disabled":
+      return "Auto-update is off (`lumi-runner config set autoUpdate on` to enable).";
+    case "service-not-running":
+      return "Auto-update needs the background service (this daemon would have nothing to restart it). Run `lumi-runner service install`, or `lumi-runner update` by hand.";
+    case "foreign-unit":
+      return "This process is not the one the installed service runs, so auto-update is off for it. Run `lumi-runner update` if you meant to upgrade the installed copy.";
+    case "no-npm":
+      return "Auto-update needs `npm` on the service PATH and could not find it.";
+    case "registry-unreachable":
+      return "Could not reach the npm registry to check for updates \u2014 will retry.";
+    case "no-such-tag":
+      return "The npm registry has no release on this channel yet.";
+    case "up-to-date":
+      return `Up to date (${f.current}).`;
+    case "backoff":
+      return "A recent update attempt did not take \u2014 waiting before trying again.";
+    case "exhausted":
+      return `Gave up updating after ${MAX_UPDATE_ATTEMPTS} attempts. Still on ${f.current} \u2014 run \`lumi-runner update\` to see why, or wait for the next release.`;
+  }
+}
+
+// src/update/registry.ts
+var DEFAULT_REGISTRY = "https://registry.npmjs.org";
+var REGISTRY_TIMEOUT_MS = 1e4;
+function registryBase(env = process.env) {
+  return (env.LUMI_RUNNER_REGISTRY || DEFAULT_REGISTRY).replace(/\/+$/, "");
+}
+async function fetchDistTags(options = {}) {
+  const base = options.registry ?? registryBase();
+  const doFetch = options.fetchImpl ?? fetch;
+  const url = `${base}/${encodeURIComponent(PACKAGE_NAME)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? REGISTRY_TIMEOUT_MS);
+  try {
+    const response = await doFetch(url, {
+      headers: { accept: "application/vnd.npm.install-v1+json" },
+      signal: controller.signal
+    });
+    if (!response.ok) return null;
+    const body = await response.json();
+    const tags = body?.["dist-tags"];
+    if (!tags || typeof tags !== "object" || Array.isArray(tags)) return null;
+    const out = {};
+    for (const [tag, version] of Object.entries(tags)) {
+      if (typeof version === "string") out[tag] = version;
+    }
+    return out;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/update/state.ts
+import fs5 from "node:fs";
+import path6 from "node:path";
+var UPDATE_STATE_FILE = "update.json";
+function updateStatePath() {
+  return path6.join(configDir(), UPDATE_STATE_FILE);
+}
+function readUpdateState() {
+  try {
+    const parsed = JSON.parse(fs5.readFileSync(updateStatePath(), "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeUpdateState(state) {
+  try {
+    fs5.mkdirSync(configDir(), { recursive: true, mode: 448 });
+    fs5.writeFileSync(updateStatePath(), `${JSON.stringify(state, null, 2)}
+`, { mode: 384 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function clearUpdateState() {
+  try {
+    fs5.rmSync(updateStatePath(), { force: true });
+  } catch {
+  }
+}
+
+// src/update/install.ts
+import { spawn as spawn4, spawnSync as spawnSync2 } from "node:child_process";
+import fs6 from "node:fs";
+import path7 from "node:path";
+var INSTALL_TIMEOUT_MS = 5 * 6e4;
+var STDERR_KEEP = 400;
+function npmPresent() {
+  const probe = process.platform === "win32" ? "where" : "which";
+  try {
+    return spawnSync2(probe, ["npm"], { encoding: "utf8" }).status === 0;
+  } catch {
+    return false;
+  }
+}
+function installArgs(target, cliPath2) {
+  const args = ["install", "--global", "--no-fund", "--no-audit", `${PACKAGE_NAME}@${target}`];
+  const prefix = globalPrefixFrom(cliPath2);
+  if (prefix) args.push("--prefix", prefix);
+  return args;
+}
+async function installGlobal(target, cliPath2, options = {}) {
+  const args = installArgs(target, cliPath2);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn4("npm", args, { stdio: ["ignore", "ignore", "pipe"] });
+    } catch (e) {
+      resolve({ ok: false, detail: e instanceof Error ? e.message : String(e) });
+      return;
+    }
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr = `${stderr}${chunk.toString()}`.slice(-STDERR_KEEP);
+    });
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timeoutMs = options.timeoutMs ?? INSTALL_TIMEOUT_MS;
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 5e3).unref();
+      finish({ ok: false, detail: `npm install timed out after ${timeoutMs / 6e4} minutes.` });
+    }, timeoutMs);
+    timer.unref();
+    child.on("error", (e) => finish({ ok: false, detail: e.message }));
+    child.on(
+      "close",
+      (code) => finish({ ok: code === 0, detail: stderr.trim() || `npm exited ${code}` })
+    );
+  });
+}
+function installedVersionAt(cliPath2) {
+  try {
+    const pkg = JSON.parse(
+      fs6.readFileSync(path7.join(packageRootFrom(cliPath2), "package.json"), "utf8")
+    );
+    const version = pkg?.version;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/daemon.ts
+var HEARTBEAT_MS = 3e4;
+var JOB_TIMEOUT_MS = 20 * 60 * 1e3;
+var MAX_ATTEMPTS = 2;
+var SHUTDOWN_GRACE_MS = 1e4;
+var STOP_POLL_MS = 5e3;
+async function startDaemon() {
+  const moved = migrateLegacyDir();
+  let config2 = requireConfig();
+  if (config2.ships.length === 0) {
+    console.error("No Ships assigned. Run: lumi-runner ship add <shipId>");
+    process.exit(1);
+  }
+  const { sessions, failures } = await openShipSessions(
+    config2,
+    (shipId) => initFirebase(config2, `ship-${shipId}`)
+  );
+  for (const f of failures) console.error(f.message);
+  const orphanFailures = (await Promise.all(orphanShipKeys(config2).map((shipId) => probeShipKey(config2, shipId)))).filter((f) => f !== null);
+  const pruned = pruneDeadShips(config2, [...failures, ...orphanFailures]);
+  if (pruned.dropped.length > 0) {
+    saveConfig(pruned.config);
+    config2 = pruned.config;
+    console.log(
+      `Forgot ${pruned.dropped.length} Ship(s) this machine can no longer open: ${pruned.dropped.join(", ")}. Deleted, or this machine was revoked \u2014 run \`lumi-runner login\` if that was not expected.`
+    );
+  }
+  if (sessions.length === 0) {
+    console.error("No Ship could be signed in to. Run: lumi-runner login");
+    process.exit(1);
+  }
+  const byShip = new Map(sessions.map((s) => [s.shipId, s]));
+  const sess = (shipId) => {
+    const s = byShip.get(shipId);
+    if (!s) throw new Error(`No session for Ship ${shipId}`);
+    return s;
+  };
+  const serving = new Set(sessions.map((s) => s.shipId));
+  console.log(
+    `Runner ${config2.runnerId} serving ${serving.size} Ship(s): ${[...serving].join(", ")}`
+  );
+  const logLines = [];
+  const log2 = (line) => {
+    const stamped = `${(/* @__PURE__ */ new Date()).toISOString()} ${line}`;
+    console.log(stamped);
+    appendLog(stamped);
+    logLines.push(stamped);
+    if (logLines.length > 20) logLines.shift();
+  };
+  if (moved?.migrated) log2(`Moved runner config from ${moved.from} to ${moved.to}.`);
+  const startedAt = Date.now();
+  const running = /* @__PURE__ */ new Map();
+  const runningByShip = () => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const r of running.values()) counts.set(r.shipId, (counts.get(r.shipId) ?? 0) + 1);
+    return counts;
+  };
+  const liveJobsOn = (shipId) => [...running.values()].filter((r) => r.shipId === shipId && r.mirror).map((r) => r.mirror).sort((a, b) => a.startedAt - b.startedAt);
+  const approved = /* @__PURE__ */ new Map();
+  const warnedUnapproved = /* @__PURE__ */ new Set();
+  const shipRunnerRef = (shipId) => doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.runners, config2.runnerId);
+  const needsRefill = /* @__PURE__ */ new Set();
+  let beating = false;
+  async function heartbeat() {
+    if (beating) return;
+    beating = true;
+    const now = Date.now();
+    try {
+      for (const shipId of [...serving]) {
+        try {
+          const snap = await getDoc6(shipRunnerRef(shipId));
+          if (!snap.exists()) {
+            forgetShipLocally(shipId, "a captain removed this machine on the Daemons page");
+            continue;
+          }
+          const isApproved = snap.data()?.approved === true;
+          const wasApproved = approved.get(shipId) === true;
+          approved.set(shipId, isApproved);
+          if (!isApproved && !warnedUnapproved.has(shipId)) {
+            warnedUnapproved.add(shipId);
+            log2(
+              `Ship ${shipId}: this machine's approval was withdrawn \u2014 idle here until a captain approves it again on the Daemons page.`
+            );
+          }
+          if (isApproved && !wasApproved) {
+            warnedUnapproved.delete(shipId);
+            needsRefill.add(shipId);
+          }
+          const live = liveJobsOn(shipId);
+          await setDoc2(
+            shipRunnerRef(shipId),
+            {
+              hostname: os4.hostname(),
+              version: RUNNER_VERSION,
+              status: "online",
+              lastSeenAt: now,
+              startedAt,
+              currentJob: live[0] ?? null,
+              currentJobs: live,
+              parallelLimit: shipCap(config2, shipId),
+              lastLogLines: [...logLines],
+              // §15.37. Written on EVERY heartbeat, `null` when idle, exactly like `currentJob`
+              // above — so a machine that finishes or abandons an update clears its own badge
+              // without needing a separate write. Both names must appear in `liveFields()` in
+              // firestore.rules, and that rules change must be deployed BEFORE this version is
+              // published: `hasOnly()` fails the whole write for one unlisted key, which would
+              // take every heartbeat down, not just the badge.
+              updateAvailable: updateAvailableVersion,
+              updatePhase
+            },
+            { merge: true }
+          );
+        } catch (e) {
+          if (isEnrolmentGone(e)) {
+            forgetShipLocally(shipId, "this machine is no longer enrolled on that Ship");
+            continue;
+          }
+          console.error(`heartbeat failed (${shipId}):`, e instanceof Error ? e.message : e);
+        }
+      }
+    } finally {
+      beating = false;
+    }
+    for (const shipId of [...needsRefill]) {
+      needsRefill.delete(shipId);
+      if (!serving.has(shipId) || approved.get(shipId) !== true) continue;
+      try {
+        const snap = await getDocs4(
+          query4(
+            collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs),
+            where4("status", "==", "queued"),
+            orderBy4("createdAt", "asc")
+          )
+        );
+        for (const d of snap.docs) {
+          pending.set(`${shipId}/${d.id}`, {
+            shipId,
+            job: { id: d.id, ...d.data() }
+          });
+        }
+        log2(`Ship ${shipId}: approved \u2014 picking up ${snap.size} queued job(s).`);
+      } catch (e) {
+        console.error(`queue refill failed (${shipId}):`, e instanceof Error ? e.message : e);
+      }
+      poke();
+    }
+  }
+  const pending = /* @__PURE__ */ new Map();
+  const engineLimits = /* @__PURE__ */ new Map();
+  const agentEngines = /* @__PURE__ */ new Map();
+  const unsubsByShip = /* @__PURE__ */ new Map();
+  const listenerError = (shipId, what) => (e) => {
+    if (isEnrolmentGone(e)) {
+      forgetShipLocally(shipId, "a captain removed this machine on the Daemons page");
+      return;
+    }
+    console.error(`${what} listener error (${shipId}):`, e.message);
+  };
+  for (const shipId of serving) {
+    const q = query4(
+      collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs),
+      where4("status", "==", "queued"),
+      orderBy4("createdAt", "asc")
+    );
+    unsubsByShip.set(shipId, [
+      onSnapshot2(
+        q,
+        (snap) => {
+          for (const key of [...pending.keys()]) {
+            if (pending.get(key)?.shipId === shipId) pending.delete(key);
+          }
+          for (const d of snap.docs) {
+            pending.set(`${shipId}/${d.id}`, {
+              shipId,
+              job: { id: d.id, ...d.data() }
+            });
+          }
+          poke();
+        },
+        listenerError(shipId, "jobs")
+      ),
+      // Agents, purely so the claim gate can resolve a queued job's engine without a read.
+      onSnapshot2(
+        collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.agents),
+        (snap) => {
+          for (const d of snap.docs) {
+            agentEngines.set(`${shipId}/${d.id}`, agentEngine(d.data()));
+          }
+          poke();
+        },
         listenerError(shipId, "agents")
       ),
       // Exhausted usage windows. The FIRST snapshot is the startup seed: a restarted daemon —
@@ -2596,9 +3241,14 @@ async function startDaemon() {
   let dispatching = false;
   let pokeRequested = false;
   let shuttingDown = false;
+  let updating = null;
+  let updateDrainTimer = null;
+  let nextUpdateCheckAt = Date.now() + UPDATE_FIRST_CHECK_MS + Math.floor(Math.random() * UPDATE_JITTER_MS);
+  let updateAvailableVersion = null;
+  let updatePhase = null;
   function poke() {
-    if (dispatching || shuttingDown) {
-      pokeRequested = !shuttingDown;
+    if (dispatching || shuttingDown || updating) {
+      pokeRequested = !shuttingDown && !updating;
       return;
     }
     dispatch();
@@ -2632,7 +3282,7 @@ async function startDaemon() {
     try {
       for (; ; ) {
         pokeRequested = false;
-        if (shuttingDown) break;
+        if (shuttingDown || updating) break;
         const now = Date.now();
         const picks = selectDispatch({
           pending: pending.values(),
@@ -2664,6 +3314,10 @@ async function startDaemon() {
       log2(`job ${job.id} ended abnormally: ${e instanceof Error ? e.message : e}`);
     }).finally(() => {
       running.delete(job.id);
+      if (updating) {
+        if (running.size === 0) void applyUpdate();
+        return;
+      }
       if (!shuttingDown) poke();
     });
   }
@@ -2741,7 +3395,7 @@ async function startDaemon() {
       void (async () => {
         if (slot.stop) return;
         try {
-          const snap = await getDoc5(
+          const snap = await getDoc6(
             doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id)
           );
           const fresh = snap.data();
@@ -2796,7 +3450,7 @@ async function startDaemon() {
       onDenied: () => {
         void (async () => {
           try {
-            const snap = await getDoc5(
+            const snap = await getDoc6(
               doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id)
             );
             const fresh = snap.data();
@@ -2889,7 +3543,7 @@ async function startDaemon() {
         // §15.36. The driver emits Crew's step vocabulary; the writer coalesces, redacts and
         // persists. A throw here must never reach the driver's stdout loop, which is why `push`
         // swallows everything.
-        onStep: (step) => progress.push(step)
+        onStep: (step2) => progress.push(step2)
       });
       transcript = redactTranscript(session.transcript, knownSecrets);
       usage = session.usage;
@@ -3038,623 +3692,491 @@ async function startDaemon() {
   const heartbeatTimer = setInterval(() => {
     void heartbeat();
     sweepLimits();
+    void maybeCheckForUpdate();
   }, HEARTBEAT_MS);
   let stopping = false;
-  const shutdown = async (signal) => {
+  const shutdown = async (reason) => {
     if (stopping) return;
     stopping = true;
     shuttingDown = true;
     clearInterval(heartbeatTimer);
-    if (limitTimer) clearTimeout(limitTimer);
-    for (const shipUnsubs of unsubsByShip.values()) shipUnsubs.forEach((u) => u());
-    const inFlight = [...running.values()];
-    if (inFlight.length > 0) {
-      log2(
-        `${signal} received with ${inFlight.length} job(s) in flight \u2014 stopping the sessions and releasing them.`
-      );
-      notify(
-        "Crew runner stopping",
-        `${inFlight.length} job(s) were in progress; they have been returned to the queue.`
-      );
-      for (const r of inFlight) r.abort.abort();
-    } else {
-      log2(`${signal} received \u2014 shutting down.`);
-    }
-    if (inFlight.length > 0) {
-      await Promise.race([
-        Promise.all(inFlight.map((r) => r.promise)),
-        new Promise((resolve) => setTimeout(resolve, SHUTDOWN_GRACE_MS).unref())
-      ]);
-    }
-    const now = Date.now();
-    try {
-      for (const shipId of serving) {
-        await setDoc2(
-          doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.runners, config2.runnerId),
-          {
-            status: "offline",
-            lastSeenAt: now,
-            currentJob: deleteField2(),
-            currentJobs: deleteField2()
-          },
-          { merge: true }
-        );
-      }
-    } catch {
-    }
-    process.exit(0);
-  };
-  process.on("SIGINT", () => void shutdown("SIGINT"));
-  process.on("SIGTERM", () => void shutdown("SIGTERM"));
-  const caps = [...serving].map((s) => `${s}:${shipCap(config2, s)}`).join(" ");
-  log2(
-    `Runner online \u2014 watching ${serving.size} Ship(s), up to ${machineCap(config2)} job(s) at once (${caps}), MCP: ${mcpUrl(config2)}`
-  );
-  await new Promise(() => {
-  });
-}
-
-// src/cli/ui.ts
-import * as clack from "@clack/prompts";
-import { createColors } from "picocolors";
-var CliError = class extends Error {
-  constructor(message, exitCode = 1) {
-    super(message);
-    this.exitCode = exitCode;
-    this.name = "CliError";
-  }
-  exitCode;
-};
-var jsonMode = false;
-var assumeYes = false;
-var palette = createColors();
-var delegate = (name) => (input) => palette[name](input);
-var pc = {
-  bold: delegate("bold"),
-  dim: delegate("dim"),
-  black: delegate("black"),
-  red: delegate("red"),
-  green: delegate("green"),
-  yellow: delegate("yellow"),
-  cyan: delegate("cyan"),
-  bgCyan: delegate("bgCyan")
-};
-function configureOutput(options) {
-  jsonMode = options.json === true;
-  assumeYes = options.yes === true;
-  if (options.color === false || jsonMode) palette = createColors(false);
-}
-function isJson() {
-  return jsonMode;
-}
-function emitJson(value) {
-  process.stdout.write(`${JSON.stringify(value, null, 2)}
-`);
-}
-function canPrompt() {
-  return !jsonMode && process.stdin.isTTY === true && process.stdout.isTTY === true;
-}
-function requireInteractive(what, flagHint) {
-  if (canPrompt()) return;
-  throw new CliError(
-    `${what} needs an interactive terminal. Run it in a terminal, or pass ${pc.bold(flagHint)}.`
-  );
-}
-var say = {
-  intro(title) {
-    if (!jsonMode) clack.intro(pc.bgCyan(pc.black(` ${title} `)));
-  },
-  outro(message) {
-    if (!jsonMode) clack.outro(message);
-  },
-  info(message) {
-    if (!jsonMode) clack.log.info(message);
-  },
-  success(message) {
-    if (!jsonMode) clack.log.success(message);
-  },
-  warn(message) {
-    if (!jsonMode) clack.log.warn(message);
-  },
-  error(message) {
-    if (!jsonMode) clack.log.error(message);
-  },
-  step(message) {
-    if (!jsonMode) clack.log.step(message);
-  },
-  note(body, title) {
-    if (!jsonMode) clack.note(body, title);
-  },
-  /** Raw line straight to stdout — for `logs`, where the content IS the output. */
-  line(message) {
-    process.stdout.write(`${message}
-`);
-  }
-};
-function spinner2() {
-  if (jsonMode) {
-    return { start: () => {
-    }, update: () => {
-    }, stop: () => {
-    } };
-  }
-  if (!canPrompt()) {
+    if (limitTimer) clearTimeout(limitTimer);
+    if (updateDrainTimer) clearTimeout(updateDrainTimer);
+    for (const shipUnsubs of unsubsByShip.values()) shipUnsubs.forEach((u) => u());
+    const inFlight = [...running.values()];
+    if (inFlight.length > 0) {
+      log2(
+        `${reason} with ${inFlight.length} job(s) in flight \u2014 stopping the sessions and releasing them.`
+      );
+      notify(
+        "Crew runner stopping",
+        `${inFlight.length} job(s) were in progress; they have been returned to the queue.`
+      );
+      for (const r of inFlight) r.abort.abort();
+    } else {
+      log2(`${reason} \u2014 shutting down.`);
+    }
+    if (inFlight.length > 0) {
+      await Promise.race([
+        Promise.all(inFlight.map((r) => r.promise)),
+        new Promise((resolve) => setTimeout(resolve, SHUTDOWN_GRACE_MS).unref())
+      ]);
+    }
+    const now = Date.now();
+    try {
+      for (const shipId of serving) {
+        await setDoc2(
+          doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.runners, config2.runnerId),
+          {
+            status: "offline",
+            lastSeenAt: now,
+            currentJob: deleteField2(),
+            currentJobs: deleteField2()
+          },
+          { merge: true }
+        );
+      }
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", () => void shutdown("SIGINT received"));
+  process.on("SIGTERM", () => void shutdown("SIGTERM received"));
+  const loggedRefusals = /* @__PURE__ */ new Set();
+  let checkingUpdate = false;
+  let applyingUpdate = false;
+  function updateFacts(distTags) {
     return {
-      start: (msg) => process.stderr.write(`${msg}
-`),
-      update: (msg) => process.stderr.write(`${msg}
-`),
-      stop: (msg) => msg && process.stderr.write(`${msg}
-`)
+      platform: process.platform,
+      current: RUNNER_VERSION,
+      autoUpdate: config2.autoUpdate !== false,
+      // absent means on
+      channel: resolveChannel(RUNNER_VERSION, config2, process.env),
+      // THUNKS. Both shell out synchronously, and the ladder refuses most machines before it
+      // reaches them — see the note on `UpdateFacts.service`.
+      service: () => {
+        const s = serviceStatus();
+        return { state: s.state, execPath: s.execPath };
+      },
+      npmPresent,
+      cliPath: cliPath(),
+      distTags,
+      state: readUpdateState(),
+      now: Date.now()
     };
   }
-  const s = clack.spinner();
-  return {
-    start: (msg) => s.start(msg),
-    update: (msg) => s.message(msg),
-    stop: (msg) => s.stop(msg)
-  };
-}
-function unwrap(value) {
-  if (clack.isCancel(value)) throw new CliError("Cancelled.", 130);
-  return value;
-}
-async function promptMultiSelect(options) {
-  requireInteractive(options.message, options.flagHint);
-  return unwrap(
-    await clack.multiselect({
-      message: options.message,
-      options: options.choices,
-      initialValues: options.initialValues,
-      required: options.required ?? false
-    })
-  );
-}
-async function promptConfirm(options) {
-  if (assumeYes && options.yesFlagApplies !== false) return true;
-  requireInteractive(options.message, "--yes");
-  return unwrap(await clack.confirm({ message: options.message, initialValue: options.initialValue }));
-}
-function glyph(level) {
-  if (level === "ok") return pc.green("\u2714");
-  if (level === "warn") return pc.yellow("\u25B2");
-  return pc.red("\u2716");
-}
-
-// src/cli/commands/config.ts
-var TOGGLES = {
-  notifications: "Desktop notifications when a job starts, finishes or fails",
-  keepAwake: "Keep this machine awake while a job is running"
-};
-var PARALLEL = "parallel";
-var PARALLEL_HELP = "How many jobs to run at once (1 = one at a time, as before)";
-var DEFAULT_WORDS = ["default", "auto", "reset"];
-function isToggle(key) {
-  return Object.hasOwn(TOGGLES, key);
-}
-function parseBool(value) {
-  if (["on", "true", "yes", "1"].includes(value.toLowerCase())) return true;
-  if (["off", "false", "no", "0"].includes(value.toLowerCase())) return false;
-  throw new CliError(`Expected on/off, got "${value}".`);
-}
-function parseParallel(value) {
-  if (DEFAULT_WORDS.includes(value.toLowerCase())) return null;
-  const n = Number(value);
-  if (!Number.isInteger(n) || n < 1 || n > PARALLEL_MAX) {
-    throw new CliError(
-      `Expected a whole number from 1 to ${PARALLEL_MAX} (or "default"), got "${value}".`
-    );
-  }
-  return n;
-}
-async function runConfigList() {
-  const config2 = requireConfig();
-  const values = Object.fromEntries(
-    Object.keys(TOGGLES).map((key) => [key, config2[key] !== false])
-  );
-  const machine = machineCap(config2);
-  const ships = config2.ships.map((shipId) => ({
-    shipId,
-    parallel: shipCap(config2, shipId),
-    explicit: config2.shipParallelJobs?.[shipId] !== void 0
-  }));
-  if (isJson()) {
-    emitJson({ configDir: configDir(), ...values, parallel: machine, ships });
-    return 0;
-  }
-  say.line(`  ${configDir()}`);
-  say.line("");
-  for (const key of Object.keys(TOGGLES)) {
-    say.line(`  ${key.padEnd(16)} ${values[key] ? "on" : "off"}   ${TOGGLES[key]}`);
+  function refuse(reason) {
+    if (loggedRefusals.has(reason)) return;
+    loggedRefusals.add(reason);
+    if (reason !== "up-to-date") log2(describeRefusal(reason, { current: RUNNER_VERSION }));
   }
-  say.line(`  ${PARALLEL.padEnd(16)} ${String(machine).padEnd(2)}   ${PARALLEL_HELP}`);
-  if (ships.length > 0) {
-    say.line("");
-    for (const ship2 of ships) {
-      const note2 = ship2.explicit ? "" : " (machine default)";
-      say.line(`  ${`${PARALLEL} --ship`.padEnd(16)} ${ship2.shipId} = ${ship2.parallel}${note2}`);
+  async function maybeCheckForUpdate() {
+    if (checkingUpdate || updating || shuttingDown || Date.now() < nextUpdateCheckAt) return;
+    checkingUpdate = true;
+    try {
+      const local = decideUpdate(updateFacts(null));
+      if (!local.update && local.reason !== "registry-unreachable") {
+        refuse(local.reason);
+        return;
+      }
+      const decision = decideUpdate(updateFacts(await fetchDistTags()));
+      if (!decision.update) {
+        refuse(decision.reason);
+        return;
+      }
+      loggedRefusals.clear();
+      beginUpdate(decision.target, decision.channel);
+    } catch (e) {
+      log2(`Update check failed: ${e instanceof Error ? e.message : e}`);
+    } finally {
+      checkingUpdate = false;
+      nextUpdateCheckAt = Date.now() + checkIntervalMs(config2);
     }
   }
-  return 0;
-}
-async function runConfigSet(key, value, options = {}) {
-  const config2 = requireConfig();
-  if (key === PARALLEL) return setParallel(config2, value, options.ship);
-  if (!isToggle(key)) {
-    throw new CliError(
-      `Unknown setting "${key}". Known: ${[...Object.keys(TOGGLES), PARALLEL].join(", ")}.`
+  function beginUpdate(target, channel) {
+    updating = { target, channel };
+    updateAvailableVersion = target;
+    updatePhase = "draining";
+    log2(
+      `Update available: ${RUNNER_VERSION} \u2192 ${target} (${channel}). Not claiming new jobs; ${running.size} in flight.`
     );
-  }
-  if (options.ship) {
-    throw new CliError(`"${key}" is a machine-wide setting \u2014 it takes no --ship.`);
-  }
-  config2[key] = parseBool(value);
-  saveConfig(config2);
-  if (isJson()) {
-    emitJson({ [key]: config2[key] });
-    return 0;
-  }
-  say.success(`${key} = ${config2[key] ? "on" : "off"}`);
-  return 0;
-}
-function setParallel(config2, value, ship2) {
-  const parsed = parseParallel(value);
-  if (ship2) {
-    if (!config2.ships.includes(ship2)) {
-      throw new CliError(
-        `This machine does not serve Ship "${ship2}". Run \`lumi-runner ship list\` to see which Ships it serves, or \`lumi-runner ship add ${ship2}\` to add it.`
-      );
-    }
-    const overrides = { ...config2.shipParallelJobs ?? {} };
-    if (parsed === null) delete overrides[ship2];
-    else overrides[ship2] = parsed;
-    config2.shipParallelJobs = overrides;
-  } else if (parsed === null) {
-    delete config2.maxParallelJobs;
-  } else {
-    config2.maxParallelJobs = parsed;
-  }
-  saveConfig(config2);
-  const effective = ship2 ? shipCap(config2, ship2) : machineCap(config2);
-  if (isJson()) {
-    emitJson({ parallel: effective, ...ship2 ? { shipId: ship2 } : {} });
-    return 0;
-  }
-  const machine = machineCap(config2);
-  say.success(
-    ship2 ? `${PARALLEL} for Ship ${ship2} = ${effective}${parsed === null ? " (machine default)" : ""}` : `${PARALLEL} = ${effective}`
-  );
-  if (ship2 && parsed !== null && parsed > machine) {
-    say.line(
-      `  Capped at the machine-wide limit of ${machine}. Raise it with \`lumi-runner config set ${PARALLEL} ${parsed}\`.`
+    updateDrainTimer = setTimeout(
+      () => abandonUpdate("jobs did not finish in time"),
+      UPDATE_DRAIN_MAX_MS
     );
-  }
-  say.line("  Restart the daemon for this to take effect: `lumi-runner service restart`.");
-  return 0;
-}
-
-// src/cli/commands/doctor.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import { collection as collection6, doc as doc8, getDoc as getDoc6, getDocs as getDocs5 } from "firebase/firestore";
-
-// src/service.ts
-import { spawnSync } from "node:child_process";
-import fs4 from "node:fs";
-import os4 from "node:os";
-import path4 from "node:path";
-import { fileURLToPath } from "node:url";
-var SERVICE_LABEL = "com.lumi.runner";
-var LINUX_UNIT = "lumi-runner.service";
-var WINDOWS_TASK = "LumiRunner";
-var LEGACY_SERVICE_LABEL = "com.lumi.crew-runner";
-var LEGACY_LINUX_UNIT = "crew-runner.service";
-var LEGACY_WINDOWS_TASK = "CrewRunner";
-var ServiceError = class extends Error {
-};
-function run(command, args) {
-  const result = spawnSync(command, args, { encoding: "utf8" });
-  return {
-    ok: result.status === 0,
-    out: `${result.stdout ?? ""}${result.stderr ?? ""}`.trim()
-  };
-}
-function cliPath() {
-  return fileURLToPath(import.meta.url);
-}
-function uid() {
-  return String(process.getuid?.() ?? 0);
-}
-function launchAgentPath() {
-  return path4.join(os4.homedir(), "Library/LaunchAgents", `${SERVICE_LABEL}.plist`);
-}
-function systemdUnitPath() {
-  return path4.join(os4.homedir(), ".config/systemd/user", LINUX_UNIT);
-}
-function legacyLaunchAgentPath() {
-  return path4.join(os4.homedir(), "Library/LaunchAgents", `${LEGACY_SERVICE_LABEL}.plist`);
-}
-function legacySystemdUnitPath() {
-  return path4.join(os4.homedir(), ".config/systemd/user", LEGACY_LINUX_UNIT);
-}
-function serviceEnv() {
-  const env = { PATH: process.env.PATH ?? "" };
-  if (process.env.LUMI_RUNNER_HOME || process.env.CREW_RUNNER_HOME) {
-    env.LUMI_RUNNER_HOME = configDir();
-  }
-  return env;
-}
-function removeLegacyService() {
-  const removed = [];
-  if (process.platform === "darwin") {
-    const unitPath = legacyLaunchAgentPath();
-    if (fs4.existsSync(unitPath)) {
-      run("launchctl", ["bootout", `gui/${uid()}/${LEGACY_SERVICE_LABEL}`]);
-      fs4.rmSync(unitPath, { force: true });
-      removed.push(unitPath);
+    updateDrainTimer.unref();
+    if (running.size === 0) void applyUpdate();
+  }
+  function abandonUpdate(why) {
+    if (!updating) return;
+    const { target } = updating;
+    updating = null;
+    updateAvailableVersion = null;
+    updatePhase = null;
+    if (updateDrainTimer) {
+      clearTimeout(updateDrainTimer);
+      updateDrainTimer = null;
     }
-    return removed;
-  }
-  if (process.platform === "linux") {
-    const unitPath = legacySystemdUnitPath();
-    if (fs4.existsSync(unitPath)) {
-      run("systemctl", ["--user", "disable", "--now", LEGACY_LINUX_UNIT]);
-      fs4.rmSync(unitPath, { force: true });
-      run("systemctl", ["--user", "daemon-reload"]);
-      removed.push(unitPath);
+    log2(`Update to ${target} abandoned \u2014 ${why}. Claiming again; will retry later.`);
+    poke();
+  }
+  async function applyUpdate() {
+    if (!updating || applyingUpdate || shuttingDown) return;
+    applyingUpdate = true;
+    const { target } = updating;
+    if (updateDrainTimer) {
+      clearTimeout(updateDrainTimer);
+      updateDrainTimer = null;
+    }
+    try {
+      updatePhase = "installing";
+      log2(`No jobs in flight \u2014 installing ${PACKAGE_NAME}@${target}\u2026`);
+      await heartbeat();
+      const previous = readUpdateState();
+      const attempts = previous?.target === target ? (previous.attempts ?? 0) + 1 : 1;
+      writeUpdateState({ target, from: RUNNER_VERSION, attempts, at: Date.now() });
+      const result = await installGlobal(target, cliPath());
+      if (!result.ok) {
+        applyingUpdate = false;
+        abandonUpdate(`npm install failed: ${result.detail.slice(0, 200)}`);
+        return;
+      }
+      const onDisk = installedVersionAt(cliPath());
+      if (onDisk !== target) {
+        applyingUpdate = false;
+        abandonUpdate(
+          `npm reported success but ${cliPath()} is still ${onDisk ?? "unreadable"} \u2014 the install probably went to a different npm prefix`
+        );
+        return;
+      }
+      log2(`Updated to ${target} \u2014 restarting to pick it up.`);
+      await shutdown(`Updated to ${target}`);
+    } catch (e) {
+      applyingUpdate = false;
+      abandonUpdate(`the install threw: ${e instanceof Error ? e.message : e}`);
     }
-    return removed;
   }
-  if (process.platform === "win32") {
-    if (run("schtasks", ["/Query", "/TN", LEGACY_WINDOWS_TASK]).ok) {
-      run("schtasks", ["/Delete", "/TN", LEGACY_WINDOWS_TASK, "/F"]);
-      removed.push(LEGACY_WINDOWS_TASK);
+  {
+    const verdict = reconcile(readUpdateState(), RUNNER_VERSION);
+    if (verdict.action === "clear") {
+      log2(`Self-update to ${verdict.target} completed.`);
+      clearUpdateState();
+    } else if (verdict.action === "keep") {
+      log2(
+        `A previous self-update to ${verdict.state.target} did not take \u2014 still on ${RUNNER_VERSION} (attempt ${verdict.state.attempts} of ${MAX_UPDATE_ATTEMPTS}).`
+      );
     }
-    return removed;
   }
-  return removed;
-}
-var BOOTSTRAP_RETRY_DELAYS_MS = [250, 500, 1e3, 2e3, 2e3];
-function isTransientBootstrapError(out) {
-  const text = out.toLowerCase();
-  return (
-    // The observed one: `Bootstrap failed: 5: Input/output error`.
-    text.includes("input/output error") || // Same cause, different report: the old generation is still registered.
-    text.includes("service already loaded") || text.includes("service is already loaded") || text.includes("eexist") || // launchd is mid-teardown and says so.
-    text.includes("operation already in progress") || text.includes("operation now in progress")
+  const caps = [...serving].map((s) => `${s}:${shipCap(config2, s)}`).join(" ");
+  log2(
+    `Runner online \u2014 watching ${serving.size} Ship(s), up to ${machineCap(config2)} job(s) at once (${caps}), MCP: ${mcpUrl(config2)}`
   );
+  log2(
+    `Version ${RUNNER_VERSION} on the ${resolveChannel(RUNNER_VERSION, config2, process.env)} channel; auto-update ${config2.autoUpdate === false ? "off" : "on"}.`
+  );
+  await new Promise(() => {
+  });
 }
-function retryWhileTransient(attempt, wait, delays = BOOTSTRAP_RETRY_DELAYS_MS) {
-  let result = attempt();
-  for (const delay of delays) {
-    if (result.ok || !isTransientBootstrapError(result.out)) return result;
-    wait(delay);
-    result = attempt();
+
+// src/cli/ui.ts
+import * as clack from "@clack/prompts";
+import { createColors } from "picocolors";
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
   }
-  return result;
-}
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function plistXml() {
-  const env = serviceEnv();
-  const envEntries = Object.entries(env).map(([k, v]) => `      <key>${k}</key>
-      <string>${escapeXml(v)}</string>`).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>${SERVICE_LABEL}</string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>${escapeXml(process.execPath)}</string>
-    <string>${escapeXml(cliPath())}</string>
-    <string>start</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>KeepAlive</key>
-  <true/>
-  <key>ExitTimeOut</key>
-  <integer>20</integer>
-  <key>EnvironmentVariables</key>
-  <dict>
-${envEntries}
-  </dict>
-  <key>StandardOutPath</key>
-  <string>${escapeXml(path4.join(logDir(), "service.out.log"))}</string>
-  <key>StandardErrorPath</key>
-  <string>${escapeXml(path4.join(logDir(), "service.err.log"))}</string>
-</dict>
-</plist>
-`;
+  exitCode;
+};
+var jsonMode = false;
+var assumeYes = false;
+var palette = createColors();
+var delegate = (name) => (input) => palette[name](input);
+var pc = {
+  bold: delegate("bold"),
+  dim: delegate("dim"),
+  black: delegate("black"),
+  red: delegate("red"),
+  green: delegate("green"),
+  yellow: delegate("yellow"),
+  cyan: delegate("cyan"),
+  bgCyan: delegate("bgCyan")
+};
+function configureOutput(options) {
+  jsonMode = options.json === true;
+  assumeYes = options.yes === true;
+  if (options.color === false || jsonMode) palette = createColors(false);
 }
-function escapeXml(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+function isJson() {
+  return jsonMode;
 }
-function unescapeXml(value) {
-  return value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
+function emitJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
 }
-function parsePlistCliPath(plist) {
-  const block = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(plist);
-  if (!block) return void 0;
-  const args = [...block[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => unescapeXml(m[1]));
-  return args.length >= 2 ? args[1] : void 0;
+function canPrompt() {
+  return !jsonMode && process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
-function parseSystemdCliPath(unit) {
-  const line = /^ExecStart=(.*)$/m.exec(unit);
-  if (!line) return void 0;
-  const command = line[1].trim();
-  if (!command.endsWith(" start")) return void 0;
-  const parts = command.slice(0, -" start".length).split(" ");
-  return parts.length === 2 ? parts[1] : void 0;
+function requireInteractive(what, flagHint) {
+  if (canPrompt()) return;
+  throw new CliError(
+    `${what} needs an interactive terminal. Run it in a terminal, or pass ${pc.bold(flagHint)}.`
+  );
 }
-function execFacts(unitPath, parse) {
-  let text;
-  try {
-    text = fs4.readFileSync(unitPath, "utf8");
-  } catch {
-    return {};
+var say = {
+  intro(title) {
+    if (!jsonMode) clack.intro(pc.bgCyan(pc.black(` ${title} `)));
+  },
+  outro(message) {
+    if (!jsonMode) clack.outro(message);
+  },
+  info(message) {
+    if (!jsonMode) clack.log.info(message);
+  },
+  success(message) {
+    if (!jsonMode) clack.log.success(message);
+  },
+  warn(message) {
+    if (!jsonMode) clack.log.warn(message);
+  },
+  error(message) {
+    if (!jsonMode) clack.log.error(message);
+  },
+  step(message) {
+    if (!jsonMode) clack.log.step(message);
+  },
+  note(body, title) {
+    if (!jsonMode) clack.note(body, title);
+  },
+  /** Raw line straight to stdout — for `logs`, where the content IS the output. */
+  line(message) {
+    process.stdout.write(`${message}
+`);
   }
-  const execPath = parse(text);
-  if (!execPath || !path4.isAbsolute(execPath)) return {};
-  return { execPath, execMissing: !fs4.existsSync(execPath) };
-}
-function systemdUnit() {
-  const env = serviceEnv();
-  const envLines = Object.entries(env).map(([k, v]) => `Environment="${k}=${v}"`).join("\n");
-  return `[Unit]
-Description=Lumi Crew runner daemon
-After=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${process.execPath} ${cliPath()} start
-Restart=always
-RestartSec=5
-# Must exceed the daemon's SHUTDOWN_GRACE_MS: a SIGKILL mid-release is exactly the stranded
-# job the graceful shutdown exists to prevent.
-TimeoutStopSec=20
-${envLines}
-
-[Install]
-WantedBy=default.target
-`;
-}
-function serviceStatus() {
-  if (process.platform === "darwin") {
-    const unitPath = launchAgentPath();
-    if (!fs4.existsSync(unitPath)) return { state: "not-installed", detail: "No LaunchAgent installed." };
-    const exec = execFacts(unitPath, parsePlistCliPath);
-    const printed = run("launchctl", ["print", `gui/${uid()}/${SERVICE_LABEL}`]);
-    if (!printed.ok) {
-      return { state: "installed", detail: "LaunchAgent present but not loaded.", unitPath, ...exec };
-    }
-    const running = /\bpid = \d+/.test(printed.out);
-    return {
-      state: running ? "running" : "installed",
-      detail: running ? "LaunchAgent loaded and running." : "LaunchAgent loaded but not running.",
-      unitPath,
-      ...exec
-    };
+};
+function spinner2() {
+  if (jsonMode) {
+    return { start: () => {
+    }, update: () => {
+    }, stop: () => {
+    } };
   }
-  if (process.platform === "linux") {
-    const unitPath = systemdUnitPath();
-    if (!fs4.existsSync(unitPath)) return { state: "not-installed", detail: "No systemd user unit installed." };
-    const active = run("systemctl", ["--user", "is-active", LINUX_UNIT]);
+  if (!canPrompt()) {
     return {
-      state: active.out === "active" ? "running" : "installed",
-      detail: `systemd user unit is ${active.out || "unknown"}.`,
-      unitPath,
-      ...execFacts(unitPath, parseSystemdCliPath)
+      start: (msg) => process.stderr.write(`${msg}
+`),
+      update: (msg) => process.stderr.write(`${msg}
+`),
+      stop: (msg) => msg && process.stderr.write(`${msg}
+`)
     };
   }
-  if (process.platform === "win32") {
-    const query6 = run("schtasks", ["/Query", "/TN", WINDOWS_TASK]);
-    if (!query6.ok) return { state: "not-installed", detail: "No scheduled task installed." };
-    return {
-      state: /\bRunning\b/i.test(query6.out) ? "running" : "installed",
-      detail: "Scheduled task installed (runs at logon).",
-      unitPath: WINDOWS_TASK
-    };
+  const s = clack.spinner();
+  return {
+    start: (msg) => s.start(msg),
+    update: (msg) => s.message(msg),
+    stop: (msg) => s.stop(msg)
+  };
+}
+function unwrap(value) {
+  if (clack.isCancel(value)) throw new CliError("Cancelled.", 130);
+  return value;
+}
+async function promptMultiSelect(options) {
+  requireInteractive(options.message, options.flagHint);
+  return unwrap(
+    await clack.multiselect({
+      message: options.message,
+      options: options.choices,
+      initialValues: options.initialValues,
+      required: options.required ?? false
+    })
+  );
+}
+async function promptConfirm(options) {
+  if (assumeYes && options.yesFlagApplies !== false) return true;
+  requireInteractive(options.message, "--yes");
+  return unwrap(await clack.confirm({ message: options.message, initialValue: options.initialValue }));
+}
+function glyph(level) {
+  if (level === "ok") return pc.green("\u2714");
+  if (level === "warn") return pc.yellow("\u25B2");
+  return pc.red("\u2716");
+}
+
+// src/cli/commands/config.ts
+var TOGGLES = {
+  notifications: "Desktop notifications when a job starts, finishes or fails",
+  keepAwake: "Keep this machine awake while a job is running",
+  autoUpdate: "Install new versions of the runner by itself and restart (PRD \xA715.37)"
+};
+var PARALLEL = "parallel";
+var PARALLEL_HELP = "How many jobs to run at once (1 = one at a time, as before)";
+var CHANNEL = "channel";
+var CHANNEL_HELP = "Which npm release channel to follow (default: derived from the version)";
+var CHECK_EVERY = "checkEvery";
+var CHECK_EVERY_HELP = `Minutes between update checks (${CHECK_MINUTES_MIN}-${CHECK_MINUTES_MAX})`;
+var DEFAULT_WORDS = ["default", "auto", "reset"];
+function isToggle(key) {
+  return Object.hasOwn(TOGGLES, key);
+}
+function parseChannel(value) {
+  if (DEFAULT_WORDS.includes(value.toLowerCase())) return null;
+  const lower = value.toLowerCase();
+  if (CHANNELS.includes(lower)) return lower;
+  throw new CliError(`Expected ${CHANNELS.join(" or ")} (or "default"), got "${value}".`);
+}
+function parseCheckEvery(value) {
+  if (DEFAULT_WORDS.includes(value.toLowerCase())) return null;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < CHECK_MINUTES_MIN || n > CHECK_MINUTES_MAX) {
+    throw new CliError(
+      `Expected a whole number of minutes from ${CHECK_MINUTES_MIN} to ${CHECK_MINUTES_MAX} (or "default"), got "${value}".`
+    );
+  }
+  return n;
+}
+function parseBool(value) {
+  if (["on", "true", "yes", "1"].includes(value.toLowerCase())) return true;
+  if (["off", "false", "no", "0"].includes(value.toLowerCase())) return false;
+  throw new CliError(`Expected on/off, got "${value}".`);
+}
+function parseParallel(value) {
+  if (DEFAULT_WORDS.includes(value.toLowerCase())) return null;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1 || n > PARALLEL_MAX) {
+    throw new CliError(
+      `Expected a whole number from 1 to ${PARALLEL_MAX} (or "default"), got "${value}".`
+    );
   }
-  return { state: "unsupported", detail: `No service integration for ${process.platform}.` };
+  return n;
 }
-function installService() {
-  const notes = [];
-  fs4.mkdirSync(logDir(), { recursive: true, mode: 448 });
-  for (const unit of removeLegacyService()) {
-    notes.push(`Removed the previous crew-runner service (${unit}).`);
+async function runConfigList() {
+  const config2 = requireConfig();
+  const values = Object.fromEntries(
+    Object.keys(TOGGLES).map((key) => [key, config2[key] !== false])
+  );
+  const machine = machineCap(config2);
+  const ships = config2.ships.map((shipId) => ({
+    shipId,
+    parallel: shipCap(config2, shipId),
+    explicit: config2.shipParallelJobs?.[shipId] !== void 0
+  }));
+  const channel = resolveChannel(RUNNER_VERSION, config2, process.env);
+  const checkEvery = checkIntervalMs(config2) / 6e4;
+  if (isJson()) {
+    emitJson({ configDir: configDir(), ...values, parallel: machine, channel, checkEvery, ships });
+    return 0;
   }
-  if (process.platform === "darwin") {
-    const unitPath = launchAgentPath();
-    fs4.mkdirSync(path4.dirname(unitPath), { recursive: true });
-    fs4.writeFileSync(unitPath, plistXml());
-    run("launchctl", ["bootout", `gui/${uid()}/${SERVICE_LABEL}`]);
-    const boot = retryWhileTransient(
-      () => run("launchctl", ["bootstrap", `gui/${uid()}`, unitPath]),
-      sleepSync
-    );
-    if (!boot.ok) throw new ServiceError(`launchctl bootstrap failed: ${boot.out}`);
-    return { unitPath, notes };
+  say.line(`  ${configDir()}`);
+  say.line("");
+  for (const key of Object.keys(TOGGLES)) {
+    say.line(`  ${key.padEnd(16)} ${values[key] ? "on" : "off"}   ${TOGGLES[key]}`);
   }
-  if (process.platform === "linux") {
-    const unitPath = systemdUnitPath();
-    fs4.mkdirSync(path4.dirname(unitPath), { recursive: true });
-    fs4.writeFileSync(unitPath, systemdUnit());
-    const reload = run("systemctl", ["--user", "daemon-reload"]);
-    if (!reload.ok) throw new ServiceError(`systemctl daemon-reload failed: ${reload.out}`);
-    const enable = run("systemctl", ["--user", "enable", "--now", LINUX_UNIT]);
-    if (!enable.ok) throw new ServiceError(`systemctl enable failed: ${enable.out}`);
-    const linger = run("loginctl", ["show-user", os4.userInfo().username, "--property=Linger"]);
-    if (!linger.out.includes("Linger=yes")) {
-      notes.push(
-        `Run \`sudo loginctl enable-linger ${os4.userInfo().username}\` so the daemon survives logout and starts at boot.`
-      );
+  say.line(`  ${PARALLEL.padEnd(16)} ${String(machine).padEnd(2)}   ${PARALLEL_HELP}`);
+  say.line(`  ${CHANNEL.padEnd(16)} ${channel.padEnd(2)}   ${CHANNEL_HELP}`);
+  say.line(`  ${CHECK_EVERY.padEnd(16)} ${String(checkEvery).padEnd(2)}   ${CHECK_EVERY_HELP}`);
+  if (ships.length > 0) {
+    say.line("");
+    for (const ship2 of ships) {
+      const note2 = ship2.explicit ? "" : " (machine default)";
+      say.line(`  ${`${PARALLEL} --ship`.padEnd(16)} ${ship2.shipId} = ${ship2.parallel}${note2}`);
     }
-    return { unitPath, notes };
   }
-  if (process.platform === "win32") {
-    const command = `"${process.execPath}" "${cliPath()}" start`;
-    const create = run("schtasks", [
-      "/Create",
-      "/TN",
-      WINDOWS_TASK,
-      "/TR",
-      command,
-      "/SC",
-      "ONLOGON",
-      "/RL",
-      "LIMITED",
-      "/F"
-    ]);
-    if (!create.ok) throw new ServiceError(`schtasks /Create failed: ${create.out}`);
-    notes.push(
-      "Task Scheduler starts the daemon at logon but does not restart it if it exits. For a true always-on box, run the daemon under pm2 or a Windows service wrapper instead."
+  return 0;
+}
+async function runConfigSet(key, value, options = {}) {
+  const config2 = requireConfig();
+  if (key === PARALLEL) return setParallel(config2, value, options.ship);
+  if (key === CHANNEL || key === CHECK_EVERY) return setUpdateSetting(config2, key, value, options.ship);
+  if (!isToggle(key)) {
+    throw new CliError(
+      `Unknown setting "${key}". Known: ${[...Object.keys(TOGGLES), PARALLEL, CHANNEL, CHECK_EVERY].join(", ")}.`
     );
-    return { unitPath: WINDOWS_TASK, notes };
   }
-  throw new ServiceError(`Service install is not supported on ${process.platform}.`);
+  if (options.ship) {
+    throw new CliError(`"${key}" is a machine-wide setting \u2014 it takes no --ship.`);
+  }
+  config2[key] = parseBool(value);
+  saveConfig(config2);
+  if (isJson()) {
+    emitJson({ [key]: config2[key] });
+    return 0;
+  }
+  say.success(`${key} = ${config2[key] ? "on" : "off"}`);
+  return 0;
 }
-function uninstallService() {
-  removeLegacyService();
-  if (process.platform === "darwin") {
-    run("launchctl", ["bootout", `gui/${uid()}/${SERVICE_LABEL}`]);
-    fs4.rmSync(launchAgentPath(), { force: true });
-    return;
+function setUpdateSetting(config2, key, value, ship2) {
+  if (ship2) throw new CliError(`"${key}" is a machine-wide setting \u2014 it takes no --ship.`);
+  if (key === CHANNEL) {
+    const parsed = parseChannel(value);
+    if (parsed === null) delete config2.updateChannel;
+    else config2.updateChannel = parsed;
+  } else {
+    const parsed = parseCheckEvery(value);
+    if (parsed === null) delete config2.updateCheckMinutes;
+    else config2.updateCheckMinutes = parsed;
   }
-  if (process.platform === "linux") {
-    run("systemctl", ["--user", "disable", "--now", LINUX_UNIT]);
-    fs4.rmSync(systemdUnitPath(), { force: true });
-    run("systemctl", ["--user", "daemon-reload"]);
-    return;
+  saveConfig(config2);
+  const channel = resolveChannel(RUNNER_VERSION, config2, process.env);
+  const minutes = checkIntervalMs(config2) / 6e4;
+  if (isJson()) {
+    emitJson({ channel, checkEvery: minutes });
+    return 0;
   }
-  if (process.platform === "win32") {
-    run("schtasks", ["/Delete", "/TN", WINDOWS_TASK, "/F"]);
-    return;
+  say.success(key === CHANNEL ? `${CHANNEL} = ${channel}` : `${CHECK_EVERY} = ${minutes}`);
+  if (key === CHANNEL && config2.updateChannel === void 0) {
+    say.line(`  Derived from the installed version (${RUNNER_VERSION}).`);
   }
-  throw new ServiceError(`Service uninstall is not supported on ${process.platform}.`);
+  if (key === CHANNEL && parseChannel(value) === "latest" && RUNNER_VERSION.includes("-")) {
+    say.line(
+      `  This machine is on a prerelease (${RUNNER_VERSION}). If \`latest\` is behind it, nothing will install until a stable release passes it \u2014 to move now: \`npm i -g @lumi.ai/runner@latest\`.`
+    );
+  }
+  say.line("  Restart the daemon for this to take effect: `lumi-runner service restart`.");
+  return 0;
 }
-function restartService() {
-  if (process.platform === "darwin") {
-    const result = run("launchctl", ["kickstart", "-k", `gui/${uid()}/${SERVICE_LABEL}`]);
-    if (!result.ok) throw new ServiceError(`launchctl kickstart failed: ${result.out}`);
-    return;
+function setParallel(config2, value, ship2) {
+  const parsed = parseParallel(value);
+  if (ship2) {
+    if (!config2.ships.includes(ship2)) {
+      throw new CliError(
+        `This machine does not serve Ship "${ship2}". Run \`lumi-runner ship list\` to see which Ships it serves, or \`lumi-runner ship add ${ship2}\` to add it.`
+      );
+    }
+    const overrides = { ...config2.shipParallelJobs ?? {} };
+    if (parsed === null) delete overrides[ship2];
+    else overrides[ship2] = parsed;
+    config2.shipParallelJobs = overrides;
+  } else if (parsed === null) {
+    delete config2.maxParallelJobs;
+  } else {
+    config2.maxParallelJobs = parsed;
   }
-  if (process.platform === "linux") {
-    const result = run("systemctl", ["--user", "restart", LINUX_UNIT]);
-    if (!result.ok) throw new ServiceError(`systemctl restart failed: ${result.out}`);
-    return;
+  saveConfig(config2);
+  const effective = ship2 ? shipCap(config2, ship2) : machineCap(config2);
+  if (isJson()) {
+    emitJson({ parallel: effective, ...ship2 ? { shipId: ship2 } : {} });
+    return 0;
   }
-  if (process.platform === "win32") {
-    run("schtasks", ["/End", "/TN", WINDOWS_TASK]);
-    const result = run("schtasks", ["/Run", "/TN", WINDOWS_TASK]);
-    if (!result.ok) throw new ServiceError(`schtasks /Run failed: ${result.out}`);
-    return;
+  const machine = machineCap(config2);
+  say.success(
+    ship2 ? `${PARALLEL} for Ship ${ship2} = ${effective}${parsed === null ? " (machine default)" : ""}` : `${PARALLEL} = ${effective}`
+  );
+  if (ship2 && parsed !== null && parsed > machine) {
+    say.line(
+      `  Capped at the machine-wide limit of ${machine}. Raise it with \`lumi-runner config set ${PARALLEL} ${parsed}\`.`
+    );
   }
-  throw new ServiceError(`Service restart is not supported on ${process.platform}.`);
+  say.line("  Restart the daemon for this to take effect: `lumi-runner service restart`.");
+  return 0;
 }
 
+// src/cli/commands/doctor.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import { collection as collection6, doc as doc8, getDoc as getDoc7, getDocs as getDocs5 } from "firebase/firestore";
+
 // src/cli/session.ts
 async function openShipSession(shipId) {
   const config2 = requireConfig();
@@ -3681,7 +4203,7 @@ var fail = (id, label, detail, fix) => ({
 });
 function onPath(binary) {
   const probe = process.platform === "win32" ? "where" : "which";
-  return spawnSync2(probe, [binary], { stdio: "ignore" }).status === 0;
+  return spawnSync3(probe, [binary], { stdio: "ignore" }).status === 0;
 }
 function checkNode() {
   const major = Number(process.versions.node.split(".")[0]);
@@ -3727,6 +4249,33 @@ function serviceCheckFrom(status) {
 function checkService() {
   return serviceCheckFrom(serviceStatus());
 }
+function versionCheckFrom(input) {
+  const { current, latest, channel, autoUpdate } = input;
+  const label = "Runner version";
+  if (current === DEV_VERSION) {
+    return ok("version", label, `${current} \u2014 development build, not checked.`);
+  }
+  if (latest === null) {
+    return warn("version", label, `${current} \u2014 could not reach the npm registry to check.`);
+  }
+  if (!isNewer(latest, current)) return ok("version", label, `${current} (${channel})`);
+  return warn(
+    "version",
+    label,
+    `${current} \u2014 ${latest} is available on \`${channel}\`.`,
+    autoUpdate ? "Nothing to do \u2014 this machine installs it by itself. `lumi-runner update` does it now." : "Auto-update is off. Run `lumi-runner update`."
+  );
+}
+async function checkVersion(config2) {
+  const channel = resolveChannel(RUNNER_VERSION, config2, process.env);
+  const tags = await fetchDistTags();
+  return versionCheckFrom({
+    current: RUNNER_VERSION,
+    latest: tags?.[channel] ?? null,
+    channel,
+    autoUpdate: config2.autoUpdate !== false
+  });
+}
 async function checkShips(config2) {
   const checks = [];
   const engines = /* @__PURE__ */ new Set();
@@ -3754,7 +4303,7 @@ async function checkShips(config2) {
       continue;
     }
     try {
-      const snap = await getDoc6(
+      const snap = await getDoc7(
         doc8(fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.runners, config2.runnerId)
       );
       if (!snap.exists()) {
@@ -3862,6 +4411,7 @@ async function runDoctor() {
   }
   checks.push(await checkMcp(mcpUrl(config2)));
   checks.push(checkService());
+  checks.push(await checkVersion(config2));
   progress.stop("Checks complete.");
   return report(checks);
 }
@@ -3894,7 +4444,7 @@ function report(checks) {
 }
 
 // src/cli/commands/login.ts
-import { spawn as spawn4 } from "node:child_process";
+import { spawn as spawn5 } from "node:child_process";
 import os5 from "node:os";
 import { signInWithCustomToken as signInWithCustomToken2 } from "firebase/auth";
 function buildLoginResult(approved, existing, fallbackProjectId, mcpUrl2) {
@@ -3920,7 +4470,7 @@ function buildLoginResult(approved, existing, fallbackProjectId, mcpUrl2) {
 function openBrowser(url) {
   const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
   try {
-    const child = spawn4(command, args, { stdio: "ignore", detached: true });
+    const child = spawn5(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {
     });
     child.unref();
@@ -4140,20 +4690,20 @@ async function runServiceStatus() {
 }
 
 // src/cli/commands/uninstall.ts
-import fs5 from "node:fs";
+import fs7 from "node:fs";
 async function runUninstall(options) {
   const before = serviceStatus();
   const dir = configDir();
   const hadService = before.state !== "not-installed" && before.state !== "unsupported";
   if (hadService) uninstallService();
   let purged = false;
-  if (options.purge && fs5.existsSync(dir)) {
+  if (options.purge && fs7.existsSync(dir)) {
     const confirmed = await promptConfirm({
       message: `Delete ${dir}? This machine loses its identity \u2014 a captain has to approve it again after reinstalling.`,
       initialValue: false
     });
     if (confirmed) {
-      fs5.rmSync(dir, { recursive: true, force: true });
+      fs7.rmSync(dir, { recursive: true, force: true });
       purged = true;
     }
   }
@@ -4179,7 +4729,7 @@ async function runUninstall(options) {
 }
 
 // src/cli/commands/ship.ts
-import { doc as doc9, getDoc as getDoc7 } from "firebase/firestore";
+import { doc as doc9, getDoc as getDoc8 } from "firebase/firestore";
 async function listMyShips() {
   const config2 = requireConfig();
   const ids = Object.keys(config2.shipKeys ?? {});
@@ -4187,7 +4737,7 @@ async function listMyShips() {
     ids.map(async (id) => {
       try {
         const { fb } = await openShipSession(id);
-        const snap = await getDoc7(doc9(fb.db, COLLECTIONS.ships, id));
+        const snap = await getDoc8(doc9(fb.db, COLLECTIONS.ships, id));
         return { id, ...snap.data() };
       } catch {
         return null;
@@ -4314,7 +4864,7 @@ import {
   collection as collection7,
   doc as doc10,
   getCountFromServer as getCountFromServer2,
-  getDoc as getDoc8,
+  getDoc as getDoc9,
   getDocs as getDocs6,
   query as query5,
   where as where5
@@ -4352,7 +4902,7 @@ async function runStatus() {
       continue;
     }
     const shipRef = doc10(fb.db, COLLECTIONS.ships, shipId);
-    const mirrorSnap = await getDoc8(doc10(shipRef, COLLECTIONS.runners, config2.runnerId));
+    const mirrorSnap = await getDoc9(doc10(shipRef, COLLECTIONS.runners, config2.runnerId));
     const mirror = mirrorSnap.data();
     let queued = 0;
     try {
@@ -4363,7 +4913,7 @@ async function runStatus() {
     } catch {
       queued = 0;
     }
-    const usageSnap = await getDoc8(doc10(shipRef, COLLECTIONS.usageDaily, utcDay(Date.now())));
+    const usageSnap = await getDoc9(doc10(shipRef, COLLECTIONS.usageDaily, utcDay(Date.now())));
     const today = { ...EMPTY_USAGE_TOTALS, ...usageSnap.data()?.totals ?? {} };
     const now = Date.now();
     const limitsSnap = await getDocs6(collection7(shipRef, COLLECTIONS.engineLimits));
@@ -4427,6 +4977,106 @@ async function runStatus() {
   return 0;
 }
 
+// src/cli/commands/update.ts
+function pickChannel(option) {
+  if (option) {
+    const lower = option.toLowerCase();
+    if (!CHANNELS.includes(lower)) {
+      throw new CliError(`Expected ${CHANNELS.join(" or ")}, got "${option}".`);
+    }
+    return lower;
+  }
+  return resolveChannel(RUNNER_VERSION, loadConfig() ?? {}, process.env);
+}
+async function runUpdate(options = {}) {
+  if (RUNNER_VERSION === DEV_VERSION) {
+    if (isJson()) {
+      emitJson({ current: RUNNER_VERSION, updateAvailable: null, reason: "dev-build" });
+      return 0;
+    }
+    say.info("Development build \u2014 nothing to update.");
+    return 0;
+  }
+  const channel = pickChannel(options.channel);
+  const tags = await fetchDistTags();
+  const latest = tags?.[channel] ?? null;
+  if (latest === null) {
+    const reason = tags === null ? "the npm registry could not be reached" : `nothing is published on \`${channel}\``;
+    if (isJson()) {
+      emitJson({ current: RUNNER_VERSION, channel, updateAvailable: null, reason });
+      return options.check ? 0 : 1;
+    }
+    if (options.check) {
+      say.info(`Could not check for updates \u2014 ${reason}.`);
+      return 0;
+    }
+    throw new CliError(`Could not update \u2014 ${reason}.`);
+  }
+  if (!isNewer(latest, RUNNER_VERSION)) {
+    if (isJson()) {
+      emitJson({ current: RUNNER_VERSION, latest, channel, updateAvailable: null });
+      return 0;
+    }
+    say.success(`Already up to date \u2014 ${RUNNER_VERSION} on \`${channel}\`.`);
+    return 0;
+  }
+  if (options.check) {
+    if (isJson()) {
+      emitJson({ current: RUNNER_VERSION, latest, channel, updateAvailable: latest });
+      return 0;
+    }
+    say.info(`${RUNNER_VERSION} \u2192 ${latest} is available on \`${channel}\`.`);
+    say.line("  Install it with: lumi-runner update");
+    return 0;
+  }
+  const args = installArgs(latest, cliPath());
+  if (process.platform === "win32") {
+    if (isJson()) {
+      emitJson({ current: RUNNER_VERSION, latest, channel, updateAvailable: latest, command: `npm ${args.join(" ")}` });
+      return 0;
+    }
+    say.info(`${RUNNER_VERSION} \u2192 ${latest} is available.`);
+    say.line("  Windows locks the running file, so stop the task first, then install:");
+    say.line("    schtasks /End /TN LumiRunner");
+    say.line(`    npm ${args.join(" ")}`);
+    return 0;
+  }
+  if (options.dryRun) {
+    if (isJson()) {
+      emitJson({ current: RUNNER_VERSION, latest, channel, updateAvailable: latest, command: `npm ${args.join(" ")}`, installed: false });
+      return 0;
+    }
+    say.info(`Would run: npm ${args.join(" ")}`);
+    return 0;
+  }
+  if (!npmPresent()) throw new CliError("`npm` is not on PATH, so there is nothing to install with.");
+  say.line(`Installing ${PACKAGE_NAME}@${latest}\u2026`);
+  const result = await installGlobal(latest, cliPath());
+  if (!result.ok) throw new CliError(`npm install failed: ${result.detail.slice(0, 400)}`);
+  const onDisk = installedVersionAt(cliPath());
+  if (onDisk !== latest) {
+    throw new CliError(
+      `npm reported success, but ${cliPath()} is still ${onDisk ?? "unreadable"}. The install probably went to a different npm prefix \u2014 check \`npm prefix -g\` and which node is on PATH.`
+    );
+  }
+  clearUpdateState();
+  const service2 = serviceStatus();
+  let restarted = false;
+  if (service2.state === "running" || service2.state === "installed") {
+    restartService();
+    restarted = true;
+  }
+  if (isJson()) {
+    emitJson({ current: RUNNER_VERSION, latest, channel, installed: true, restarted });
+    return 0;
+  }
+  say.success(`Updated to ${latest}.`);
+  say.line(
+    restarted ? "  The background service has been restarted on the new version." : "  Restart your daemon to pick it up."
+  );
+  return 0;
+}
+
 // src/cli/index.ts
 var program = new Command();
 program.name("lumi-runner").description("Lumi Crew runner daemon \u2014 runs agent jobs for your Ships on this machine.").version(RUNNER_VERSION).option("--json", "machine-readable output on stdout").option("-y, --yes", "assume yes for confirmations").option("--no-color", "disable coloured output").hook("preAction", (command) => {
@@ -4475,6 +5125,7 @@ program.command("start").description("Run the daemon in the foreground").action(
 );
 program.command("doctor").description("Check whether this machine can run jobs").action(action(runDoctor));
 program.command("status").description("Show what this machine is doing").action(action(runStatus));
+program.command("update").description("Update this machine to the latest published version").option("--check", "report whether a newer version exists, and install nothing").option("--dry-run", "print the npm command that would run").option("--channel <name>", "latest or dev (default: whichever this version came from)").action(action((options) => runUpdate(options)));
 program.command("logs").description("Show the daemon's log file").option("-n, --lines <count>", "how many lines to show", "50").option("-f, --follow", "keep printing new lines").action(
   action(
     async (options) => runLogs({ lines: Number(options.lines) || 50, follow: options.follow === true })