@lumi.ai/runner 0.3.6 → 0.5.0

package/README.md

@@ -5,7 +5,7 @@ workspace.
 
 Crew agents don't run in the cloud. They run **on your machine**, in your checkouts, with your
 tools. This daemon is what makes that happen: it watches the job queues of the Ships you assign it
-to, claims work one job at a time, and executes each as a headless Claude session.
+to, claims work oldest-first, and executes each job as a headless Claude session.
 
 ```bash
 npm i -g @lumi.ai/runner
@@ -98,6 +98,24 @@ reachability, the background service, and whether that service still points at a
 Your `PATH` is captured into the unit at install time. launchd and systemd start processes with a
 minimal environment, so without that `claude`, `git` and `gh` would not be found.
 
+## How many jobs at once
+
+One, until you say otherwise — the same behaviour this daemon has always had.
+
+```bash
+lumi-runner config set parallel 3                    # this machine, across every Ship
+lumi-runner config set parallel 1 --ship shp_abc123  # cap one Ship's share of it
+lumi-runner config set parallel default --ship shp_abc123   # back to the machine number
+lumi-runner config list                              # what is set, and what each Ship gets
+```
+
+The machine number is a ceiling, not a total: three Ships at `2` each on a machine set to `3` will
+never run more than three sessions. A Ship with no number of its own may use the whole machine.
+
+Each job is a separate `claude` process with its own empty working directory, so they don't share
+state — but they do share your CPU, your RAM and your Claude usage window. Start at 2 and watch a
+real job before going higher. Restart the daemon (`lumi-runner service restart`) to pick up a change.
+
 ## While a job runs
 
 - **Idle sleep is inhibited** (`caffeinate` / `systemd-inhibit`, best-effort on Windows), so a
@@ -105,9 +123,9 @@ minimal environment, so without that `claude`, `git` and `gh` would not be found
   gets that veto on macOS, and it shouldn't.
 - **A desktop notification** fires on job start, finish and terminal failure, and when the daemon is
   stopped with work in flight. Silence it with `lumi-runner config set notifications off`.
-- **SIGTERM releases the job.** The daemon aborts the session, hands the job back to the queue with
-  its retry budget **unspent**, and only then writes itself offline. Stopping the daemon never costs
-  you an attempt.
+- **SIGTERM releases the job.** The daemon aborts every running session, hands each job back to the
+  queue with its retry budget **unspent**, and only then writes itself offline. Stopping the daemon
+  never costs you an attempt.
 
 ## Credentials
 

package/dist/cli.js

@@ -532,12 +532,27 @@ function saveConfig(config2) {
   fs.writeFileSync(configPath(), `${JSON.stringify(config2, null, 2)}
 `, { mode: 384 });
 }
+function forgetShip(config2, shipId) {
+  const shipKeys = { ...config2.shipKeys ?? {} };
+  delete shipKeys[shipId];
+  const next = {
+    ...config2,
+    shipKeys,
+    ships: config2.ships.filter((id) => id !== shipId)
+  };
+  if (next.shipParallelJobs) {
+    const overrides = { ...next.shipParallelJobs };
+    delete overrides[shipId];
+    next.shipParallelJobs = overrides;
+  }
+  return next;
+}
 function mcpUrl(config2) {
   return process.env.CREW_MCP_URL || config2.mcpUrl || `https://us-central1-${config2.projectId}.cloudfunctions.net/workspaceMcp`;
 }
 
 // src/version.ts
-var RUNNER_VERSION = true ? "0.3.6" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.5.0" : "0.0.0-dev";
 
 // src/auth.ts
 import { signInWithCustomToken } from "firebase/auth";
@@ -609,13 +624,11 @@ async function probeShipKey(config2, shipId) {
 }
 function pruneDeadShips(config2, failures) {
   const dropped = failures.filter((f) => f.gone).map((f) => f.shipId);
-  if (dropped.length === 0) return { config: config2, dropped };
-  const shipKeys = { ...config2.shipKeys ?? {} };
-  for (const shipId of dropped) delete shipKeys[shipId];
-  return {
-    config: { ...config2, shipKeys, ships: config2.ships.filter((id) => !dropped.includes(id)) },
-    dropped
-  };
+  return { config: dropped.reduce(forgetShip, config2), dropped };
+}
+function isEnrolmentGone(error) {
+  const code = error?.code;
+  return code === "permission-denied" || code === "firestore/permission-denied";
 }
 async function signInToShip(fb, config2, shipId) {
   const key = config2.shipKeys?.[shipId];
@@ -1655,6 +1668,35 @@ function subscribeEngineLimits(db, shipId, cb, onError) {
   );
 }
 
