@lumi.ai/runner 0.6.0 → 0.6.3

package/README.md

@@ -84,7 +84,9 @@ Run this first when something isn't working. Everything it checks used to be dis
 running job*, surfacing as a failed task on your board minutes later: a missing `claude` binary,
 unsaved Ship credentials, a machine no captain approved. It checks Node ≥ 20, your stored session,
 per-Ship approval and credentials, the engine binary, `git`/`gh` when an agent uses GitHub, server
-reachability, the background service, and whether that service still points at a CLI that exists.
+reachability, the background service, whether that service still points at a CLI that exists, and
+whether the **service's own `PATH`** can still reach the binaries your jobs spawn — which is a
+different question from whether your shell can (see below).
 
 ### Background service
 
@@ -99,6 +101,21 @@ 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.
 
+**It is captured once, and a restart does not refresh it.** `service restart` re-runs the unit
+exactly as written, so a daemon keeps the `PATH` of whatever shell first installed it. Install a
+tool somewhere new afterwards — `~/.local/bin`, a Homebrew prefix, an nvm switch — and the daemon
+cannot see it, while every check you can run by hand (`which claude`, `lumi-runner doctor`) is
+answered by your *current* shell and looks fine. The symptom is a job that fails minutes later
+with `spawn claude ENOENT`.
+
+Two things close that gap: `doctor` reports it as **Service PATH**, and `lumi-runner setup` now
+reinstalls the service (rather than merely restarting it) when your environment has drifted from
+the installed unit. To fix it directly, from a shell where the tool works:
+
+```bash
+lumi-runner service install    # rewrites the unit with your current PATH
+```
+
 ## How many jobs at once
 
 One, until you say otherwise — the same behaviour this daemon has always had.
@@ -187,8 +204,11 @@ always as a warning — being out of date never fails the preflight.
 - **Idle sleep is inhibited** (`caffeinate` / `systemd-inhibit`, best-effort on Windows), so a
   laptop doesn't suspend mid-session. It cannot veto you choosing Shut Down — no background process
   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`.
+- **Desktop notifications are off by default.** They fire on job start, finish, terminal failure and
+  on a daemon stopped with work in flight — which on a busy machine is an interruption every few
+  minutes carrying nothing the task board and the Daemons live log do not already show. Turn them on
+  with `lumi-runner config set notifications on`. (Sleep inhibition is a separate setting and stays
+  on: "don't close the lid" is `keepAwake`, not a notification.)
 - **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.
@@ -254,7 +274,7 @@ claiming from one queue.
 |---|---|
 | `LUMI_RUNNER_HOME` | Config + log directory (default `~/.lumi-runner`) |
 | `CREW_CLAUDE_BIN` | Path to the Claude binary (default: `claude` from `PATH`) |
-| `CREW_NO_NOTIFY` | Disable desktop notifications |
+| `CREW_NO_NOTIFY` | Force desktop notifications off, whatever the config says (they are off by default) |
 | `CREW_NO_POWER` | Disable sleep inhibition |
 | `LUMI_RUNNER_REGISTRY` | npm registry to check for updates (default `https://registry.npmjs.org`) |
 | `LUMI_RUNNER_CHANNEL` | Force the update channel: `latest` or `dev` |

package/dist/cli.js

@@ -251,9 +251,9 @@ function str(input, key) {
   const value = input[key];
   return typeof value === "string" && value.trim() ? value : void 0;
 }
