@sleds/cli 0.1.0

package/dist/sleds.mjs

@@ -0,0 +1,2721 @@
+#!/usr/bin/env node
+// @bun
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/index.ts
+import { realpathSync } from "fs";
+import { homedir, platform as platform2 } from "os";
+import { fileURLToPath } from "url";
+
+// 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";
+
+// src/config.ts
+import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "node:fs";
+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";
+var BASE_URL_KEY = "ANTHROPIC_BASE_URL";
+var AUTH_TOKEN_KEY = "ANTHROPIC_AUTH_TOKEN";
+var claudeDir = (home, env = process.env) => {
+  const o = env.CLAUDE_CONFIG_DIR?.trim();
+  return o ? resolve(home, o) : join(home, ".claude");
+};
+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 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);
+var envOf = (settings) => {
+  const env = settings.env;
+  return isObject(env) ? env : {};
+};
+var applyProxy = (settings, cfg) => ({
+  ...settings,
+  env: { ...envOf(settings), [BASE_URL_KEY]: cfg.url, [AUTH_TOKEN_KEY]: cfg.token }
+});
+var removeProxy = (settings) => {
+  if (!isObject(settings.env))
+    return { ...settings };
+  const { [BASE_URL_KEY]: _url, [AUTH_TOKEN_KEY]: _token, ...rest } = settings.env;
+  return { ...settings, env: rest };
+};
+var readProxy = (settings) => {
+  const env = envOf(settings);
+  const url = env[BASE_URL_KEY];
+  const token = env[AUTH_TOKEN_KEY];
+  if (typeof url !== "string" || typeof token !== "string")
+    return null;
+  return { url, token };
+};
+var STATUS_LINE_KEY = "statusLine";
+var statusLineEntry = (command) => ({ type: "command", command });
+var isSledsStatusLine = (value) => isObject(value) && value.type === "command" && typeof value.command === "string" && /\bstatusline\b/.test(value.command);
+var applyStatusLine = (settings, command) => {
+  const current = settings[STATUS_LINE_KEY];
+  const prior = current === undefined || isSledsStatusLine(current) ? undefined : current;
+  return { settings: { ...settings, [STATUS_LINE_KEY]: statusLineEntry(command) }, prior };
+};
+var removeStatusLine = (settings, prior) => {
+  if (!isSledsStatusLine(settings[STATUS_LINE_KEY]))
+    return { ...settings };
+  const { [STATUS_LINE_KEY]: _ours, ...rest } = settings;
+  return prior === undefined ? rest : { ...rest, [STATUS_LINE_KEY]: prior };
+};
+var HOOKS_KEY = "hooks";
+var NOTIFICATION_EVENT = "Notification";
+var SEAT_EVENT_MATCHER = "quota_auto_resume_fired|quota_auto_resume_stale|quota_auto_resume_disabled";
+var SEAT_EVENT_TIMEOUT_S = 10;
+var isSledsSeatHook = (entry) => {
+  if (!isObject(entry) || !Array.isArray(entry.hooks))
+    return false;
+  return entry.hooks.some((h) => isObject(h) && h.type === "command" && typeof h.command === "string" && /\bseat-event\b/.test(h.command));
+};
+var seatHookEntry = (command) => ({
+  matcher: SEAT_EVENT_MATCHER,
+  hooks: [{ type: "command", command, timeout: SEAT_EVENT_TIMEOUT_S }]
+});
+var notificationHooks = (settings) => {
+  const hooks = settings[HOOKS_KEY];
+  if (!isObject(hooks))
+    return [];
+  const list = hooks[NOTIFICATION_EVENT];
+  return Array.isArray(list) ? list : [];
+};
+var withNotificationHooks = (settings, list) => {
+  const hooks = isObject(settings[HOOKS_KEY]) ? settings[HOOKS_KEY] : {};
+  if (list.length === 0) {
+    const { [NOTIFICATION_EVENT]: _gone, ...restHooks } = hooks;
+    if (Object.keys(restHooks).length === 0) {
+      const { [HOOKS_KEY]: _none, ...rest } = settings;
+      return rest;
+    }
+    return { ...settings, [HOOKS_KEY]: restHooks };
+  }
+  return { ...settings, [HOOKS_KEY]: { ...hooks, [NOTIFICATION_EVENT]: list } };
+};
+var applySeatHook = (settings, command) => {
+  const list = notificationHooks(settings);
+  const idx = list.findIndex(isSledsSeatHook);
+  const entry = seatHookEntry(command);
+  const next = idx === -1 ? [...list, entry] : list.map((e, i) => i === idx ? entry : e);
+  return withNotificationHooks(settings, next);
+};
+var removeSeatHook = (settings) => {
+  const list = notificationHooks(settings);
+  if (!list.some(isSledsSeatHook))
+    return { ...settings };
+  return withNotificationHooks(settings, list.filter((e) => !isSledsSeatHook(e)));
+};
+var hasSeatHook = (settings) => notificationHooks(settings).some(isSledsSeatHook);
+var POST_TOOL_EVENT = "PostToolUse";
+var SPEC_EVENT_MATCHER = "Write|Edit|MultiEdit";
+var SPEC_EVENT_TIMEOUT_S = 5;
+var isSledsSpecHook = (entry) => {
+  if (!isObject(entry) || !Array.isArray(entry.hooks))
+    return false;
+  return entry.hooks.some((h) => isObject(h) && h.type === "command" && typeof h.command === "string" && /\bspec-event\b/.test(h.command));
+};
+var specHookEntry = (command) => ({
+  matcher: SPEC_EVENT_MATCHER,
+  hooks: [{ type: "command", command, timeout: SPEC_EVENT_TIMEOUT_S }]
+});
+var eventHooks = (settings, event) => {
+  const hooks = settings[HOOKS_KEY];
+  if (!isObject(hooks))
+    return [];
+  const list = hooks[event];
+  return Array.isArray(list) ? list : [];
+};
+var withEventHooks = (settings, event, list) => {
+  const hooks = isObject(settings[HOOKS_KEY]) ? settings[HOOKS_KEY] : {};
+  if (list.length === 0) {
+    const { [event]: _gone, ...restHooks } = hooks;
+    if (Object.keys(restHooks).length === 0) {
+      const { [HOOKS_KEY]: _none, ...rest } = settings;
+      return rest;
+    }
+    return { ...settings, [HOOKS_KEY]: restHooks };
+  }
+  return { ...settings, [HOOKS_KEY]: { ...hooks, [event]: list } };
+};
+var applySpecHook = (settings, command) => {
+  const list = eventHooks(settings, POST_TOOL_EVENT);
+  const idx = list.findIndex(isSledsSpecHook);
+  const entry = specHookEntry(command);
+  const next = idx === -1 ? [...list, entry] : list.map((e, i) => i === idx ? entry : e);
+  return withEventHooks(settings, POST_TOOL_EVENT, next);
+};
+var removeSpecHook = (settings) => {
+  const list = eventHooks(settings, POST_TOOL_EVENT);
+  if (!list.some(isSledsSpecHook))
+    return { ...settings };
+  return withEventHooks(settings, POST_TOOL_EVENT, list.filter((e) => !isSledsSpecHook(e)));
+};
+var hasSpecHook = (settings) => eventHooks(settings, POST_TOOL_EVENT).some(isSledsSpecHook);
+var isSeatToken = (token) => /^sled_[A-Za-z0-9_-]+$/.test(token);
+var maskToken = (token) => token.length <= 9 ? `${token.slice(0, 5)}…` : `${token.slice(0, 9)}…`;
+var serialize = (settings) => `${JSON.stringify(settings, null, 2)}
+`;
+var hasClaudeCode = (home) => existsSync(claudeDir(home));
+var readSettings = (home) => {
+  const p = settingsPath(home);
+  if (!existsSync(p))
+    return {};
+  const parsed = JSON.parse(readFileSync(p, "utf8"));
+  if (!isObject(parsed))
+    throw new Error(`${p} is not a JSON object`);
+  return parsed;
+};
+var writeSettings = (home, settings) => {
+  mkdirSync(claudeDir(home), { recursive: true });
+  const target = settingsPath(home);
+  const tmp = `${target}.${process.pid}.tmp`;
+  writeFileSync(tmp, serialize(settings));
+  renameSync(tmp, target);
+};
+var backupSettings = (home) => {
+  const src = settingsPath(home);
+  const dst = backupPath(home);
+  if (!existsSync(src) || existsSync(dst))
+    return false;
+  writeFileSync(dst, readFileSync(src));
+  return true;
+};
+var readTokenFile = (home) => {
+  const p = tokenPath(home);
+  if (!existsSync(p))
+    return null;
+  const t = readFileSync(p, "utf8").trim();
+  return t.length > 0 ? t : null;
+};
+var writeTokenFile = (home, token) => {
+  writeFileSync(tokenPath(home), `${token}
+`, { mode: 384 });
+};
+
+// src/config.ts
+var configDir = (home, env = process.env) => {
+  const o = env.SLEDS_HOME?.trim();
+  return o ? resolve2(home, o) : join2(home, ".config", "sleds");
+};
+var configPath = (home) => join2(configDir(home), "config.json");
+var isObject2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var optString = (v) => typeof v === "string" ? v : undefined;
+var parsePriorEnv = (v) => {
+  if (!isObject2(v))
+    return;
+  const out = {};
+  const url = optString(v[BASE_URL_KEY]);
+  const token = optString(v[AUTH_TOKEN_KEY]);
+  if (url !== undefined)
+    out[BASE_URL_KEY] = url;
+  if (token !== undefined)
+    out[AUTH_TOKEN_KEY] = token;
+  if (typeof v.hadEnv === "boolean")
+    out.hadEnv = v.hadEnv;
+  return out;
+};
+var parseSchedule = (v) => v === "launchd" || v === "systemd" || v === "manual" ? v : undefined;
+var parseConfig = (raw) => {
+  if (!isObject2(raw))
+    return {};
+  const cfg = {};
+  const token = optString(raw.token);
+  const proxyUrl = optString(raw.proxyUrl);
+  const email = optString(raw.email);
+  const since = optString(raw.since);
+  const untilReset = optString(raw.untilReset);
+  const reason = optString(raw.reason);
+  const priorEnv = parsePriorEnv(raw.priorEnv);
+  const schedule = parseSchedule(raw.schedule);
+  if (token !== undefined)
+    cfg.token = token;
+  if (proxyUrl !== undefined)
+    cfg.proxyUrl = proxyUrl;
+  if (email !== undefined)
+    cfg.email = email;
+  if (raw.mode === "on" || raw.mode === "off")
+    cfg.mode = raw.mode;
+  if (since !== undefined)
+    cfg.since = since;
+  if (untilReset !== undefined)
+    cfg.untilReset = untilReset;
+  if (reason !== undefined)
+    cfg.reason = reason;
+  if (priorEnv !== undefined)
+    cfg.priorEnv = priorEnv;
+  if (schedule !== undefined)
+    cfg.schedule = schedule;
+  if (raw.priorStatusLine !== undefined)
+    cfg.priorStatusLine = raw.priorStatusLine;
+  return cfg;
+};
+var readConfig = (home) => {
+  const p = configPath(home);
+  if (!existsSync2(p))
+    return {};
+  return parseConfig(JSON.parse(readFileSync2(p, "utf8")));
+};
+var writeConfig = (home, cfg) => {
+  const dir = configDir(home);
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  const target = configPath(home);
+  const tmp = `${target}.${process.pid}.tmp`;
+  writeFileSync2(tmp, `${JSON.stringify(cfg, null, 2)}
+`, { mode: 384 });
+  renameSync2(tmp, target);
+  chmodSync(target, 384);
+};
+
+// src/meter.ts
+var METER_CACHE_TTL_MS = 1e4;
+var METER_TIMEOUT_MS = 1500;
+var isObject3 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
+var str = (v) => typeof v === "string" ? v : undefined;
+var parseMeter = (raw) => {
+  if (!isObject3(raw))
+    return null;
+  const seat = isObject3(raw.seat) ? str(raw.seat.email) : undefined;
+  const today = isObject3(raw.today) ? raw.today : null;
+  const month = isObject3(raw.month) ? raw.month : null;
+  const jobs = isObject3(raw.jobs) ? raw.jobs : null;
+  const todayUsd = today ? num(today.spentUsd) : undefined;
+  const monthUsd = month ? num(month.spentUsd) : undefined;
+  if (seat === undefined || todayUsd === undefined || monthUsd === undefined || !jobs)
+    return null;
+  const band = Array.isArray(jobs.queuedEstimateUsd) ? jobs.queuedEstimateUsd : [];
+  const low = num(band[0]) ?? 0;
+  const high = num(band[1]) ?? low;
+  const window = isObject3(raw.window) ? raw.window : {};
+  const allowance = isObject3(raw.allowance) ? raw.allowance : {};
+  const out = {
+    seat: { email: seat },
+    today: { spentUsd: todayUsd, requests: (today && num(today.requests)) ?? 0 },
+    month: { spentUsd: monthUsd },
+    window: {},
+    allowance: {},
+    jobs: {
+      queued: num(jobs.queued) ?? 0,
+      queuedEstimateUsd: [low, Math.max(low, high)],
+      running: num(jobs.running) ?? 0,
+      deliveredToday: num(jobs.deliveredToday) ?? 0
+    },
+    ts: num(raw.ts) ?? 0
+  };
+  const ceiling = month ? num(month.ceilingUsd) : undefined;
+  if (ceiling !== undefined)
+    out.month.ceilingUsd = ceiling;
+  const pct = num(window.utilizationPct);
+  if (pct !== undefined)
+    out.window.utilizationPct = pct;
+  const resetAt = num(window.resetAt);
+  if (resetAt !== undefined)
+    out.window.resetAt = resetAt;
+  const remaining = num(allowance.remainingUsd);
+  if (remaining !== undefined)
+    out.allowance.remainingUsd = remaining;
+  const expiresAt = num(allowance.expiresAt);
+  if (expiresAt !== undefined)
+    out.allowance.expiresAt = expiresAt;
+  if (isObject3(raw.lastWall)) {
+    const kind = str(raw.lastWall.kind);
+    const ts = num(raw.lastWall.ts);
+    if (kind !== undefined && ts !== undefined)
+      out.lastWall = { kind, choice: str(raw.lastWall.choice) ?? null, ts };
+  }
+  const acc = num(raw.estimateAccuracyPct);
+  if (acc !== undefined)
+    out.estimateAccuracyPct = acc;
+  return out;
+};
+var usd = (n) => {
+  const abs = Math.abs(n);
+  if (abs >= 1000)
+    return `${n < 0 ? "-" : ""}$${Math.round(abs).toLocaleString("en-US")}`;
+  return `${n < 0 ? "-" : ""}$${abs.toFixed(2)}`;
+};
+var usdRange = (low, high) => {
+  const d = high >= 10 ? 0 : 2;
+  return `$${low.toFixed(d)}–${high.toFixed(d)}`;
+};
+var shortDuration = (ms) => {
+  const total = Math.max(0, Math.round(ms / 60000));
+  const d = Math.floor(total / (24 * 60));
+  const h = Math.floor(total % (24 * 60) / 60);
+  const m = total % 60;
+  if (d > 0)
+    return h > 0 ? `${d}d ${h}h` : `${d}d`;
+  if (h > 0)
+    return `${h}h${String(m).padStart(2, "0")}m`;
+  return `${m}m`;
+};
+var KIND_WORDS = {
+  rate_limit: "rate limit hit",
+  weekly_cap: "usage limit reached",
+  budget: "budget exhausted",
+  provider_down: "provider unavailable"
+};
+var kindInWords = (kind) => KIND_WORDS[kind] ?? kind.replace(/_/g, " ");
+var SEP = " · ";
+var PREFIX = "sleds  ";
+var OFFLINE_LINE = `${PREFIX}offline`;
+var jobParts = (m) => {
+  const parts = [];
+  const [low, high] = m.jobs.queuedEstimateUsd;
+  if (m.jobs.queued > 0) {
+    const band = high > 0 ? ` ~${usdRange(low, high)}` : "";
+    parts.push(`${m.jobs.queued} queued${band}`);
+  }
+  if (m.jobs.running > 0)
+    parts.push(`${m.jobs.running} running`);
+  if (m.jobs.deliveredToday > 0)
+    parts.push(`${m.jobs.deliveredToday} delivered`);
+  return parts;
+};
+var formatMeterLine = (m, now, seatFragment = null) => {
+  if (!m)
+    return seatFragment ? `${OFFLINE_LINE}${SEP}${seatFragment}` : OFFLINE_LINE;
+  const parts = [`${usd(m.today.spentUsd)} today`];
+  if (seatFragment)
+    parts.push(seatFragment);
+  if (m.window.utilizationPct !== undefined) {
+    parts.push(`window ${Math.round(m.window.utilizationPct)}%`);
+    if (m.window.resetAt !== undefined && m.window.resetAt > now)
+      parts.push(`reset ${shortDuration(m.window.resetAt - now)}`);
+  }
+  if (m.allowance.remainingUsd !== undefined)
+    parts.push(`allowance ${usd(m.allowance.remainingUsd)}`);
+  parts.push(...jobParts(m));
+  return `${PREFIX}${parts.join(SEP)}`;
+};
+var row = (label, value) => `${label.padEnd(12)}${value}`;
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var formatMeter = (m, now) => {
+  const lines = [row("Seat:", m.seat.email)];
+  lines.push(row("Built today:", `${usd(m.today.spentUsd)}${SEP}${plural(m.today.requests, "request")}`));
+  lines.push(row("Month:", m.month.ceilingUsd !== undefined ? `${usd(m.month.spentUsd)} of ${usd(m.month.ceilingUsd)} ceiling` : usd(m.month.spentUsd)));
+  if (m.window.utilizationPct !== undefined) {
+    const reset = m.window.resetAt !== undefined && m.window.resetAt > now ? `${SEP}resets in ${shortDuration(m.window.resetAt - now)}` : "";
+    lines.push(row("Window:", `${Math.round(m.window.utilizationPct)}% used${reset}`));
+  }
+  if (m.allowance.remainingUsd !== undefined) {
+    const exp = m.allowance.expiresAt !== undefined && m.allowance.expiresAt > now ? `${SEP}expires in ${shortDuration(m.allowance.expiresAt - now)}` : "";
+    lines.push(row("Allowance:", `${usd(m.allowance.remainingUsd)} left${exp}`));
+  }
+  const [low, high] = m.jobs.queuedEstimateUsd;
+  lines.push(row("Queued:", m.jobs.queued === 0 ? "0" : `${plural(m.jobs.queued, "job")}${high > 0 ? `${SEP}~${usdRange(low, high)}` : ""}`));
+  if (m.jobs.running > 0)
+    lines.push(row("Running:", plural(m.jobs.running, "job")));
+  lines.push(row("Delivered:", `${m.jobs.deliveredToday} today`));
+  if (m.lastWall) {
+    const choice = m.lastWall.choice ?? "open";
+    lines.push(row("Last wall:", `${kindInWords(m.lastWall.kind)} → ${choice}${SEP}${shortDuration(now - m.lastWall.ts)} ago`));
+  }
+  if (m.estimateAccuracyPct !== undefined)
+    lines.push(row("Estimates:", `${Math.round(m.estimateAccuracyPct)}% landed in band`));
+  return lines;
+};
+var meterCachePath = (home) => join3(configDir(home), "meter.json");
+var readMeterCache = (home, now) => {
+  const p = meterCachePath(home);
+  if (!existsSync3(p))
+    return null;
+  try {
+    const raw = JSON.parse(readFileSync3(p, "utf8"));
+    if (!isObject3(raw))
+      return null;
+    const fetchedAt = num(raw.fetchedAt);
+    if (fetchedAt === undefined || now - fetchedAt >= METER_CACHE_TTL_MS || fetchedAt > now)
+      return null;
+    return parseMeter(raw.meter);
+  } catch {
+    return null;
+  }
+};
+var writeMeterCache = (home, meter, now) => {
+  const dir = configDir(home);
+  mkdirSync3(dir, { recursive: true, mode: 448 });
+  const target = meterCachePath(home);
+  const tmp = `${target}.${process.pid}.tmp`;
+  const file = { fetchedAt: now, meter };
+  writeFileSync3(tmp, `${JSON.stringify(file)}
+`, { mode: 384 });
+  renameSync3(tmp, target);
+};
+var fetchMeter = async (o) => {
+  const fetchFn = o.fetchFn ?? fetch;
+  try {
+    const res = await fetchFn(`${o.proxyUrl}/proxy/meter`, {
+      headers: { authorization: `Bearer ${o.token}` },
+      signal: AbortSignal.timeout(o.timeoutMs ?? METER_TIMEOUT_MS)
+    });
+    if (!res.ok)
+      return null;
+    return parseMeter(await res.json());
+  } catch {
+    return null;
+  }
+};
+var meterSource = (home) => {
+  const cfg = readConfig(home);
+  const settings = existsSync3(settingsPath(home)) ? readSettings(home) : {};
+  const inSettings = readProxy(settings);
+  const proxyUrl = inSettings?.url ?? cfg.proxyUrl;
+  const token = inSettings?.token ?? cfg.token;
+  return proxyUrl && token ? { proxyUrl, token } : null;
+};
+var loadMeter = async (o) => {
+  const now = o.now ?? Date.now();
+  const cached = readMeterCache(o.home, now);
+  if (cached)
+    return cached;
+  const src = meterSource(o.home);
+  if (!src)
+    return null;
+  const fresh = await fetchMeter({ ...src, fetchFn: o.fetchFn, timeoutMs: o.timeoutMs });
+  if (fresh) {
+    try {
+      writeMeterCache(o.home, fresh, now);
+    } catch {}
+  }
+  return fresh;
+};
+
+// 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";
+var SEAT_POST_MIN_DELTA_PCT = 1;
+var SEAT_POST_MIN_INTERVAL_MS = 5 * 60000;
+var SEAT_POST_TIMEOUT_MS = 1500;
+var STDIN_TIMEOUT_MS = 300;
+var isObject4 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var num2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
+var EPOCH_MS_THRESHOLD = 100000000000;
+var parseResetsAt = (v) => {
+  const n = num2(v);
+  if (n !== undefined) {
+    if (n <= 0)
+      return;
+    return n >= EPOCH_MS_THRESHOLD ? Math.round(n) : Math.round(n * 1000);
+  }
+  if (typeof v === "string" && v.trim() !== "") {
+    const parsed = Date.parse(v);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return;
+};
+var parseBar = (v) => {
+  if (!isObject4(v))
+    return;
+  const usedPct = num2(v.used_percentage) ?? num2(v.usedPct);
+  const resetsAt = parseResetsAt(v.resets_at ?? v.resetsAt);
+  if (usedPct === undefined || usedPct < 0 || resetsAt === undefined)
+    return;
+  return { usedPct, resetsAt };
+};
+var parseSeatWindow = (raw, capturedAt) => {
+  if (!isObject4(raw))
+    return null;
+  const limits = isObject4(raw.rate_limits) ? raw.rate_limits : raw;
+  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)
+    return null;
+  const out = { capturedAt };
+  if (fiveHour)
+    out.fiveHour = fiveHour;
+  if (sevenDay)
+    out.sevenDay = sevenDay;
+  if (spendLimit)
+    out.spendLimit = spendLimit;
+  return out;
+};
+var seatWindowFromStdin = (text, capturedAt) => {
+  const trimmed = text.trim();
+  if (!trimmed)
+    return null;
+  try {
+    return parseSeatWindow(JSON.parse(trimmed), capturedAt);
+  } catch {
+    return null;
+  }
+};
+var formatSeatFragment = (w) => {
+  if (!w)
+    return null;
+  const parts = [];
+  if (w.sevenDay)
+    parts.push(`wk ${Math.round(w.sevenDay.usedPct)}%`);
+  if (w.fiveHour)
+    parts.push(`5h ${Math.round(w.fiveHour.usedPct)}%`);
+  if (w.spendLimit)
+    parts.push(`spend ${Math.round(w.spendLimit.usedPct)}%`);
+  if (parts.length === 0)
+    return null;
+  return `seat ${parts.join(SEP)}`;
+};
+var seatStatePath = (home) => join4(configDir(home), "seat.json");
+var parseWindowStored = (v) => {
+  if (!isObject4(v))
+    return;
+  const capturedAt = num2(v.capturedAt);
+  if (capturedAt === undefined)
+    return;
+  return parseSeatWindow(v, capturedAt) ?? undefined;
+};
+var parseSeatState = (raw) => {
+  if (!isObject4(raw))
+    return {};
+  const out = {};
+  const window = parseWindowStored(raw.window);
+  if (window)
+    out.window = window;
+  const lastPostedAt = num2(raw.lastPostedAt);
+  if (lastPostedAt !== undefined)
+    out.lastPostedAt = lastPostedAt;
+  if (isObject4(raw.lastPosted)) {
+    const lp = {};
+    const f = num2(raw.lastPosted.fiveHour);
+    const s = num2(raw.lastPosted.sevenDay);
+    const sp = num2(raw.lastPosted.spendLimit);
+    if (f !== undefined)
+      lp.fiveHour = f;
+    if (s !== undefined)
+      lp.sevenDay = s;
+    if (sp !== undefined)
+      lp.spendLimit = sp;
+    out.lastPosted = lp;
+  }
+  const lastWallResetsAt = num2(raw.lastWallResetsAt);
+  if (lastWallResetsAt !== undefined)
+    out.lastWallResetsAt = lastWallResetsAt;
+  return out;
+};
+var readSeatState = (home) => {
+  const p = seatStatePath(home);
+  if (!existsSync4(p))
+    return {};
+  try {
+    return parseSeatState(JSON.parse(readFileSync4(p, "utf8")));
+  } catch {
+    return {};
+  }
+};
+var writeSeatState = (home, state) => {
+  const dir = configDir(home);
+  mkdirSync4(dir, { recursive: true, mode: 448 });
+  const target = seatStatePath(home);
+  const tmp = `${target}.${process.pid}.tmp`;
+  writeFileSync4(tmp, `${JSON.stringify(state)}
+`, { mode: 384 });
+  renameSync4(tmp, target);
+};
+var pctOf = (b) => b?.usedPct;
+var shouldPostSeat = (state, next, now) => {
+  if (state.lastPostedAt === undefined || !state.lastPosted)
+    return true;
+  if (now - state.lastPostedAt >= SEAT_POST_MIN_INTERVAL_MS)
+    return true;
+  const pairs = [
+    [state.lastPosted.fiveHour, pctOf(next.fiveHour)],
+    [state.lastPosted.sevenDay, pctOf(next.sevenDay)],
+    [state.lastPosted.spendLimit, pctOf(next.spendLimit)]
+  ];
+  for (const [prev, cur] of pairs) {
+    if (prev === undefined && cur === undefined)
+      continue;
+    if (prev === undefined || cur === undefined)
+      return true;
+    if (Math.abs(cur - prev) >= SEAT_POST_MIN_DELTA_PCT)
+      return true;
+  }
+  return false;
+};
+var markPosted = (state, w, now) => {
+  const lastPosted = {};
+  if (w.fiveHour)
+    lastPosted.fiveHour = w.fiveHour.usedPct;
+  if (w.sevenDay)
+    lastPosted.sevenDay = w.sevenDay.usedPct;
+  if (w.spendLimit)
+    lastPosted.spendLimit = w.spendLimit.usedPct;
+  return { ...state, window: w, lastPostedAt: now, lastPosted };
+};
+var seatWallDue = (state, w) => {
+  if (!w?.sevenDay || w.sevenDay.usedPct < 100)
+    return false;
+  return state.lastWallResetsAt === undefined || state.lastWallResetsAt < w.sevenDay.resetsAt;
+};
+var seatWindowBody = (w) => ({
+  capturedAt: w.capturedAt,
+  ...w.fiveHour ? { fiveHour: w.fiveHour } : {},
+  ...w.sevenDay ? { sevenDay: w.sevenDay } : {},
+  ...w.spendLimit ? { spendLimit: w.spendLimit } : {}
+});
+var postJson = async (o, path, body) => {
+  const fetchFn = o.fetchFn ?? fetch;
+  try {
+    const res = await fetchFn(`${o.proxyUrl}${path}`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${o.token}`, "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(o.timeoutMs ?? SEAT_POST_TIMEOUT_MS)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+};
+var postSeatWindow = (o, w) => postJson(o, "/proxy/seat", seatWindowBody(w));
+var postSeatWall = (o, input) => postJson(o, "/proxy/seat-wall", input);
+var SEAT_WALL_LINE = "Seat limit hit. sleds on --until-reset to continue on the org key.";
+var readStdin = (timeoutMs, stdin = process.stdin) => new Promise((resolve3) => {
+  if (stdin.isTTY) {
+    resolve3("");
+    return;
+  }
+  let data = "";
+  let settled = false;
+  const finish = () => {
+    if (settled)
+      return;
+    settled = true;
+    clearTimeout(timer);
+    resolve3(data);
+  };
+  const timer = setTimeout(finish, timeoutMs);
+  stdin.setEncoding("utf8");
+  stdin.on("data", (chunk) => {
+    data += chunk;
+  });
+  stdin.on("end", finish);
+  stdin.on("error", finish);
+  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
+var bar = async (o) => {
+  const log = o.log ?? console.log;
+  const now = (o.now ?? Date.now)();
+  const seat = freshSeat(readSeatState(o.home).window, now);
+  if (!meterSource(o.home)) {
+    log("sleds not set up");
+    log("---");
+    log("Run `sleds init` first | font=Menlo size=12");
+    return 0;
+  }
+  const m = await loadMeter({ home: o.home, now, fetchFn: o.fetchFn, timeoutMs: o.timeoutMs });
+  for (const line of formatBar(m, seat, now))
+    log(line);
+  return 0;
+};
+
+// src/commands/hooks.ts
+var DEFAULT_SEAT_EVENT_COMMAND = "sleds seat-event";
+var DEFAULT_SPEC_EVENT_COMMAND = "sleds spec-event";
+var hooks = (o) => {
+  const log = o.log ?? console.log;
+  const error = o.error ?? console.error;
+  if (!hasClaudeCode(o.home)) {
+    error(`Claude Code not found (${claudeDir(o.home)} does not exist). Install it, then re-run.`);
+    return 1;
+  }
+  const settings = readSettings(o.home);
+  const had = hasSeatHook(settings);
+  const hadSpec = hasSpecHook(settings);
+  const withSeat = applySeatHook(settings, o.seatEventCommand ?? DEFAULT_SEAT_EVENT_COMMAND);
+  writeSettings(o.home, applySpecHook(withSeat, o.specEventCommand ?? DEFAULT_SPEC_EVENT_COMMAND));
+  log(`${had ? "refreshed" : "set"} hooks.Notification (${SEAT_EVENT_MATCHER}) in ${settingsPath(o.home)}`);
+  log(`${hadSpec ? "refreshed" : "set"} hooks.PostToolUse (${SPEC_EVENT_MATCHER} → estimate spec files) in ${settingsPath(o.home)}`);
+  return 0;
+};
+
+// src/commands/init.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
+import { createInterface } from "node:readline";
+
+// src/skill.ts
+var SKILL_MD = `---
+name: sled
+description: Hand work to SLEDS — continue past a rate limit or credit wall on the org's key, hold until reset, or run overnight at half price. Use when the user says /sled, hits a usage limit, mentions their window reset, asks what ran overnight, or asks to defer or schedule agent work.
+---
+
+# SLEDS
+
+Nine to five is 40 of 168 hours. SLEDS puts the other 128 to work: it carries a session past a wall, and it runs whole tasks overnight with the Musher, a night-shift orchestrator that answers the questions an agent would otherwise stop on. Nothing changes until a wall or a \`/sled\`.
+
+## Hit a limit on your seat
+
+A Team or Max seat caps on Anthropic's side ("You've hit your limit…"). SLEDS is what you switch to. When the user reports a limit, a cap, or that Claude stopped for the day, tell them exactly this:
+
+\`\`\`
+sleds on --until-reset +5h
+\`\`\`
+
+then restart \`claude\`. Claude Code runs on the org key through the proxy; the seat is untouched. \`--until-reset\` takes \`+5h\`, \`+90m\`, or an ISO time; \`--reason "<text>"\` notes why. The switch reverts itself at the deadline where a scheduler exists.
+
+## At the wall
+
+When the proxy is active it answers a walled request with its options. The user picks one by number:
+
+\`\`\`
+/sled 1    continue now on the org key
+/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%)
+\`\`\`
+
+## Window reset
+
+When the user mentions their window has reset, or the deadline shown by \`sleds status\` has passed:
+
+\`\`\`
+sleds off
+\`\`\`
+
+then restart \`claude\`. Settings go back to exactly what they were.
+
+## Check
+
+\`sleds status\` — on/off, since, reverts at, proxy health, wall mode.
+
+The status line's \`seat wk 52% · 5h 12%\` is the user's own Pro/Max window as Claude Code reports it (weekly, then 5-hour); \`window\` is the org key's headroom through the proxy. At \`wk 100%\` the answer is \`sleds on --until-reset\`.
+
+## /sled — estimate the task, offer overnight
+
+Bare \`/sled\` (or \`/sled <spec>\`) means: size the current task and offer to hand it to the night shift. Do this in order.
+
+1. Read the task. The spec is the argument if given, otherwise the current conversation's open task (the todo list, the last user request).
+2. Estimate with \`/sled estimate <spec>\` — the proxy answers with the calibrated band and cap, and the estimate is recorded so its actuals feed the next one. Quote that band, never a point and never your own guess.
+3. Offer the window when any of these hold: the high end of the cost band is above the org's approval threshold, the wall-clock is over 30 minutes, or the result is not needed before end of day. The offer is one line: \`Run this overnight from 18:00? Estimated $40–120 at half price.\`
+4. On yes, write the hand-off the Musher will work from: the spec, the acceptance test, the org conventions that apply, and every decision already made in this session as \`question -> answer\` pairs. Ask one thing before queueing: the autonomy for this job.
+   - \`ask\`: every question pages on-call.
+   - \`decide_and_flag\` (default): reversible defaults are taken and listed in the morning.
+   - \`decide\`: reversible defaults are taken quietly.
+   Irreversible questions always page, whatever the autonomy. No answer in 30 minutes parks the job and the Musher moves to the next one.
+5. Queue it with \`/sled overnight <spec>\` (the hand-off from step 4 is the spec). The proxy runs the real estimator (its cap bounds the job's spend), schedules the job for the org's overnight window, and snapshots this session so the batch runner has the context. Confirm with the job id and the band from the reply — not your own guess.
+
+## /sled review — the morning queue
+
+Morning ritual. List what the night shift did, grouped:
+
+- Delivered: jobs with a PR or a result, with actual cost against the estimate.
+- Flagged: decisions the Musher took on a \`decide_and_flag\` job, each as \`question -> answer\` with the rung that answered it (spec, convention, or default). These need a human eye, not a redo.
+- Parked: questions nobody answered in 30 minutes. Each shows the option set; answering resumes the job.
+
+Read the Musher log for every delivered job before summarizing, and put each decision into the PR body with its reasoning. Then offer the next step for each: merge, kick back with a note, or \`/sled resume <id>\`. On Monday the review covers the weekend.
+
+## /sled weekend — Friday sweep
+
+Friday afternoon. Sweep the open task list into a weekend batch: everything the user has queued or labeled for the weekend becomes overnight jobs with the org's default autonomy, and the Monday review covers all of it. For now, explain that the sweep queues the current task list as overnight jobs; sweeping issues by GitHub label is a later ticket. Confirm the count and the total estimate band before queueing.
+
+## /sled overnight [spec]
+
+Queue a batch job without waiting for a wall. \`/sled overnight <spec>\` runs the spec; bare \`/sled overnight\` runs the session's original ask. The reply carries the band, the cap, when it runs, and \`/sled resume <id>\` for the morning. Half price on the batch tier.
+
+## /sled jobs
+
+List the org's jobs: queued, running, delivered, parked, with the estimate band, the actual so far, and the autonomy. Parked jobs show the unanswered question. Keep it to one line per job.
+
+## /sled resume <id>
+
+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.
+
+## Voice
+
+Plain sentences, sentence case, no emoji. Numbers with units and bands. Say what happens next, not what could.
+
+## Overnight jobs (how it runs)
+
+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 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.
+`;
+
+// src/commands/hooks.ts
+var DEFAULT_SEAT_EVENT_COMMAND2 = "sleds seat-event";
+var DEFAULT_SPEC_EVENT_COMMAND2 = "sleds spec-event";
+var hooks2 = (o) => {
+  const log = o.log ?? console.log;
+  const error = o.error ?? console.error;
+  if (!hasClaudeCode(o.home)) {
+    error(`Claude Code not found (${claudeDir(o.home)} does not exist). Install it, then re-run.`);
+    return 1;
+  }
+  const settings = readSettings(o.home);
+  const had = hasSeatHook(settings);
+  const hadSpec = hasSpecHook(settings);
+  const withSeat = applySeatHook(settings, o.seatEventCommand ?? DEFAULT_SEAT_EVENT_COMMAND2);
+  writeSettings(o.home, applySpecHook(withSeat, o.specEventCommand ?? DEFAULT_SPEC_EVENT_COMMAND2));
+  log(`${had ? "refreshed" : "set"} hooks.Notification (${SEAT_EVENT_MATCHER}) in ${settingsPath(o.home)}`);
+  log(`${hadSpec ? "refreshed" : "set"} hooks.PostToolUse (${SPEC_EVENT_MATCHER} → estimate spec files) in ${settingsPath(o.home)}`);
+  return 0;
+};
+
+// src/commands/init.ts
+var DEFAULT_PROXY_URL = "http://localhost:8787";
+var DEFAULT_STATUS_LINE_COMMAND = "sleds statusline";
+var promptStdin = (question) => new Promise((resolve3) => {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  rl.question(question, (answer) => {
+    rl.close();
+    resolve3(answer.trim());
+  });
+});
+async function signupIndividual(proxyUrl, email, credential, fetchFn = fetch) {
+  try {
+    const res = await fetchFn(`${proxyUrl}/signup`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ email, apiKey: credential }),
+      signal: AbortSignal.timeout(20000)
+    });
+    const body = await res.json().catch(() => ({}));
+    if (res.ok && typeof body.token === "string")
+      return { ok: true, token: body.token, created: body.created === true };
+    return {
+      ok: false,
+      reason: typeof body.reason === "string" ? body.reason : `http_${res.status}`,
+      status: res.status
+    };
+  } catch {
+    return { ok: false, reason: "unreachable", status: 0 };
+  }
+}
+var SIGNUP_REASONS = {
+  email: "that does not look like an email address.",
+  key: "that does not look like an Anthropic API key (sk-ant-…).",
+  key_rejected: "Anthropic did not accept that API key. Check it at console.anthropic.com → API keys.",
+  rate_limited: "too many signups from this network in the last hour. Try again later.",
+  not_configured: "the proxy is not set up for self-serve signup yet.",
+  unavailable: "the proxy could not reach its control plane. Try again in a moment.",
+  unreachable: "could not reach the proxy."
+};
+function signupFailureText(r) {
+  return `Signup failed: ${SIGNUP_REASONS[r.reason] ?? `unexpected answer (${r.reason}, HTTP ${r.status}).`}`;
+}
+var resolveToken = async (o) => {
+  const env = o.env ?? process.env;
+  if (o.token)
+    return { token: o.token.trim(), source: "flag" };
+  if (env.SLEDS_TOKEN)
+    return { token: env.SLEDS_TOKEN.trim(), source: "env" };
+  const fromFile = readTokenFile(o.home);
+  if (fromFile)
+    return { token: fromFile, source: "file" };
+  if (o.nonInteractive || !o.prompt)
+    return null;
+  if (!o.signup) {
+    const typed = (await o.prompt("Paste your SLEDS seat token (sled_…), or press enter to sign up as an individual: ")).trim();
+    if (typed)
+      return { token: typed, source: "prompt" };
+  }
+  const url = (o.url ?? env.SLEDS_PROXY_URL ?? DEFAULT_PROXY_URL).replace(/\/+$/, "");
+  const email = (await o.prompt("Your email: ")).trim();
+  if (!email.includes("@"))
+    return null;
+  const credential = (await o.prompt("Your Anthropic API key (sk-ant-…, stored encrypted, spends only your account): ")).trim();
+  if (!credential)
+    return null;
+  const r = await signupIndividual(url, email, credential, o.fetchFn);
+  if (!r.ok) {
+    (o.error ?? console.error)(signupFailureText(r));
+    return null;
+  }
+  (o.log ?? console.log)(r.created ? `Created your individual seat (${email}). Your key is stored encrypted and is the only key this seat spends.` : `Re-issued your individual seat (${email}); the previous token is revoked.`);
+  return { token: r.token, source: "signup" };
+};
+var init = async (o) => {
+  const log = o.log ?? console.log;
+  const error = o.error ?? console.error;
+  const env = o.env ?? process.env;
+  if (!hasClaudeCode(o.home)) {
+    error(`Claude Code not found (${claudeDir(o.home)} does not exist). Install it, then re-run.`);
+    return 1;
+  }
+  const resolved = await resolveToken(o);
+  if (!resolved) {
+    error(o.signup ? "Signup did not complete. Nothing was changed." : "No seat token. Pass --token, set SLEDS_TOKEN, run without --non-interactive, or use --signup.");
+    return 2;
+  }
+  if (!isSeatToken(resolved.token)) {
+    error("Invalid seat token: expected something like sled_xxxxxxxx.");
+    return 2;
+  }
+  const url = (o.url ?? env.SLEDS_PROXY_URL ?? DEFAULT_PROXY_URL).replace(/\/+$/, "");
+  const wrote = [];
+  if (backupSettings(o.home))
+    wrote.push(`backed up settings to ${backupPath(o.home)}`);
+  const withProxy = applyProxy(readSettings(o.home), { url, token: resolved.token });
+  const statusLine = applyStatusLine(withProxy, o.statusLineCommand ?? DEFAULT_STATUS_LINE_COMMAND);
+  writeSettings(o.home, statusLine.settings);
+  wrote.push(`set env.ANTHROPIC_BASE_URL and env.ANTHROPIC_AUTH_TOKEN in ${settingsPath(o.home)}`);
+  wrote.push(statusLine.prior === undefined ? `set statusLine in ${settingsPath(o.home)}` : `set statusLine in ${settingsPath(o.home)} (previous one kept for uninstall)`);
+  hooks2({
+    home: o.home,
+    seatEventCommand: o.seatEventCommand ?? DEFAULT_SEAT_EVENT_COMMAND2,
+    specEventCommand: o.specEventCommand ?? DEFAULT_SPEC_EVENT_COMMAND2,
+    log: (line) => wrote.push(line),
+    error
+  });
+  if (resolved.source !== "file") {
+    writeTokenFile(o.home, resolved.token);
+    wrote.push(`saved token to ${tokenPath(o.home)} (0600)`);
+  }
+  const prior = readConfig(o.home);
+  writeConfig(o.home, {
+    ...prior,
+    token: resolved.token,
+    proxyUrl: url,
+    ...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);
+  wrote.push(`installed skill at ${skillPath(o.home)}`);
+  log("Nothing changes until a wall.");
+  log("");
+  for (const w of wrote)
+    log(`  ${w}`);
+  log("");
+  log(`Claude Code now talks to ${url}. 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`.");
+  return 0;
+};
+
+// src/mcp.ts
+var PROTOCOL_VERSION = "2025-06-18";
+var SERVER_INFO = { name: "sleds", version: "0.0.1" };
+var MCP_TIMEOUT_MS = 5000;
+var specSchema = {
+  type: "object",
+  properties: {
+    spec: {
+      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." }
+  },
+  required: ["spec"]
+};
+var TOOLS = [
+  {
+    name: "usage",
+    description: "The SLEDS meter for this seat: built today, month against the ceiling, window and reset, allowance, queued/running/delivered jobs, the last wall, and the seat's own Pro/Max limit bars.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "estimate",
+    description: "Size a task before running it: the org estimator's cost and time band with confidence and a spend cap. Recorded, so its actuals calibrate the next estimate. Never a point figure.",
+    inputSchema: specSchema
+  },
+  {
+    name: "overnight",
+    description: "Queue a task as an overnight batch job at half price. The estimator sizes it first and its cap bounds the spend; the job runs in the org's overnight window and is pulled into a session later with /sled resume <id>.",
+    inputSchema: specSchema
+  },
+  {
+    name: "jobs",
+    description: "This seat's overnight jobs, newest first: id, status, route, cost, when.",
+    inputSchema: { type: "object", properties: {} }
+  }
+];
+var NOT_SET_UP = {
+  text: "SLEDS is not set up on this machine. Run `sleds init` first.",
+  isError: true
+};
+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 num3 = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
+var str2 = (v) => typeof v === "string" ? v : undefined;
+async function proxyPost(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)
+    });
+    if (!res.ok)
+      return null;
+    const parsed = await res.json();
+    return isObject5(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function proxyGet(deps, path) {
+  const src = meterSource(deps.home);
+  if (!src)
+    return null;
+  const fetchFn = deps.fetchFn ?? fetch;
+  try {
+    const res = await fetchFn(`${src.proxyUrl}${path}`, {
+      headers: { authorization: `Bearer ${src.token}` },
+      signal: AbortSignal.timeout(deps.timeoutMs ?? MCP_TIMEOUT_MS)
+    });
+    if (!res.ok)
+      return null;
+    const parsed = await res.json();
+    return isObject5(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function usageTool(deps) {
+  if (!meterSource(deps.home))
+    return NOT_SET_UP;
+  const now = (deps.now ?? Date.now)();
+  const m = await loadMeter({
+    home: deps.home,
+    now,
+    fetchFn: deps.fetchFn,
+    timeoutMs: deps.timeoutMs
+  });
+  const frag = formatSeatFragment(readSeatState(deps.home).window ?? null);
+  if (!m) {
+    return {
+      text: frag ? `sleds offline (proxy did not answer) · ${frag}` : "sleds offline (proxy did not answer).",
+      isError: true
+    };
+  }
+  const lines = formatMeter(m, now);
+  if (frag)
+    lines.push(`${"Limits:".padEnd(12)}${frag.replace(/^seat /, "")}`);
+  return { text: lines.join(`
+`) };
+}
+function bandLine(band) {
+  if (!isObject5(band))
+    return null;
+  const low = num3(band.lowUsd);
+  const high = num3(band.highUsd);
+  const lowM = num3(band.lowMinutes);
+  const highM = num3(band.highMinutes);
+  const conf = num3(band.confidence);
+  if (low === undefined || high === undefined)
+    return null;
+  const d = high >= 10 ? 0 : 2;
+  const mins = lowM !== undefined && highM !== undefined ? ` · ${Math.max(0, Math.round(lowM))}–${Math.max(0, Math.round(highM))} min` : "";
+  const pct = conf !== undefined ? ` · ${Math.round(conf * 100)}%` : "";
+  return `$${low.toFixed(d)}–${high.toFixed(d)}${mins}${pct}`;
+}
+async function estimateTool(deps, args) {
+  if (!meterSource(deps.home))
+    return NOT_SET_UP;
+  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) });
+  if (!r)
+    return UNREACHABLE;
+  const band = isObject5(r.band) ? r.band : {};
+  const line = bandLine(band) ?? "band unreadable";
+  const method = str2(band.method) ?? "plan";
+  const cap = num3(band.capUsd);
+  const threshold = num3(r.approvalThresholdUsd);
+  const over = threshold !== undefined && threshold > 0 && num3(band.highUsd) !== undefined ? ` Over the ${usd(threshold)} threshold? ${num3(band.highUsd) > threshold ? "yes" : "no"}.` : "";
+  const assumptions = Array.isArray(band.assumptions) ? band.assumptions.filter((a) => typeof a === "string") : [];
+  const tail = assumptions.length > 0 ? `
+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}` };
+}
+function byModelText(raw) {
+  if (!Array.isArray(raw))
+    return "";
+  const parts = [];
+  for (const row2 of raw) {
+    if (!isObject5(row2) || !isObject5(row2.standard))
+      continue;
+    const model = str2(row2.model);
+    const low = num3(row2.standard.lowUsd);
+    const high = num3(row2.standard.highUsd);
+    if (!model || low === undefined || high === undefined)
+      continue;
+    const m = /^claude-([a-z]+)-(\d+)(?:-(\d+))?/.exec(model);
+    const short = m?.[1] && m[2] ? `${m[1]} ${m[2]}${m[3] ? `.${m[3]}` : ""}` : model;
+    parts.push(`${short} ${usdRange(low, high)}`);
+  }
+  return parts.length > 0 ? `
+By model: ${parts.join(" · ")} (overnight batch ½).` : "";
+}
+function routingText(raw) {
+  if (!isObject5(raw) || !Array.isArray(raw.segments) || !isObject5(raw.cost))
+    return "";
+  const short = (model) => {
+    const m = /^claude-([a-z]+)-(\d+)(?:-(\d+))?/.exec(model);
+    return m?.[1] && m[2] ? `${m[1]} ${m[2]}${m[3] ? `.${m[3]}` : ""}` : model;
+  };
+  const parts = [];
+  for (const s of raw.segments) {
+    if (!isObject5(s))
+      continue;
+    const from = num3(s.from);
+    const to = num3(s.to);
+    const model = str2(s.model);
+    if (from === undefined || to === undefined || !model)
+      continue;
+    const reasons = Array.isArray(s.reasons) ? s.reasons.filter((x) => typeof x === "string") : [];
+    parts.push(`${from === to ? from : `${from}–${to}`} ${short(model)}${reasons.length ? ` (${reasons.slice(0, 3).join(", ")})` : ""}`);
+  }
+  const c = raw.cost;
+  const lo = num3(c.lowUsd);
+  const hi = num3(c.highUsd);
+  const slo = num3(c.singleLowUsd);
+  const shi = num3(c.singleHighUsd);
+  const single = str2(c.singleModel);
+  if (parts.length === 0 || lo === undefined || hi === undefined || slo === undefined || shi === undefined || !single)
+    return "";
+  return `
+Routing: ${parts.join(" · ")} ≈ ${usdRange(lo, hi)} vs ${usdRange(slo, shi)} all ${short(single)}.`;
+}
+async function overnightTool(deps, args) {
+  if (!meterSource(deps.home))
+    return NOT_SET_UP;
+  const spec = str2(args.spec)?.trim();
+  if (!spec)
+    return { text: "Nothing to queue. Pass spec: what the job should do.", isError: true };
+  const r = await proxyPost(deps, "/proxy/overnight", { spec, model: str2(args.model) });
+  if (!r)
+    return { text: `Could not queue the job. ${UNREACHABLE.text}`, isError: true };
+  const jobId = str2(r.jobId) ?? "unknown";
+  const now = (deps.now ?? Date.now)();
+  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 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}.`
+  };
+}
+async function jobsTool(deps) {
+  if (!meterSource(deps.home))
+    return NOT_SET_UP;
+  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 now = (deps.now ?? Date.now)();
+  const lines = rows.map((j) => {
+    const when = (ts) => num3(ts) !== undefined ? shortDuration(Math.abs(now - num3(ts))) : "";
+    const status = str2(j.status) ?? "unknown";
+    const cost = num3(j.costUsd);
+    const tail = status === "delivered" ? `delivered ${when(j.deliveredAt)} ago` : status === "scheduled" ? num3(j.scheduledAt) !== undefined && num3(j.scheduledAt) > now ? `runs in ${when(j.scheduledAt)}` : "runs at the next tick" : str2(j.reason) ?? "";
+    return [
+      str2(j.jobId) ?? "?",
+      status.padEnd(12),
+      (str2(j.route) ?? "").padEnd(6),
+      cost !== undefined ? usd(cost).padStart(8) : "".padStart(8),
+      tail
+    ].join("  ").trimEnd();
+  });
+  lines.push("Resume a delivered job in a session with /sled resume <id>.");
+  return { text: lines.join(`
+`) };
+}
+async function callTool(name, args, deps) {
+  switch (name) {
+    case "usage":
+      return usageTool(deps);
+    case "estimate":
+      return estimateTool(deps, args);
+    case "overnight":
+      return overnightTool(deps, args);
+    case "jobs":
+      return jobsTool(deps);
+    default:
+      return { text: `Unknown tool: ${name}`, isError: true };
+  }
+}
+var response = (id, result) => JSON.stringify({ jsonrpc: "2.0", id, result });
+var errorResponse = (id, code, message) => JSON.stringify({ jsonrpc: "2.0", id, error: { code, message } });
+async function handleLine(line, deps) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0)
+    return null;
+  let msg;
+  try {
+    msg = JSON.parse(trimmed);
+  } catch {
+    return errorResponse(null, -32700, "parse error");
+  }
+  if (!isObject5(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);
+  const isNotification = msg.id === undefined;
+  if (!method)
+    return isNotification ? null : errorResponse(id, -32600, "invalid request");
+  if (method.startsWith("notifications/"))
+    return null;
+  const params = isObject5(msg.params) ? msg.params : {};
+  switch (method) {
+    case "initialize": {
+      const requested = str2(params.protocolVersion);
+      return response(id, {
+        protocolVersion: requested ?? PROTOCOL_VERSION,
+        capabilities: { tools: {} },
+        serverInfo: SERVER_INFO
+      });
+    }
+    case "ping":
+      return response(id, {});
+    case "tools/list":
+      return response(id, { tools: TOOLS });
+    case "tools/call": {
+      const name = str2(params.name) ?? "";
+      const args = isObject5(params.arguments) ? params.arguments : {};
+      const r = await callTool(name, args, deps);
+      return response(id, {
+        content: [{ type: "text", text: r.text }],
+        ...r.isError ? { isError: true } : {}
+      });
+    }
+    default:
+      return isNotification ? null : errorResponse(id, -32601, `method not found: ${method}`);
+  }
+}
+
+// src/commands/mcp.ts
+var mcp = async (o) => {
+  const stdin = o.stdin ?? process.stdin;
+  const write = o.write ?? ((line) => process.stdout.write(`${line}
+`));
+  let buffer = "";
+  for await (const chunk of stdin) {
+    buffer += typeof chunk === "string" ? chunk : new TextDecoder().decode(chunk);
+    let nl = buffer.indexOf(`
+`);
+    while (nl !== -1) {
+      const line = buffer.slice(0, nl);
+      buffer = buffer.slice(nl + 1);
+      const out = await handleLine(line, { home: o.home });
+      if (out !== null)
+        write(out);
+      nl = buffer.indexOf(`
+`);
+    }
+  }
+  if (buffer.trim().length > 0) {
+    const out = await handleLine(buffer, { home: o.home });
+    if (out !== null)
+      write(out);
+  }
+  return 0;
+};
+
+// src/commands/meter.ts
+var meter = async (o) => {
+  const log = o.log ?? console.log;
+  const now = (o.now ?? Date.now)();
+  const src = meterSource(o.home);
+  if (!src) {
+    log(`SLEDS is not set up (${configPath(o.home)}). Run \`sleds init\` first.`);
+    return 1;
+  }
+  const m = await loadMeter({ home: o.home, now, fetchFn: o.fetchFn, timeoutMs: o.timeoutMs });
+  if (!m) {
+    log(`sleds  offline. ${src.proxyUrl} did not answer → \`sleds status\` for the proxy health.`);
+    return 2;
+  }
+  for (const line of formatMeter(m, now))
+    log(line);
+  return 0;
+};
+
+// src/schedule.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join5 } from "node:path";
+var REVERT_LABEL = "ai.sleds.revert";
+var plistPath = (home) => join5(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(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${REVERT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Month</key>
+    <integer>${deadline.getMonth() + 1}</integer>
+    <key>Day</key>
+    <integer>${deadline.getDate()}</integer>
+    <key>Hour</key>
+    <integer>${deadline.getHours()}</integer>
+    <key>Minute</key>
+    <integer>${deadline.getMinutes()}</integer>
+  </dict>
+  <key>RunAtLoad</key>
+  <false/>
+</dict>
+</plist>
+`;
+};
+var pad2 = (n) => String(n).padStart(2, "0");
+var systemdCalendar = (deadline) => `${deadline.getFullYear()}-${pad2(deadline.getMonth() + 1)}-${pad2(deadline.getDate())} ` + `${pad2(deadline.getHours())}:${pad2(deadline.getMinutes())}:00`;
+var scheduleRevert = (d, deadlineMs) => {
+  const deadline = new Date(deadlineMs);
+  if (d.platform === "darwin") {
+    const p = plistPath(d.home);
+    try {
+      mkdirSync6(join5(d.home, "Library", "LaunchAgents"), { recursive: true });
+      d.exec("launchctl", ["unload", p]);
+      writeFileSync6(p, buildLaunchdPlist(d.sledsArgv, deadline));
+      const r = d.exec("launchctl", ["load", p]);
+      if (r.ok)
+        return { kind: "launchd", detail: `launchd agent ${REVERT_LABEL}` };
+      return { kind: "manual", detail: `launchctl load failed: ${r.stderr.trim() || "unknown"}` };
+    } catch (err) {
+      return { kind: "manual", detail: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  if (d.platform === "linux") {
+    d.exec("systemctl", ["--user", "stop", `${REVERT_LABEL}.timer`]);
+    const r = d.exec("systemd-run", [
+      "--user",
+      `--unit=${REVERT_LABEL}`,
+      `--on-calendar=${systemdCalendar(deadline)}`,
+      ...d.sledsArgv,
+      "off"
+    ]);
+    if (r.ok)
+      return { kind: "systemd", detail: `systemd user timer ${REVERT_LABEL}` };
+    return { kind: "manual", detail: `systemd-run failed: ${r.stderr.trim() || "unavailable"}` };
+  }
+  return { kind: "manual", detail: `no scheduler on ${d.platform}` };
+};
+var cancelRevert = (d, kind) => {
+  if (kind === "launchd" || d.platform === "darwin") {
+    const p = plistPath(d.home);
+    if (existsSync5(p)) {
+      d.exec("launchctl", ["unload", p]);
+      rmSync(p, { force: true });
+    }
+  }
+  if (kind === "systemd" || d.platform === "linux") {
+    d.exec("systemctl", ["--user", "stop", `${REVERT_LABEL}.timer`]);
+  }
+};
+
+// 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;
+  const cfg = readConfig(o.home);
+  const settings = readSettings(o.home);
+  const wasOn = cfg.mode === "on" || isPointedAtProxy(settings);
+  if (wasOn)
+    writeSettings(o.home, switchOff(settings, cfg.priorEnv ?? {}));
+  if (o.scheduler)
+    cancelRevert(o.scheduler, cfg.schedule);
+  const next = {
+    ...cfg,
+    mode: "off",
+    since: undefined,
+    untilReset: undefined,
+    reason: undefined,
+    priorEnv: undefined,
+    schedule: undefined
+  };
+  writeConfig(o.home, next);
+  if (!wasOn) {
+    log("Sleds already off. Claude Code is on your seat.");
+    return 0;
+  }
+  log("Sleds off. Claude Code back on your seat. Restart claude to apply.");
+  return 0;
+};
+
+// src/commands/init.ts
+var DEFAULT_PROXY_URL2 = "http://localhost:8787";
+
+// src/commands/on.ts
+var on = (o) => {
+  const log = o.log ?? console.log;
+  const error = o.error ?? console.error;
+  const env = o.env ?? process.env;
+  const now = (o.now ?? Date.now)();
+  if (!hasClaudeCode(o.home)) {
+    error(`Claude Code not found (${claudeDir(o.home)} does not exist). Install it, then re-run.`);
+    return 1;
+  }
+  const cfg = readConfig(o.home);
+  const token = cfg.token ?? readTokenFile(o.home) ?? env.SLEDS_TOKEN?.trim();
+  if (!token) {
+    error(`No seat token in ${configPath(o.home)}. Run \`sleds init\` first.`);
+    return 2;
+  }
+  if (!isSeatToken(token)) {
+    error("Saved token is not a sled_ token. Run `sleds init --token <sled_…>`.");
+    return 2;
+  }
+  const url = (o.url ?? cfg.proxyUrl ?? env.SLEDS_PROXY_URL ?? DEFAULT_PROXY_URL2).replace(/\/+$/, "");
+  let untilResetMs;
+  if (o.untilReset !== undefined) {
+    try {
+      untilResetMs = parseUntilReset(o.untilReset, now);
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      return 2;
+    }
+  }
+  const settings = readSettings(o.home);
+  const priorEnv = cfg.mode === "on" && cfg.priorEnv ? cfg.priorEnv : capturePriorEnv(settings);
+  const backedUp = backupSettings(o.home);
+  writeSettings(o.home, switchOn(settings, { url, token }));
+  let schedule;
+  let scheduleNote;
+  if (untilResetMs !== undefined && !o.noSchedule && o.scheduler && hasHomeOverride(env)) {
+    error("SLEDS_HOME / CLAUDE_CONFIG_DIR is set: the auto-revert timer would act on the default seat. Re-run with --no-schedule and run `sleds off` yourself at the reset.");
+    return 2;
+  }
+  if (untilResetMs !== undefined && !o.noSchedule && o.scheduler) {
+    const r = scheduleRevert(o.scheduler, untilResetMs);
+    schedule = r.kind;
+    scheduleNote = r.kind === "manual" ? r.detail : undefined;
+  }
+  const next = {
+    ...cfg,
+    token,
+    proxyUrl: url,
+    mode: "on",
+    since: new Date(now).toISOString(),
+    priorEnv
+  };
+  if (untilResetMs !== undefined)
+    next.untilReset = new Date(untilResetMs).toISOString();
+  else
+    next.untilReset = undefined;
+  next.reason = o.reason?.trim() || undefined;
+  next.schedule = schedule;
+  writeConfig(o.home, next);
+  log(`Sleds on. Claude Code now runs on the org key through ${url}. Restart claude to apply.`);
+  if (untilResetMs !== undefined) {
+    log(`Reverts at ${formatLocal(untilResetMs, o.tz)} — run \`sleds off\` earlier if you want.`);
+    if (schedule === undefined || schedule === "manual") {
+      const why = scheduleNote ? ` (${scheduleNote})` : "";
+      log(`Auto-revert not scheduled${why}. Run \`sleds off\` after the reset.`);
+    }
+  }
+  if (backedUp)
+    log(`Backed up ${settingsPath(o.home)} to ${backupPath(o.home)}.`);
+  return 0;
+};
+
+// src/commands/seatEvent.ts
+var HOOK_STDIN_TIMEOUT_MS = 1000;
+var NOTIFICATION_TITLE = "sleds";
+var isObject7 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var notificationType = (text) => {
+  try {
+    const raw = JSON.parse(text);
+    if (!isObject7(raw))
+      return;
+    return typeof raw.notification_type === "string" ? raw.notification_type : undefined;
+  } catch {
+    return;
+  }
+};
+var osascriptArgs = (title, body) => [
+  "-e",
+  "on run argv",
+  "-e",
+  "display notification (item 2 of argv) with title (item 1 of argv)",
+  "-e",
+  "end run",
+  title,
+  body
+];
+var seatEvent = async (o) => {
+  const log = o.log ?? console.log;
+  const now = (o.now ?? Date.now)();
+  const input = o.stdin ?? await readStdin(HOOK_STDIN_TIMEOUT_MS);
+  const kind = notificationType(input);
+  try {
+    const state = readSeatState(o.home);
+    const week = state.window?.sevenDay;
+    const src = meterSource(o.home);
+    if (src) {
+      await postSeatWall({ ...src, fetchFn: o.fetchFn, timeoutMs: o.timeoutMs ?? SEAT_POST_TIMEOUT_MS }, {
+        ...week ? { resetsAt: week.resetsAt, usedPct: week.usedPct } : {},
+        ...kind ? { notification: kind } : {}
+      });
+    }
+    if (week && week.resetsAt > now)
+      writeSeatState(o.home, { ...state, lastWallResetsAt: week.resetsAt });
+  } catch {}
+  log(SEAT_WALL_LINE);
+  if ((o.platform ?? process.platform) === "darwin" && o.exec) {
+    try {
+      o.exec("osascript", osascriptArgs(NOTIFICATION_TITLE, SEAT_WALL_LINE));
+    } catch {}
+  }
+  return 0;
+};
+
+// 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 { platform } from "node:os";
+import { join as join7 } 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";
+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) {
+  if (isBun()) {
+    const { Database } = await import("bun:sqlite");
+    const conn2 = new Database(dbPath, { readonly: true });
+    try {
+      return conn2.query(QUERY).all();
+    } finally {
+      conn2.close();
+    }
+  }
+  const mod = nodeSqlite();
+  const conn = new mod.DatabaseSync(dbPath, { readOnly: true });
+  try {
+    return conn.prepare(QUERY).all();
+  } finally {
+    conn.close();
+  }
+}
+function nodeSqlite() {
+  const get = process.getBuiltinModule;
+  const mod = get ? get("node:sqlite") : undefined;
+  if (!mod)
+    throw new Error("this Node has no node:sqlite (need Node ≥ 22.5) and Bun is not running");
+  return mod;
+}
+async function readCookieRows(dbPath) {
+  const copy = join6(tmpdir(), `sleds-cookies-${process.pid}-${Date.now()}.sqlite`);
+  copyFileSync(dbPath, copy);
+  try {
+    const rows = await queryRows(copy);
+    return rows.map((r) => ({ name: r.name, encrypted_value: Buffer.from(r.ev, "hex") }));
+  } finally {
+    try {
+      rmSync2(copy, { force: true });
+    } catch {}
+  }
+}
+
+// src/seatSync.ts
+import { createDecipheriv, pbkdf2Sync } from "node:crypto";
+var BROWSERS = {
+  claude: { appDir: "Claude", keychainService: "Claude Safe Storage", profiled: false },
+  chrome: { appDir: "Google/Chrome", keychainService: "Chrome Safe Storage", profiled: true },
+  "chrome-beta": {
+    appDir: "Google/Chrome Beta",
+    keychainService: "Chrome Safe Storage",
+    profiled: true
+  },
+  "chrome-canary": {
+    appDir: "Google/Chrome Canary",
+    keychainService: "Chrome Safe Storage",
+    profiled: true
+  },
+  chromium: { appDir: "Chromium", keychainService: "Chromium Safe Storage", profiled: true },
+  brave: {
+    appDir: "BraveSoftware/Brave-Browser",
+    keychainService: "Brave Safe Storage",
+    profiled: true
+  },
+  edge: {
+    appDir: "Microsoft Edge",
+    keychainService: "Microsoft Edge Safe Storage",
+    profiled: true
+  }
+};
+var isBrowserId = (s) => Object.hasOwn(BROWSERS, s);
+var SOURCE_FLAGS = new Set(["browser", "profile", "org", "token"]);
+function parseSeatSyncArgs(argv) {
+  const source = { browser: "claude", install: false, uninstall: false };
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === undefined)
+      continue;
+    if (arg === "--install") {
+      source.install = true;
+      continue;
+    }
+    if (arg === "--uninstall") {
+      source.uninstall = true;
+      continue;
+    }
+    if (!arg.startsWith("--"))
+      return { error: `unexpected argument: ${arg}` };
+    const eq = arg.indexOf("=");
+    const key = eq === -1 ? arg.slice(2) : arg.slice(2, eq);
+    if (!SOURCE_FLAGS.has(key))
+      return { error: `unknown flag: --${key}` };
+    let value;
+    if (eq !== -1)
+      value = arg.slice(eq + 1);
+    else {
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith("--")) {
+        value = next;
+        i++;
+      }
+    }
+    if (!value)
+      return { error: `--${key} needs a value` };
+    if (key === "browser") {
+      if (!isBrowserId(value))
+        return { error: `unknown browser: ${value} (one of ${Object.keys(BROWSERS).join(", ")})` };
+      source.browser = value;
+    } else
+      source[key] = value;
+  }
+  if (source.profile && !BROWSERS[source.browser].profiled)
+    return { error: `--profile does not apply to --browser ${source.browser}` };
+  return { source };
+}
+function resolveProfileDir(localStateJson, profile) {
+  let cache = {};
+  if (localStateJson) {
+    try {
+      const raw = JSON.parse(localStateJson);
+      const p = isObject8(raw) && isObject8(raw.profile) ? raw.profile : null;
+      if (p && isObject8(p.info_cache))
+        cache = p.info_cache;
+    } catch {}
+  }
+  if (Object.hasOwn(cache, profile))
+    return { dir: profile };
+  const want = profile.toLowerCase();
+  const hits = [];
+  for (const [dir, info] of Object.entries(cache)) {
+    if (!isObject8(info))
+      continue;
+    const match = ["name", "user_name", "gaia_name"].some((k) => {
+      const v = info[k];
+      return typeof v === "string" && v.toLowerCase() === want;
+    });
+    if (match)
+      hits.push(dir);
+  }
+  if (hits.length === 1)
+    return { dir: hits[0] ?? null };
+  if (hits.length > 1)
+    return { dir: null, ambiguous: hits };
+  return { dir: Object.keys(cache).length === 0 ? profile : null };
+}
+function cookieDbCandidates(profileDir) {
+  return [`${profileDir}/Network/Cookies`, `${profileDir}/Cookies`];
+}
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+function launchLabel(source) {
+  const base = "ai.sleds.seat-sync";
+  if (source.browser === "claude" && !source.profile)
+    return base;
+  const parts = [source.browser, ...source.profile ? [slug(source.profile)] : []];
+  return `${base}.${parts.join("-")}`;
+}
+function sourceArgs(source) {
+  const out = [];
+  if (source.browser !== "claude")
+    out.push("--browser", source.browser);
+  if (source.profile)
+    out.push("--profile", source.profile);
+  if (source.org)
+    out.push("--org", source.org);
+  if (source.token)
+    out.push("--token", source.token);
+  return out;
+}
+var isObject8 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var num4 = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
+var round2 = (n) => Math.round(n * 100) / 100;
+function parseUsageResponse(raw, now = Date.now()) {
+  if (!isObject8(raw))
+    return null;
+  const out = { capturedAt: now, models: {} };
+  for (const [k, v] of Object.entries(raw)) {
+    if (!isObject8(v))
+      continue;
+    if (k === "extra_usage") {
+      const credits = num4(v.used_credits);
+      if (credits !== undefined)
+        out.usedCreditsUsd = round2(credits / 100);
+      continue;
+    }
+    const usedPct = num4(v.utilization);
+    const resetsAt = parseResetsAt(v.resets_at);
+    if (usedPct === undefined || usedPct < 0 || resetsAt === undefined)
+      continue;
+    const bar2 = { usedPct, resetsAt };
+    if (k === "five_hour")
+      out.fiveHour = bar2;
+    else if (k === "seven_day")
+      out.sevenDay = bar2;
+    else
+      out.models[k] = bar2;
+  }
+  const hasAny = out.fiveHour || out.sevenDay || Object.keys(out.models).length > 0 || out.usedCreditsUsd !== undefined;
+  return hasAny ? out : null;
+}
+function seatSyncBody(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 } : {}
+  };
+}
+function deriveKey(safeStoragePw) {
+  return pbkdf2Sync(safeStoragePw, "saltysalt", 1003, 16, "sha1");
+}
+function decryptCookieBytes(enc, key) {
+  if (enc.length < 3 || enc.subarray(0, 3).toString("latin1") !== "v10")
+    return null;
+  const iv = Buffer.alloc(16, 32);
+  const d = createDecipheriv("aes-128-cbc", key, iv);
+  d.setAutoPadding(false);
+  let out;
+  try {
+    out = Buffer.concat([d.update(enc.subarray(3)), d.final()]);
+  } catch {
+    return null;
+  }
+  if (out.length === 0)
+    return null;
+  const pad = out[out.length - 1] ?? 0;
+  if (pad > 0 && pad <= 16 && pad <= out.length)
+    out = out.subarray(0, out.length - pad);
+  return out;
+}
+var DOMAIN_HASH_LEN = 32;
+function prefixLen(sessionKeyBytes) {
+  if (sessionKeyBytes && sessionKeyBytes.subarray(0, 6).toString("latin1") === "sk-ant")
+    return 0;
+  return DOMAIN_HASH_LEN;
+}
+function decryptCookieJar(rows, key) {
+  const raw = [];
+  for (const r of rows) {
+    const bytes = decryptCookieBytes(r.encrypted_value, key);
+    if (bytes)
+      raw.push({ name: r.name, bytes });
+  }
+  const sessionKey = raw.find((r) => r.name === "sessionKey")?.bytes ?? null;
+  const strip = prefixLen(sessionKey);
+  const jar = {};
+  for (const r of raw)
+    jar[r.name] = r.bytes.subarray(strip).toString("utf8");
+  return jar;
+}
+var SEAT_SYNC_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36";
+function cookieHeader(jar, activeOrg) {
+  const j = activeOrg ? { ...jar, lastActiveOrg: activeOrg } : jar;
+  return Object.entries(j).map(([k, v]) => `${k}=${v}`).join("; ");
+}
+function usageUrl(org) {
+  return `https://claude.ai/api/organizations/${org}/usage`;
+}
+function usageHeaders(cookie) {
+  return {
+    Cookie: cookie,
+    "User-Agent": SEAT_SYNC_UA,
+    accept: "*/*",
+    origin: "https://claude.ai",
+    referer: "https://claude.ai/",
+    "anthropic-client-platform": "web_claude_ai",
+    "sec-fetch-site": "same-origin",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-dest": "empty"
+  };
+}
+var USAGE_MAX_SECONDS = 8;
+function usageCurlArgs(org, cookie) {
+  const args = [
+    "-sS",
+    "-o",
+    "-",
+    "-w",
+    `
+%{http_code}`,
+    "--max-time",
+    String(USAGE_MAX_SECONDS),
+    usageUrl(org)
+  ];
+  for (const [k, v] of Object.entries(usageHeaders(cookie)))
+    args.push("-H", `${k}: ${v}`);
+  return args;
+}
+function parseCurlOutput(out) {
+  const nl = out.lastIndexOf(`
+`);
+  if (nl === -1)
+    return { status: 0, body: out };
+  return { status: Number.parseInt(out.slice(nl + 1).trim(), 10) || 0, body: out.slice(0, nl) };
+}
+
+// src/commands/seatSync.ts
+var APP_SUPPORT = "Library/Application Support";
+var SYNC_INTERVAL_S = 600;
+var FETCH_TIMEOUT_MS = 8000;
+function findFile(root, name) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    if (!dir || !existsSync6(dir))
+      continue;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const p = join7(dir, e.name);
+      if (e.isDirectory())
+        stack.push(p);
+      else if (e.name === name)
+        return p;
+    }
+  }
+  return null;
+}
+function findCookieDb(home, source) {
+  const b = BROWSERS[source.browser];
+  const root = join7(home, APP_SUPPORT, b.appDir);
+  if (!existsSync6(root))
+    throw new Error(`no ${source.browser} data at ${root} (is it installed?)`);
+  if (!b.profiled) {
+    const db2 = findFile(root, "Cookies");
+    if (!db2)
+      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 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));
+  if (!db)
+    throw new Error(`profile "${dir}" has no cookie store yet (open claude.ai in it once)`);
+  return db;
+}
+async function readCookieRowsBun(home, source) {
+  return readCookieRows(findCookieDb(home, source));
+}
+function keychainKey(service) {
+  try {
+    return execFileSync("security", ["find-generic-password", "-w", "-s", service], {
+      encoding: "utf8"
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function decryptJar(rows, safeStoragePw) {
+  return decryptCookieJar(rows, deriveKey(safeStoragePw));
+}
+var curlUsage = (org, cookie) => {
+  try {
+    const out = execFileSync("curl", usageCurlArgs(org, cookie), {
+      encoding: "utf8",
+      maxBuffer: 8000000
+    });
+    return parseCurlOutput(out);
+  } catch {
+    return { status: 0, body: "" };
+  }
+};
+function fetchSeatUsage(jar, org, now, run) {
+  const { status, body } = run(org, cookieHeader(jar, org));
+  if (status !== 200)
+    return { usage: null, status };
+  try {
+    return { usage: parseUsageResponse(JSON.parse(body), now), status };
+  } catch {
+    return { usage: null, status };
+  }
+}
+function launchAgentPlist(bun, script, home, source) {
+  const label = launchLabel(source);
+  const log = join7(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(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key><string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>StartInterval</key><integer>${SYNC_INTERVAL_S}</integer>
+  <key>RunAtLoad</key><true/>
+  <key>StandardOutPath</key><string>${esc(log)}</string>
+  <key>StandardErrorPath</key><string>${esc(log)}</string>
+</dict>
+</plist>
+`;
+}
+function plistPath2(home, source) {
+  return join7(home, "Library", "LaunchAgents", `${launchLabel(source)}.plist`);
+}
+function install(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 path = plistPath2(home, source);
+  writeFileSync7(path, launchAgentPlist(bun, script, home, source), { mode: 384 });
+  try {
+    execFileSync("launchctl", ["unload", path], { stdio: "ignore" });
+  } catch {}
+  execFileSync("launchctl", ["load", "-w", path]);
+  log(`seat-sync timer installed (every ${SYNC_INTERVAL_S / 60} min) → ${path}`);
+  return 0;
+}
+function uninstall(home, source, log) {
+  const path = plistPath2(home, source);
+  try {
+    execFileSync("launchctl", ["unload", "-w", path], { stdio: "ignore" });
+  } catch {}
+  log(existsSync6(path) ? `seat-sync timer removed (${path} can be deleted)` : "no seat-sync timer");
+  return 0;
+}
+var seatSync = async (o) => {
+  const log = o.log ?? console.log;
+  const now = (o.now ?? Date.now)();
+  const parsed = parseSeatSyncArgs(o.argv ?? process.argv.slice(3));
+  if ("error" in parsed) {
+    log(`seat-sync: ${parsed.error}`);
+    return 1;
+  }
+  const { source } = parsed;
+  if (source.uninstall)
+    return uninstall(o.home, source, log);
+  if (source.install)
+    return install(o.home, [process.execPath, process.argv[1] ?? ""], source, log);
+  if (platform() !== "darwin" && !o.readCookieRows) {
+    log("seat-sync is macOS-only for now.");
+    return 2;
+  }
+  const saved = meterSource(o.home);
+  const proxyUrl = saved?.proxyUrl;
+  const token = source.token ?? saved?.token;
+  if (!proxyUrl || !token) {
+    log("SLEDS is not set up. Run `sleds init` first.");
+    return 1;
+  }
+  let rows;
+  try {
+    rows = o.readCookieRows ? o.readCookieRows(o.home, source) : await readCookieRowsBun(o.home, source);
+  } catch (e) {
+    log(`seat-sync: ${e instanceof Error ? e.message : String(e)}`);
+    return 1;
+  }
+  const service = BROWSERS[source.browser].keychainService;
+  const pw = (o.safeStorageKey ?? keychainKey)(service);
+  if (!pw) {
+    log(`seat-sync: could not read the "${service}" key from your Keychain.`);
+    return 1;
+  }
+  const jar = decryptJar(rows, pw);
+  const where = source.browser === "claude" ? "the Claude app" : `this ${source.browser} profile`;
+  if (!rows.some((r) => r.name === "sessionKey")) {
+    log(`seat-sync: ${where} has ${rows.length} claude.ai cookies but no sessionKey — sign in to claude.ai there, or read a browser profile with --browser chrome --profile <yours>.`);
+    return 1;
+  }
+  if (!jar.sessionKey?.startsWith("sk-ant")) {
+    log(`seat-sync: could not decrypt ${where}'s session (wrong "${service}" Keychain key?).`);
+    return 1;
+  }
+  const org = source.org ?? jar.lastActiveOrg;
+  if (!org) {
+    log("seat-sync: no active org in the session cookie (pass --org <uuid>).");
+    return 1;
+  }
+  const { usage, status } = fetchSeatUsage(jar, org, now, o.runUsage ?? curlUsage);
+  if (!usage) {
+    const why = status === 403 ? "claude.ai refused the read (403) — session expired, or this org is not readable by this session." : status === 0 ? "could not reach claude.ai." : `unexpected HTTP ${status}.`;
+    log(`seat-sync: usage read failed — ${why}`);
+    return 2;
+  }
+  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;
+  const credits = usage.usedCreditsUsd !== undefined ? ` · $${usage.usedCreditsUsd.toFixed(2)}` : "";
+  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;
+};
+async function postSeat(proxyUrl, token, body, fetchFn) {
+  try {
+    const res = await fetchFn(`${proxyUrl}/proxy/seat`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/specEvent.ts
+import { readFileSync as readFileSync6, statSync } from "node:fs";
+import { basename, isAbsolute, relative } from "node:path";
+var HOOK_STDIN_TIMEOUT_MS2 = 1000;
+var ESTIMATE_TIMEOUT_MS = 4000;
+var MIN_SPEC_CHARS = 200;
+var MAX_SPEC_CHARS = 12000;
+var SPEC_DIRS = /(^|\/)(specs?|docs?|plans?|design|rfcs?|prds?|proposals?)(\/|$)/i;
+var SPEC_NAMES = /(spec|plan|prd|design|rfc|proposal|brief|requirements)/i;
+var NOT_SPEC = /(^|\/)(readme|changelog|contributing|license|code_of_conduct|node_modules)(\.|\/|$)/i;
+function isSpecPath(path) {
+  if (!/\.(md|mdx)$/i.test(path))
+    return false;
+  if (NOT_SPEC.test(path))
+    return false;
+  return SPEC_DIRS.test(path) || SPEC_NAMES.test(basename(path));
+}
+function specTitle(body, path) {
+  const m = /^#\s+(.+?)\s*$/m.exec(body);
+  const t = m?.[1]?.trim();
+  return (t && t.length > 0 ? t : basename(path).replace(/\.(md|mdx)$/i, "")).slice(0, 120);
+}
+function looksLikeSpec(body) {
+  if (body.trim().length < MIN_SPEC_CHARS)
+    return false;
+  return /^#{1,3}\s/m.test(body) || /^\s*(?:[-*+]|\d+[.)])\s+/m.test(body);
+}
+function parseHookInput(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const p = parsed;
+  const toolName = typeof p.tool_name === "string" ? p.tool_name : "";
+  const input = typeof p.tool_input === "object" && p.tool_input !== null ? p.tool_input : {};
+  const filePath = typeof input.file_path === "string" ? input.file_path : "";
+  if (!filePath)
+    return null;
+  const cwd = typeof p.cwd === "string" ? p.cwd : "";
+  return { toolName, filePath, cwd };
+}
+function projectKey(filePath, cwd) {
+  if (cwd && isAbsolute(filePath) && isAbsolute(cwd)) {
+    const rel = relative(cwd, filePath);
+    if (rel && !rel.startsWith(".."))
+      return rel;
+  }
+  return filePath;
+}
+function readFileOrNull(path) {
+  try {
+    if (statSync(path).size > 2000000)
+      return null;
+    return readFileSync6(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+var specEvent = async (o) => {
+  const log = o.log ?? console.log;
+  const raw = o.stdin ?? await readStdin(HOOK_STDIN_TIMEOUT_MS2);
+  const input = raw ? parseHookInput(raw) : null;
+  if (!input || !isSpecPath(input.filePath))
+    return 0;
+  const src = meterSource(o.home);
+  if (!src)
+    return 0;
+  const body = (o.readFile ?? readFileOrNull)(input.filePath);
+  if (!body || !looksLikeSpec(body))
+    return 0;
+  const project = projectKey(input.filePath, input.cwd);
+  const spec = {
+    title: specTitle(body, input.filePath),
+    body: body.slice(0, MAX_SPEC_CHARS),
+    repoHint: input.cwd ? basename(input.cwd) : undefined
+  };
+  try {
+    const res = await (o.fetchFn ?? fetch)(`${src.proxyUrl}/proxy/estimate`, {
+      method: "POST",
+      headers: { authorization: `Bearer ${src.token}`, "content-type": "application/json" },
+      body: JSON.stringify({ spec, project }),
+      signal: AbortSignal.timeout(ESTIMATE_TIMEOUT_MS)
+    });
+    if (!res.ok)
+      return 0;
+    const r = await res.json();
+    const b = r.band;
+    if (b && typeof b.lowUsd === "number" && typeof b.highUsd === "number") {
+      const min = (n) => typeof n === "number" ? Math.round(n) : "?";
+      log(`sleds: ${project} sized at $${b.lowUsd.toFixed(2)}–${b.highUsd.toFixed(2)} · ${min(b.lowMinutes)}–${min(b.highMinutes)} min`);
+    }
+  } catch {}
+  return 0;
+};
+
+// src/commands/status.ts
+import { existsSync as existsSync7 } from "node:fs";
+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";
+  }
+};
+var fetchProxyStatus = async (url, fetchFn = fetch, timeoutMs = 1000) => {
+  try {
+    const res = await fetchFn(`${url}/status`, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok)
+      return {};
+    const body = await res.json();
+    if (typeof body !== "object" || body === null)
+      return {};
+    const b = body;
+    const out = {};
+    if (typeof b.wallMode === "string")
+      out.wallMode = b.wallMode;
+    if (typeof b.version === "string")
+      out.version = b.version;
+    return out;
+  } catch {
+    return {};
+  }
+};
+var row2 = (label, value) => `${label.padEnd(12)}${value}`;
+var formatStatus = (s) => {
+  const lines = [];
+  const stale = s.mode === "on" && !s.pointed;
+  lines.push(row2("Sleds:", `${s.mode}${stale ? " (settings.json no longer points at the proxy)" : ""}`));
+  if (s.mode === "on") {
+    if (s.sinceMs !== undefined) {
+      lines.push(row2("Since:", `${formatLocal(s.sinceMs, s.tz)} (${formatDuration(s.nowMs - s.sinceMs)} ago)`));
+    }
+    if (s.untilResetMs !== undefined) {
+      const passed = s.untilResetMs <= s.nowMs;
+      lines.push(row2("Reverts:", passed ? `${formatLocal(s.untilResetMs, s.tz)} — reset passed. Run \`sleds off\`.` : `${formatLocal(s.untilResetMs, s.tz)} (in ${formatDuration(s.untilResetMs - s.nowMs)})`));
+    }
+    if (s.reason)
+      lines.push(row2("Reason:", s.reason));
+  }
+  if (s.proxyUrl) {
+    lines.push(row2("Proxy:", s.proxyUrl));
+    if (s.tokenMasked)
+      lines.push(row2("Token:", s.tokenMasked));
+    if (s.health) {
+      const extra = [];
+      if (s.proxy?.wallMode)
+        extra.push(`wall mode ${s.proxy.wallMode}`);
+      if (s.proxy?.version)
+        extra.push(`v${s.proxy.version}`);
+      lines.push(row2("Health:", `${s.health}${extra.length ? ` (${extra.join(", ")})` : ""}`));
+    }
+  }
+  if (s.email)
+    lines.push(row2("Seat:", s.email));
+  if (s.mode === "off") {
+    lines.push(s.pointed ? "Claude Code is pointed at the proxy by settings.json (set by `sleds init`)." : "Claude Code is on your seat. Hit a limit? `sleds on --until-reset +5h`.");
+  }
+  return lines;
+};
+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 inSettings = readProxy(settings);
+  const proxyUrl = inSettings?.url ?? cfg.proxyUrl;
+  const token = inSettings?.token ?? cfg.token;
+  if (!proxyUrl && !token && cfg.mode === undefined) {
+    log(`SLEDS is not set up (${configPath(o.home)} and ${settingsPath(o.home)}).`);
+    log("Run `sleds init` first.");
+    return 1;
+  }
+  const info = {
+    mode: cfg.mode ?? "off",
+    pointed: inSettings !== null,
+    nowMs,
+    settingsFile: settingsPath(o.home),
+    configFile: configPath(o.home)
+  };
+  if (proxyUrl)
+    info.proxyUrl = proxyUrl;
+  if (token)
+    info.tokenMasked = maskToken(token);
+  if (cfg.email)
+    info.email = cfg.email;
+  if (cfg.reason)
+    info.reason = cfg.reason;
+  if (o.tz)
+    info.tz = o.tz;
+  const since = cfg.since ? Date.parse(cfg.since) : Number.NaN;
+  if (!Number.isNaN(since))
+    info.sinceMs = since;
+  const until = cfg.untilReset ? Date.parse(cfg.untilReset) : Number.NaN;
+  if (!Number.isNaN(until))
+    info.untilResetMs = until;
+  if (proxyUrl) {
+    const [health, proxy] = await Promise.all([
+      checkHealth(proxyUrl, o.fetchFn, o.timeoutMs),
+      fetchProxyStatus(proxyUrl, o.fetchFn, o.timeoutMs)
+    ]);
+    info.health = health;
+    info.proxy = proxy;
+  }
+  for (const line of formatStatus(info))
+    log(line);
+  return 0;
+};
+
+// src/commands/statusline.ts
+var statusline = async (o) => {
+  const log = o.log ?? console.log;
+  const now = (o.now ?? Date.now)();
+  const input = o.stdin ?? await readStdin(STDIN_TIMEOUT_MS);
+  const window = seatWindowFromStdin(input, now);
+  let posts = [];
+  try {
+    if (window)
+      posts = rememberSeat(o, window, now);
+  } catch {}
+  const seatFragment = formatSeatFragment(window);
+  let line;
+  try {
+    const meter2 = await loadMeter({
+      home: o.home,
+      now,
+      fetchFn: o.fetchFn,
+      timeoutMs: o.timeoutMs
+    });
+    line = formatMeterLine(meter2, now, seatFragment);
+  } catch {
+    line = formatMeterLine(null, now, seatFragment);
+  }
+  log(line);
+  await Promise.allSettled(posts);
+  return 0;
+};
+var rememberSeat = (o, window, now) => {
+  const prior = readSeatState(o.home);
+  let state = { ...prior, window };
+  const src = meterSource(o.home);
+  const posts = [];
+  if (src) {
+    const opts = { ...src, fetchFn: o.fetchFn, timeoutMs: o.timeoutMs ?? SEAT_POST_TIMEOUT_MS };
+    if (shouldPostSeat(prior, window, now)) {
+      state = markPosted(state, window, now);
+      posts.push(postSeatWindow(opts, window));
+    }
+    if (seatWallDue(prior, window) && window.sevenDay) {
+      state = { ...state, lastWallResetsAt: window.sevenDay.resetsAt };
+      posts.push(postSeatWall(opts, {
+        resetsAt: window.sevenDay.resetsAt,
+        usedPct: window.sevenDay.usedPct,
+        notification: "statusline"
+      }));
+    }
+  }
+  writeSeatState(o.home, state);
+  return posts;
+};
+
+// src/commands/uninstall.ts
+import { existsSync as existsSync8, rmSync as rmSync3 } from "node:fs";
+var uninstall2 = (o) => {
+  const log = o.log ?? console.log;
+  const removed = [];
+  if (existsSync8(settingsPath(o.home))) {
+    let settings = readSettings(o.home);
+    let changed = false;
+    if (hasEitherKey(settings)) {
+      settings = removeProxy(settings);
+      changed = true;
+      removed.push(`env.ANTHROPIC_BASE_URL and env.ANTHROPIC_AUTH_TOKEN from ${settingsPath(o.home)}`);
+    }
+    if (isSledsStatusLine(settings[STATUS_LINE_KEY])) {
+      const cfg = readConfig(o.home);
+      settings = removeStatusLine(settings, cfg.priorStatusLine);
+      changed = true;
+      removed.push(cfg.priorStatusLine === undefined ? `statusLine from ${settingsPath(o.home)}` : `statusLine from ${settingsPath(o.home)} (previous one restored)`);
+      if (cfg.priorStatusLine !== undefined) {
+        const { priorStatusLine: _restored, ...rest } = cfg;
+        writeConfig(o.home, rest);
+      }
+    }
+    if (hasSeatHook(settings)) {
+      settings = removeSeatHook(settings);
+      changed = true;
+      removed.push(`hooks.Notification seat-event entry from ${settingsPath(o.home)}`);
+    }
+    if (hasSpecHook(settings)) {
+      settings = removeSpecHook(settings);
+      changed = true;
+      removed.push(`hooks.PostToolUse spec-event entry from ${settingsPath(o.home)}`);
+    }
+    if (changed)
+      writeSettings(o.home, settings);
+  }
+  for (const file of [meterCachePath(o.home), seatStatePath(o.home)]) {
+    if (existsSync8(file)) {
+      rmSync3(file, { force: true });
+      removed.push(file);
+    }
+  }
+  const skill = skillDir(o.home);
+  if (existsSync8(skill)) {
+    rmSync3(skill, { recursive: true, force: true });
+    removed.push(skill);
+  }
+  if (removed.length === 0) {
+    log("Nothing to remove; SLEDS was not installed.");
+  } else {
+    log("Removed:");
+    for (const r of removed)
+      log(`  ${r}`);
+  }
+  log(`Kept ${tokenPath(o.home)} (delete it yourself if you want the token gone).`);
+  return 0;
+};
+var hasEitherKey = (settings) => {
+  const env = settings.env;
+  if (typeof env !== "object" || env === null)
+    return false;
+  return BASE_URL_KEY in env || AUTH_TOKEN_KEY in env;
+};
+
+// src/schedule.ts
+import { spawnSync } from "node:child_process";
+var defaultExec = (cmd, args) => {
+  const r = spawnSync(cmd, [...args], { stdio: ["ignore", "ignore", "pipe"], encoding: "utf8" });
+  if (r.error)
+    return { ok: false, stderr: r.error.message };
+  return { ok: r.status === 0, stderr: r.stderr ?? "" };
+};
+
+// src/index.ts
+var USAGE = `usage: sleds <command> [options]
+
+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})
+              --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)
+  on          Hit a limit on your seat? Switch Claude Code to the org key through the proxy.
+              --until-reset <when>   revert at this time: +5h, +90m, or an ISO timestamp
+              --reason "<text>"      note shown by \`sleds status\`
+              --no-schedule          record the deadline but do not install a launchd/systemd revert
+  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.
+  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).
+  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
+              claude.ai session and post it to the proxy. macOS.
+              --browser <claude|chrome|brave|edge|chromium|\u2026>  which cookie store (default claude)
+              --profile <name>       browser profile dir ("Profile 1") or its display name/email
+              --org <uuid>           claude.ai org to read (else the session's active org)
+              --token <sled_\u2026>       post as this seat (else the one \`init\` saved)
+              --install / --uninstall  a 10-min launchd timer for this source (one per source)
+  statusline  Print the one-line meter Claude Code shows (installed by init; 10s cache).
+  hooks       Register the Claude Code Notification hook for seat limits (init does this too).
+  seat-event  Claude Code hook: record a seat wall and say how to continue. Reads hook JSON on stdin.
+  spec-event  Claude Code PostToolUse hook: when a spec-shaped markdown file is written, size it
+              (POST /proxy/estimate with the file path as the project). Silent unless it estimates.
+  --help      Show this message.
+
+env:
+  SLEDS_HOME          where sleds keeps its state (default ~/.config/sleds)
+  CLAUDE_CONFIG_DIR   Claude Code's config dir (its own convention; default ~/.claude)
+                      Set both to run a second seat under one macOS login; \`on --until-reset\`
+                      then needs --no-schedule (the timer would revert the default seat).
+
+Nothing changes until a wall.`;
+var parseArgs = (argv) => {
+  const [cmd = "--help", ...rest] = argv;
+  const flags = {};
+  for (let i = 0;i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === undefined || !arg.startsWith("--"))
+      continue;
+    const eq = arg.indexOf("=");
+    if (eq !== -1) {
+      flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+      continue;
+    }
+    const next = rest[i + 1];
+    if (next !== undefined && !next.startsWith("--")) {
+      flags[arg.slice(2)] = next;
+      i++;
+    } else {
+      flags[arg.slice(2)] = true;
+    }
+  }
+  return { cmd, flags };
+};
+var stringFlag = (flags, name) => {
+  const v = flags[name];
+  return typeof v === "string" ? v : undefined;
+};
+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 main = async (argv) => {
+  const { cmd, flags } = parseArgs(argv);
+  const home = homedir();
+  const scheduler = {
+    platform: platform2(),
+    home,
+    sledsArgv: sledsArgv(),
+    exec: defaultExec
+  };
+  switch (cmd) {
+    case "init":
+      return init({
+        home,
+        token: stringFlag(flags, "token"),
+        url: stringFlag(flags, "url"),
+        nonInteractive: flags["non-interactive"] === true,
+        signup: flags.signup === true,
+        prompt: promptStdin,
+        statusLineCommand: statusLineCommand(sledsArgv()),
+        seatEventCommand: seatEventCommand(sledsArgv()),
+        specEventCommand: specEventCommand(sledsArgv())
+      });
+    case "hooks":
+      return hooks({
+        home,
+        seatEventCommand: seatEventCommand(sledsArgv()),
+        specEventCommand: specEventCommand(sledsArgv())
+      });
+    case "seat-event":
+      return seatEvent({ home, platform: platform2(), exec: defaultExec });
+    case "spec-event":
+      return specEvent({ home });
+    case "on":
+      return on({
+        home,
+        untilReset: stringFlag(flags, "until-reset"),
+        reason: stringFlag(flags, "reason"),
+        url: stringFlag(flags, "url"),
+        noSchedule: flags["no-schedule"] === true,
+        scheduler
+      });
+    case "off":
+      return off({ home, scheduler });
+    case "uninstall":
+      return uninstall2({ home });
+    case "status":
+      return status({ home });
+    case "meter":
+      return meter({ home });
+    case "bar":
+      return bar({ home });
+    case "mcp":
+      return mcp({ home });
+    case "seat-sync":
+      return seatSync({ home, argv: process.argv.slice(3) });
+    case "statusline":
+      return statusline({ home });
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(USAGE);
+      return 0;
+    default:
+      console.error(`unknown command: ${cmd}
+`);
+      console.error(USAGE);
+      return 1;
+  }
+};
+var isMain = () => {
+  if (undefined)
+    ;
+  const arg = process.argv[1];
+  if (!arg)
+    return false;
+  try {
+    return realpathSync(arg) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+};
+if (isMain()) {
+  main(process.argv.slice(2)).then((code) => process.exit(code), (err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  });
+}
+export {
+  parseArgs,
+  seatEventCommand,
+  specEventCommand,
+  statusLineCommand
+};