+// src/jobs/capacity.ts
+var DEFAULT_PARALLEL_JOBS = 1;
+var PARALLEL_MAX = 8;
+var clamp = (n) => Math.min(PARALLEL_MAX, Math.max(1, Math.floor(n)));
+var readCount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 1 ? clamp(value) : null;
+function machineCap(config2) {
+  return readCount(config2.maxParallelJobs) ?? DEFAULT_PARALLEL_JOBS;
+}
+function shipCap(config2, shipId) {
+  const machine = machineCap(config2);
+  const own = readCount(config2.shipParallelJobs?.[shipId]);
+  return own === null ? machine : Math.min(own, machine);
+}
+function selectDispatch(input) {
+  const free = input.machineCap - input.runningTotal;
+  if (free <= 0) return [];
+  const taken = new Map(input.runningByShip);
+  const picked = [];
+  for (const entry of [...input.pending].sort((a, b) => a.job.createdAt - b.job.createdAt)) {
+    if (picked.length >= free) break;
+    if (!input.eligible(entry)) continue;
+    const running = taken.get(entry.shipId) ?? 0;
+    if (running >= input.shipCap(entry.shipId)) continue;
+    taken.set(entry.shipId, running + 1);
+    picked.push(entry);
+  }
+  return picked;
+}
+
 // src/jobs/finish.ts
 import {
   addDoc,
@@ -1821,9 +1863,9 @@ async function startDaemon() {
     if (!s) throw new Error(`No session for Ship ${shipId}`);
     return s;
   };
-  const liveShips = sessions.map((s) => s.shipId);
+  const serving = new Set(sessions.map((s) => s.shipId));
   console.log(
-    `Runner ${config2.runnerId} serving ${liveShips.length} Ship(s): ${liveShips.join(", ")}`
+    `Runner ${config2.runnerId} serving ${serving.size} Ship(s): ${[...serving].join(", ")}`
   );
   const logLines = [];
   const log2 = (line) => {
@@ -1835,7 +1877,13 @@ async function startDaemon() {
   };
   if (moved?.migrated) log2(`Moved runner config from ${moved.from} to ${moved.to}.`);
   const startedAt = Date.now();
-  let currentJob = null;
+  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);
@@ -1846,43 +1894,56 @@ async function startDaemon() {
     beating = true;
     const now = Date.now();
     try {
-      for (const shipId of liveShips) {
-        await setDoc2(
-          shipRunnerRef(shipId),
-          {
-            hostname: os3.hostname(),
-            version: RUNNER_VERSION,
-            status: "online",
-            lastSeenAt: now,
-            startedAt,
-            currentJob: currentJob ?? null,
-            lastLogLines: [...logLines]
-          },
-          { merge: true }
-        );
-        const snap = await getDoc5(shipRunnerRef(shipId));
-        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.`
+      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 }
           );
-        }
-        if (isApproved && !wasApproved) {
-          warnedUnapproved.delete(shipId);
-          needsRefill.add(shipId);
+        } 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);
         }
       }
-    } catch (e) {
-      console.error("heartbeat failed:", e instanceof Error ? e.message : e);
     } finally {
       beating = false;
     }
     for (const shipId of [...needsRefill]) {
       needsRefill.delete(shipId);
-      if (approved.get(shipId) !== true) continue;
+      if (!serving.has(shipId) || approved.get(shipId) !== true) continue;
       try {
         const snap = await getDocs3(
           query3(
@@ -1907,14 +1968,21 @@ async function startDaemon() {
   const pending = /* @__PURE__ */ new Map();
   const engineLimits = /* @__PURE__ */ new Map();
   const agentEngines = /* @__PURE__ */ new Map();
-  const unsubs = [];
-  for (const shipId of liveShips) {
+  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 = query3(
       collection5(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs),
       where3("status", "==", "queued"),
       orderBy3("createdAt", "asc")
     );
-    unsubs.push(
+    unsubsByShip.set(shipId, [
       onSnapshot2(
         q,
         (snap) => {
@@ -1929,10 +1997,9 @@ async function startDaemon() {
           }
           poke();
         },
-        (e) => console.error(`jobs listener error (${shipId}):`, e.message)
-      )
-    );
-    unsubs.push(
+        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) => {
@@ -1941,10 +2008,11 @@ async function startDaemon() {
           }
           poke();
         },
-        (e) => console.error(`agents listener error (${shipId}):`, e.message)
-      )
-    );
-    unsubs.push(
+        listenerError(shipId, "agents")
+      ),
+      // Exhausted usage windows. The FIRST snapshot is the startup seed: a restarted daemon —
+      // and a second daemon on this Ship — inherits the pause instead of running a doomed
+      // session to rediscover it.
       subscribeEngineLimits(
         sess(shipId).fb.db,
         shipId,
@@ -1963,22 +2031,58 @@ async function startDaemon() {
           }
           sweepLimits();
         },
-        (e) => console.error(`engine limits listener error (${shipId}):`, e.message)
+        listenerError(shipId, "engine limits")
       )
+    ]);
+  }
+  function forgetShipLocally(shipId, why) {
+    if (!serving.delete(shipId)) return;
+    for (const unsub of unsubsByShip.get(shipId) ?? []) unsub();
+    unsubsByShip.delete(shipId);
+    for (const key of [...pending.keys()]) {
+      if (pending.get(key)?.shipId === shipId) pending.delete(key);
+    }
+    for (const key of [...engineLimits.keys()]) {
+      if (engineLimits.get(key)?.shipId === shipId) engineLimits.delete(key);
+    }
+    for (const key of [...agentEngines.keys()]) {
+      if (key.startsWith(`${shipId}/`)) agentEngines.delete(key);
+    }
+    approved.delete(shipId);
+    warnedUnapproved.delete(shipId);
+    needsRefill.delete(shipId);
+    config2 = forgetShip(config2, shipId);
+    try {
+      saveConfig(config2);
+    } catch (e) {
+      log2(`Could not rewrite the config after leaving Ship ${shipId}: ${e instanceof Error ? e.message : e}`);
+    }
+    log2(
+      `Ship ${shipId}: ${why}. Deleted its runner key, its assignment and its queued work from this machine. To serve it again, run \`lumi-runner login\` here and have a captain approve this machine in the browser.`
     );
+    const stranded = [...running.values()].filter((r) => r.shipId === shipId);
+    if (stranded.length > 0) {
+      log2(
+        `Stopping the ${stranded.length} job(s) it was running there \u2014 this machine can no longer write to Ship ${shipId}, so the Ship put them back on the queue itself.`
+      );
+      for (const r of stranded) r.abort.abort();
+    }
+    if (serving.size === 0) {
+      log2(
+        "This machine now serves no Ships. Staying up and idle \u2014 run `lumi-runner login` to connect it again, or `lumi-runner uninstall` to retire it."
+      );
+    }
   }
   const engineForJob = (shipId, job) => agentEngines.get(`${shipId}/${job.agentId}`) ?? DEFAULT_ENGINE_ID;
-  let working = false;
+  let dispatching = false;
   let pokeRequested = false;
   let shuttingDown = false;
-  let sessionAbort = null;
-  let inFlight = null;
   function poke() {
-    if (working || shuttingDown) {
+    if (dispatching || shuttingDown) {
       pokeRequested = !shuttingDown;
       return;
     }
-    void workLoop();
+    dispatch();
   }
   let limitTimer = null;
   function armLimitTimer() {
@@ -2004,30 +2108,51 @@ async function startDaemon() {
     armLimitTimer();
     if (cleared.length > 0) poke();
   }
-  async function workLoop() {
-    working = true;
+  function dispatch() {
+    dispatching = true;
     try {
       for (; ; ) {
         pokeRequested = false;
         if (shuttingDown) break;
         const now = Date.now();
-        const next = [...pending.values()].filter((p) => approved.get(p.shipId) === true).filter((p) => !isLimited(engineLimits, p.shipId, engineForJob(p.shipId, p.job), now)).sort((a, b) => a.job.createdAt - b.job.createdAt)[0];
-        if (!next) break;
-        pending.delete(`${next.shipId}/${next.job.id}`);
-        inFlight = processJob(next.shipId, next.job);
-        try {
-          await inFlight;
-        } finally {
-          inFlight = null;
+        const picks = selectDispatch({
+          pending: pending.values(),
+          runningByShip: runningByShip(),
+          runningTotal: running.size,
+          machineCap: machineCap(config2),
+          shipCap: (shipId) => shipCap(config2, shipId),
+          // Only Ships that have approved this machine are eligible; claiming elsewhere would
+          // just be denied by the rules, so skip rather than hammer the queue. Engine-generic:
+          // the limit map is keyed by (Ship, engine) and the engine comes from the registry via
+          // the agent, so the job loop still knows nothing about Claude. Skipped entries STAY in
+          // `pending`, which is what lets a reset resume them with only a poke.
+          eligible: (p) => approved.get(p.shipId) === true && !isLimited(engineLimits, p.shipId, engineForJob(p.shipId, p.job), now)
+        });
+        for (const pick of picks) {
+          pending.delete(`${pick.shipId}/${pick.job.id}`);
+          startJob(pick.shipId, pick.job);
         }
-        if (!pokeRequested && pending.size === 0) break;
+        if (!pokeRequested) break;
       }
     } finally {
-      working = false;
-      if (pokeRequested) poke();
+      dispatching = false;
     }
   }
+  function startJob(shipId, job) {
+    const entry = { shipId, abort: new AbortController(), promise: Promise.resolve() };
+    running.set(job.id, entry);
+    entry.promise = processJob(shipId, job, entry).catch((e) => {
+      log2(`job ${job.id} ended abnormally: ${e instanceof Error ? e.message : e}`);
+    }).finally(() => {
+      running.delete(job.id);
+      if (!shuttingDown) poke();
+    });
+  }
   async function claim(shipId, job) {
+    if (isLimited(engineLimits, shipId, engineForJob(shipId, job), Date.now())) {
+      pending.set(`${shipId}/${job.id}`, { shipId, job });
+      return null;
+    }
     const jobRef = doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.jobs, job.id);
     try {
       let claimed = null;
@@ -2058,7 +2183,7 @@ async function startDaemon() {
   async function loadSecrets(shipId) {
     return loadRunnerSecrets(sess(shipId).fb.db, shipId);
   }
-  async function processJob(shipId, queuedJob) {
+  async function processJob(shipId, queuedJob, slot) {
     const job = await claim(shipId, queuedJob);
     if (!job) return;
     const target = jobTarget(job);
@@ -2078,12 +2203,13 @@ async function startDaemon() {
         transcriptPath: "",
         error: "Job names neither a task nor a chat, so there is nothing to run."
       });
-      currentJob = null;
       return;
     }
     const targetLabel = target.kind === "task" ? `task ${target.taskId}` : `chat ${target.chatId}`;
-    log2(`Claimed job ${job.id} (ship ${shipId}, ${targetLabel}, attempt ${job.attempt})`);
-    currentJob = {
+    log2(
+      `Claimed job ${job.id} (ship ${shipId}, ${targetLabel}, attempt ${job.attempt}) \u2014 slot ${running.size}/${machineCap(config2)}`
+    );
+    slot.mirror = {
       jobId: job.id,
       // Conditional spread: Firestore rejects an explicit undefined in the mirror write.
       ...target.kind === "task" ? { taskId: target.taskId } : { chatId: target.chatId },
@@ -2095,7 +2221,6 @@ async function startDaemon() {
     await setAgentStatus(shipId, job.agentId, "working");
     void heartbeat();
     const wake = config2.keepAwake === false ? null : inhibitSleep(`Crew job ${job.id}`);
-    sessionAbort = new AbortController();
     notify(
       "Crew job started",
       target.kind === "task" ? `Agent is working on task ${target.taskId}.` : "Agent is replying in a chat."
@@ -2155,7 +2280,7 @@ async function startDaemon() {
         }
         throw e;
       }
-      if (sessionAbort.signal.aborted) throw new Error("Shutting down before the session started.");
+      if (slot.abort.signal.aborted) throw new Error("Stopped before the session started.");
       const session = await getDriver(engineId).run({
         prompt,
         agent,
@@ -2166,7 +2291,7 @@ async function startDaemon() {
         secrets,
         githubToken,
         timeoutMs: JOB_TIMEOUT_MS,
-        signal: sessionAbort.signal,
+        signal: slot.abort.signal,
         log: log2
       });
       transcript = redactTranscript(session.transcript, [
@@ -2192,9 +2317,12 @@ async function startDaemon() {
       failure = e instanceof Error ? e.message : String(e);
     }
     wake?.release();
-    sessionAbort = null;
     try {
-      if (shuttingDown) {
+      if (!serving.has(shipId)) {
+        log2(
+          `Job ${job.id} stopped \u2014 Ship ${shipId} removed this machine mid-run. The Ship has put the job back on its own queue; nothing more is written from here.`
+        );
+      } else if (shuttingDown) {
         await releaseJob(
           sess(shipId).fb.db,
           shipId,
@@ -2244,11 +2372,11 @@ async function startDaemon() {
     } catch (e) {
       log2(`finalize failed for ${job.id}: ${e instanceof Error ? e.message : e}`);
     }
-    currentJob = null;
-    await setAgentStatus(shipId, job.agentId, "idle");
+    slot.mirror = void 0;
+    if (serving.has(shipId)) await setAgentStatus(shipId, job.agentId, "idle");
     if (!shuttingDown) void heartbeat();
   }
-  await Promise.all(liveShips.map((shipId) => loadSecrets(shipId).catch(() => null)));
+  await Promise.all([...serving].map((shipId) => loadSecrets(shipId).catch(() => null)));
   await heartbeat();
   const heartbeatTimer = setInterval(() => {
     void heartbeat();
@@ -2261,26 +2389,37 @@ async function startDaemon() {
     shuttingDown = true;
     clearInterval(heartbeatTimer);
     if (limitTimer) clearTimeout(limitTimer);
-    unsubs.forEach((u) => u());
-    if (sessionAbort) {
-      log2(`${signal} received with a job in flight \u2014 stopping the session and releasing it.`);
-      notify("Crew runner stopping", "A job was in progress; it has been returned to the queue.");
-      sessionAbort.abort();
+    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) {
+    if (inFlight.length > 0) {
       await Promise.race([
-        inFlight,
+        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 liveShips) {
+      for (const shipId of serving) {
         await setDoc2(
           doc7(sess(shipId).fb.db, COLLECTIONS.ships, shipId, COLLECTIONS.runners, config2.runnerId),
-          { status: "offline", lastSeenAt: now, currentJob: deleteField() },
+          {
+            status: "offline",
+            lastSeenAt: now,
+            currentJob: deleteField(),
+            currentJobs: deleteField()
+          },
           { merge: true }
         );
       }
@@ -2290,7 +2429,10 @@ async function startDaemon() {
   };
   process.on("SIGINT", () => void shutdown("SIGINT"));
   process.on("SIGTERM", () => void shutdown("SIGTERM"));
-  log2(`Runner online \u2014 watching ${liveShips.length} Ship(s), MCP: ${mcpUrl(config2)}`);
+  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(() => {
   });
 }
@@ -2427,6 +2569,9 @@ 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);
 }
@@ -2435,13 +2580,29 @@ function parseBool(value) {
   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 });
+    emitJson({ configDir: configDir(), ...values, parallel: machine, ships });
     return 0;
   }
   say.line(`  ${configDir()}`);
@@ -2449,13 +2610,27 @@ async function runConfigList() {
   for (const key of Object.keys(TOGGLES)) {
     say.line(`  ${key.padEnd(16)} ${values[key] ? "on" : "off"}   ${TOGGLES[key]}`);
   }
+  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}`);
+    }
+  }
   return 0;
 }
-async function runConfigSet(key, value) {
+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).join(", ")}.`);
+    throw new CliError(
+      `Unknown setting "${key}". Known: ${[...Object.keys(TOGGLES), PARALLEL].join(", ")}.`
+    );
+  }
+  if (options.ship) {
+    throw new CliError(`"${key}" is a machine-wide setting \u2014 it takes no --ship.`);
   }
-  const config2 = requireConfig();
   config2[key] = parseBool(value);
   saveConfig(config2);
   if (isJson()) {
@@ -2465,6 +2640,41 @@ async function runConfigSet(key, value) {
   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}\`.`
+    );
+  }
+  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";
@@ -3621,6 +3831,12 @@ service.command("status").description("Is the background service installed and r
 program.command("uninstall").description("Remove the background service and print the final npm step").option("--purge", "also delete the config directory (loses this machine's runner id)").action(action(async (options) => runUninstall(options)));
 var config = program.command("config").description("Local per-machine preferences");
 config.command("list").description("Show current settings").action(action(runConfigList));
-config.command("set <key> <value>").description("Change a setting (notifications | keepAwake \u2192 on/off)").action(action(async (key, value) => runConfigSet(key, value)));
+config.command("set <key> <value>").description(
+  'Change a setting (notifications | keepAwake \u2192 on/off, parallel \u2192 1-8 or "default")'
+).option("--ship <shipId>", "apply to one Ship only (parallel)").action(
+  action(
+    async (key, value, options) => runConfigSet(key, value, options)
+  )
+);
 await program.parseAsync(process.argv);
 //# sourceMappingURL=cli.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumi.ai/runner",
-  "version": "0.3.6",
+  "version": "0.5.0",
   "type": "module",
   "description": "Lumi Crew runner daemon — claims jobs from your Ships and executes them as headless Claude sessions on your own machine.",
   "//name": "The ONLY package in this monorepo published to the public registry, so it is the one that does not follow the internal @lumi/crew-* convention: `@lumi` is not a scope we own, `@lumi.ai` is (the npm org). The workspace DIRECTORY stays packages/crew/runner — renaming the package is not renaming the folder.",