@lumi.ai/runner 0.4.0 → 0.5.1

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

@@ -535,14 +535,24 @@ function saveConfig(config2) {
 function forgetShip(config2, shipId) {
   const shipKeys = { ...config2.shipKeys ?? {} };
   delete shipKeys[shipId];
-  return { ...config2, shipKeys, ships: config2.ships.filter((id) => id !== 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.4.0" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.5.1" : "0.0.0-dev";
 
 // src/auth.ts
 import { signInWithCustomToken } from "firebase/auth";
@@ -1658,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,
@@ -1838,8 +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;
-  let currentJobShip = 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);
@@ -1870,6 +1914,7 @@ async function startDaemon() {
             warnedUnapproved.delete(shipId);
             needsRefill.add(shipId);
           }
+          const live = liveJobsOn(shipId);
           await setDoc2(
             shipRunnerRef(shipId),
             {
@@ -1878,7 +1923,9 @@ async function startDaemon() {
               status: "online",
               lastSeenAt: now,
               startedAt,
-              currentJob: currentJob ?? null,
+              currentJob: live[0] ?? null,
+              currentJobs: live,
+              parallelLimit: shipCap(config2, shipId),
               lastLogLines: [...logLines]
             },
             { merge: true }
@@ -2013,11 +2060,12 @@ async function startDaemon() {
     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.`
     );
-    if (currentJobShip === shipId && sessionAbort) {
+    const stranded = [...running.values()].filter((r) => r.shipId === shipId);
+    if (stranded.length > 0) {
       log2(
-        `Stopping the job it was running \u2014 this machine can no longer write to Ship ${shipId}, so the Ship put that job back on the queue itself.`
+        `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.`
       );
-      sessionAbort.abort();
+      for (const r of stranded) r.abort.abort();
     }
     if (serving.size === 0) {
       log2(
@@ -2026,17 +2074,15 @@ async function startDaemon() {
     }
   }
   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() {
@@ -2062,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;
@@ -2116,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);
@@ -2136,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 },
@@ -2150,11 +2218,9 @@ async function startDaemon() {
       ...job.workflowName ? { workflowName: job.workflowName } : {},
       startedAt: Date.now()
     };
-    currentJobShip = shipId;
     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."
@@ -2214,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,
@@ -2225,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, [
@@ -2251,7 +2317,6 @@ async function startDaemon() {
       failure = e instanceof Error ? e.message : String(e);
     }
     wake?.release();
-    sessionAbort = null;
     try {
       if (!serving.has(shipId)) {
         log2(
@@ -2307,8 +2372,7 @@ async function startDaemon() {
     } catch (e) {
       log2(`finalize failed for ${job.id}: ${e instanceof Error ? e.message : e}`);
     }
-    currentJob = null;
-    currentJobShip = null;
+    slot.mirror = void 0;
     if (serving.has(shipId)) await setAgentStatus(shipId, job.agentId, "idle");
     if (!shuttingDown) void heartbeat();
   }
@@ -2326,16 +2390,22 @@ async function startDaemon() {
     clearInterval(heartbeatTimer);
     if (limitTimer) clearTimeout(limitTimer);
     for (const shipUnsubs of unsubsByShip.values()) shipUnsubs.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();
+    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())
       ]);
     }
@@ -2344,7 +2414,12 @@ async function startDaemon() {
       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 }
         );
       }
@@ -2354,7 +2429,10 @@ async function startDaemon() {
   };
   process.on("SIGINT", () => void shutdown("SIGINT"));
   process.on("SIGTERM", () => void shutdown("SIGTERM"));
-  log2(`Runner online \u2014 watching ${serving.size} 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(() => {
   });
 }
@@ -2491,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);
 }
@@ -2499,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()}`);
@@ -2513,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()) {
@@ -2529,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";
@@ -3685,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.4.0",
+  "version": "0.5.1",
   "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.",