@sleds/cli 0.1.0 → 0.1.4

package/dist/sleds.mjs

@@ -5,9 +5,23 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { realpathSync } from "fs";
-import { homedir, platform as platform2 } from "os";
+import { homedir as homedir3, platform as platform2 } from "os";
 import { fileURLToPath } from "url";
 
+// src/commands/bar.ts
+import { execFileSync } from "node:child_process";
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync5,
+  lstatSync,
+  mkdirSync as mkdirSync5,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import { homedir } from "node:os";
+import { join as join5, resolve as resolve3 } from "node:path";
+
 // src/meter.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync3, writeFileSync as writeFileSync3 } from "node:fs";
 import { join as join3 } from "node:path";
@@ -18,7 +32,7 @@ import { join as join2, resolve as resolve2 } from "node:path";
 
 // src/settings.ts
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 var BASE_URL_KEY = "ANTHROPIC_BASE_URL";
 var AUTH_TOKEN_KEY = "ANTHROPIC_AUTH_TOKEN";
 var claudeDir = (home, env = process.env) => {
@@ -28,7 +42,10 @@ var claudeDir = (home, env = process.env) => {
 var hasHomeOverride = (env = process.env) => Boolean(env.SLEDS_HOME?.trim() || env.CLAUDE_CONFIG_DIR?.trim());
 var settingsPath = (home) => join(claudeDir(home), "settings.json");
 var backupPath = (home) => join(claudeDir(home), "settings.json.sleds-backup");
-var tokenPath = (home) => join(home, ".sleds-token");
+var tokenPath = (home, env = process.env) => {
+  const o = env.SLEDS_HOME?.trim();
+  return o ? join(resolve(home, o), ".sleds-token") : join(home, ".sleds-token");
+};
 var skillDir = (home) => join(claudeDir(home), "skills", "sled");
 var skillPath = (home) => join(skillDir(home), "SKILL.md");
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
@@ -196,6 +213,7 @@ var readTokenFile = (home) => {
   return t.length > 0 ? t : null;
 };
 var writeTokenFile = (home, token) => {
+  mkdirSync(dirname(tokenPath(home)), { recursive: true, mode: 448 });
   writeFileSync(tokenPath(home), `${token}
 `, { mode: 384 });
 };
@@ -489,6 +507,95 @@ var loadMeter = async (o) => {
   return fresh;
 };
 
+// src/bar.ts
+var SEAT_BAR_FRESH_MS = 6 * 60 * 60 * 1000;
+var DASHBOARD_URL = "https://app.sleds.ai";
+var WARM_PCT = 75;
+var HOT_PCT = 90;
+var MONO = "font=Menlo size=12";
+var HOT_COLOR = "#ff453a";
+var WARM_COLOR = "#ff9f0a";
+var freshSeat = (w, now) => {
+  if (!w)
+    return null;
+  return now - w.capturedAt < SEAT_BAR_FRESH_MS ? w : null;
+};
+var modelLabel = (bucket) => bucket.replace(/^(seven_day|five_hour|weekly|daily)_/, "").toLowerCase();
+var seatBars = (w) => {
+  if (!w)
+    return [];
+  const out = [];
+  if (w.sevenDay)
+    out.push({ label: "wk", bar: w.sevenDay });
+  if (w.fiveHour)
+    out.push({ label: "5h", bar: w.fiveHour });
+  if (w.spendLimit)
+    out.push({ label: "spend", bar: w.spendLimit });
+  for (const k of Object.keys(w.models ?? {}).sort()) {
+    const bar = w.models?.[k];
+    if (bar)
+      out.push({ label: modelLabel(k), bar });
+  }
+  return out;
+};
+var hottest = (w) => seatBars(w).reduce((best, cur) => !best || cur.bar.usedPct > best.bar.usedPct ? cur : best, null);
+var toneOf = (pct) => pct === undefined ? null : pct >= HOT_PCT ? "hot" : pct >= WARM_PCT ? "warm" : null;
+var colorParam = (tone) => tone === "hot" ? ` color=${HOT_COLOR}` : tone === "warm" ? ` color=${WARM_COLOR}` : "";
+var barTitle = (m, seat) => {
+  const head = m ? usd(m.today.spentUsd) : "offline";
+  const wk = seat?.sevenDay ? `wk ${Math.round(seat.sevenDay.usedPct)}%` : null;
+  const top = hottest(seat);
+  const risk = top && top.label !== "wk" && toneOf(top.bar.usedPct) ? `${top.label} ${Math.round(top.bar.usedPct)}%` : null;
+  return [`sleds ${head}`, ...wk ? [wk] : [], ...risk ? [risk] : []].join(SEP);
+};
+var resetIn = (bar, now) => bar.resetsAt > now ? `${SEP}resets in ${shortDuration(bar.resetsAt - now)}` : "";
+var formatBar = (m, seat, now) => {
+  const tone = toneOf(hottest(seat)?.bar.usedPct);
+  const lines = [`${barTitle(m, seat)}${colorParam(tone)}`, "---"];
+  if (m) {
+    for (const row2 of formatMeter(m, now))
+      lines.push(`${row2} | ${MONO}`);
+  } else {
+    lines.push(`offline${SEP}proxy did not answer | ${MONO}`);
+  }
+  const bars = seatBars(seat);
+  if (bars.length > 0 || seat?.usedCreditsUsd !== undefined) {
+    lines.push("---");
+    lines.push(`Seat limits${seat ? `${SEP}${shortDuration(now - seat.capturedAt)} ago` : ""} | ${MONO}`);
+    for (const { label, bar } of bars) {
+      const pct = Math.round(bar.usedPct);
+      lines.push(`${label.padEnd(12)}${String(pct).padStart(3)}%${resetIn(bar, now)} | ${MONO}${colorParam(toneOf(bar.usedPct))}`);
+    }
+    if (seat?.usedCreditsUsd !== undefined)
+      lines.push(`${"credits".padEnd(12)}${usd(seat.usedCreditsUsd)} spent | ${MONO}`);
+  }
+  lines.push("---");
+  lines.push(`Open dashboard | href=${DASHBOARD_URL}`);
+  lines.push("Refresh | refresh=true");
+  return lines;
+};
+var pluginScript = (nodePath, cliPath, env = {}) => [
+  "#!/bin/bash",
+  "# SLEDS menu-bar meter for SwiftBar — written by `sleds bar --install`; re-run it after moving the CLI.",
+  "# <swiftbar.title>SLEDS</swiftbar.title>",
+  "# <swiftbar.hideAbout>true</swiftbar.hideAbout>",
+  "# <swiftbar.hideRunInTerminal>true</swiftbar.hideRunInTerminal>",
+  "# <swiftbar.hideSwiftBar>true</swiftbar.hideSwiftBar>",
+  ...env.sledsHome ? [`export SLEDS_HOME=${shellQuote(env.sledsHome)}`] : ["unset SLEDS_HOME"],
+  ...env.claudeConfigDir ? [`export CLAUDE_CONFIG_DIR=${shellQuote(env.claudeConfigDir)}`] : ["unset CLAUDE_CONFIG_DIR"],
+  'export PATH="$HOME/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$PATH"',
+  `if [ -x ${shellQuote(nodePath)} ] && [ -f ${shellQuote(cliPath)} ]; then`,
+  `  exec ${shellQuote(nodePath)} ${shellQuote(cliPath)} bar`,
+  "fi",
+  "if command -v sleds >/dev/null 2>&1; then exec sleds bar; fi",
+  'echo "sleds not found"',
+  'echo "---"',
+  'echo "Run \\`npx @sleds/cli bar --install\\` again. | font=Menlo size=12"',
+  ""
+].join(`
+`);
+var shellQuote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+
 // src/seat.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join4 } from "node:path";
@@ -528,7 +635,16 @@ var parseSeatWindow = (raw, capturedAt) => {
   const fiveHour = parseBar(limits.five_hour ?? limits.fiveHour);
   const sevenDay = parseBar(limits.seven_day ?? limits.sevenDay);
   const spendLimit = parseBar(limits.spend_limit ?? limits.spendLimit);
-  if (!fiveHour && !sevenDay && !spendLimit)
+  const models = {};
+  if (isObject4(limits.models))
+    for (const [k, v] of Object.entries(limits.models)) {
+      const bar = parseBar(v);
+      if (bar)
+        models[k] = bar;
+    }
+  const usedCreditsUsd = num2(limits.usedCreditsUsd);
+  const hasModels = Object.keys(models).length > 0;
+  if (!fiveHour && !sevenDay && !spendLimit && !hasModels && usedCreditsUsd === undefined)
     return null;
   const out = { capturedAt };
   if (fiveHour)
@@ -537,6 +653,10 @@ var parseSeatWindow = (raw, capturedAt) => {
     out.sevenDay = sevenDay;
   if (spendLimit)
     out.spendLimit = spendLimit;
+  if (hasModels)
+    out.models = models;
+  if (usedCreditsUsd !== undefined)
+    out.usedCreditsUsd = usedCreditsUsd;
   return out;
 };
 var seatWindowFromStdin = (text, capturedAt) => {
@@ -702,40 +822,31 @@ var readStdin = (timeoutMs, stdin = process.stdin) => new Promise((resolve3) =>
   stdin.resume();
 });
 
-// src/bar.ts
-var SEAT_BAR_FRESH_MS = 6 * 60 * 60 * 1000;
-var DASHBOARD_URL = "https://app.sleds.ai";
-var MONO = "font=Menlo size=12";
-var freshSeat = (w, now) => {
-  if (!w)
-    return null;
-  return now - w.capturedAt < SEAT_BAR_FRESH_MS ? w : null;
-};
-var barTitle = (m, seat) => {
-  const head = m ? usd(m.today.spentUsd) : "offline";
-  const wk = seat?.sevenDay ? `wk ${Math.round(seat.sevenDay.usedPct)}%` : null;
-  return [`sleds ${head}`, ...wk ? [wk] : []].join(SEP);
-};
-var formatBar = (m, seat, now) => {
-  const lines = [barTitle(m, seat), "---"];
-  if (m) {
-    for (const row2 of formatMeter(m, now))
-      lines.push(`${row2} | ${MONO}`);
-  } else {
-    lines.push(`offline${SEP}proxy did not answer | ${MONO}`);
-  }
-  const frag = formatSeatFragment(seat);
-  if (frag)
-    lines.push(`${"Limits:".padEnd(12)}${frag.replace(/^seat /, "")} | ${MONO}`);
-  lines.push("---");
-  lines.push(`Open dashboard | href=${DASHBOARD_URL}`);
-  lines.push("Refresh | refresh=true");
-  return lines;
-};
-
 // src/commands/bar.ts
+function parseInstallArgs(argv, env) {
+  const flag = (name2) => {
+    const i = argv.indexOf(`--${name2}`);
+    const v = i >= 0 ? argv[i + 1] : undefined;
+    return v && !v.startsWith("--") ? v : undefined;
+  };
+  const sledsHome = flag("home") ?? (env.SLEDS_HOME?.trim() || undefined);
+  const claudeConfigDir = flag("claude-config") ?? (env.CLAUDE_CONFIG_DIR?.trim() || undefined);
+  const name = flag("name");
+  return {
+    ...sledsHome ? { sledsHome } : {},
+    ...claudeConfigDir ? { claudeConfigDir } : {},
+    ...name ? { name } : {}
+  };
+}
+var PLUGIN_NAME = "sleds.1m.sh";
+var pluginName = (name) => name ? `sleds-${name}.1m.sh` : PLUGIN_NAME;
 var bar = async (o) => {
   const log = o.log ?? console.log;
+  const argv = o.argv ?? [];
+  if (argv.includes("--install"))
+    return install(o, log);
+  if (argv.includes("--uninstall"))
+    return uninstall(o, log);
   const now = (o.now ?? Date.now)();
   const seat = freshSeat(readSeatState(o.home).window, now);
   if (!meterSource(o.home)) {
@@ -749,6 +860,393 @@ var bar = async (o) => {
     log(line);
   return 0;
 };
+function swiftBarPluginDir() {
+  try {
+    const out = execFileSync("defaults", ["read", "com.ameba.SwiftBar", "PluginDirectory"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out ? out.replace(/^~(?=$|\/)/, homedir()) : null;
+  } catch {
+    return null;
+  }
+}
+var pluginPath = (home, name) => join5(configDir(home, {}), "swiftbar", pluginName(name));
+function install(o, log) {
+  const opts = parseInstallArgs(o.argv ?? [], o.env ?? process.env);
+  const script = pluginPath(o.home, opts.name);
+  mkdirSync5(join5(script, ".."), { recursive: true, mode: 448 });
+  writeFileSync5(script, pluginScript(o.nodePath ?? process.execPath, o.cliPath ?? process.argv[1] ?? "", {
+    ...opts.sledsHome ? { sledsHome: resolve3(o.home, opts.sledsHome) } : {},
+    ...opts.claudeConfigDir ? { claudeConfigDir: resolve3(o.home, opts.claudeConfigDir) } : {}
+  }), {
+    mode: 493
+  });
+  chmodSync2(script, 493);
+  log(`wrote ${script}`);
+  if (opts.sledsHome || opts.claudeConfigDir)
+    log(`tracks the seat at ${[opts.sledsHome && `SLEDS_HOME=${opts.sledsHome}`, opts.claudeConfigDir && `CLAUDE_CONFIG_DIR=${opts.claudeConfigDir}`].filter(Boolean).join(" ")}`);
+  const dir = (o.swiftBarPluginDir ?? swiftBarPluginDir)();
+  if (!dir) {
+    log("SwiftBar is not set up yet: `brew install --cask swiftbar`, launch it once and pick a plugin");
+    log("folder, then run `sleds bar --install` again — or symlink the file above into that folder.");
+    return 0;
+  }
+  const link = join5(dir, pluginName(opts.name));
+  try {
+    mkdirSync5(dir, { recursive: true });
+    if (existsSync5(link) || isDanglingLink(link))
+      unlinkSync(link);
+    symlinkSync(script, link);
+    log(`linked ${link}`);
+    log("SwiftBar picks it up within a minute; the item reads `sleds $… · wk …%`.");
+    return 0;
+  } catch (e) {
+    log(`could not link into ${dir}: ${e instanceof Error ? e.message : String(e)}`);
+    log(`symlink it yourself: ln -sf ${script} ${link}`);
+    return 1;
+  }
+}
+function uninstall(o, log) {
+  const { name } = parseInstallArgs(o.argv ?? [], {});
+  const dir = (o.swiftBarPluginDir ?? swiftBarPluginDir)();
+  const link = dir ? join5(dir, pluginName(name)) : null;
+  if (link && (existsSync5(link) || isDanglingLink(link))) {
+    unlinkSync(link);
+    log(`removed ${link}`);
+  } else
+    log("no SwiftBar plugin link to remove");
+  const script = pluginPath(o.home, name);
+  if (existsSync5(script)) {
+    unlinkSync(script);
+    log(`removed ${script}`);
+  }
+  return 0;
+}
+var isDanglingLink = (p) => {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+};
+
+// src/commands/doctor.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
+import { existsSync as existsSync6, lstatSync as lstatSync2, readFileSync as readFileSync5, readdirSync, readlinkSync } from "node:fs";
+import { join as join7 } from "node:path";
+
+// src/commands/bar.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { homedir as homedir2 } from "node:os";
+import { join as join6, resolve as resolve4 } from "node:path";
+var PLUGIN_NAME2 = "sleds.1m.sh";
+var pluginName2 = (name) => name ? `sleds-${name}.1m.sh` : PLUGIN_NAME2;
+function swiftBarPluginDir2() {
+  try {
+    const out = execFileSync2("defaults", ["read", "com.ameba.SwiftBar", "PluginDirectory"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out ? out.replace(/^~(?=$|\/)/, homedir2()) : null;
+  } catch {
+    return null;
+  }
+}
+var pluginPath2 = (home, name) => join6(configDir(home, {}), "swiftbar", pluginName2(name));
+
+// src/switch.ts
+var isObject5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var envOf2 = (settings) => isObject5(settings.env) ? settings.env : {};
+var capturePriorEnv = (settings) => {
+  const env = envOf2(settings);
+  const prior = { hadEnv: isObject5(settings.env) };
+  const url = env[BASE_URL_KEY];
+  const token = env[AUTH_TOKEN_KEY];
+  if (typeof url === "string")
+    prior[BASE_URL_KEY] = url;
+  if (typeof token === "string")
+    prior[AUTH_TOKEN_KEY] = token;
+  return prior;
+};
+var switchOn = (settings, cfg) => applyProxy(settings, cfg);
+var switchOff = (settings, prior) => {
+  const hadEnv = prior.hadEnv === true;
+  const stripped = removeProxy(settings);
+  const env = { ...envOf2(stripped) };
+  const url = prior[BASE_URL_KEY];
+  const token = prior[AUTH_TOKEN_KEY];
+  if (url !== undefined)
+    env[BASE_URL_KEY] = url;
+  if (token !== undefined)
+    env[AUTH_TOKEN_KEY] = token;
+  if (Object.keys(env).length === 0 && !hadEnv) {
+    const { env: _env, ...rest } = stripped;
+    return rest;
+  }
+  return { ...stripped, env };
+};
+var isPointedAtProxy = (settings) => {
+  const env = envOf2(settings);
+  return BASE_URL_KEY in env || AUTH_TOKEN_KEY in env;
+};
+var RELATIVE = /^\+(?:(\d+)h)?(?:(\d+)m)?$/;
+var parseUntilReset = (input, nowMs) => {
+  const trimmed = input.trim();
+  const rel = RELATIVE.exec(trimmed);
+  let deadline;
+  if (rel) {
+    const hours = Number(rel[1] ?? 0);
+    const minutes = Number(rel[2] ?? 0);
+    if (hours === 0 && minutes === 0) {
+      throw new Error(`--until-reset: "${input}" is zero; use something like +5h or +90m`);
+    }
+    deadline = nowMs + (hours * 60 + minutes) * 60000;
+  } else {
+    deadline = Date.parse(trimmed);
+    if (Number.isNaN(deadline)) {
+      throw new Error(`--until-reset: "${input}" is not +<n>h[<n>m] or an ISO timestamp`);
+    }
+  }
+  if (deadline <= nowMs) {
+    throw new Error(`--until-reset: ${trimmed} is in the past`);
+  }
+  return deadline;
+};
+var formatLocal = (ms, tz) => new Intl.DateTimeFormat("en-US", {
+  month: "short",
+  day: "numeric",
+  hour: "numeric",
+  minute: "2-digit",
+  timeZoneName: "short",
+  ...tz ? { timeZone: tz } : {}
+}).format(new Date(ms));
+var formatDuration = (ms) => {
+  const total = Math.max(0, Math.round(ms / 60000));
+  const h = Math.floor(total / 60);
+  const m = total % 60;
+  if (h === 0)
+    return `${m}m`;
+  return m === 0 ? `${h}h` : `${h}h ${m}m`;
+};
+
+// src/commands/status.ts
+var checkHealth = async (url, fetchFn = fetch, timeoutMs = 1000) => {
+  try {
+    const res = await fetchFn(`${url}/healthz`, { signal: AbortSignal.timeout(timeoutMs) });
+    return res.ok ? "ok" : "unreachable";
+  } catch {
+    return "unreachable";
+  }
+};
+
+// src/commands/doctor.ts
+var NODE_MIN = "22.5.0";
+function nodeOk(version, min = NODE_MIN) {
+  const parse = (v) => v.replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const [a, b, c] = parse(version);
+  const [x, y, z] = parse(min);
+  return (a ?? 0) !== (x ?? 0) ? (a ?? 0) > (x ?? 0) : (b ?? 0) !== (y ?? 0) ? (b ?? 0) > (y ?? 0) : (c ?? 0) >= (z ?? 0);
+}
+function pluginEnv(body) {
+  const out = {};
+  const home = /^export SLEDS_HOME='([^']*)'/m.exec(body);
+  const cfg = /^export CLAUDE_CONFIG_DIR='([^']*)'/m.exec(body);
+  if (home?.[1])
+    out.sledsHome = home[1];
+  if (cfg?.[1])
+    out.claudeConfigDir = cfg[1];
+  return out;
+}
+var MARK = { ok: "ok  ", warn: "warn", fail: "FAIL" };
+function formatDoctor(checks) {
+  const lines = checks.map((c) => `${MARK[c.level]}  ${c.name.padEnd(16)}${c.detail}`);
+  const fixes = checks.filter((c) => c.level !== "ok" && c.fix);
+  if (fixes.length > 0) {
+    lines.push("");
+    for (const c of fixes)
+      lines.push(`  ${c.name}: ${c.fix}`);
+  }
+  const fails = checks.filter((c) => c.level === "fail").length;
+  const warns = checks.filter((c) => c.level === "warn").length;
+  lines.push("");
+  lines.push(fails === 0 && warns === 0 ? "All good." : `${fails} problem${fails === 1 ? "" : "s"}, ${warns} warning${warns === 1 ? "" : "s"}.`);
+  return lines;
+}
+function defaultWhich(cmd) {
+  try {
+    return execFileSync3("which", ["-a", cmd], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).split(`
+`).map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function defaultLaunchctl() {
+  try {
+    return execFileSync3("launchctl", ["list"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return "";
+  }
+}
+async function runDoctor(o) {
+  const env = o.env ?? process.env;
+  const checks = [];
+  const home = o.home;
+  const overrides = [
+    env.SLEDS_HOME?.trim() ? `SLEDS_HOME=${env.SLEDS_HOME.trim()}` : null,
+    env.CLAUDE_CONFIG_DIR?.trim() ? `CLAUDE_CONFIG_DIR=${env.CLAUDE_CONFIG_DIR.trim()}` : null
+  ].filter(Boolean);
+  const cfgDir = configDir(home, env);
+  const cfg = readConfig(home);
+  const cfgExists = existsSync6(configPath(home));
+  if (!cfgExists) {
+    checks.push({
+      level: "fail",
+      name: "config",
+      detail: `${configPath(home)} does not exist${overrides.length ? ` (this shell has ${overrides.join(" ")})` : ""}`,
+      fix: overrides.length ? "unset SLEDS_HOME CLAUDE_CONFIG_DIR — or run `sleds init` for this seat" : "sleds init --token <sled_…>"
+    });
+  } else {
+    checks.push({
+      level: "ok",
+      name: "config",
+      detail: `${cfgDir}${cfg.email ? ` · ${cfg.email}` : ""}${cfg.token ? ` · ${maskToken(cfg.token)}` : ""}${overrides.length ? ` · ${overrides.join(" ")}` : ""}`
+    });
+  }
+  const sPath = settingsPath(home);
+  const settings = existsSync6(sPath) ? readSettings(home) : null;
+  const pointed = settings ? readProxy(settings) : null;
+  if (!settings) {
+    checks.push({
+      level: "fail",
+      name: "claude",
+      detail: `${claudeDir(home)} has no settings.json — is Claude Code installed for this config dir?`
+    });
+  } else if (!pointed) {
+    checks.push({
+      level: cfg.mode === "off" && cfg.token ? "ok" : "warn",
+      name: "claude",
+      detail: cfg.mode === "off" && cfg.token ? `${sPath} on your own seat (sleds off)` : `${sPath} does not point at the proxy`,
+      fix: cfg.mode === "off" && cfg.token ? undefined : "sleds init (or `sleds on` to switch)"
+    });
+  } else if (cfg.token && pointed.token !== cfg.token) {
+    checks.push({
+      level: "warn",
+      name: "claude",
+      detail: `${sPath} carries a different token (${maskToken(pointed.token)}) than ${configPath(home)} (${maskToken(cfg.token)})`,
+      fix: "sleds init --token <the one you mean>"
+    });
+  } else {
+    checks.push({ level: "ok", name: "claude", detail: `${sPath} → ${pointed.url}` });
+  }
+  const src = meterSource(home);
+  if (src) {
+    const health = await checkHealth(src.proxyUrl, o.fetchFn, o.timeoutMs);
+    checks.push({
+      level: health === "ok" ? "ok" : "fail",
+      name: "proxy",
+      detail: `${src.proxyUrl} ${health === "ok" ? "answers /healthz" : "did not answer"}`,
+      fix: health === "ok" ? undefined : "check the URL (a trailing dot or wrong host); `sleds init --url https://proxy.sleds.ai`"
+    });
+  }
+  if (settings) {
+    const seat2 = hasSeatHook(settings);
+    const spec = hasSpecHook(settings);
+    checks.push({
+      level: seat2 && spec ? "ok" : "warn",
+      name: "hooks",
+      detail: `seat-event ${seat2 ? "on" : "missing"} · spec-event ${spec ? "on" : "missing"}`,
+      fix: seat2 && spec ? undefined : "sleds hooks"
+    });
+    const skill = existsSync6(skillPath(home));
+    checks.push({
+      level: skill ? "ok" : "warn",
+      name: "skill",
+      detail: skill ? skillPath(home) : `no /sled skill at ${skillPath(home)}`,
+      fix: skill ? undefined : "sleds init (re-run; keeps your token)"
+    });
+  }
+  const nodeVersion = o.nodeVersion ?? process.version;
+  checks.push({
+    level: nodeOk(nodeVersion) ? "ok" : "warn",
+    name: "node",
+    detail: `${nodeVersion}${nodeOk(nodeVersion) ? "" : ` — seat-sync needs ≥ ${NODE_MIN} (node:sqlite)`}`,
+    fix: nodeOk(nodeVersion) ? undefined : `brew install node@22 && echo 'export PATH="/opt/homebrew/opt/node@22/bin:$PATH"' >> ~/.zshrc`
+  });
+  const which = (o.which ?? defaultWhich)("sleds");
+  const stale = which.filter((p) => {
+    try {
+      const target = lstatSync2(p).isSymbolicLink() ? readlinkSync(p) : p;
+      return /\/src\/index\.ts$/.test(target) || /\.bun\/bin\/sleds$/.test(p);
+    } catch {
+      return false;
+    }
+  });
+  if (stale.length > 0)
+    checks.push({
+      level: "warn",
+      name: "path",
+      detail: `an old link shadows the installed CLI: ${stale.join(", ")}`,
+      fix: `rm -f ${stale.join(" ")}`
+    });
+  else if (which.length > 0)
+    checks.push({ level: "ok", name: "path", detail: which[0] ?? "" });
+  const pluginBody = existsSync6(pluginPath2(home)) ? readFileSync5(pluginPath2(home), "utf8") : null;
+  const dir = (o.swiftBarPluginDir ?? swiftBarPluginDir2)();
+  if (pluginBody) {
+    const baked = pluginEnv(pluginBody);
+    const linked = dir ? existsSync6(join7(dir, PLUGIN_NAME2)) : false;
+    const seatDesc = baked.sledsHome || baked.claudeConfigDir ? `seat at ${[baked.sledsHome && `SLEDS_HOME=${baked.sledsHome}`, baked.claudeConfigDir && `CLAUDE_CONFIG_DIR=${baked.claudeConfigDir}`].filter(Boolean).join(" ")}` : "default seat";
+    checks.push({
+      level: linked ? "ok" : "warn",
+      name: "menu bar",
+      detail: linked ? `${PLUGIN_NAME2} linked · ${seatDesc}` : `plugin written but not linked into SwiftBar${dir ? ` (${dir})` : " (SwiftBar not set up)"}`,
+      fix: linked ? undefined : "sleds bar --install"
+    });
+  } else {
+    checks.push({
+      level: "warn",
+      name: "menu bar",
+      detail: "no SwiftBar plugin",
+      fix: "sleds bar --install"
+    });
+  }
+  const agents = join7(home, "Library", "LaunchAgents");
+  const plists = existsSync6(agents) ? readdirSync(agents).filter((f) => f.startsWith("ai.sleds.") && f.endsWith(".plist")) : [];
+  const loaded = (o.launchctlList ?? defaultLaunchctl)();
+  const seat = readSeatState(home);
+  const age = seat.window ? Math.round((Date.now() - seat.window.capturedAt) / 60000) : null;
+  if (plists.length === 0)
+    checks.push({
+      level: "warn",
+      name: "seat-sync",
+      detail: "no timer installed (seat bars stay empty)",
+      fix: "sleds seat-sync --install"
+    });
+  else {
+    const running = plists.filter((p) => loaded.includes(p.replace(/\.plist$/, "")));
+    checks.push({
+      level: running.length === plists.length ? age !== null && age < 6 * 60 ? "ok" : "warn" : "warn",
+      name: "seat-sync",
+      detail: `${running.length}/${plists.length} timer${plists.length === 1 ? "" : "s"} loaded${age !== null ? ` · last read ${age}m ago` : " · no read yet"}`,
+      fix: running.length === plists.length && age !== null && age < 6 * 60 ? undefined : "sleds seat-sync (run once by hand and read its message)"
+    });
+  }
+  return checks;
+}
+var doctor = async (o) => {
+  const log = o.log ?? console.log;
+  const checks = await runDoctor(o);
+  for (const line of formatDoctor(checks))
+    log(line);
+  return checks.some((c) => c.level === "fail") ? 1 : 0;
+};
 
 // src/commands/hooks.ts
 var DEFAULT_SEAT_EVENT_COMMAND = "sleds seat-event";
@@ -771,7 +1269,7 @@ var hooks = (o) => {
 };
 
 // src/commands/init.ts
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "node:fs";
 import { createInterface } from "node:readline";
 
 // src/skill.ts
@@ -803,6 +1301,7 @@ When the proxy is active it answers a walled request with its options. The user
 /sled 2    hold; resume when the window resets
 /sled 3    run overnight at half price
 /sled 4    switch to a cheaper model for the rest of the session (offered when one saves ≥15%)
+/sled 5    hand off to an idle coworker, or park for the team (offered on a team of two or more)
 \`\`\`
 
 ## Window reset
@@ -861,6 +1360,16 @@ List the org's jobs: queued, running, delivered, parked, with the estimate band,
 
 Resume a parked job. Show the unanswered question and its options, take the answer, and confirm the job is back in the queue. The answer is logged with the user's name, and it becomes a prior decision the Musher can reuse on the next question like it.
 
+## /sled sync-backlog — price the backlog
+
+With the \`sleds\` MCP server available, size every open issue so the dashboard's Projects page shows the backlog in dollars and hours, not T-shirt sizes or points. SLEDS is not a tracker and never the system of record: Linear and GitHub keep the issues; SLEDS mirrors their words (cycle, labels, priority, assignee, state) and adds the price.
+
+1. Find the issues. In Cowork with a Claude Project attached: each spec doc, each phase or slice inside a spec, and each line of a backlog list (a numbered or bulleted list under a heading like Backlog, Next, To do, Roadmap). With a Linear or GitHub MCP available: the open issues of the team / repo the user names, with their cycle or milestone, labels, priority, assignee and state. Skip anything done, closed or shipped.
+2. For each issue call the \`estimate\` tool with \`spec\` = the title on the first line, then the body (quote the issue or doc, do not paraphrase), and \`source\` = \`{ kind: "linear" | "github" | "claude-project", project: <team, repo or Project name>, doc: <issue key like ENG-42 or #123, or the doc path>, item: <heading or line, only when a doc holds many>, url, cycle, labels, priority, assignee, state }\` — the tracker's values verbatim. The estimator dedupes: an unchanged issue returns its existing estimate, so re-running is safe.
+3. Report one line per issue — \`ENG-42 · Cycle 34 · high · priya · $6–18 · 60–150 min · 55%\` — then the total of what is open, and the Projects page address (\`/o/<slug>/projects\`). Never invent a number: the band is the estimator's. Do not change anything in the tracker from this command; the page's verbs (defer, prioritize, hand off) do that, and write back in the tracker's terms.
+
+To keep the backlog priced as issues change, set a Cowork scheduled task: "Every weekday at 7:00, run /sled sync-backlog for <team or Project> and post the open total." An issue whose text changed gets a fresh band; the page counts how many times each was re-sized.
+
 ## Voice
 
 Plain sentences, sentence case, no emoji. Numbers with units and bands. Say what happens next, not what could.
@@ -869,10 +1378,18 @@ Plain sentences, sentence case, no emoji. Numbers with units and bands. Say what
 
 At a wall the proxy prints its options; \`/sled 3\` queues the session for the org's overnight window on the batch tier at half price. The next morning:
 
-- \`/sled jobs\` — this seat's jobs: id, status, route, cost, when.
+- \`/sled jobs\` — this seat's jobs: id, status, route, cost, when — then the team's open hand-offs waiting for pickup (yours first).
 - \`/sled resume <id>\` — pull a delivered job's output into the session as the assistant's reply and keep going.
 
 A job that is \`parked\` or \`failed\` shows its reason in \`/sled jobs\`; the admin can see and cancel jobs on the dashboard's Jobs page.
+
+## Team hand-off
+
+\`/sled 5\` at a wall hands the snapshotted session to the most idle coworker (or parks it for anyone on the team). The team hears on Slack and the dashboard's Jobs page lists open hand-offs with the pickup command.
+
+- \`/sled pickup <id>\` — in the coworker's Claude Code session: the handed-off session resumes there on the org key, metered to them. A task parked from Cowork (no session) starts this turn from the task text. A hand-off meant for someone else or already taken gets one line saying so.
+
+From Cowork or any MCP client (\`sleds mcp\`): the \`handoffs\` tool lists what is waiting, \`handoff\` parks the current task for a teammate (give the task in full — the picker starts from that text), and \`pickup\` takes one and returns its context to continue there.
 `;
 
 // src/commands/hooks.ts
@@ -898,11 +1415,11 @@ var hooks2 = (o) => {
 // src/commands/init.ts
 var DEFAULT_PROXY_URL = "http://localhost:8787";
 var DEFAULT_STATUS_LINE_COMMAND = "sleds statusline";
-var promptStdin = (question) => new Promise((resolve3) => {
+var promptStdin = (question) => new Promise((resolve5) => {
   const rl = createInterface({ input: process.stdin, output: process.stderr });
   rl.question(question, (answer) => {
     rl.close();
-    resolve3(answer.trim());
+    resolve5(answer.trim());
   });
 });
 async function signupIndividual(proxyUrl, email, credential, fetchFn = fetch) {
@@ -937,6 +1454,33 @@ var SIGNUP_REASONS = {
 function signupFailureText(r) {
   return `Signup failed: ${SIGNUP_REASONS[r.reason] ?? `unexpected answer (${r.reason}, HTTP ${r.status}).`}`;
 }
+function normalizeProxyUrl(raw) {
+  let t = raw.trim();
+  if (!t)
+    return null;
+  if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(t))
+    t = `https://${t}`;
+  t = t.replace(/[./]+$/, "");
+  try {
+    const u = new URL(t);
+    if (u.protocol !== "http:" && u.protocol !== "https:")
+      return null;
+    if (!u.hostname)
+      return null;
+    u.hostname = u.hostname.replace(/\.+$/, "");
+    return `${u.protocol}//${u.host}${u.pathname === "/" ? "" : u.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return null;
+  }
+}
+async function probeProxy(url, fetchFn = fetch) {
+  try {
+    const res = await fetchFn(`${url}/health`, { signal: AbortSignal.timeout(3000) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
 var resolveToken = async (o) => {
   const env = o.env ?? process.env;
   if (o.token)
@@ -953,7 +1497,9 @@ var resolveToken = async (o) => {
     if (typed)
       return { token: typed, source: "prompt" };
   }
-  const url = (o.url ?? env.SLEDS_PROXY_URL ?? DEFAULT_PROXY_URL).replace(/\/+$/, "");
+  const url = normalizeProxyUrl(o.url ?? env.SLEDS_PROXY_URL ?? DEFAULT_PROXY_URL);
+  if (!url)
+    return null;
   const email = (await o.prompt("Your email: ")).trim();
   if (!email.includes("@"))
     return null;
@@ -985,7 +1531,15 @@ var init = async (o) => {
     error("Invalid seat token: expected something like sled_xxxxxxxx.");
     return 2;
   }
-  const url = (o.url ?? env.SLEDS_PROXY_URL ?? DEFAULT_PROXY_URL).replace(/\/+$/, "");
+  const url = normalizeProxyUrl(o.url ?? env.SLEDS_PROXY_URL ?? DEFAULT_PROXY_URL);
+  if (!url) {
+    error(`Invalid proxy URL: ${JSON.stringify(o.url ?? env.SLEDS_PROXY_URL ?? "")}. Expected https://proxy.sleds.ai.`);
+    return 2;
+  }
+  if (!o.noProbe && !await probeProxy(url, o.fetchFn)) {
+    error(`No SLEDS proxy answered at ${url}/health. Check the URL (or pass --no-probe to save it anyway).`);
+    return 2;
+  }
   const wrote = [];
   if (backupSettings(o.home))
     wrote.push(`backed up settings to ${backupPath(o.home)}`);
@@ -1013,17 +1567,17 @@ var init = async (o) => {
     ...statusLine.prior !== undefined ? { priorStatusLine: statusLine.prior } : {}
   });
   wrote.push(`saved token and proxy URL to ${configPath(o.home)} (0600)`);
-  mkdirSync5(skillDir(o.home), { recursive: true });
-  writeFileSync5(skillPath(o.home), SKILL_MD);
+  mkdirSync6(skillDir(o.home), { recursive: true });
+  writeFileSync6(skillPath(o.home), SKILL_MD);
   wrote.push(`installed skill at ${skillPath(o.home)}`);
-  log("Nothing changes until a wall.");
+  log("Claude Code now runs through SLEDS on the org key.");
   log("");
   for (const w of wrote)
     log(`  ${w}`);
   log("");
-  log(`Claude Code now talks to ${url}. Run \`sleds status\` to check.`);
+  log(`Every request goes to ${url} and is metered to this seat. Run \`sleds status\` to check.`);
   log("The status line shows your meter: spend today, seat limits, window, allowance, queued jobs.");
-  log("On a Team or Max seat, keep your seat and switch only at a wall: `sleds on` / `sleds off`.");
+  log("Prefer to burn your own Pro/Max/Team seat first? `sleds off` puts Claude Code back on it; `sleds on --until-reset +5h` switches to the org key at a wall.");
   return 0;
 };
 
@@ -1031,6 +1585,21 @@ var init = async (o) => {
 var PROTOCOL_VERSION = "2025-06-18";
 var SERVER_INFO = { name: "sleds", version: "0.0.1" };
 var MCP_TIMEOUT_MS = 5000;
+var sourceSchema = {
+  type: "object",
+  description: "Where this item lives, so the Projects page groups it: a Claude Project doc, a repo spec, a Linear/GitHub issue. Same source + same text on a later call returns the same estimate (idempotent sync).",
+  properties: {
+    kind: { type: "string", enum: ["claude-project", "repo", "linear", "github", "manual"] },
+    project: { type: "string", description: "Project / repo / board name." },
+    doc: { type: "string", description: "Doc path or issue key inside it." },
+    item: {
+      type: "string",
+      description: "The line or phase inside the doc, when a doc holds many."
+    },
+    url: { type: "string", description: "Link to open it, if any." }
+  },
+  required: ["kind", "project"]
+};
 var specSchema = {
   type: "object",
   properties: {
@@ -1038,7 +1607,8 @@ var specSchema = {
       type: "string",
       description: "What the job should do. The first line becomes the title."
     },
-    model: { type: "string", description: "Model to price and run with; org default when absent." }
+    model: { type: "string", description: "Model to price and run with; org default when absent." },
+    source: sourceSchema
   },
   required: ["spec"]
 };
@@ -1060,8 +1630,38 @@ var TOOLS = [
   },
   {
     name: "jobs",
-    description: "This seat's overnight jobs, newest first: id, status, route, cost, when.",
+    description: "This seat's overnight jobs, newest first (id, status, route, cost, when), then the team's open hand-offs waiting for pickup.",
     inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "handoffs",
+    description: "The team's open hand-offs: tasks and walled sessions parked for pickup, the ones meant for this seat first. Each has an id for the pickup tool (or /sled pickup <id> in Claude Code).",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "handoff",
+    description: "Park the current task for a teammate (or anyone on the team) to pick up. Give the task in full — what to do, where things stand, what is left — because the picker starts from this text alone. Optionally name the coworker by email. The team is told on Slack; they take it with /sled pickup <id>.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "The task to hand off, in full. First line becomes the title."
+        },
+        to: { type: "string", description: "Coworker's email; omit to park for anyone." },
+        note: { type: "string", description: "One line on where things stand (≤280 chars)." }
+      },
+      required: ["task"]
+    }
+  },
+  {
+    name: "pickup",
+    description: "Take an open hand-off and get its context to continue here: a parked task comes back verbatim; a walled Claude Code session comes back as its first and last user messages. Marks it picked for the team.",
+    inputSchema: {
+      type: "object",
+      properties: { handoffId: { type: "string", description: "From the handoffs tool." } },
+      required: ["handoffId"]
+    }
   }
 ];
 var NOT_SET_UP = {
@@ -1072,7 +1672,7 @@ var UNREACHABLE = {
   text: "Control plane unreachable. Nothing was recorded → try again in a moment.",
   isError: true
 };
-var isObject5 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isObject6 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
 var str2 = (v) => typeof v === "string" ? v : undefined;
 async function proxyPost(deps, path, body) {
@@ -1090,11 +1690,35 @@ async function proxyPost(deps, path, body) {
     if (!res.ok)
       return null;
     const parsed = await res.json();
-    return isObject5(parsed) ? parsed : null;
+    return isObject6(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function proxyPostFull(deps, path, body) {
+  const src = meterSource(deps.home);
+  if (!src)
+    return null;
+  const fetchFn = deps.fetchFn ?? fetch;
+  try {
+    const res = await fetchFn(`${src.proxyUrl}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${src.token}` },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(deps.timeoutMs ?? MCP_TIMEOUT_MS)
+    });
+    let json = null;
+    try {
+      json = await res.json();
+    } catch {
+      json = null;
+    }
+    return { status: res.status, json: isObject6(json) ? json : null };
   } catch {
     return null;
   }
 }
+var errorMessage = (j) => isObject6(j?.error) ? str2(j.error.message) : undefined;
 async function proxyGet(deps, path) {
   const src = meterSource(deps.home);
   if (!src)
@@ -1108,7 +1732,7 @@ async function proxyGet(deps, path) {
     if (!res.ok)
       return null;
     const parsed = await res.json();
-    return isObject5(parsed) ? parsed : null;
+    return isObject6(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -1137,7 +1761,7 @@ async function usageTool(deps) {
 `) };
 }
 function bandLine(band) {
-  if (!isObject5(band))
+  if (!isObject6(band))
     return null;
   const low = num3(band.lowUsd);
   const high = num3(band.highUsd);
@@ -1157,10 +1781,15 @@ async function estimateTool(deps, args) {
   const spec = str2(args.spec)?.trim();
   if (!spec)
     return { text: "Nothing to estimate. Pass spec: what the job should do.", isError: true };
-  const r = await proxyPost(deps, "/proxy/estimate", { spec, model: str2(args.model) });
+  const source = isObject6(args.source) && str2(args.source.kind) && str2(args.source.project) ? args.source : undefined;
+  const r = await proxyPost(deps, "/proxy/estimate", {
+    spec,
+    model: str2(args.model),
+    ...source ? { source } : {}
+  });
   if (!r)
     return UNREACHABLE;
-  const band = isObject5(r.band) ? r.band : {};
+  const band = isObject6(r.band) ? r.band : {};
   const line = bandLine(band) ?? "band unreadable";
   const method = str2(band.method) ?? "plan";
   const cap = num3(band.capUsd);
@@ -1172,14 +1801,18 @@ Assumes: ${assumptions.join("; ")}.` : "";
   const capText = cap !== undefined ? ` Cap ${usd(cap)}.` : "";
   const models = byModelText(r.byModel);
   const routing = routingText(r.routing);
-  return { text: `Estimate: ${line} (${method}).${capText}${over}${tail}${models}${routing}` };
+  const filed = source ? `
+Filed under ${str2(source.kind)} ${str2(source.project)}${str2(source.doc) ? ` › ${str2(source.doc)}` : ""}${str2(source.item) ? ` › ${str2(source.item)}` : ""} on the Projects page.` : "";
+  return {
+    text: `Estimate: ${line} (${method}).${capText}${over}${tail}${models}${routing}${filed}`
+  };
 }
 function byModelText(raw) {
   if (!Array.isArray(raw))
     return "";
   const parts = [];
   for (const row2 of raw) {
-    if (!isObject5(row2) || !isObject5(row2.standard))
+    if (!isObject6(row2) || !isObject6(row2.standard))
       continue;
     const model = str2(row2.model);
     const low = num3(row2.standard.lowUsd);
@@ -1194,7 +1827,7 @@ function byModelText(raw) {
 By model: ${parts.join(" · ")} (overnight batch ½).` : "";
 }
 function routingText(raw) {
-  if (!isObject5(raw) || !Array.isArray(raw.segments) || !isObject5(raw.cost))
+  if (!isObject6(raw) || !Array.isArray(raw.segments) || !isObject6(raw.cost))
     return "";
   const short = (model) => {
     const m = /^claude-([a-z]+)-(\d+)(?:-(\d+))?/.exec(model);
@@ -1202,7 +1835,7 @@ function routingText(raw) {
   };
   const parts = [];
   for (const s of raw.segments) {
-    if (!isObject5(s))
+    if (!isObject6(s))
       continue;
     const from = num3(s.from);
     const to = num3(s.to);
@@ -1237,7 +1870,7 @@ async function overnightTool(deps, args) {
   const at = num3(r.scheduledAt);
   const when = at !== undefined && at > now ? `Runs in ${shortDuration(at - now)}` : "Runs at the next tick";
   const band = bandLine(r.band);
-  const cap = isObject5(r.band) ? num3(r.band.capUsd) : undefined;
+  const cap = isObject6(r.band) ? num3(r.band.capUsd) : undefined;
   const sized = band ? ` ${band}${cap !== undefined ? ` · cap ${usd(cap)}` : ""}.` : "";
   return {
     text: `Queued overnight. Batch tier · ½ price.${sized} ${when}. Check with the jobs tool; pull the result into a session with /sled resume ${jobId}.`
@@ -1249,10 +1882,14 @@ async function jobsTool(deps) {
   const r = await proxyGet(deps, "/proxy/jobs");
   if (!r)
     return UNREACHABLE;
-  const rows = Array.isArray(r.jobs) ? r.jobs.filter(isObject5) : [];
-  if (rows.length === 0)
-    return { text: "No jobs for this seat. Queue one with the overnight tool." };
+  const rows = Array.isArray(r.jobs) ? r.jobs.filter(isObject6) : [];
+  const handoffs = Array.isArray(r.handoffs) ? r.handoffs.filter(isObject6) : [];
   const now = (deps.now ?? Date.now)();
+  if (rows.length === 0 && handoffs.length === 0)
+    return { text: "No jobs for this seat. Queue one with the overnight tool." };
+  if (rows.length === 0)
+    return { text: ["No jobs for this seat.", ...handoffLines(handoffs, now)].join(`
+`) };
   const lines = rows.map((j) => {
     const when = (ts) => num3(ts) !== undefined ? shortDuration(Math.abs(now - num3(ts))) : "";
     const status = str2(j.status) ?? "unknown";
@@ -1267,9 +1904,110 @@ async function jobsTool(deps) {
     ].join("  ").trimEnd();
   });
   lines.push("Resume a delivered job in a session with /sled resume <id>.");
+  lines.push(...handoffLines(handoffs, now));
   return { text: lines.join(`
 `) };
 }
+function handoffLines(handoffs, now) {
+  if (handoffs.length === 0)
+    return [];
+  const out = ["", `Hand-offs waiting (${handoffs.length}):`];
+  for (const h of handoffs) {
+    const forMe = h.forMe === true;
+    const to = str2(h.to);
+    const who = forMe ? to ? "for you" : "parked for anyone" : `for ${to ?? "anyone"}`;
+    const created = num3(h.createdAt);
+    const age = created !== undefined ? `${shortDuration(Math.max(0, now - created))} ago` : "";
+    const note = str2(h.note);
+    const parts = [`from ${str2(h.from) ?? "?"}`, who, str2(h.wallKind) ?? "", age].filter(Boolean);
+    if (h.hasSnapshot === false)
+      parts.push("note only");
+    out.push(`${str2(h.handoffId) ?? "?"}  ${parts.join(" · ")}${note ? `  «${note.length > 60 ? `${note.slice(0, 57)}…` : note}»` : ""}`);
+  }
+  out.push("Take one in Claude Code with /sled pickup <id>.");
+  return out;
+}
+async function handoffsTool(deps) {
+  if (!meterSource(deps.home))
+    return NOT_SET_UP;
+  const r = await proxyGet(deps, "/proxy/jobs");
+  if (!r)
+    return UNREACHABLE;
+  const handoffs = Array.isArray(r.handoffs) ? r.handoffs.filter(isObject6) : [];
+  if (handoffs.length === 0)
+    return { text: "No open hand-offs on your team. Park one with the handoff tool." };
+  const now = (deps.now ?? Date.now)();
+  return { text: handoffLines(handoffs, now).slice(1).join(`
+`) };
+}
+async function handoffTool(deps, args) {
+  if (!meterSource(deps.home))
+    return NOT_SET_UP;
+  const task = str2(args.task)?.trim();
+  if (!task)
+    return { text: "Nothing to hand off. Pass task: what the picker should do.", isError: true };
+  const to = str2(args.to)?.trim();
+  const r = await proxyPostFull(deps, "/proxy/handoff/park", {
+    task,
+    to: to || undefined,
+    note: str2(args.note)?.trim() || undefined
+  });
+  if (!r)
+    return { text: `Nothing was parked. ${UNREACHABLE.text}`, isError: true };
+  if (r.status === 404 && to)
+    return { text: `${to} is not a member of your org. Nothing was parked.`, isError: true };
+  if (r.status !== 200)
+    return {
+      text: errorMessage(r.json) ?? `Nothing was parked (HTTP ${r.status}).`,
+      isError: true
+    };
+  const id = str2(r.json?.handoffId) ?? "unknown";
+  return {
+    text: `${to ? `Handed off to ${to}` : "Parked for the team"}. They take it in Claude Code with /sled pickup ${id}, or with the pickup tool here. The team was told on Slack.`
+  };
+}
+async function pickupTool(deps, args) {
+  if (!meterSource(deps.home))
+    return NOT_SET_UP;
+  const handoffId = str2(args.handoffId)?.trim();
+  if (!handoffId)
+    return { text: "Pass handoffId, from the handoffs tool.", isError: true };
+  const r = await proxyPostFull(deps, "/proxy/handoff/pickup", { handoffId });
+  if (!r)
+    return { text: `Nothing was picked up. ${UNREACHABLE.text}`, isError: true };
+  if (r.status !== 200)
+    return {
+      text: errorMessage(r.json) ?? `Could not pick it up (HTTP ${r.status}).`,
+      isError: true
+    };
+  const j = r.json ?? {};
+  const from = str2(j.from) ?? "a teammate";
+  const note = str2(j.note);
+  const head = `Picked up from ${from}.${note ? ` Where it stands: ${note}` : ""}`;
+  if (j.kind === "task")
+    return { text: `${head}
+
+The task:
+${str2(j.task) ?? ""}
+
+Carry it through from here.` };
+  const first = str2(j.firstUserText) ?? "";
+  const last = str2(j.lastUserText) ?? "";
+  const n = num3(j.messageCount);
+  return {
+    text: [
+      `${head} This was a Claude Code session${n !== undefined ? ` (${n} messages)` : ""} that hit a wall; its snapshot can also be replayed in Claude Code with /sled pickup ${handoffId} — but it is now marked picked by you.`,
+      "",
+      `It started with:
+${first}`,
+      ...last && last !== first ? ["", `The last ask was:
+${last}`] : [],
+      "",
+      "Continue the work from here."
+    ].join(`
+`)
+  };
+}
 async function callTool(name, args, deps) {
   switch (name) {
     case "usage":
@@ -1280,6 +2018,12 @@ async function callTool(name, args, deps) {
       return overnightTool(deps, args);
     case "jobs":
       return jobsTool(deps);
+    case "handoffs":
+      return handoffsTool(deps);
+    case "handoff":
+      return handoffTool(deps, args);
+    case "pickup":
+      return pickupTool(deps, args);
     default:
       return { text: `Unknown tool: ${name}`, isError: true };
   }
@@ -1296,7 +2040,7 @@ async function handleLine(line, deps) {
   } catch {
     return errorResponse(null, -32700, "parse error");
   }
-  if (!isObject5(msg))
+  if (!isObject6(msg))
     return errorResponse(null, -32600, "invalid request");
   const id = typeof msg.id === "string" || typeof msg.id === "number" ? msg.id : null;
   const method = str2(msg.method);
@@ -1305,7 +2049,7 @@ async function handleLine(line, deps) {
     return isNotification ? null : errorResponse(id, -32600, "invalid request");
   if (method.startsWith("notifications/"))
     return null;
-  const params = isObject5(msg.params) ? msg.params : {};
+  const params = isObject6(msg.params) ? msg.params : {};
   switch (method) {
     case "initialize": {
       const requested = str2(params.protocolVersion);
@@ -1321,7 +2065,7 @@ async function handleLine(line, deps) {
       return response(id, { tools: TOOLS });
     case "tools/call": {
       const name = str2(params.name) ?? "";
-      const args = isObject5(params.arguments) ? params.arguments : {};
+      const args = isObject6(params.arguments) ? params.arguments : {};
       const r = await callTool(name, args, deps);
       return response(id, {
         content: [{ type: "text", text: r.text }],
@@ -1381,10 +2125,10 @@ var meter = async (o) => {
 };
 
 // src/schedule.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, rmSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { join as join8 } from "node:path";
 var REVERT_LABEL = "ai.sleds.revert";
-var plistPath = (home) => join5(home, "Library", "LaunchAgents", `${REVERT_LABEL}.plist`);
+var plistPath = (home) => join8(home, "Library", "LaunchAgents", `${REVERT_LABEL}.plist`);
 var xmlEscape = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 var buildLaunchdPlist = (sledsArgv, deadline) => {
   const args = [...sledsArgv, "off"].map((a) => `    <string>${xmlEscape(a)}</string>`).join(`
@@ -1423,9 +2167,9 @@ var scheduleRevert = (d, deadlineMs) => {
   if (d.platform === "darwin") {
     const p = plistPath(d.home);
     try {
-      mkdirSync6(join5(d.home, "Library", "LaunchAgents"), { recursive: true });
+      mkdirSync7(join8(d.home, "Library", "LaunchAgents"), { recursive: true });
       d.exec("launchctl", ["unload", p]);
-      writeFileSync6(p, buildLaunchdPlist(d.sledsArgv, deadline));
+      writeFileSync7(p, buildLaunchdPlist(d.sledsArgv, deadline));
       const r = d.exec("launchctl", ["load", p]);
       if (r.ok)
         return { kind: "launchd", detail: `launchd agent ${REVERT_LABEL}` };
@@ -1452,7 +2196,7 @@ var scheduleRevert = (d, deadlineMs) => {
 var cancelRevert = (d, kind) => {
   if (kind === "launchd" || d.platform === "darwin") {
     const p = plistPath(d.home);
-    if (existsSync5(p)) {
+    if (existsSync7(p)) {
       d.exec("launchctl", ["unload", p]);
       rmSync(p, { force: true });
     }
@@ -1462,81 +2206,6 @@ var cancelRevert = (d, kind) => {
   }
 };
 
-// src/switch.ts
-var isObject6 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
-var envOf2 = (settings) => isObject6(settings.env) ? settings.env : {};
-var capturePriorEnv = (settings) => {
-  const env = envOf2(settings);
-  const prior = { hadEnv: isObject6(settings.env) };
-  const url = env[BASE_URL_KEY];
-  const token = env[AUTH_TOKEN_KEY];
-  if (typeof url === "string")
-    prior[BASE_URL_KEY] = url;
-  if (typeof token === "string")
-    prior[AUTH_TOKEN_KEY] = token;
-  return prior;
-};
-var switchOn = (settings, cfg) => applyProxy(settings, cfg);
-var switchOff = (settings, prior) => {
-  const hadEnv = prior.hadEnv === true;
-  const stripped = removeProxy(settings);
-  const env = { ...envOf2(stripped) };
-  const url = prior[BASE_URL_KEY];
-  const token = prior[AUTH_TOKEN_KEY];
-  if (url !== undefined)
-    env[BASE_URL_KEY] = url;
-  if (token !== undefined)
-    env[AUTH_TOKEN_KEY] = token;
-  if (Object.keys(env).length === 0 && !hadEnv) {
-    const { env: _env, ...rest } = stripped;
-    return rest;
-  }
-  return { ...stripped, env };
-};
-var isPointedAtProxy = (settings) => {
-  const env = envOf2(settings);
-  return BASE_URL_KEY in env || AUTH_TOKEN_KEY in env;
-};
-var RELATIVE = /^\+(?:(\d+)h)?(?:(\d+)m)?$/;
-var parseUntilReset = (input, nowMs) => {
-  const trimmed = input.trim();
-  const rel = RELATIVE.exec(trimmed);
-  let deadline;
-  if (rel) {
-    const hours = Number(rel[1] ?? 0);
-    const minutes = Number(rel[2] ?? 0);
-    if (hours === 0 && minutes === 0) {
-      throw new Error(`--until-reset: "${input}" is zero; use something like +5h or +90m`);
-    }
-    deadline = nowMs + (hours * 60 + minutes) * 60000;
-  } else {
-    deadline = Date.parse(trimmed);
-    if (Number.isNaN(deadline)) {
-      throw new Error(`--until-reset: "${input}" is not +<n>h[<n>m] or an ISO timestamp`);
-    }
-  }
-  if (deadline <= nowMs) {
-    throw new Error(`--until-reset: ${trimmed} is in the past`);
-  }
-  return deadline;
-};
-var formatLocal = (ms, tz) => new Intl.DateTimeFormat("en-US", {
-  month: "short",
-  day: "numeric",
-  hour: "numeric",
-  minute: "2-digit",
-  timeZoneName: "short",
-  ...tz ? { timeZone: tz } : {}
-}).format(new Date(ms));
-var formatDuration = (ms) => {
-  const total = Math.max(0, Math.round(ms / 60000));
-  const h = Math.floor(total / 60);
-  const m = total % 60;
-  if (h === 0)
-    return `${m}m`;
-  return m === 0 ? `${h}h` : `${h}h ${m}m`;
-};
-
 // src/commands/off.ts
 var off = (o) => {
   const log = o.log ?? console.log;
@@ -1693,15 +2362,15 @@ var seatEvent = async (o) => {
 };
 
 // src/commands/seatSync.ts
-import { execFileSync } from "node:child_process";
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync5, readdirSync, writeFileSync as writeFileSync7 } from "node:fs";
+import { execFileSync as execFileSync4 } from "node:child_process";
+import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync8 } from "node:fs";
 import { platform } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join10 } from "node:path";
 
 // src/cookieDb.ts
 import { copyFileSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join9 } from "node:path";
 var QUERY = "SELECT name, hex(encrypted_value) AS ev FROM cookies WHERE host_key LIKE '%claude.ai%'";
 var isBun = () => typeof globalThis.Bun !== "undefined";
 async function queryRows(dbPath) {
@@ -1730,7 +2399,7 @@ function nodeSqlite() {
   return mod;
 }
 async function readCookieRows(dbPath) {
-  const copy = join6(tmpdir(), `sleds-cookies-${process.pid}-${Date.now()}.sqlite`);
+  const copy = join9(tmpdir(), `sleds-cookies-${process.pid}-${Date.now()}.sqlite`);
   copyFileSync(dbPath, copy);
   try {
     const rows = await queryRows(copy);
@@ -2003,16 +2672,16 @@ function findFile(root, name) {
   const stack = [root];
   while (stack.length > 0) {
     const dir = stack.pop();
-    if (!dir || !existsSync6(dir))
+    if (!dir || !existsSync8(dir))
       continue;
     let entries;
     try {
-      entries = readdirSync(dir, { withFileTypes: true });
+      entries = readdirSync2(dir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const e of entries) {
-      const p = join7(dir, e.name);
+      const p = join10(dir, e.name);
       if (e.isDirectory())
         stack.push(p);
       else if (e.name === name)
@@ -2023,8 +2692,8 @@ function findFile(root, name) {
 }
 function findCookieDb(home, source) {
   const b = BROWSERS[source.browser];
-  const root = join7(home, APP_SUPPORT, b.appDir);
-  if (!existsSync6(root))
+  const root = join10(home, APP_SUPPORT, b.appDir);
+  if (!existsSync8(root))
     throw new Error(`no ${source.browser} data at ${root} (is it installed?)`);
   if (!b.profiled) {
     const db2 = findFile(root, "Cookies");
@@ -2032,15 +2701,15 @@ function findCookieDb(home, source) {
       throw new Error(`no cookie store under ${root}`);
     return db2;
   }
-  const localStatePath = join7(root, "Local State");
-  const localState = existsSync6(localStatePath) ? readFileSync5(localStatePath, "utf8") : null;
+  const localStatePath = join10(root, "Local State");
+  const localState = existsSync8(localStatePath) ? readFileSync6(localStatePath, "utf8") : null;
   const wanted = source.profile ?? "Default";
   const { dir, ambiguous } = resolveProfileDir(localState, wanted);
   if (ambiguous)
     throw new Error(`"${wanted}" names ${ambiguous.length} ${source.browser} profiles (${ambiguous.join(", ")}) — pass the directory or the account email instead`);
   if (!dir)
     throw new Error(`no ${source.browser} profile named "${wanted}" (check chrome://version)`);
-  const db = cookieDbCandidates(join7(root, dir)).find((p) => existsSync6(p));
+  const db = cookieDbCandidates(join10(root, dir)).find((p) => existsSync8(p));
   if (!db)
     throw new Error(`profile "${dir}" has no cookie store yet (open claude.ai in it once)`);
   return db;
@@ -2050,7 +2719,7 @@ async function readCookieRowsBun(home, source) {
 }
 function keychainKey(service) {
   try {
-    return execFileSync("security", ["find-generic-password", "-w", "-s", service], {
+    return execFileSync4("security", ["find-generic-password", "-w", "-s", service], {
       encoding: "utf8"
     }).trim();
   } catch {
@@ -2062,7 +2731,7 @@ function decryptJar(rows, safeStoragePw) {
 }
 var curlUsage = (org, cookie) => {
   try {
-    const out = execFileSync("curl", usageCurlArgs(org, cookie), {
+    const out = execFileSync4("curl", usageCurlArgs(org, cookie), {
       encoding: "utf8",
       maxBuffer: 8000000
     });
@@ -2083,7 +2752,7 @@ function fetchSeatUsage(jar, org, now, run) {
 }
 function launchAgentPlist(bun, script, home, source) {
   const label = launchLabel(source);
-  const log = join7(home, ".config", "sleds", `${label.slice("ai.sleds.".length)}.log`);
+  const log = join10(home, ".config", "sleds", `${label.slice("ai.sleds.".length)}.log`);
   const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
   const args = [bun, script, "seat-sync", ...sourceArgs(source)].map((a) => `    <string>${esc(a)}</string>`).join(`
 `);
@@ -2105,32 +2774,32 @@ ${args}
 `;
 }
 function plistPath2(home, source) {
-  return join7(home, "Library", "LaunchAgents", `${launchLabel(source)}.plist`);
+  return join10(home, "Library", "LaunchAgents", `${launchLabel(source)}.plist`);
 }
-function install(home, argv, source, log) {
+function install2(home, argv, source, log) {
   const bun = argv[0] ?? process.execPath;
   const script = argv[1] ?? "";
   if (!script) {
     log("cannot resolve the sleds script path to install the timer");
     return 1;
   }
-  const dir = join7(home, "Library", "LaunchAgents");
-  mkdirSync7(dir, { recursive: true });
+  const dir = join10(home, "Library", "LaunchAgents");
+  mkdirSync8(dir, { recursive: true });
   const path = plistPath2(home, source);
-  writeFileSync7(path, launchAgentPlist(bun, script, home, source), { mode: 384 });
+  writeFileSync8(path, launchAgentPlist(bun, script, home, source), { mode: 384 });
   try {
-    execFileSync("launchctl", ["unload", path], { stdio: "ignore" });
+    execFileSync4("launchctl", ["unload", path], { stdio: "ignore" });
   } catch {}
-  execFileSync("launchctl", ["load", "-w", path]);
+  execFileSync4("launchctl", ["load", "-w", path]);
   log(`seat-sync timer installed (every ${SYNC_INTERVAL_S / 60} min) → ${path}`);
   return 0;
 }
-function uninstall(home, source, log) {
+function uninstall2(home, source, log) {
   const path = plistPath2(home, source);
   try {
-    execFileSync("launchctl", ["unload", "-w", path], { stdio: "ignore" });
+    execFileSync4("launchctl", ["unload", "-w", path], { stdio: "ignore" });
   } catch {}
-  log(existsSync6(path) ? `seat-sync timer removed (${path} can be deleted)` : "no seat-sync timer");
+  log(existsSync8(path) ? `seat-sync timer removed (${path} can be deleted)` : "no seat-sync timer");
   return 0;
 }
 var seatSync = async (o) => {
@@ -2143,9 +2812,9 @@ var seatSync = async (o) => {
   }
   const { source } = parsed;
   if (source.uninstall)
-    return uninstall(o.home, source, log);
+    return uninstall2(o.home, source, log);
   if (source.install)
-    return install(o.home, [process.execPath, process.argv[1] ?? ""], source, log);
+    return install2(o.home, [process.execPath, process.argv[1] ?? ""], source, log);
   if (platform() !== "darwin" && !o.readCookieRows) {
     log("seat-sync is macOS-only for now.");
     return 2;
@@ -2191,6 +2860,9 @@ var seatSync = async (o) => {
     log(`seat-sync: usage read failed — ${why}`);
     return 2;
   }
+  try {
+    writeSeatState(o.home, { ...readSeatState(o.home), window: usageAsWindow(usage) });
+  } catch {}
   const posted = await postSeat(proxyUrl, token, seatSyncBody(usage), o.fetchFn ?? fetch);
   const wk = usage.sevenDay ? `wk ${Math.round(usage.sevenDay.usedPct)}%` : "wk —";
   const models = Object.keys(usage.models).length;
@@ -2198,6 +2870,15 @@ var seatSync = async (o) => {
   log(posted ? `seat-sync: posted ${wk} · ${models} model bucket${models === 1 ? "" : "s"}${credits}` : `seat-sync: read ${wk} but the proxy did not accept it`);
   return posted ? 0 : 2;
 };
+function usageAsWindow(u) {
+  return {
+    capturedAt: u.capturedAt,
+    ...u.fiveHour ? { fiveHour: u.fiveHour } : {},
+    ...u.sevenDay ? { sevenDay: u.sevenDay } : {},
+    ...Object.keys(u.models).length > 0 ? { models: u.models } : {},
+    ...u.usedCreditsUsd !== undefined ? { usedCreditsUsd: u.usedCreditsUsd } : {}
+  };
+}
 async function postSeat(proxyUrl, token, body, fetchFn) {
   try {
     const res = await fetchFn(`${proxyUrl}/proxy/seat`, {
@@ -2213,7 +2894,7 @@ async function postSeat(proxyUrl, token, body, fetchFn) {
 }
 
 // src/commands/specEvent.ts
-import { readFileSync as readFileSync6, statSync } from "node:fs";
+import { readFileSync as readFileSync7, statSync } from "node:fs";
 import { basename, isAbsolute, relative } from "node:path";
 var HOOK_STDIN_TIMEOUT_MS2 = 1000;
 var ESTIMATE_TIMEOUT_MS = 4000;
@@ -2269,7 +2950,7 @@ function readFileOrNull(path) {
   try {
     if (statSync(path).size > 2000000)
       return null;
-    return readFileSync6(path, "utf8");
+    return readFileSync7(path, "utf8");
   } catch {
     return null;
   }
@@ -2312,8 +2993,8 @@ var specEvent = async (o) => {
 };
 
 // src/commands/status.ts
-import { existsSync as existsSync7 } from "node:fs";
-var checkHealth = async (url, fetchFn = fetch, timeoutMs = 1000) => {
+import { existsSync as existsSync9 } from "node:fs";
+var checkHealth2 = async (url, fetchFn = fetch, timeoutMs = 1000) => {
   try {
     const res = await fetchFn(`${url}/healthz`, { signal: AbortSignal.timeout(timeoutMs) });
     return res.ok ? "ok" : "unreachable";
@@ -2380,7 +3061,7 @@ var status = async (o) => {
   const log = o.log ?? console.log;
   const nowMs = (o.now ?? Date.now)();
   const cfg = readConfig(o.home);
-  const settings = existsSync7(settingsPath(o.home)) ? readSettings(o.home) : {};
+  const settings = existsSync9(settingsPath(o.home)) ? readSettings(o.home) : {};
   const inSettings = readProxy(settings);
   const proxyUrl = inSettings?.url ?? cfg.proxyUrl;
   const token = inSettings?.token ?? cfg.token;
@@ -2414,7 +3095,7 @@ var status = async (o) => {
     info.untilResetMs = until;
   if (proxyUrl) {
     const [health, proxy] = await Promise.all([
-      checkHealth(proxyUrl, o.fetchFn, o.timeoutMs),
+      checkHealth2(proxyUrl, o.fetchFn, o.timeoutMs),
       fetchProxyStatus(proxyUrl, o.fetchFn, o.timeoutMs)
     ]);
     info.health = health;
@@ -2478,11 +3159,11 @@ var rememberSeat = (o, window, now) => {
 };
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync8, rmSync as rmSync3 } from "node:fs";
-var uninstall2 = (o) => {
+import { existsSync as existsSync10, rmSync as rmSync3 } from "node:fs";
+var uninstall3 = (o) => {
   const log = o.log ?? console.log;
   const removed = [];
-  if (existsSync8(settingsPath(o.home))) {
+  if (existsSync10(settingsPath(o.home))) {
     let settings = readSettings(o.home);
     let changed = false;
     if (hasEitherKey(settings)) {
@@ -2514,13 +3195,13 @@ var uninstall2 = (o) => {
       writeSettings(o.home, settings);
   }
   for (const file of [meterCachePath(o.home), seatStatePath(o.home)]) {
-    if (existsSync8(file)) {
+    if (existsSync10(file)) {
       rmSync3(file, { force: true });
       removed.push(file);
     }
   }
   const skill = skillDir(o.home);
-  if (existsSync8(skill)) {
+  if (existsSync10(skill)) {
     rmSync3(skill, { recursive: true, force: true });
     removed.push(skill);
   }
@@ -2557,6 +3238,7 @@ commands:
   init        Point Claude Code at a SLEDS proxy, install the /sled skill and the status line.
               --token <sled_\u2026>       seat token (else SLEDS_TOKEN, ~/.sleds-token, or prompt)
               --url <proxy-url>      proxy base URL (else SLEDS_PROXY_URL, default ${DEFAULT_PROXY_URL})
+              --no-probe             skip the /health check of the proxy URL
               --non-interactive      never prompt; exit 2 if no token is available
               --signup               no org? create an individual seat: your email + your own
                                      Anthropic API key (validated, stored encrypted, the only key it spends)
@@ -2567,8 +3249,11 @@ commands:
   off         Switch Claude Code back to your seat. Restores whatever \`on\` replaced.
   uninstall   Remove the proxy settings, skill and status line. Keeps ~/.sleds-token.
   status      Show the switch state, deadline, proxy health and wall mode.
+  doctor      Check the whole install: which seat this shell is, Claude settings, proxy, hooks,
+              Node version, stale links, the SwiftBar plugin, the seat-sync timer.
   meter       Show the pipeline: built today, queued with its band, delivered overnight.
-  bar         Print the menu-bar meter in SwiftBar format (used by infra/swiftbar/sleds.1m.sh).
+  bar         Print the menu-bar meter in SwiftBar format; --install links it into SwiftBar
+              (--home/--claude-config pick the seat it tracks; --name <x> adds a second item).
   mcp         Run the MCP server on stdio: tools usage, estimate, overnight, jobs.
               Register with \`claude mcp add sleds -- sleds mcp\` (Cowork sees the same server).
   seat-sync   Read the seat's subscription usage (weekly/5h limits, per-model, credits) from a
@@ -2622,13 +3307,13 @@ var sledsArgv = () => {
   const script = process.argv[1];
   return script ? [process.execPath, script] : [process.execPath];
 };
-var shellQuote = (s) => /^[\w./-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
-var statusLineCommand = (argv) => [...argv, "statusline"].map(shellQuote).join(" ");
-var seatEventCommand = (argv) => [...argv, "seat-event"].map(shellQuote).join(" ");
-var specEventCommand = (argv) => [...argv, "spec-event"].map(shellQuote).join(" ");
+var shellQuote2 = (s) => /^[\w./-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
+var statusLineCommand = (argv) => [...argv, "statusline"].map(shellQuote2).join(" ");
+var seatEventCommand = (argv) => [...argv, "seat-event"].map(shellQuote2).join(" ");
+var specEventCommand = (argv) => [...argv, "spec-event"].map(shellQuote2).join(" ");
 var main = async (argv) => {
   const { cmd, flags } = parseArgs(argv);
-  const home = homedir();
+  const home = homedir3();
   const scheduler = {
     platform: platform2(),
     home,
@@ -2643,6 +3328,7 @@ var main = async (argv) => {
         url: stringFlag(flags, "url"),
         nonInteractive: flags["non-interactive"] === true,
         signup: flags.signup === true,
+        noProbe: flags["no-probe"] === true,
         prompt: promptStdin,
         statusLineCommand: statusLineCommand(sledsArgv()),
         seatEventCommand: seatEventCommand(sledsArgv()),
@@ -2670,13 +3356,15 @@ var main = async (argv) => {
     case "off":
       return off({ home, scheduler });
     case "uninstall":
-      return uninstall2({ home });
+      return uninstall3({ home });
+    case "doctor":
+      return doctor({ home });
     case "status":
       return status({ home });
     case "meter":
       return meter({ home });
     case "bar":
-      return bar({ home });
+      return bar({ home, argv: process.argv.slice(3) });
     case "mcp":
       return mcp({ home });
     case "seat-sync":