-function basename(path8) {
-  const parts = path8.split(/[\\/]/).filter(Boolean);
-  return parts[parts.length - 1] ?? path8;
+function basename(path9) {
+  const parts = path9.split(/[\\/]/).filter(Boolean);
+  return parts[parts.length - 1] ?? path9;
 }
 function hostOf(url) {
   try {
@@ -341,8 +341,8 @@ function builtinDetail(tool, input) {
     case "Write":
     case "Edit":
     case "MultiEdit": {
-      const path8 = str(input, "file_path");
-      return path8 ? basename(path8) : void 0;
+      const path9 = str(input, "file_path");
+      return path9 ? basename(path9) : void 0;
     }
     case "Glob":
     case "Grep":
@@ -759,12 +759,20 @@ function forgetShip(config2, shipId) {
 function allowsLocalMcp(config2, shipId) {
   return Array.isArray(config2.allowLocalMcp) && config2.allowLocalMcp.includes(shipId);
 }
+var TOGGLE_DEFAULTS = {
+  notifications: false,
+  keepAwake: true,
+  autoUpdate: true
+};
+function notificationsEnabled(config2) {
+  return config2?.notifications ?? TOGGLE_DEFAULTS.notifications;
+}
 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.6.0" : "0.0.0-dev";
+var RUNNER_VERSION = true ? "0.6.3" : "0.0.0-dev";
 
 // src/auth.ts
 import { signInWithCustomToken } from "firebase/auth";
@@ -1030,7 +1038,7 @@ var WINDOWS_SCRIPT = [
 ].join(" ");
 function enabled() {
   if (process.env.CREW_NO_NOTIFY === "1") return false;
-  return loadConfig()?.notifications !== false;
+  return notificationsEnabled(loadConfig());
 }
 function notify(title, body) {
   if (!enabled()) return;
@@ -1890,7 +1898,7 @@ async function claudeHealthCheck() {
     const done = (health) => {
       if (settled) return;
       settled = true;
-      resolve(health);
+      resolve({ ...health, binary: bin });
     };
     let stdout = "";
     const child = spawn3(bin, ["--version"], { stdio: ["ignore", "pipe", "ignore"] });
@@ -2328,6 +2336,48 @@ function subscribeEngineLimits(db, shipId, cb, onError) {
   );
 }
 
+// src/jobs/claimBackoff.ts
+var BACKOFF_BASE_MS = 3e3;
+var BACKOFF_MAX_MS = 6e4;
+var BACKOFF_RETENTION_MS = 10 * 6e4;
+function backoffFor(releases) {
+  return Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** Math.max(0, releases - 1));
+}
+function noteTransientRelease(backoff, jobId, now) {
+  const releases = (backoff.get(jobId)?.releases ?? 0) + 1;
+  const entry = { releases, eligibleAt: now + backoffFor(releases), poked: false };
+  backoff.set(jobId, entry);
+  return entry;
+}
+function isBackedOff(backoff, jobId, now) {
+  const entry = backoff.get(jobId);
+  return !!entry && entry.eligibleAt > now;
+}
+function clearBackoff(backoff, jobId) {
+  backoff.delete(jobId);
+}
+function pruneExpired2(backoff, now) {
+  const cleared = [];
+  for (const [key, entry] of backoff) {
+    if (entry.eligibleAt > now) continue;
+    if (!entry.poked) {
+      cleared.push(key);
+      entry.poked = true;
+    }
+    if (now - entry.eligibleAt >= BACKOFF_RETENTION_MS) backoff.delete(key);
+  }
+  return cleared;
+}
+function nextEligibleAt(backoff, now) {
+  let soonest = null;
+  for (const entry of backoff.values()) {
+    if (entry.eligibleAt > now && (soonest === null || entry.eligibleAt < soonest)) {
+      soonest = entry.eligibleAt;
+    }
+  }
+  return soonest;
+}
+
 // src/jobs/capacity.ts
 var DEFAULT_PARALLEL_JOBS = 1;
 var PARALLEL_MAX = 8;
@@ -2386,11 +2436,11 @@ function redactTranscript(transcript, knownSecrets) {
   return out;
 }
 async function uploadTranscript(storage, shipId, jobId, redacted) {
-  const path8 = `crew/${shipId}/transcripts/${jobId}.jsonl`;
-  await uploadBytes(storageRef(storage, path8), new TextEncoder().encode(redacted), {
+  const path9 = `crew/${shipId}/transcripts/${jobId}.jsonl`;
+  await uploadBytes(storageRef(storage, path9), new TextEncoder().encode(redacted), {
     contentType: "application/x-ndjson"
   });
-  return path8;
+  return path9;
 }
 function utcDay(millis) {
   return new Date(millis).toISOString().slice(0, 10);
@@ -2729,6 +2779,10 @@ function serviceEnv() {
   }
   return env;
 }
+function serviceEnvDrift(current, installed) {
+  if (!installed) return [];
+  return Object.keys(current).filter((name) => current[name] !== installed[name]).sort();
+}
 function removeLegacyService() {
   const removed = [];
   if (process.platform === "darwin") {
@@ -2827,6 +2881,24 @@ function parsePlistCliPath(plist) {
   const args = [...block[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => unescapeXml(m[1]));
   return args.length >= 2 ? args[1] : void 0;
 }
+function parsePlistEnv(plist) {
+  const block = /<key>EnvironmentVariables<\/key>\s*<dict>([\s\S]*?)<\/dict>/.exec(plist);
+  if (!block) return void 0;
+  const env = {};
+  for (const m of block[1].matchAll(/<key>([\s\S]*?)<\/key>\s*<string>([\s\S]*?)<\/string>/g)) {
+    env[unescapeXml(m[1])] = unescapeXml(m[2]);
+  }
+  return env;
+}
+function parseSystemdEnv(unit) {
+  const env = {};
+  let found = false;
+  for (const m of unit.matchAll(/^Environment="([^="]+)=([^"]*)"\s*$/gm)) {
+    env[m[1]] = m[2];
+    found = true;
+  }
+  return found ? env : void 0;
+}
 function parseSystemdCliPath(unit) {
   const line = /^ExecStart=(.*)$/m.exec(unit);
   if (!line) return void 0;
@@ -2835,16 +2907,17 @@ function parseSystemdCliPath(unit) {
   const parts = command.slice(0, -" start".length).split(" ");
   return parts.length === 2 ? parts[1] : void 0;
 }
-function execFacts(unitPath, parse) {
+function execFacts(unitPath, parse, parseEnv) {
   let text;
   try {
     text = fs4.readFileSync(unitPath, "utf8");
   } catch {
     return {};
   }
+  const unitEnv = parseEnv(text);
   const execPath = parse(text);
-  if (!execPath || !path4.isAbsolute(execPath)) return {};
-  return { execPath, execMissing: !fs4.existsSync(execPath) };
+  if (!execPath || !path4.isAbsolute(execPath)) return { ...unitEnv ? { unitEnv } : {} };
+  return { execPath, execMissing: !fs4.existsSync(execPath), ...unitEnv ? { unitEnv } : {} };
 }
 function systemdUnit() {
   const env = serviceEnv();
@@ -2871,7 +2944,7 @@ 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 exec = execFacts(unitPath, parsePlistCliPath, parsePlistEnv);
     const printed = run("launchctl", ["print", `gui/${uid()}/${SERVICE_LABEL}`]);
     if (!printed.ok) {
       return { state: "installed", detail: "LaunchAgent present but not loaded.", unitPath, ...exec };
@@ -2892,7 +2965,7 @@ function serviceStatus() {
       state: active.out === "active" ? "running" : "installed",
       detail: `systemd user unit is ${active.out || "unknown"}.`,
       unitPath,
-      ...execFacts(unitPath, parseSystemdCliPath)
+      ...execFacts(unitPath, parseSystemdCliPath, parseSystemdEnv)
     };
   }
   if (process.platform === "win32") {
@@ -3445,6 +3518,7 @@ async function startDaemon() {
   }
   const pending = /* @__PURE__ */ new Map();
   const engineLimits = /* @__PURE__ */ new Map();
+  const claimBackoff = /* @__PURE__ */ new Map();
   const agentEngines = /* @__PURE__ */ new Map();
   const unsubsByShip = /* @__PURE__ */ new Map();
   const listenerError = (shipId, what) => (e) => {
@@ -3627,6 +3701,23 @@ async function startDaemon() {
     limitTimer = setTimeout(sweepLimits, Math.max(0, at - Date.now()) + 1e3);
     limitTimer.unref();
   }
+  let backoffTimer = null;
+  function armBackoffTimer() {
+    if (backoffTimer) {
+      clearTimeout(backoffTimer);
+      backoffTimer = null;
+    }
+    const at = nextEligibleAt(claimBackoff, Date.now());
+    if (at === null) return;
+    backoffTimer = setTimeout(sweepBackoff, Math.max(0, at - Date.now()) + 1e3);
+    backoffTimer.unref();
+  }
+  function sweepBackoff() {
+    backoffTimer = null;
+    const cleared = pruneExpired2(claimBackoff, Date.now());
+    armBackoffTimer();
+    if (cleared.length > 0) poke();
+  }
   function sweepLimits() {
     limitTimer = null;
     const cleared = pruneExpired(engineLimits, Date.now());
@@ -3658,7 +3749,11 @@ async function startDaemon() {
           // 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)
+          eligible: (p) => approved.get(p.shipId) === true && !isLimited(engineLimits, p.shipId, engineForJob(p.shipId, p.job), now) && // The connection cooldown. Same "skip, don't stop" shape as the limit gate above, and
+          // skipped entries STAY in `pending` for the same reason — `sweepBackoff` resumes them
+          // with a poke. Without this the `transient` release below re-claims what it just put
+          // down, every three seconds, forever (jobs/claimBackoff.ts).
+          !isBackedOff(claimBackoff, p.job.id, now)
         });
         for (const pick of picks) {
           pending.delete(`${pick.shipId}/${pick.job.id}`);
@@ -4014,14 +4109,16 @@ async function startDaemon() {
           target.kind === "task" ? `Task ${target.taskId} is done.` : delivery === "agent-replied" ? "Agent replied in a chat." : "Agent finished a chat run without replying \u2014 its answer was posted for it."
         );
       } else if (transient) {
+        const held = noteTransientRelease(claimBackoff, job.id, Date.now());
         await releaseJob(
           sess(shipId).fb.db,
           shipId,
           job,
           `Lost the connection to Firestore \u2014 released without consuming a retry: ${failure.slice(0, 120)}`
         );
+        armBackoffTimer();
         log2(
-          `Job ${job.id} released: lost the connection to Firestore. Attempt ${job.attempt} preserved \u2014 ${failure.slice(0, 120)}`
+          `Job ${job.id} released: lost the connection to Firestore. Attempt ${job.attempt} preserved \u2014 ${failure.slice(0, 120)}. Not re-claiming it here for ${Math.round((held.eligibleAt - Date.now()) / 1e3)}s (drop ${held.releases} on this machine); another daemon may take it meanwhile.`
         );
       } else if (!terminal && job.attempt < MAX_ATTEMPTS) {
         log2(`Job ${job.id} failed (attempt ${job.attempt}) \u2014 re-queueing: ${failure.slice(0, 120)}`);
@@ -4043,6 +4140,7 @@ async function startDaemon() {
         log2(`Job ${job.id} FAILED terminally: ${failure.slice(0, 120)}`);
         notify("Crew job failed", `${targetLabel}: ${failure.slice(0, 120)}`);
       }
+      if (!transient) clearBackoff(claimBackoff, job.id);
     } catch (e) {
       log2(`finalize failed for ${job.id}: ${e instanceof Error ? e.message : e}`);
     }
@@ -4370,7 +4468,7 @@ function glyph(level) {
 
 // src/cli/commands/config.ts
 var TOGGLES = {
-  notifications: "Desktop notifications when a job starts, finishes or fails",
+  notifications: "Desktop notifications when a job starts, finishes or fails (off by default)",
   keepAwake: "Keep this machine awake while a job is running",
   autoUpdate: "Install new versions of the runner by itself and restart (PRD \xA715.37)"
 };
@@ -4420,7 +4518,7 @@ function parseParallel(value) {
 async function runConfigList() {
   const config2 = requireConfig();
   const values = Object.fromEntries(
-    Object.keys(TOGGLES).map((key) => [key, config2[key] !== false])
+    Object.keys(TOGGLES).map((key) => [key, config2[key] ?? TOGGLE_DEFAULTS[key]])
   );
   const machine = machineCap(config2);
   const ships = config2.ships.map((shipId) => ({
@@ -4579,6 +4677,8 @@ function setParallel(config2, value, ship2) {
 
 // src/cli/commands/doctor.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
+import fs7 from "node:fs";
+import path8 from "node:path";
 import { collection as collection6, doc as doc8, getDoc as getDoc7, getDocs as getDocs5 } from "firebase/firestore";
 
 // src/cli/session.ts
@@ -4650,8 +4750,36 @@ function serviceCheckFrom(status) {
   }
   return warn("service", "Background service", `Unrecognised service state: ${status.state}.`);
 }
-function checkService() {
-  return serviceCheckFrom(serviceStatus());
+function serviceBinaryCheckFrom(input) {
+  const { status, binaries, resolves } = input;
+  if (status.state === "not-installed" || status.state === "unsupported") return null;
+  const pathValue = status.unitEnv?.PATH;
+  if (pathValue === void 0) return null;
+  const relative = [...new Set(binaries)].filter((b) => !path8.isAbsolute(b));
+  if (relative.length === 0) return null;
+  const missing = relative.filter((b) => !resolves(b, pathValue));
+  const id = "service:path";
+  const label = "Service PATH";
+  if (missing.length === 0) {
+    return ok(id, label, `The daemon can reach ${relative.join(", ")}.`);
+  }
+  return warn(
+    id,
+    label,
+    `The daemon's PATH is missing ${missing.join(", ")} \u2014 it was captured when the service was installed, and jobs will fail with \`spawn ${missing[0]} ENOENT\` even though this terminal finds it.`,
+    "Run `lumi-runner service install` from a shell where these work, to rewrite the unit with the current PATH."
+  );
+}
+function resolvesOnPath(binary, pathValue) {
+  for (const dir of pathValue.split(path8.delimiter)) {
+    if (!dir) continue;
+    try {
+      fs7.accessSync(path8.join(dir, binary), fs7.constants.X_OK);
+      return true;
+    } catch {
+    }
+  }
+  return false;
 }
 function versionCheckFrom(input) {
   const { current, latest, channel, autoUpdate } = input;
@@ -4819,14 +4947,17 @@ async function runDoctor() {
     for (const id of shipResults.engines) engines.add(id);
   }
   const needsGithub = shipResults.needsGithub;
+  const jobBinaries = [];
   for (const engineId of engines) {
     const health = await getDriver(engineId).healthCheck();
+    if (health.binary) jobBinaries.push(health.binary);
     checks.push(
       health.ok ? ok(`engine:${engineId}`, `Engine "${engineId}"`, health.detail) : fail(`engine:${engineId}`, `Engine "${engineId}"`, health.detail, health.fix)
     );
   }
   if (needsGithub) {
     for (const binary of ["git", "gh"]) {
+      jobBinaries.push(binary);
       checks.push(
         onPath(binary) ? ok(`bin:${binary}`, `\`${binary}\``, "On PATH.") : fail(
           `bin:${binary}`,
@@ -4838,7 +4969,14 @@ async function runDoctor() {
     }
   }
   checks.push(await checkMcp(mcpUrl(config2)));
-  checks.push(checkService());
+  const service2 = serviceStatus();
+  checks.push(serviceCheckFrom(service2));
+  const servicePath = serviceBinaryCheckFrom({
+    status: service2,
+    binaries: jobBinaries,
+    resolves: resolvesOnPath
+  });
+  if (servicePath) checks.push(servicePath);
   checks.push(await checkVersion(config2));
   progress.stop("Checks complete.");
   return report2(checks);
@@ -5094,6 +5232,17 @@ async function runServiceUninstall() {
   say.success("Service removed. The daemon will not start on its own any more.");
   return 0;
 }
+async function runServiceRepair(reason) {
+  const result = installService();
+  restartService();
+  if (isJson()) {
+    emitJson({ repaired: true, reason, unitPath: result.unitPath, notes: result.notes, ...serviceStatus() });
+    return 0;
+  }
+  say.success(`Service reinstalled (${reason}): ${result.unitPath}`);
+  for (const note2 of result.notes) say.warn(note2);
+  return 0;
+}
 async function runServiceRestart() {
   restartService();
   if (isJson()) {
@@ -5118,20 +5267,20 @@ async function runServiceStatus() {
 }
 
 // src/cli/commands/uninstall.ts
-import fs7 from "node:fs";
+import fs8 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 && fs7.existsSync(dir)) {
+  if (options.purge && fs8.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) {
-      fs7.rmSync(dir, { recursive: true, force: true });
+      fs8.rmSync(dir, { recursive: true, force: true });
       purged = true;
     }
   }
@@ -5268,7 +5417,8 @@ async function runSetup(options) {
   }
   say.step("Checking this machine\u2026");
   const doctorExit = await runDoctor();
-  const service2 = serviceStatus().state;
+  const status = serviceStatus();
+  const service2 = status.state;
   if (service2 === "not-installed") {
     const install = await promptConfirm({
       message: "Start the daemon automatically whenever this machine is on?",
@@ -5278,8 +5428,14 @@ async function runSetup(options) {
     if (install) await runServiceInstall();
     else say.info("Skipped. Run `lumi-runner start` manually, or `lumi-runner service install` later.");
   } else if (service2 === "running" || service2 === "installed") {
-    say.step("Restarting the daemon so it picks up this configuration\u2026");
-    await runServiceRestart();
+    const drift = serviceEnvDrift(serviceEnv(), status.unitEnv);
+    if (drift.length > 0) {
+      say.step(`Reinstalling the service \u2014 ${drift.join(", ")} changed since it was installed\u2026`);
+      await runServiceRepair(`${drift.join(", ")} changed`);
+    } else {
+      say.step("Restarting the daemon so it picks up this configuration\u2026");
+      await runServiceRestart();
+    }
   }
   say.outro(
     doctorExit === 0 ? "Ready. This machine will claim jobs for its Ships." : "Setup finished, but some checks failed \u2014 fix those and re-run `lumi-runner doctor`."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumi.ai/runner",
-  "version": "0.6.0",
+  "version": "0.6.3",
   "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.",