@sideboard-ai/core 0.1.198 → 0.1.199

package/dist/index.cjs

@@ -1032,6 +1032,7 @@ __export(app_settings_exports, {
   childEnvWithAppSettings: () => childEnvWithAppSettings,
   claudeChromeEnabled: () => claudeChromeEnabled,
   claudeUserSettingsPath: () => claudeUserSettingsPath,
+  confirmClaudeUsageOverLimitEnabled: () => confirmClaudeUsageOverLimitEnabled,
   cowboyModeEnabled: () => cowboyModeEnabled,
   deleteBranchOnPurgeEnabled: () => deleteBranchOnPurgeEnabled,
   disconnectAbleTimeConnection: () => disconnectAbleTimeConnection,
@@ -1459,6 +1460,9 @@ function normalizeAdvanced(raw) {
   if (typeof source.showCost === "boolean") {
     out.showCost = source.showCost;
   }
+  if (typeof source.confirmClaudeUsageOverLimit === "boolean") {
+    out.confirmClaudeUsageOverLimit = source.confirmClaudeUsageOverLimit;
+  }
   if (typeof source.autoArchiveOnMerge === "boolean") {
     out.autoArchiveOnMerge = source.autoArchiveOnMerge;
   }
@@ -2321,6 +2325,9 @@ function updateAdvancedSettings(patch) {
   if (typeof patch.showCost === "boolean") {
     advanced.showCost = patch.showCost;
   }
+  if (typeof patch.confirmClaudeUsageOverLimit === "boolean") {
+    advanced.confirmClaudeUsageOverLimit = patch.confirmClaudeUsageOverLimit;
+  }
   if (typeof patch.autoArchiveOnMerge === "boolean") {
     advanced.autoArchiveOnMerge = patch.autoArchiveOnMerge;
   }
@@ -2383,6 +2390,9 @@ function cowboyModeEnabled(settings = loadAppSettings()) {
 function showCostEnabled(settings = loadAppSettings()) {
   return Boolean(settings.advanced.showCost);
 }
+function confirmClaudeUsageOverLimitEnabled(settings = loadAppSettings()) {
+  return Boolean(settings.advanced.confirmClaudeUsageOverLimit);
+}
 function autoArchiveOnMergeEnabled(settings = loadAppSettings()) {
   return Boolean(settings.advanced.autoArchiveOnMerge);
 }
@@ -2845,14 +2855,14 @@ function fileMtimeMs(path2) {
   }
 }
 function rememberThread(thread, mtimeMs) {
-  const cache = cacheForDir();
-  cache.byId.set(thread.id, thread);
-  if (mtimeMs != null) cache.mtimeMs.set(thread.id, mtimeMs);
+  const cache2 = cacheForDir();
+  cache2.byId.set(thread.id, thread);
+  if (mtimeMs != null) cache2.mtimeMs.set(thread.id, mtimeMs);
 }
 function forgetThread(id) {
-  const cache = cacheForDir();
-  cache.byId.delete(id);
-  cache.mtimeMs.delete(id);
+  const cache2 = cacheForDir();
+  cache2.byId.delete(id);
+  cache2.mtimeMs.delete(id);
 }
 function invalidateThreadListCache() {
   listCache = null;
@@ -2864,9 +2874,9 @@ function readThread(id) {
     forgetThread(id);
     return null;
   }
-  const cache = cacheForDir();
-  const cached = cache.byId.get(id);
-  if (cached && cache.mtimeMs.get(id) === mtimeMs) return cached;
+  const cache2 = cacheForDir();
+  const cached = cache2.byId.get(id);
+  if (cached && cache2.mtimeMs.get(id) === mtimeMs) return cached;
   const raw = (0, import_node_fs9.readFileSync)(path2, "utf8");
   const thread = normalizeThread(JSON.parse(raw));
   rememberThread(thread, mtimeMs);
@@ -2888,7 +2898,7 @@ function isThreadRecordFile(nameOrPath) {
   return name.endsWith(".json") && !name.endsWith(".live.json");
 }
 function listThreads(opts) {
-  const cache = cacheForDir();
+  const cache2 = cacheForDir();
   const files = (0, import_node_fs9.readdirSync)(threadsDir()).filter(isThreadRecordFile);
   const seen = /* @__PURE__ */ new Set();
   for (const f of files) {
@@ -2900,10 +2910,10 @@ function listThreads(opts) {
     } catch {
     }
   }
-  for (const id of [...cache.byId.keys()]) {
+  for (const id of [...cache2.byId.keys()]) {
     if (!seen.has(id)) forgetThread(id);
   }
-  const threads = [...cache.byId.values()].sort(
+  const threads = [...cache2.byId.values()].sort(
     (a, b) => b.updatedAt.localeCompare(a.updatedAt)
   );
   if (opts?.includeArchived) return threads;
@@ -13674,6 +13684,361 @@ var init_session_quota = __esm({
   }
 });
 
+// src/agents/claude-usage.ts
+function parseClaudeResetsAt(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ms = value > 1e12 ? value : value * 1e3;
+    const d = new Date(ms);
+    return Number.isNaN(d.getTime()) ? null : d.toISOString();
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (/^\d+(\.\d+)?$/.test(trimmed)) {
+      return parseClaudeResetsAt(Number(trimmed));
+    }
+    const d = new Date(trimmed);
+    return Number.isNaN(d.getTime()) ? null : d.toISOString();
+  }
+  return null;
+}
+function parseClaudeUtilization(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(0, Math.min(100, value));
+}
+function windowFromRaw(id, raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const row = raw;
+  const used = parseClaudeUtilization(row.utilization ?? row.used_percentage);
+  if (used == null) return null;
+  const meta = WINDOW_META[id];
+  return {
+    id,
+    label: meta.label,
+    shortLabel: meta.shortLabel,
+    detail: meta.detail,
+    usedPercent: used,
+    remainingPercent: Math.max(0, Math.min(100, 100 - used)),
+    resetsAt: parseClaudeResetsAt(row.resets_at)
+  };
+}
+function extraUsageFromRaw(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const row = raw;
+  const enabled = row.is_enabled === true || row.enabled === true;
+  if (!enabled && row.is_enabled !== false && row.enabled !== false) return void 0;
+  const usedCredits = numberOrUndef(row.used_credits ?? row.used);
+  const monthlyLimit = numberOrUndef(row.monthly_limit);
+  const usedPercent = parseClaudeUtilization(row.utilization) ?? void 0;
+  return {
+    enabled,
+    ...usedCredits != null ? { usedCredits } : {},
+    ...monthlyLimit != null ? { monthlyLimit } : {},
+    ...usedPercent != null ? { usedPercent } : {}
+  };
+}
+function numberOrUndef(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return void 0;
+  return value;
+}
+function parseClaudeUsagePayload(raw, fetchedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const source = obj.rate_limits && typeof obj.rate_limits === "object" ? obj.rate_limits : obj;
+  const windows = [];
+  for (const id of WINDOW_ORDER) {
+    const parsed = windowFromRaw(id, source[id]);
+    if (parsed) windows.push(parsed);
+  }
+  if (windows.length === 0) return null;
+  const extra = extraUsageFromRaw(obj.extra_usage ?? source.extra_usage);
+  return {
+    windows,
+    ...extra ? { extraUsage: extra } : {},
+    fetchedAt
+  };
+}
+function hottestClaudeWindow(usage) {
+  if (usage.windows.length === 0) return null;
+  return usage.windows.reduce((a, b) => b.usedPercent > a.usedPercent ? b : a);
+}
+function formatClaudeUsageReset(resetsAt, now = /* @__PURE__ */ new Date()) {
+  if (!resetsAt) return "";
+  const at = new Date(resetsAt);
+  if (Number.isNaN(at.getTime())) return "";
+  const ms = at.getTime() - now.getTime();
+  if (ms <= 0) return "resets soon";
+  const minutes = Math.round(ms / 6e4);
+  if (minutes < 60) return `resets in ${Math.max(1, minutes)}m`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 36) return `resets in ${hours}h`;
+  try {
+    return `resets ${at.toLocaleString(void 0, {
+      weekday: "short",
+      hour: "numeric",
+      minute: "2-digit"
+    })}`;
+  } catch {
+    return `resets ${at.toISOString()}`;
+  }
+}
+function formatClaudeUsageResetClock(resetsAt) {
+  if (!resetsAt) return "";
+  const at = new Date(resetsAt);
+  if (Number.isNaN(at.getTime())) return "";
+  try {
+    return at.toLocaleString(void 0, {
+      weekday: "short",
+      month: "short",
+      day: "numeric",
+      hour: "numeric",
+      minute: "2-digit"
+    });
+  } catch {
+    return at.toISOString();
+  }
+}
+function formatClaudeUsageFetchedAt(fetchedAt, now = /* @__PURE__ */ new Date()) {
+  const at = new Date(fetchedAt);
+  if (Number.isNaN(at.getTime())) return "";
+  const minutes = Math.max(0, Math.round((now.getTime() - at.getTime()) / 6e4));
+  if (minutes < 1) return "Updated just now";
+  if (minutes < 60) return `Updated ${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 36) return `Updated ${hours}h ago`;
+  return `Updated ${formatClaudeUsageResetClock(fetchedAt)}`;
+}
+function formatClaudeExtraUsageDetail(extra) {
+  if (!extra.enabled) return "Extra usage off";
+  const bits = ["Extra usage on"];
+  if (extra.usedCredits != null && extra.monthlyLimit != null) {
+    bits.push(`${extra.usedCredits} / ${extra.monthlyLimit} credits this month`);
+  } else if (extra.usedCredits != null) {
+    bits.push(`${extra.usedCredits} credits used`);
+  }
+  if (extra.usedPercent != null) {
+    bits.push(`${Math.round(extra.usedPercent)}% of extra pool`);
+  }
+  return bits.join(" \xB7 ");
+}
+function formatClaudeUsageWindowLine(window, now = /* @__PURE__ */ new Date()) {
+  const reset = formatClaudeUsageReset(window.resetsAt, now);
+  const clock = formatClaudeUsageResetClock(window.resetsAt);
+  const left = `${Math.round(window.remainingPercent)}% left`;
+  const used = `${Math.round(window.usedPercent)}% used`;
+  const resetBit = reset ? clock && !reset.includes(clock) ? `${reset} (${clock})` : reset : "";
+  return resetBit ? `${window.label} \u2014 ${window.detail}. ${left} \xB7 ${used} \xB7 ${resetBit}` : `${window.label} \u2014 ${window.detail}. ${left} \xB7 ${used}`;
+}
+function formatClaudeUsageTooltip(usage, now = /* @__PURE__ */ new Date()) {
+  const lines = [
+    "Claude Code plan",
+    ...usage.windows.map((w) => formatClaudeUsageWindowLine(w, now))
+  ];
+  if (usage.extraUsage) {
+    lines.push(formatClaudeExtraUsageDetail(usage.extraUsage));
+  }
+  const fetched = formatClaudeUsageFetchedAt(usage.fetchedAt, now);
+  if (fetched) lines.push(fetched);
+  return lines.join("\n");
+}
+function formatClaudeUsageCompact(window) {
+  return `${window.shortLabel} ${Math.round(window.remainingPercent)}%`;
+}
+function claudeUsageWindowOverLimit(window) {
+  return window.remainingPercent <= 0 || window.usedPercent >= 100;
+}
+function claudeUsageOverLimitWindows(usage) {
+  if (!usage) return [];
+  return usage.windows.filter(claudeUsageWindowOverLimit);
+}
+function formatClaudeUsageOverLimitConfirm(windows, now = /* @__PURE__ */ new Date()) {
+  if (windows.length === 0) return "";
+  const parts = windows.map((w) => {
+    const reset = formatClaudeUsageReset(w.resetsAt, now);
+    return reset ? `${w.label} (${reset})` : w.label;
+  });
+  const list = parts.join(", ");
+  const verb = windows.length === 1 ? "is" : "are";
+  return `Claude Code ${list} ${verb} at or over the plan limit. Send this message anyway?`;
+}
+var WINDOW_META, WINDOW_ORDER;
+var init_claude_usage = __esm({
+  "src/agents/claude-usage.ts"() {
+    "use strict";
+    WINDOW_META = {
+      five_hour: {
+        label: "5-hour session",
+        shortLabel: "5h",
+        detail: "Rolling 5-hour limit across all models"
+      },
+      seven_day: {
+        label: "Weekly",
+        shortLabel: "wk",
+        detail: "7-day cap across all models"
+      },
+      seven_day_opus: {
+        label: "Opus",
+        shortLabel: "Opus",
+        detail: "Weekly Opus-only cap"
+      },
+      seven_day_sonnet: {
+        label: "Sonnet",
+        shortLabel: "Sonnet",
+        detail: "Weekly Sonnet-only cap"
+      }
+    };
+    WINDOW_ORDER = [
+      "five_hour",
+      "seven_day",
+      "seven_day_opus",
+      "seven_day_sonnet"
+    ];
+  }
+});
+
+// src/agents/claude-usage-client.ts
+function accessTokenFromCredentialsJson(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("sk-ant-")) {
+    const token = trimmed.split(/\s+/)[0];
+    return token || null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    const oauth = parsed.claudeAiOauth && typeof parsed.claudeAiOauth === "object" ? parsed.claudeAiOauth : parsed;
+    const token = oauth.accessToken ?? oauth.access_token;
+    return typeof token === "string" && token.trim() ? token.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function claudeCredentialsPath() {
+  const root = process.env.CLAUDE_CONFIG_DIR?.trim() || (0, import_node_path37.join)((0, import_node_os13.homedir)(), ".claude");
+  return (0, import_node_path37.join)(root, ".credentials.json");
+}
+async function readFileAccessToken() {
+  const path2 = claudeCredentialsPath();
+  if (!(0, import_node_fs37.existsSync)(path2)) return null;
+  try {
+    return accessTokenFromCredentialsJson((0, import_node_fs37.readFileSync)(path2, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function readKeychainAccessToken() {
+  if (process.platform !== "darwin") return null;
+  for (const service of KEYCHAIN_SERVICES) {
+    const result = await run("security", ["find-generic-password", "-s", service, "-w"], {
+      reject: false,
+      timeoutMs: 4e3
+    });
+    if (result.exitCode !== 0 || !result.stdout.trim()) continue;
+    const token = accessTokenFromCredentialsJson(result.stdout);
+    if (token) return token;
+  }
+  return null;
+}
+async function readClaudeAccessToken() {
+  const envToken = process.env.CLAUDE_CODE_OAUTH_TOKEN?.trim();
+  if (envToken) return envToken;
+  const fromFile = await readFileAccessToken();
+  if (fromFile) return fromFile;
+  return readKeychainAccessToken();
+}
+async function resolveClaudeUserAgent() {
+  if (claudeVersion) return `claude-code/${claudeVersion}`;
+  try {
+    const claude = resolveClaudeExecutable();
+    const result = await run(claude, ["--version"], { reject: false, timeoutMs: 4e3 });
+    const match = `${result.stdout}
+${result.stderr}`.match(/(\d+\.\d+\.\d+)/);
+    claudeVersion = match?.[1] ?? "2.1.80";
+  } catch {
+    claudeVersion = "2.1.80";
+  }
+  return `claude-code/${claudeVersion}`;
+}
+function staleOk(now) {
+  if (!lastGood) return null;
+  if (now - lastGood.at > CLAUDE_USAGE_STALE_OK_MS) return null;
+  return lastGood.value;
+}
+async function getClaudePlanUsage(opts = {}) {
+  const now = opts.now ?? Date.now();
+  if (!opts.force) {
+    if (cache && now - cache.at < CLAUDE_USAGE_TTL_MS) return cache.value;
+    if (now < errorUntil) return staleOk(now);
+  }
+  if (inflight) return inflight;
+  inflight = (async () => {
+    try {
+      const token = await (opts.readAccessToken ?? readClaudeAccessToken)();
+      if (!token) {
+        cache = { at: now, value: null };
+        return null;
+      }
+      const fetchFn = opts.fetch ?? globalThis.fetch;
+      const userAgent = opts.userAgent ?? await resolveClaudeUserAgent();
+      const ac = new AbortController();
+      const timer = setTimeout(() => ac.abort(), 8e3);
+      let res;
+      try {
+        res = await fetchFn(CLAUDE_OAUTH_USAGE_URL, {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "anthropic-beta": "oauth-2025-04-20",
+            "User-Agent": userAgent
+          },
+          signal: ac.signal
+        });
+      } finally {
+        clearTimeout(timer);
+      }
+      if (res.status === 401 || res.status === 403) {
+        cache = { at: now, value: null };
+        return null;
+      }
+      if (!res.ok) {
+        errorUntil = now + CLAUDE_USAGE_ERROR_TTL_MS;
+        return staleOk(now);
+      }
+      const usage = parseClaudeUsagePayload(await res.json(), new Date(now).toISOString());
+      cache = { at: now, value: usage };
+      if (usage) lastGood = { at: now, value: usage };
+      return usage;
+    } catch {
+      errorUntil = now + CLAUDE_USAGE_ERROR_TTL_MS;
+      return staleOk(now);
+    } finally {
+      inflight = null;
+    }
+  })();
+  return inflight;
+}
+var import_node_fs37, import_node_os13, import_node_path37, CLAUDE_OAUTH_USAGE_URL, CLAUDE_USAGE_TTL_MS, CLAUDE_USAGE_ERROR_TTL_MS, CLAUDE_USAGE_STALE_OK_MS, KEYCHAIN_SERVICES, cache, errorUntil, inflight, lastGood, claudeVersion;
+var init_claude_usage_client = __esm({
+  "src/agents/claude-usage-client.ts"() {
+    "use strict";
+    import_node_fs37 = require("fs");
+    import_node_os13 = require("os");
+    import_node_path37 = require("path");
+    init_run();
+    init_app_settings();
+    init_claude_usage();
+    CLAUDE_OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
+    CLAUDE_USAGE_TTL_MS = 9e4;
+    CLAUDE_USAGE_ERROR_TTL_MS = 5 * 6e4;
+    CLAUDE_USAGE_STALE_OK_MS = 30 * 6e4;
+    KEYCHAIN_SERVICES = ["Claude Code-credentials", "Claude Code"];
+    cache = null;
+    errorUntil = 0;
+    inflight = null;
+    lastGood = null;
+    claudeVersion = null;
+  }
+});
+
 // src/agents/install.ts
 function getAgentSetupInfo(agent) {
   return SETUP[agent];
@@ -13922,6 +14287,7 @@ __export(agents_exports, {
   assertOrchestratorCapableAgent: () => assertOrchestratorCapableAgent,
   brightsyAdapter: () => brightsyAdapter,
   claudeAdapter: () => claudeAdapter,
+  claudeUsageOverLimitWindows: () => claudeUsageOverLimitWindows,
   codexAdapter: () => codexAdapter,
   coerceOrchestratorAgent: () => coerceOrchestratorAgent,
   conductorBundledBinDir: () => conductorBundledBinDir,
@@ -13931,8 +14297,17 @@ __export(agents_exports, {
   encodeBrightsyTarget: () => encodeBrightsyTarget,
   enrichPathWithNpmGlobalBin: () => enrichPathWithNpmGlobalBin,
   ensureAgentPath: () => ensureAgentPath,
+  formatClaudeExtraUsageDetail: () => formatClaudeExtraUsageDetail,
+  formatClaudeUsageCompact: () => formatClaudeUsageCompact,
+  formatClaudeUsageFetchedAt: () => formatClaudeUsageFetchedAt,
+  formatClaudeUsageOverLimitConfirm: () => formatClaudeUsageOverLimitConfirm,
+  formatClaudeUsageReset: () => formatClaudeUsageReset,
+  formatClaudeUsageResetClock: () => formatClaudeUsageResetClock,
+  formatClaudeUsageTooltip: () => formatClaudeUsageTooltip,
   getAdapter: () => getAdapter,
   getAgentSetupInfo: () => getAgentSetupInfo,
+  getClaudePlanUsage: () => getClaudePlanUsage,
+  hottestClaudeWindow: () => hottestClaudeWindow,
   installAgent: () => installAgent,
   installNpmGlobalPackage: () => installNpmGlobalPackage,
   isConductorBundledCli: () => isConductorBundledCli,
@@ -13950,6 +14325,7 @@ __export(agents_exports, {
   mcpStatusThinkingFromClaudeInit: () => mcpStatusThinkingFromClaudeInit,
   openInSystemTerminal: () => openInSystemTerminal,
   opencodeAdapter: () => opencodeAdapter,
+  parseClaudeUsagePayload: () => parseClaudeUsagePayload,
   parseCursorRunnerLine: () => parseCursorRunnerLine,
   parseSessionQuotaResetAt: () => parseSessionQuotaResetAt,
   permissionMode: () => permissionMode,
@@ -13990,6 +14366,8 @@ var init_agents = __esm({
     init_opencode();
     init_list_models();
     init_session_quota();
+    init_claude_usage();
+    init_claude_usage_client();
     init_orchestrator_capable();
     init_path();
     init_install();
@@ -14005,15 +14383,15 @@ var init_agents = __esm({
 
 // src/hook/worktree-pkg-cache.ts
 function worktreePkgCacheRoot(worktreePath) {
-  return (0, import_node_path37.join)(worktreePath, WORKTREE_PKG_CACHE_REL);
+  return (0, import_node_path38.join)(worktreePath, WORKTREE_PKG_CACHE_REL);
 }
 function worktreePkgCacheEnv(worktreePath) {
   const root = worktreePkgCacheRoot(worktreePath);
-  const store = (0, import_node_path37.join)(root, "pnpm-store");
-  const pnpmCache = (0, import_node_path37.join)(root, "pnpm");
-  const npmCache = (0, import_node_path37.join)(root, "npm");
-  const nodeGyp = (0, import_node_path37.join)(root, "node-gyp");
-  const electron = (0, import_node_path37.join)(root, "electron");
+  const store = (0, import_node_path38.join)(root, "pnpm-store");
+  const pnpmCache = (0, import_node_path38.join)(root, "pnpm");
+  const npmCache = (0, import_node_path38.join)(root, "npm");
+  const nodeGyp = (0, import_node_path38.join)(root, "node-gyp");
+  const electron = (0, import_node_path38.join)(root, "electron");
   return {
     npm_config_store_dir: store,
     PNPM_STORE_DIR: store,
@@ -14035,8 +14413,8 @@ function fillGroup(env, keys, values) {
   }
 }
 function ensureWorktreePkgCacheDirs(worktreePath) {
-  if (!(0, import_node_fs37.existsSync)(worktreePath)) return;
-  (0, import_node_fs37.mkdirSync)(worktreePkgCacheRoot(worktreePath), { recursive: true });
+  if (!(0, import_node_fs38.existsSync)(worktreePath)) return;
+  (0, import_node_fs38.mkdirSync)(worktreePkgCacheRoot(worktreePath), { recursive: true });
 }
 function applyWorktreePkgCacheEnv(env, worktreePath) {
   const cwd = worktreePath.trim();
@@ -14049,12 +14427,12 @@ function applyWorktreePkgCacheEnv(env, worktreePath) {
   fillGroup(env, ["electron_config_cache"], next);
   ensureWorktreePkgCacheDirs(cwd);
 }
-var import_node_fs37, import_node_path37, WORKTREE_PKG_CACHE_REL;
+var import_node_fs38, import_node_path38, WORKTREE_PKG_CACHE_REL;
 var init_worktree_pkg_cache = __esm({
   "src/hook/worktree-pkg-cache.ts"() {
     "use strict";
-    import_node_fs37 = require("fs");
-    import_node_path37 = require("path");
+    import_node_fs38 = require("fs");
+    import_node_path38 = require("path");
     WORKTREE_PKG_CACHE_REL = ".context/.sideboard/pkg-cache";
   }
 });
@@ -15213,21 +15591,21 @@ function shouldRefreshReviewRequestTemplate(content) {
   return LEGACY_REVIEW_TEMPLATE_MARKERS.every((m) => trimmed.includes(m));
 }
 function readTextIfPresent(abs) {
-  if (!(0, import_node_fs38.existsSync)(abs)) return null;
+  if (!(0, import_node_fs39.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs38.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs39.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readLocalGuidelines(worktreePath) {
-  const localAbs = (0, import_node_path38.join)(worktreePath, REVIEW_REQUEST_PATH);
+  const localAbs = (0, import_node_path39.join)(worktreePath, REVIEW_REQUEST_PATH);
   const localContent = readTextIfPresent(localAbs);
   if (localContent && !shouldRefreshReviewRequestTemplate(localContent)) {
     return { path: REVIEW_REQUEST_PATH, content: localContent };
   }
-  const legacyAbs = (0, import_node_path38.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
+  const legacyAbs = (0, import_node_path39.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH);
   const legacyContent = readTextIfPresent(legacyAbs);
   if (legacyContent && !shouldRefreshReviewRequestTemplate(legacyContent)) {
     return { path: LEGACY_REVIEW_REQUEST_PATH, content: legacyContent };
@@ -15251,27 +15629,27 @@ function contextGuidelines(content, source) {
   };
 }
 function writeContextGuidelines(worktreePath, content) {
-  const abs = (0, import_node_path38.join)(worktreePath, CONTEXT_REVIEW_PATH);
-  (0, import_node_fs38.mkdirSync)((0, import_node_path38.dirname)(abs), { recursive: true });
+  const abs = (0, import_node_path39.join)(worktreePath, CONTEXT_REVIEW_PATH);
+  (0, import_node_fs39.mkdirSync)((0, import_node_path39.dirname)(abs), { recursive: true });
   const body = content.endsWith("\n") ? content : `${content}
 `;
-  (0, import_node_fs38.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs39.writeFileSync)(abs, body, "utf8");
   return body;
 }
 function readSideboardReview(worktreePath, repoPath) {
-  const fromWorktree = readTextIfPresent((0, import_node_path38.join)(worktreePath, REPO_REVIEW_PATH));
+  const fromWorktree = readTextIfPresent((0, import_node_path39.join)(worktreePath, REPO_REVIEW_PATH));
   if (fromWorktree) return fromWorktree;
   const repo = repoPath?.replace(/\/+$/, "");
   const wt = worktreePath.replace(/\/+$/, "");
   if (!repo || repo === wt) return null;
-  return readTextIfPresent((0, import_node_path38.join)(repo, REPO_REVIEW_PATH));
+  return readTextIfPresent((0, import_node_path39.join)(repo, REPO_REVIEW_PATH));
 }
 function ensureReviewGuidelinesFile(worktreePath, repoPath) {
-  const skillContent = readTextIfPresent((0, import_node_path38.join)(worktreePath, REVIEW_SKILL_PATH));
+  const skillContent = readTextIfPresent((0, import_node_path39.join)(worktreePath, REVIEW_SKILL_PATH));
   if (skillContent) {
     return { ...skillGuidelines(skillContent, "skill"), wrote: false };
   }
-  const contextContent = readTextIfPresent((0, import_node_path38.join)(worktreePath, CONTEXT_REVIEW_PATH));
+  const contextContent = readTextIfPresent((0, import_node_path39.join)(worktreePath, CONTEXT_REVIEW_PATH));
   if (contextContent && !shouldRefreshReviewRequestTemplate(contextContent)) {
     return { ...contextGuidelines(contextContent, "local"), wrote: false };
   }
@@ -15309,7 +15687,7 @@ function buildReviewRequestAttachment(content, opts) {
   };
 }
 function readExistingReviewRequestFile(worktreePath) {
-  return readTextIfPresent((0, import_node_path38.join)(worktreePath, REVIEW_SKILL_PATH)) ?? readTextIfPresent((0, import_node_path38.join)(worktreePath, CONTEXT_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path38.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path38.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path38.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
+  return readTextIfPresent((0, import_node_path39.join)(worktreePath, REVIEW_SKILL_PATH)) ?? readTextIfPresent((0, import_node_path39.join)(worktreePath, CONTEXT_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path39.join)(worktreePath, REPO_REVIEW_PATH)) ?? readTextIfPresent((0, import_node_path39.join)(worktreePath, REVIEW_REQUEST_PATH)) ?? readTextIfPresent((0, import_node_path39.join)(worktreePath, LEGACY_REVIEW_REQUEST_PATH));
 }
 async function requestReview(threadRef, send2) {
   const from = findThreadByRef(threadRef);
@@ -15336,13 +15714,13 @@ async function requestReview(threadRef, send2) {
   const started = await send2(tab.id, REVIEW_REQUEST_PREFILL);
   return { tab: started, from };
 }
-var import_node_crypto9, import_node_fs38, import_node_path38, REPO_REVIEW_PATH, REPO_REVIEW_NAME, CONTEXT_REVIEW_PATH, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
+var import_node_crypto9, import_node_fs39, import_node_path39, REPO_REVIEW_PATH, REPO_REVIEW_NAME, CONTEXT_REVIEW_PATH, REVIEW_REQUEST_PATH, LEGACY_REVIEW_REQUEST_PATH, REVIEW_REQUEST_NAME, REVIEW_REQUEST_PREFILL, LEGACY_REVIEW_TEMPLATE_MARKERS;
 var init_request_review = __esm({
   "src/review/request-review.ts"() {
     "use strict";
     import_node_crypto9 = require("crypto");
-    import_node_fs38 = require("fs");
-    import_node_path38 = require("path");
+    import_node_fs39 = require("fs");
+    import_node_path39 = require("path");
     init_global_workspace();
     init_chat_tabs();
     init_thread_store();
@@ -15368,9 +15746,9 @@ function matchSimpleGlob(pattern, name) {
   return new RegExp(`^${escaped}$`).test(name);
 }
 function readWorktreeInclude(repoPath) {
-  const path2 = (0, import_node_path39.join)(repoPath, ".worktreeinclude");
-  if (!(0, import_node_fs39.existsSync)(path2)) return [];
-  return (0, import_node_fs39.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
+  const path2 = (0, import_node_path40.join)(repoPath, ".worktreeinclude");
+  if (!(0, import_node_fs40.existsSync)(path2)) return [];
+  return (0, import_node_fs40.readFileSync)(path2, "utf8").split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
 }
 function resolveFilesToCopy(repoPath) {
   const fromInclude = readWorktreeInclude(repoPath);
@@ -15380,10 +15758,10 @@ function resolveFilesToCopy(repoPath) {
   if (settings?.fileIncludeGlobs?.length) {
     const matched = [];
     try {
-      for (const entry of (0, import_node_fs39.readdirSync)(repoPath, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs40.readdirSync)(repoPath, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         for (const glob of settings.fileIncludeGlobs) {
-          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path39.basename)(glob), entry.name)) {
+          if (matchSimpleGlob(glob, entry.name) || matchSimpleGlob((0, import_node_path40.basename)(glob), entry.name)) {
             matched.push(entry.name);
             break;
           }
@@ -15395,7 +15773,7 @@ function resolveFilesToCopy(repoPath) {
   }
   const defaults = [];
   try {
-    for (const entry of (0, import_node_fs39.readdirSync)(repoPath, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs40.readdirSync)(repoPath, { withFileTypes: true })) {
       if (entry.isFile() && entry.name.startsWith(".env")) {
         defaults.push(entry.name);
       }
@@ -15409,11 +15787,11 @@ function copyConfiguredFiles(repoPath, worktreePath) {
   const patterns = resolveFilesToCopy(repoPath);
   const copied = [];
   for (const rel of patterns) {
-    const src = (0, import_node_path39.join)(repoPath, rel);
-    if (!(0, import_node_fs39.existsSync)(src)) continue;
-    const dest = (0, import_node_path39.join)(worktreePath, rel);
-    (0, import_node_fs39.mkdirSync)((0, import_node_path39.dirname)(dest), { recursive: true });
-    (0, import_node_fs39.copyFileSync)(src, dest);
+    const src = (0, import_node_path40.join)(repoPath, rel);
+    if (!(0, import_node_fs40.existsSync)(src)) continue;
+    const dest = (0, import_node_path40.join)(worktreePath, rel);
+    (0, import_node_fs40.mkdirSync)((0, import_node_path40.dirname)(dest), { recursive: true });
+    (0, import_node_fs40.copyFileSync)(src, dest);
     copied.push(rel);
   }
   return copied;
@@ -15448,7 +15826,7 @@ function buildWorkspaceScriptEnv(opts, baseEnv) {
   const env = stripNestedElectronEnv({
     ...baseEnv ?? process.env
   });
-  const name = opts.workspaceName ?? (0, import_node_path39.basename)(opts.worktreePath);
+  const name = opts.workspaceName ?? (0, import_node_path40.basename)(opts.worktreePath);
   const ports = opts.ports ?? [];
   const primary = ports[0];
   env.SIDEBOARD_WORKSPACE_NAME = name;
@@ -15711,13 +16089,13 @@ async function startDevServer(repoPath, worktreePath, onLine, opts) {
     done: handle.done
   };
 }
-var import_node_fs39, import_node_net, import_node_path39, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
+var import_node_fs40, import_node_net, import_node_path40, import_execa4, import_node_readline3, PORT_RANGE_SIZE, cachedLoginEnv;
 var init_conductor = __esm({
   "src/hook/conductor.ts"() {
     "use strict";
-    import_node_fs39 = require("fs");
+    import_node_fs40 = require("fs");
     import_node_net = require("net");
-    import_node_path39 = require("path");
+    import_node_path40 = require("path");
     import_execa4 = require("execa");
     import_node_readline3 = require("readline");
     init_settings();
@@ -15745,9 +16123,9 @@ async function findOrphanWorktrees(repoPaths) {
     repoPaths?.length ? repoPaths : threads.map((t) => t.repoPath).filter(Boolean)
   );
   const homeRoot = sideboardWorkspacesDir();
-  if ((0, import_node_fs40.existsSync)(homeRoot)) {
+  if ((0, import_node_fs41.existsSync)(homeRoot)) {
     try {
-      for (const entry of (0, import_node_fs40.readdirSync)(homeRoot, { withFileTypes: true })) {
+      for (const entry of (0, import_node_fs41.readdirSync)(homeRoot, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         void entry;
       }
@@ -15757,7 +16135,7 @@ async function findOrphanWorktrees(repoPaths) {
   const orphans = [];
   const seen = /* @__PURE__ */ new Set();
   for (const repoPath of repos) {
-    if (!repoPath || !(0, import_node_fs40.existsSync)(repoPath)) continue;
+    if (!repoPath || !(0, import_node_fs41.existsSync)(repoPath)) continue;
     try {
       const wts = await listWorktrees(repoPath);
       for (const wt of wts) {
@@ -15768,7 +16146,7 @@ async function findOrphanWorktrees(repoPaths) {
         seen.add(path2);
         let mtimeMs = 0;
         try {
-          mtimeMs = (0, import_node_fs40.statSync)(path2).mtimeMs;
+          mtimeMs = (0, import_node_fs41.statSync)(path2).mtimeMs;
         } catch {
           mtimeMs = 0;
         }
@@ -15778,16 +16156,16 @@ async function findOrphanWorktrees(repoPaths) {
     }
     try {
       const root = worktreesRoot(repoPath);
-      if ((0, import_node_fs40.existsSync)(root)) {
-        for (const entry of (0, import_node_fs40.readdirSync)(root, { withFileTypes: true })) {
+      if ((0, import_node_fs41.existsSync)(root)) {
+        for (const entry of (0, import_node_fs41.readdirSync)(root, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const path2 = (0, import_node_path40.join)(root, entry.name).replace(/\/$/, "");
+          const path2 = (0, import_node_path41.join)(root, entry.name).replace(/\/$/, "");
           if (known.has(path2) || seen.has(path2)) continue;
-          if (!(0, import_node_fs40.existsSync)((0, import_node_path40.join)(path2, ".git"))) continue;
+          if (!(0, import_node_fs41.existsSync)((0, import_node_path41.join)(path2, ".git"))) continue;
           seen.add(path2);
           let mtimeMs = 0;
           try {
-            mtimeMs = (0, import_node_fs40.statSync)(path2).mtimeMs;
+            mtimeMs = (0, import_node_fs41.statSync)(path2).mtimeMs;
           } catch {
             mtimeMs = Date.now();
           }
@@ -15848,12 +16226,12 @@ function worktreeCleanupSettings() {
     autoCleanupOrphans: a.autoCleanupOrphans
   };
 }
-var import_node_fs40, import_node_path40;
+var import_node_fs41, import_node_path41;
 var init_orphan_cleanup = __esm({
   "src/git/orphan-cleanup.ts"() {
     "use strict";
-    import_node_fs40 = require("fs");
-    import_node_path40 = require("path");
+    import_node_fs41 = require("fs");
+    import_node_path41 = require("path");
     init_worktree();
     init_thread_store();
     init_paths();
@@ -15956,12 +16334,12 @@ async function cloneRepoIntoSideboard(opts) {
   if (!url) throw new Error("Clone URL is required");
   let name = opts.name?.trim();
   if (!name) {
-    const leaf = (0, import_node_path41.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
+    const leaf = (0, import_node_path42.basename)(url.replace(/\/$/, "").replace(/\.git$/, ""));
     name = leaf || "repo";
   }
   name = name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "repo";
-  const dest = (0, import_node_path41.join)(sideboardReposDir(), name);
-  if ((0, import_node_fs41.existsSync)(dest)) {
+  const dest = (0, import_node_path42.join)(sideboardReposDir(), name);
+  if ((0, import_node_fs42.existsSync)(dest)) {
     const repoPath2 = await resolveRepoRoot(dest);
     const workspace2 = await ensureWorkspace(repoPath2);
     return { repoPath: repoPath2, workspace: workspace2 };
@@ -15976,12 +16354,12 @@ async function cloneRepoIntoSideboard(opts) {
   const workspace = await ensureWorkspace(repoPath);
   return { repoPath, workspace };
 }
-var import_node_fs41, import_node_path41, import_execa6;
+var import_node_fs42, import_node_path42, import_execa6;
 var init_clone_repo = __esm({
   "src/git/clone-repo.ts"() {
     "use strict";
-    import_node_fs41 = require("fs");
-    import_node_path41 = require("path");
+    import_node_fs42 = require("fs");
+    import_node_path42 = require("path");
     import_execa6 = require("execa");
     init_paths();
     init_workspaces();
@@ -16099,24 +16477,24 @@ function jobTreeAlive(pid) {
   return jobAlive(pid) || processGroupAlive(pid);
 }
 function readIntFile(file) {
-  if (!(0, import_node_fs42.existsSync)(file)) return null;
-  const n = Number.parseInt((0, import_node_fs42.readFileSync)(file, "utf8").trim(), 10);
+  if (!(0, import_node_fs43.existsSync)(file)) return null;
+  const n = Number.parseInt((0, import_node_fs43.readFileSync)(file, "utf8").trim(), 10);
   return Number.isInteger(n) ? n : null;
 }
 function jobDir(root, id, legacy = false) {
-  return (0, import_node_path42.join)(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
+  return (0, import_node_path43.join)(root, legacy ? LEGACY_DETACHED_JOBS_DIR : DETACHED_JOBS_DIR, id);
 }
 function resolveJobDir(root, id) {
   const modern = jobDir(root, id, false);
-  if ((0, import_node_fs42.existsSync)(modern)) return modern;
+  if ((0, import_node_fs43.existsSync)(modern)) return modern;
   const legacy = jobDir(root, id, true);
-  if ((0, import_node_fs42.existsSync)(legacy)) return legacy;
+  if ((0, import_node_fs43.existsSync)(legacy)) return legacy;
   return modern;
 }
 function listJobIdsIn(root, rel) {
-  const dir = (0, import_node_path42.join)(root, rel);
-  if (!(0, import_node_fs42.existsSync)(dir)) return [];
-  return (0, import_node_fs42.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
+  const dir = (0, import_node_path43.join)(root, rel);
+  if (!(0, import_node_fs43.existsSync)(dir)) return [];
+  return (0, import_node_fs43.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && JOB_ID_RE.test(e.name)).map((e) => e.name);
 }
 function listRunningDetachedJobs(worktreePath) {
   const root = worktreePath.trim();
@@ -16128,7 +16506,7 @@ function listRunningDetachedJobs(worktreePath) {
   const running = [];
   for (const id of ids) {
     const dir = resolveJobDir(root, id);
-    const pid = readIntFile((0, import_node_path42.join)(dir, "pid"));
+    const pid = readIntFile((0, import_node_path43.join)(dir, "pid"));
     if (jobTreeAlive(pid)) running.push(id);
   }
   return running.sort();
@@ -16210,8 +16588,8 @@ function planJobContinue(opts) {
   return { action: "none" };
 }
 function tailProgress(logFile, maxLines = 12) {
-  if (!(0, import_node_fs42.existsSync)(logFile)) return "(no log yet)";
-  const lines = (0, import_node_fs42.readFileSync)(logFile, "utf8").split("\n");
+  if (!(0, import_node_fs43.existsSync)(logFile)) return "(no log yet)";
+  const lines = (0, import_node_fs43.readFileSync)(logFile, "utf8").split("\n");
   return lines.slice(-maxLines).join("\n");
 }
 function lastProgressLine(progress) {
@@ -16219,8 +16597,8 @@ function lastProgressLine(progress) {
   return last ? last.slice(0, 72) : void 0;
 }
 function readLogLines(file) {
-  if (!(0, import_node_fs42.existsSync)(file)) return [];
-  const lines = (0, import_node_fs42.readFileSync)(file, "utf8").split("\n");
+  if (!(0, import_node_fs43.existsSync)(file)) return [];
+  const lines = (0, import_node_fs43.readFileSync)(file, "utf8").split("\n");
   if (lines.length && lines[lines.length - 1] === "") lines.pop();
   return lines;
 }
@@ -16231,15 +16609,15 @@ function takeDelta(logFile, cursorFile) {
   return { delta: capJobLogDelta(lines.slice(start).join("\n")), nextCursor: lines.length };
 }
 function snapshotJob(dir) {
-  const pid = readIntFile((0, import_node_path42.join)(dir, "pid"));
+  const pid = readIntFile((0, import_node_path43.join)(dir, "pid"));
   const running = jobTreeAlive(pid);
   return {
     pid,
     running,
-    exitCode: readIntFile((0, import_node_path42.join)(dir, "exit")),
-    log: (0, import_node_path42.join)(dir, "log"),
-    cursor: (0, import_node_path42.join)(dir, "present.cursor"),
-    progress: tailProgress((0, import_node_path42.join)(dir, "log"))
+    exitCode: readIntFile((0, import_node_path43.join)(dir, "exit")),
+    log: (0, import_node_path43.join)(dir, "log"),
+    cursor: (0, import_node_path43.join)(dir, "present.cursor"),
+    progress: tailProgress((0, import_node_path43.join)(dir, "log"))
   };
 }
 function toResult(id, snap, extra) {
@@ -16248,8 +16626,8 @@ function toResult(id, snap, extra) {
   const stillRunning = snap.running && !ok;
   const { delta, nextCursor } = takeDelta(snap.log, snap.cursor);
   try {
-    (0, import_node_fs42.mkdirSync)((0, import_node_path42.dirname)(snap.cursor), { recursive: true });
-    (0, import_node_fs42.writeFileSync)(snap.cursor, `${nextCursor}
+    (0, import_node_fs43.mkdirSync)((0, import_node_path43.dirname)(snap.cursor), { recursive: true });
+    (0, import_node_fs43.writeFileSync)(snap.cursor, `${nextCursor}
 `);
   } catch {
   }
@@ -16278,7 +16656,7 @@ async function waitForDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const timeoutMs = mcpWaitForJobTimeoutMs(opts?.timeoutMs);
   const sleep2 = opts?.sleep ?? sleepMs;
-  if (!(0, import_node_fs42.existsSync)(dir)) {
+  if (!(0, import_node_fs43.existsSync)(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -16324,10 +16702,10 @@ function killProcessTree(pid, signal) {
 }
 function appendJobLog(logFile, line) {
   try {
-    (0, import_node_fs42.mkdirSync)((0, import_node_path42.dirname)(logFile), { recursive: true });
+    (0, import_node_fs43.mkdirSync)((0, import_node_path43.dirname)(logFile), { recursive: true });
     const body = line.endsWith("\n") ? line : `${line}
 `;
-    (0, import_node_fs42.appendFileSync)(logFile, body);
+    (0, import_node_fs43.appendFileSync)(logFile, body);
   } catch {
   }
 }
@@ -16337,7 +16715,7 @@ async function stopDetachedJob(cwd, id, opts) {
   const dir = resolveJobDir(root, jobId);
   const sleep2 = opts?.sleep ?? sleepMs;
   const why = opts?.reason?.trim() ?? "";
-  if (!(0, import_node_fs42.existsSync)(dir)) {
+  if (!(0, import_node_fs43.existsSync)(dir)) {
     return {
       stillRunning: false,
       ok: false,
@@ -16373,10 +16751,10 @@ async function stopDetachedJob(cwd, id, opts) {
     killProcessTree(targetPid, "SIGKILL");
     await sleep2(100);
   }
-  const exitFile = (0, import_node_path42.join)(dir, "exit");
-  if (!(0, import_node_fs42.existsSync)(exitFile)) {
+  const exitFile = (0, import_node_path43.join)(dir, "exit");
+  if (!(0, import_node_fs43.existsSync)(exitFile)) {
     try {
-      (0, import_node_fs42.writeFileSync)(exitFile, "1\n");
+      (0, import_node_fs43.writeFileSync)(exitFile, "1\n");
     } catch {
     }
   }
@@ -16396,12 +16774,12 @@ async function stopDetachedJob(cwd, id, opts) {
     hint: stopped ? MCP_STOP_JOB_HINT : MCP_WAIT_JOB_STILL_RUNNING_HINT
   };
 }
-var import_node_fs42, import_node_path42, MAX_JOB_CONTINUES, MAX_JOB_DELTA_LINES, MAX_JOB_DELTA_CHARS, DEFERRED_DONE_MAX_CHARS, GH_WATCH_REFRESH, MCP_WAIT_JOB_STILL_RUNNING_HINT, MCP_STOP_JOB_HINT, JOB_ID_RE;
+var import_node_fs43, import_node_path43, MAX_JOB_CONTINUES, MAX_JOB_DELTA_LINES, MAX_JOB_DELTA_CHARS, DEFERRED_DONE_MAX_CHARS, GH_WATCH_REFRESH, MCP_WAIT_JOB_STILL_RUNNING_HINT, MCP_STOP_JOB_HINT, JOB_ID_RE;
 var init_wait_for_job = __esm({
   "src/mcp/wait-for-job.ts"() {
     "use strict";
-    import_node_fs42 = require("fs");
-    import_node_path42 = require("path");
+    import_node_fs43 = require("fs");
+    import_node_path43 = require("path");
     init_workspace_scratch();
     init_wait_for_turn();
     MAX_JOB_CONTINUES = 8;
@@ -17689,7 +18067,7 @@ function reuseLiveThread(input, repoPath, match) {
 }
 async function createThread(input, _onSetupLine) {
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs43.existsSync)(repoPath)) {
+  if (!(0, import_node_fs44.existsSync)(repoPath)) {
     throw new Error(`Repo not found: ${repoPath}`);
   }
   const reused = reuseLiveThread(input, repoPath, {
@@ -17874,11 +18252,11 @@ async function listLinearIssues(agent, repoPath) {
   }
   return adapter.listLinearIssues(repoPath);
 }
-var import_node_fs43;
+var import_node_fs44;
 var init_create = __esm({
   "src/threads/create.ts"() {
     "use strict";
-    import_node_fs43 = require("fs");
+    import_node_fs44 = require("fs");
     init_detect();
     init_worktree();
     init_home_board();
@@ -17998,20 +18376,20 @@ function writeTurnLive(threadId, progress) {
   const path2 = threadLivePath(threadId);
   const tmp = `${path2}.${process.pid}.tmp`;
   try {
-    (0, import_node_fs44.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
-    (0, import_node_fs44.renameSync)(tmp, path2);
+    (0, import_node_fs45.writeFileSync)(tmp, JSON.stringify(progress), "utf8");
+    (0, import_node_fs45.renameSync)(tmp, path2);
   } catch {
     try {
-      (0, import_node_fs44.unlinkSync)(tmp);
+      (0, import_node_fs45.unlinkSync)(tmp);
     } catch {
     }
   }
 }
 function readTurnLive(threadId) {
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs44.existsSync)(path2)) return null;
+  if (!(0, import_node_fs45.existsSync)(path2)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs44.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs45.readFileSync)(path2, "utf8"));
     if (!raw || typeof raw.summary !== "string") return null;
     return raw;
   } catch {
@@ -18023,17 +18401,17 @@ function clearTurnLive(threadId) {
   if (buf?.timer) clearTimeout(buf.timer);
   buffers.delete(threadId);
   const path2 = threadLivePath(threadId);
-  if (!(0, import_node_fs44.existsSync)(path2)) return;
+  if (!(0, import_node_fs45.existsSync)(path2)) return;
   try {
-    (0, import_node_fs44.unlinkSync)(path2);
+    (0, import_node_fs45.unlinkSync)(path2);
   } catch {
   }
 }
-var import_node_fs44, buffers, FLUSH_MS, MAX_PARTS;
+var import_node_fs45, buffers, FLUSH_MS, MAX_PARTS;
 var init_turn_live = __esm({
   "src/store/turn-live.ts"() {
     "use strict";
-    import_node_fs44 = require("fs");
+    import_node_fs45 = require("fs");
     init_message_parts();
     init_paths();
     buffers = /* @__PURE__ */ new Map();
@@ -18253,7 +18631,7 @@ var init_quota_failover = __esm({
 // src/threads/adopt.ts
 function thisModuleFile() {
   const cjsFile = typeof __filename !== "undefined" ? __filename : "";
-  return cjsFile || process.argv[1] || (0, import_node_path43.join)(process.cwd(), "package.json");
+  return cjsFile || process.argv[1] || (0, import_node_path44.join)(process.cwd(), "package.json");
 }
 function openReadonlySqlite(file) {
   const req = (0, import_node_module4.createRequire)(thisModuleFile());
@@ -18271,21 +18649,21 @@ function mapAgentType(raw) {
   return null;
 }
 function resolveConductorCursorAgentId(workspacePath) {
-  if (!workspacePath || !(0, import_node_fs45.existsSync)(CURSOR_SDK_STORE)) return null;
+  if (!workspacePath || !(0, import_node_fs46.existsSync)(CURSOR_SDK_STORE)) return null;
   const normalized = workspacePath.replace(/\/$/, "");
   let best = null;
   let hashes;
   try {
-    hashes = (0, import_node_fs45.readdirSync)(CURSOR_SDK_STORE);
+    hashes = (0, import_node_fs46.readdirSync)(CURSOR_SDK_STORE);
   } catch {
     return null;
   }
   for (const hash of hashes) {
-    const agentsFile = (0, import_node_path43.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
-    if (!(0, import_node_fs45.existsSync)(agentsFile)) continue;
+    const agentsFile = (0, import_node_path44.join)(CURSOR_SDK_STORE, hash, "agents.ndjson");
+    if (!(0, import_node_fs46.existsSync)(agentsFile)) continue;
     let text7;
     try {
-      text7 = (0, import_node_fs45.readFileSync)(agentsFile, "utf8");
+      text7 = (0, import_node_fs46.readFileSync)(agentsFile, "utf8");
     } catch {
       continue;
     }
@@ -18309,7 +18687,7 @@ function resolveConductorCursorAgentId(workspacePath) {
   return best?.agentId ?? null;
 }
 async function adoptThread(input) {
-  if (!(0, import_node_fs45.existsSync)(input.worktreePath)) {
+  if (!(0, import_node_fs46.existsSync)(input.worktreePath)) {
     throw new Error(`Worktree not found: ${input.worktreePath}`);
   }
   const repoPath = await resolveRepoRoot(input.worktreePath);
@@ -18338,18 +18716,18 @@ function conductorDbPath() {
   return CONDUCTOR_DB;
 }
 function listConductorWorkspaces() {
-  if (!(0, import_node_fs45.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs46.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs45.mkdtempSync)((0, import_node_path43.join)((0, import_node_os13.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path43.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs46.mkdtempSync)((0, import_node_path44.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path44.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs45.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs46.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs45.existsSync)(src)) {
+      if ((0, import_node_fs46.existsSync)(src)) {
         try {
-          (0, import_node_fs45.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs46.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -18425,22 +18803,22 @@ function listConductorWorkspaces() {
       db.close();
     }
   } finally {
-    (0, import_node_fs45.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs46.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 function importConductorWorkspace(workspaceId) {
-  if (!(0, import_node_fs45.existsSync)(CONDUCTOR_DB)) {
+  if (!(0, import_node_fs46.existsSync)(CONDUCTOR_DB)) {
     throw new Error(`Conductor DB not found at ${CONDUCTOR_DB}`);
   }
-  const tmp = (0, import_node_fs45.mkdtempSync)((0, import_node_path43.join)((0, import_node_os13.tmpdir)(), "sideboard-conductor-"));
-  const snapshot = (0, import_node_path43.join)(tmp, "conductor.db");
+  const tmp = (0, import_node_fs46.mkdtempSync)((0, import_node_path44.join)((0, import_node_os14.tmpdir)(), "sideboard-conductor-"));
+  const snapshot = (0, import_node_path44.join)(tmp, "conductor.db");
   try {
-    (0, import_node_fs45.copyFileSync)(CONDUCTOR_DB, snapshot);
+    (0, import_node_fs46.copyFileSync)(CONDUCTOR_DB, snapshot);
     for (const suffix of ["-wal", "-shm"]) {
       const src = `${CONDUCTOR_DB}${suffix}`;
-      if ((0, import_node_fs45.existsSync)(src)) {
+      if ((0, import_node_fs46.existsSync)(src)) {
         try {
-          (0, import_node_fs45.copyFileSync)(src, `${snapshot}${suffix}`);
+          (0, import_node_fs46.copyFileSync)(src, `${snapshot}${suffix}`);
         } catch {
         }
       }
@@ -18458,7 +18836,7 @@ function importConductorWorkspace(workspaceId) {
       ).get(workspaceId);
       if (!row) throw new Error(`Conductor workspace not found: ${workspaceId}`);
       const worktreePath = String(row.workspacePath);
-      if (!(0, import_node_fs45.existsSync)(worktreePath)) {
+      if (!(0, import_node_fs46.existsSync)(worktreePath)) {
         throw new Error(`Conductor worktree missing on disk: ${worktreePath}`);
       }
       let sessionId = null;
@@ -18521,31 +18899,31 @@ function importConductorWorkspace(workspaceId) {
       db.close();
     }
   } finally {
-    (0, import_node_fs45.rmSync)(tmp, { recursive: true, force: true });
+    (0, import_node_fs46.rmSync)(tmp, { recursive: true, force: true });
   }
 }
 async function importConductorWorkspaceAsync(workspaceId) {
   return importConductorWorkspace(workspaceId);
 }
-var import_node_child_process5, import_node_fs45, import_node_os13, import_node_path43, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
+var import_node_child_process5, import_node_fs46, import_node_os14, import_node_path44, import_node_module4, CONDUCTOR_APP_SUPPORT, CONDUCTOR_DB, CURSOR_SDK_STORE;
 var init_adopt = __esm({
   "src/threads/adopt.ts"() {
     "use strict";
     import_node_child_process5 = require("child_process");
-    import_node_fs45 = require("fs");
-    import_node_os13 = require("os");
-    import_node_path43 = require("path");
+    import_node_fs46 = require("fs");
+    import_node_os14 = require("os");
+    import_node_path44 = require("path");
     import_node_module4 = require("module");
     init_worktree();
     init_thread_store();
-    CONDUCTOR_APP_SUPPORT = (0, import_node_path43.join)(
+    CONDUCTOR_APP_SUPPORT = (0, import_node_path44.join)(
       process.env.HOME ?? "",
       "Library",
       "Application Support",
       "com.conductor.app"
     );
-    CONDUCTOR_DB = (0, import_node_path43.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
-    CURSOR_SDK_STORE = (0, import_node_path43.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
+    CONDUCTOR_DB = (0, import_node_path44.join)(CONDUCTOR_APP_SUPPORT, "conductor.db");
+    CURSOR_SDK_STORE = (0, import_node_path44.join)(CONDUCTOR_APP_SUPPORT, "cursor-sdk-store");
   }
 });
 
@@ -18612,7 +18990,7 @@ async function openStackLayer(input, _onSetupLine) {
   let createdWorktree = false;
   const trees = await listWorktrees(repoPath);
   const checkedOut = trees.find((w) => w.branch === branchName);
-  if (checkedOut?.path && (0, import_node_fs46.existsSync)(checkedOut.path)) {
+  if (checkedOut?.path && (0, import_node_fs47.existsSync)(checkedOut.path)) {
     if (input.reuseExistingWorktree !== false) {
       worktreePath = checkedOut.path;
     } else {
@@ -18754,7 +19132,7 @@ async function initStackFromThread(input, onSetupLine) {
 async function createPrStack(input, onSetupLine) {
   await requireAgent(input.agent);
   const repoPath = await resolveRepoRoot(input.repoPath);
-  if (!(0, import_node_fs46.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
+  if (!(0, import_node_fs47.existsSync)(repoPath)) throw new Error(`Repo not found: ${repoPath}`);
   if (!input.branches.length) throw new Error("At least one branch name required");
   const status = await detectGhStack(repoPath);
   if (!status.available) throw new Error(status.reason);
@@ -18821,7 +19199,7 @@ async function createPrStack(input, onSetupLine) {
     }
   }
   const claimed = new Set(threads.map((t) => t.worktreePath));
-  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs46.existsSync)(bootstrap.worktreePath)) {
+  if (!claimed.has(bootstrap.worktreePath) && (0, import_node_fs47.existsSync)(bootstrap.worktreePath)) {
     try {
       await removeWorktree(repoPath, bootstrap.worktreePath, {
         deleteBranch: bootstrap.branchName
@@ -18841,11 +19219,11 @@ function stackAgentDefaultsFrom(input) {
     planMode: input.planMode
   };
 }
-var import_node_fs46;
+var import_node_fs47;
 var init_stack_layers = __esm({
   "src/threads/stack-layers.ts"() {
     "use strict";
-    import_node_fs46 = require("fs");
+    import_node_fs47 = require("fs");
     init_detect();
     init_run();
     init_stack();
@@ -18858,7 +19236,7 @@ var init_stack_layers = __esm({
 
 // src/diff/diff.ts
 async function inspectGitWorktree(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs47.existsSync)(worktreePath)) return "missing_worktree";
+  if (!worktreePath || !(0, import_node_fs48.existsSync)(worktreePath)) return "missing_worktree";
   const check = await git(["rev-parse", "--is-inside-work-tree"], worktreePath, {
     reject: false
   });
@@ -18866,7 +19244,7 @@ async function inspectGitWorktree(worktreePath) {
   return "ok";
 }
 async function initializeGitRepository(worktreePath) {
-  if (!worktreePath || !(0, import_node_fs47.existsSync)(worktreePath)) {
+  if (!worktreePath || !(0, import_node_fs48.existsSync)(worktreePath)) {
     throw new Error("Worktree not found");
   }
   const status = await inspectGitWorktree(worktreePath);
@@ -19000,11 +19378,11 @@ new file mode 100644
   };
 }
 async function untrackedPatch(worktreePath, path2, maxHunk) {
-  const abs = (0, import_node_path44.join)(worktreePath, path2);
+  const abs = (0, import_node_path45.join)(worktreePath, path2);
   try {
-    const st = (0, import_node_fs47.statSync)(abs);
+    const st = (0, import_node_fs48.statSync)(abs);
     if (st.isFile() && st.size > maxHunk) {
-      const buf = (0, import_node_fs47.readFileSync)(abs).subarray(0, maxHunk);
+      const buf = (0, import_node_fs48.readFileSync)(abs).subarray(0, maxHunk);
       return syntheticAddPatch(path2, buf.toString("utf8"), maxHunk);
     }
   } catch {
@@ -19493,8 +19871,8 @@ function isImageRelativePath(relativePath) {
 function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? DEFAULT_UPLOAD_MAX_BYTES;
-  const abs = (0, import_node_path44.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs47.statSync)(abs);
+  const abs = (0, import_node_path45.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs48.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
@@ -19503,7 +19881,7 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
       `File too large to upload (${st.size} bytes; max ${maxBytes})`
     );
   }
-  const buf = (0, import_node_fs47.readFileSync)(abs);
+  const buf = (0, import_node_fs48.readFileSync)(abs);
   return {
     path: relativePath,
     contentBase64: buf.toString("base64"),
@@ -19513,12 +19891,12 @@ function readWorktreeFileForUpload(worktreePath, relativePath, opts) {
 function readWorktreeFile(worktreePath, relativePath, opts) {
   assertSafeRelativePath(relativePath);
   const maxBytes = opts?.maxBytes ?? 2e5;
-  const abs = (0, import_node_path44.join)(worktreePath, relativePath);
-  const st = (0, import_node_fs47.statSync)(abs);
+  const abs = (0, import_node_path45.join)(worktreePath, relativePath);
+  const st = (0, import_node_fs48.statSync)(abs);
   if (!st.isFile()) {
     throw new Error(`Not a file: ${relativePath}`);
   }
-  const buf = (0, import_node_fs47.readFileSync)(abs);
+  const buf = (0, import_node_fs48.readFileSync)(abs);
   if (isImageRelativePath(relativePath)) {
     const maxImageBytes = Math.max(maxBytes, 15e6);
     const truncated2 = buf.length > maxImageBytes;
@@ -19561,9 +19939,9 @@ function assertSafeRelativePath(relativePath) {
 }
 function writeWorktreeFile(worktreePath, relativePath, content) {
   assertSafeRelativePath(relativePath);
-  const abs = (0, import_node_path44.join)(worktreePath, relativePath);
-  (0, import_node_fs47.mkdirSync)((0, import_node_path44.dirname)(abs), { recursive: true });
-  (0, import_node_fs47.writeFileSync)(abs, content, "utf8");
+  const abs = (0, import_node_path45.join)(worktreePath, relativePath);
+  (0, import_node_fs48.mkdirSync)((0, import_node_path45.dirname)(abs), { recursive: true });
+  (0, import_node_fs48.writeFileSync)(abs, content, "utf8");
   return { path: relativePath };
 }
 async function getDiffSummary(worktreePath, repoPath, opts) {
@@ -19580,12 +19958,12 @@ async function getDiffSummary(worktreePath, repoPath, opts) {
     truncated: full.files.length > maxFiles
   };
 }
-var import_node_fs47, import_node_path44, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
+var import_node_fs48, import_node_path45, mergeBaseCache, MERGE_BASE_TTL_MS, SHA_RE, IMAGE_EXTENSIONS2, DEFAULT_UPLOAD_MAX_BYTES;
 var init_diff = __esm({
   "src/diff/diff.ts"() {
     "use strict";
-    import_node_fs47 = require("fs");
-    import_node_path44 = require("path");
+    import_node_fs48 = require("fs");
+    import_node_path45 = require("path");
     init_run();
     init_worktree();
     mergeBaseCache = /* @__PURE__ */ new Map();
@@ -19942,7 +20320,7 @@ function parseFrontmatter(content) {
 }
 function readSkill(skillMd, source) {
   try {
-    const content = (0, import_node_fs48.readFileSync)(skillMd, "utf8");
+    const content = (0, import_node_fs49.readFileSync)(skillMd, "utf8");
     const { name: fmName, description } = parseFrontmatter(content);
     const dirName = skillMd.split("/").slice(-2, -1)[0] || "skill";
     const name = fmName || dirName;
@@ -19961,19 +20339,19 @@ function readSkill(skillMd, source) {
   }
 }
 function scanSkillsDir(dir, source, out) {
-  if (!(0, import_node_fs48.existsSync)(dir)) return;
+  if (!(0, import_node_fs49.existsSync)(dir)) return;
   let entries;
   try {
-    entries = (0, import_node_fs48.readdirSync)(dir);
+    entries = (0, import_node_fs49.readdirSync)(dir);
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.startsWith(".")) continue;
-    const skillMd = (0, import_node_path45.join)(dir, entry, "SKILL.md");
-    if (!(0, import_node_fs48.existsSync)(skillMd)) continue;
+    const skillMd = (0, import_node_path46.join)(dir, entry, "SKILL.md");
+    if (!(0, import_node_fs49.existsSync)(skillMd)) continue;
     try {
-      if (!(0, import_node_fs48.statSync)(skillMd).isFile()) continue;
+      if (!(0, import_node_fs49.statSync)(skillMd).isFile()) continue;
     } catch {
       continue;
     }
@@ -19982,24 +20360,24 @@ function scanSkillsDir(dir, source, out) {
   }
 }
 function scanClaudePluginSkills(pluginsRoot, out) {
-  if (!(0, import_node_fs48.existsSync)(pluginsRoot)) return;
+  if (!(0, import_node_fs49.existsSync)(pluginsRoot)) return;
   const walk = (dir, depth, lookingForSkillsDir) => {
     if (depth > 7) return;
     let entries;
     try {
-      entries = (0, import_node_fs48.readdirSync)(dir);
+      entries = (0, import_node_fs49.readdirSync)(dir);
     } catch {
       return;
     }
     if (lookingForSkillsDir && entries.includes("SKILL.md")) {
-      const skill = readSkill((0, import_node_path45.join)(dir, "SKILL.md"), "cli");
+      const skill = readSkill((0, import_node_path46.join)(dir, "SKILL.md"), "cli");
       if (skill) out.push(skill);
     }
     for (const entry of entries) {
       if (entry === "node_modules" || entry === ".git") continue;
-      const full = (0, import_node_path45.join)(dir, entry);
+      const full = (0, import_node_path46.join)(dir, entry);
       try {
-        if (!(0, import_node_fs48.statSync)(full).isDirectory()) continue;
+        if (!(0, import_node_fs49.statSync)(full).isDirectory()) continue;
       } catch {
         continue;
       }
@@ -20014,20 +20392,20 @@ function scanClaudePluginSkills(pluginsRoot, out) {
   walk(pluginsRoot, 0, false);
 }
 function discoverSkills(worktreePath) {
-  const home = (0, import_node_os14.homedir)();
+  const home = (0, import_node_os15.homedir)();
   const collected = [];
   for (const rel of [".claude/skills", ".cursor/skills", ".sideboard/skills", ".brightsy/skills", "skills"]) {
-    scanSkillsDir((0, import_node_path45.join)(worktreePath, rel), "workspace", collected);
+    scanSkillsDir((0, import_node_path46.join)(worktreePath, rel), "workspace", collected);
   }
   for (const abs of [
-    (0, import_node_path45.join)(home, ".claude/skills"),
-    (0, import_node_path45.join)(home, ".cursor/skills"),
-    (0, import_node_path45.join)(home, ".sideboard/skills"),
-    (0, import_node_path45.join)(home, ".brightsy/skills")
+    (0, import_node_path46.join)(home, ".claude/skills"),
+    (0, import_node_path46.join)(home, ".cursor/skills"),
+    (0, import_node_path46.join)(home, ".sideboard/skills"),
+    (0, import_node_path46.join)(home, ".brightsy/skills")
   ]) {
     scanSkillsDir(abs, "user", collected);
   }
-  scanClaudePluginSkills((0, import_node_path45.join)(home, ".claude/plugins"), collected);
+  scanClaudePluginSkills((0, import_node_path46.join)(home, ".claude/plugins"), collected);
   collected.push(...bundledSkills());
   const rank = {
     workspace: 0,
@@ -20053,7 +20431,7 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 \u2026(truncated)` : body;
     }
   }
-  const raw = (0, import_node_fs48.readFileSync)(skillPath, "utf8");
+  const raw = (0, import_node_fs49.readFileSync)(skillPath, "utf8");
   if (raw.startsWith("---")) {
     const end = raw.indexOf("\n---", 3);
     if (end >= 0) {
@@ -20067,13 +20445,13 @@ function readSkillBody(skillPath, maxChars = 12e3) {
 
 \u2026(truncated)` : raw;
 }
-var import_node_fs48, import_node_os14, import_node_path45, BUNDLED_SKILL_PREFIX;
+var import_node_fs49, import_node_os15, import_node_path46, BUNDLED_SKILL_PREFIX;
 var init_discover = __esm({
   "src/skills/discover.ts"() {
     "use strict";
-    import_node_fs48 = require("fs");
-    import_node_os14 = require("os");
-    import_node_path45 = require("path");
+    import_node_fs49 = require("fs");
+    import_node_os15 = require("os");
+    import_node_path46 = require("path");
     init_long_running();
     BUNDLED_SKILL_PREFIX = "bundled:";
   }
@@ -20167,8 +20545,8 @@ var init_expand = __esm({
 // src/skills/detached-job-path.ts
 function detachedJobScriptIn(dir) {
   for (const name of DETACHED_JOB_FILENAMES) {
-    const script = (0, import_node_path46.join)(dir, "scripts", name);
-    if ((0, import_node_fs49.existsSync)(script)) return script;
+    const script = (0, import_node_path47.join)(dir, "scripts", name);
+    if ((0, import_node_fs50.existsSync)(script)) return script;
   }
   return null;
 }
@@ -20180,11 +20558,11 @@ function packagedDetachedJobPath() {
 function resolveDetachedJobScript() {
   const packaged = packagedDetachedJobPath();
   if (packaged) return packaged;
-  let dir = (0, import_node_path46.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
+  let dir = (0, import_node_path47.dirname)((0, import_node_url3.fileURLToPath)(import_meta3.url));
   for (let i = 0; i < 8; i++) {
     const candidate = detachedJobScriptIn(dir);
     if (candidate) return candidate;
-    const parent = (0, import_node_path46.dirname)(dir);
+    const parent = (0, import_node_path47.dirname)(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -20195,12 +20573,12 @@ function formatDetachedJobInvoke(scriptPath) {
   if (resolved) return `node ${JSON.stringify(resolved)}`;
   return "node scripts/detached-job.cjs";
 }
-var import_node_fs49, import_node_path46, import_node_url3, import_meta3, DETACHED_JOB_FILENAMES;
+var import_node_fs50, import_node_path47, import_node_url3, import_meta3, DETACHED_JOB_FILENAMES;
 var init_detached_job_path = __esm({
   "src/skills/detached-job-path.ts"() {
     "use strict";
-    import_node_fs49 = require("fs");
-    import_node_path46 = require("path");
+    import_node_fs50 = require("fs");
+    import_node_path47 = require("path");
     import_node_url3 = require("url");
     init_packaged_runtime();
     import_meta3 = {};
@@ -20382,9 +20760,9 @@ function formatPrGateDirective() {
 }
 function formatProcessGuideDirective(opts) {
   const worktree = opts?.worktreePath?.trim();
-  const hasGraphSkill = !!worktree && (0, import_node_fs50.existsSync)((0, import_node_path47.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
-  const hasReviewSkill = !!worktree && (0, import_node_fs50.existsSync)((0, import_node_path47.join)(worktree, ".claude/skills/review/SKILL.md"));
-  const hasInstallSkill = !!worktree && (0, import_node_fs50.existsSync)((0, import_node_path47.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
+  const hasGraphSkill = !!worktree && (0, import_node_fs51.existsSync)((0, import_node_path48.join)(worktree, ".claude/skills/graph-engineering/SKILL.md"));
+  const hasReviewSkill = !!worktree && (0, import_node_fs51.existsSync)((0, import_node_path48.join)(worktree, ".claude/skills/review/SKILL.md"));
+  const hasInstallSkill = !!worktree && (0, import_node_fs51.existsSync)((0, import_node_path48.join)(worktree, ".claude/skills/worktree-install/SKILL.md"));
   return [
     "Process guides (recurring work only):",
     hasGraphSkill ? "- Migrations, ports, batch fixes, and other fan-out: follow `.claude/skills/graph-engineering/SKILL.md` (`/graph-engineering`). Judge first; state on disk; grow the rulebook; do not patch around it." : null,
@@ -20422,12 +20800,12 @@ function formatArtifactDirective() {
 function formatUiReminder() {
   return "Sideboard UI: markdown table is enough to read data; present_schema if they ask to edit/filter (even after markdown); present_files for the file manager. html fence or present_artifact, not both for the same document. type=log appends (same artifact_id, new lines only). ask_user only for a real multiple-choice (not hellos, \u201Cwhat next?\u201D, or after a review) \u2014 reply in chat. Do not say artifacts/CMS UI are unavailable.";
 }
-var import_node_fs50, import_node_path47, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
+var import_node_fs51, import_node_path48, PR_GOAL_RE, GITHUB_TICKET_REF, KEYED_TICKET_REF;
 var init_instructions = __esm({
   "src/agents/instructions.ts"() {
     "use strict";
-    import_node_fs50 = require("fs");
-    import_node_path47 = require("path");
+    import_node_fs51 = require("fs");
+    import_node_path48 = require("path");
     init_git_auth_mode();
     init_branch_prefix();
     init_worktree_labels();
@@ -20813,40 +21191,40 @@ __export(plan_file_exports, {
   writePlanFile: () => writePlanFile
 });
 function ensureAttachmentsGitignore(worktreePath) {
-  const gitignoreAbs = (0, import_node_path48.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
-  if ((0, import_node_fs51.existsSync)(gitignoreAbs)) return;
-  (0, import_node_fs51.mkdirSync)((0, import_node_path48.dirname)(gitignoreAbs), { recursive: true });
-  (0, import_node_fs51.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
+  const gitignoreAbs = (0, import_node_path49.join)(worktreePath, ATTACHMENTS_DIR, ".gitignore");
+  if ((0, import_node_fs52.existsSync)(gitignoreAbs)) return;
+  (0, import_node_fs52.mkdirSync)((0, import_node_path49.dirname)(gitignoreAbs), { recursive: true });
+  (0, import_node_fs52.writeFileSync)(gitignoreAbs, attachmentsGitignoreBody(), "utf8");
 }
 function planFileAbs(worktreePath) {
-  return (0, import_node_path48.join)(worktreePath, PLAN_FILE_REL);
+  return (0, import_node_path49.join)(worktreePath, PLAN_FILE_REL);
 }
 function readTextIfPresent2(abs) {
-  if (!(0, import_node_fs51.existsSync)(abs)) return null;
+  if (!(0, import_node_fs52.existsSync)(abs)) return null;
   try {
-    const content = (0, import_node_fs51.readFileSync)(abs, "utf8");
+    const content = (0, import_node_fs52.readFileSync)(abs, "utf8");
     return content.trim() ? content : null;
   } catch {
     return null;
   }
 }
 function readPlanFile(worktreePath) {
-  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path48.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path48.join)(worktreePath, LEGACY_PLAN_FILE_REL));
+  return readTextIfPresent2(planFileAbs(worktreePath)) ?? readTextIfPresent2((0, import_node_path49.join)(worktreePath, `${LEGACY_ATTACHMENTS_DIR}/plan.md`)) ?? readTextIfPresent2((0, import_node_path49.join)(worktreePath, LEGACY_PLAN_FILE_REL));
 }
 function writePlanFile(worktreePath, content) {
   ensureAttachmentsGitignore(worktreePath);
   const abs = planFileAbs(worktreePath);
-  (0, import_node_fs51.mkdirSync)((0, import_node_path48.dirname)(abs), { recursive: true });
+  (0, import_node_fs52.mkdirSync)((0, import_node_path49.dirname)(abs), { recursive: true });
   const body = content.trimEnd() + (content.endsWith("\n") ? "" : "\n");
-  (0, import_node_fs51.writeFileSync)(abs, body, "utf8");
+  (0, import_node_fs52.writeFileSync)(abs, body, "utf8");
   return PLAN_FILE_REL;
 }
-var import_node_fs51, import_node_path48;
+var import_node_fs52, import_node_path49;
 var init_plan_file = __esm({
   "src/plan/plan-file.ts"() {
     "use strict";
-    import_node_fs51 = require("fs");
-    import_node_path48 = require("path");
+    import_node_fs52 = require("fs");
+    import_node_path49 = require("path");
     init_workspace_scratch();
     init_plan_present();
     init_plan_present();
@@ -20894,13 +21272,13 @@ var init_sync_branch = __esm({
 
 // src/agents/cursor-store.ts
 function cursorSdkStoreDir(threadId) {
-  const root = (0, import_node_path49.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
+  const root = (0, import_node_path50.join)(appDataDir(), CURSOR_SDK_STORE_DIR);
   const id = sanitizeCursorStoreSegment(threadId);
   if (!id) return root;
-  return (0, import_node_path49.join)(root, "threads", id);
+  return (0, import_node_path50.join)(root, "threads", id);
 }
 function cursorSdkRunsNdjsonPath(threadId) {
-  return (0, import_node_path49.join)(cursorSdkStoreDir(threadId), "runs.ndjson");
+  return (0, import_node_path50.join)(cursorSdkStoreDir(threadId), "runs.ndjson");
 }
 function cursorSdkRunsNdjsonSearchPaths(threadId) {
   const scoped = cursorSdkRunsNdjsonPath(threadId);
@@ -20913,11 +21291,11 @@ function cursorSdkRunsNdjsonSearchPaths(threadId) {
 function sanitizeCursorStoreSegment(threadId) {
   return (threadId ?? "").trim().replace(/[^a-zA-Z0-9._-]/g, "_");
 }
-var import_node_path49, CURSOR_SDK_STORE_DIR;
+var import_node_path50, CURSOR_SDK_STORE_DIR;
 var init_cursor_store = __esm({
   "src/agents/cursor-store.ts"() {
     "use strict";
-    import_node_path49 = require("path");
+    import_node_path50 = require("path");
     init_paths();
     CURSOR_SDK_STORE_DIR = "cursor-sdk-store";
   }
@@ -20939,9 +21317,9 @@ function recoverFinishedCursorRun(opts) {
   return best;
 }
 function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
-  if (!(0, import_node_fs52.existsSync)(runsPath)) return null;
+  if (!(0, import_node_fs53.existsSync)(runsPath)) return null;
   try {
-    const lines = (0, import_node_fs52.readFileSync)(runsPath, "utf8").split("\n");
+    const lines = (0, import_node_fs53.readFileSync)(runsPath, "utf8").split("\n");
     let best = null;
     for (const line of lines) {
       const trimmed = line.trim();
@@ -20967,11 +21345,11 @@ function scanFinishedCursorRuns(runsPath, agentId, startedAfterMs) {
     return null;
   }
 }
-var import_node_fs52;
+var import_node_fs53;
 var init_cursor_recover = __esm({
   "src/agents/cursor-recover.ts"() {
     "use strict";
-    import_node_fs52 = require("fs");
+    import_node_fs53 = require("fs");
     init_cursor_store();
   }
 });
@@ -21118,13 +21496,13 @@ async function startOrchestration(opts) {
   }
   return updated;
 }
-var import_node_events, import_node_fs53, LIVE_TURN_SPAWN_GRACE_MS, STALE_AGENT_PID_WAIT_MS, Orchestrator, singleton;
+var import_node_events, import_node_fs54, LIVE_TURN_SPAWN_GRACE_MS, STALE_AGENT_PID_WAIT_MS, Orchestrator, singleton;
 var init_orchestrator = __esm({
   "src/orchestrator/orchestrator.ts"() {
     "use strict";
     import_node_events = require("events");
     init_outbound_watch();
-    import_node_fs53 = require("fs");
+    import_node_fs54 = require("fs");
     init_error_detail();
     init_run();
     init_stale_lock();
@@ -21298,7 +21676,7 @@ var init_orchestrator = __esm({
             }
             continue;
           }
-          if (!(0, import_node_fs53.existsSync)(thread.worktreePath)) {
+          if (!(0, import_node_fs54.existsSync)(thread.worktreePath)) {
             setStatus(thread.id, "broken", "Worktree missing on disk");
             this.emit({ type: "status_changed", threadId: thread.id, status: "broken" });
             continue;
@@ -23245,7 +23623,7 @@ var init_orchestrator = __esm({
           this.emit({ type: "status_changed", threadId: restored2.id, status: restored2.status });
           return restored2;
         }
-        if (!(0, import_node_fs53.existsSync)(thread.worktreePath)) {
+        if (!(0, import_node_fs54.existsSync)(thread.worktreePath)) {
           if (isCowboyThread(thread) || isPrimaryCheckoutThread(thread)) {
             throw new Error(
               `Cowboy checkout missing: ${thread.worktreePath}. Re-add the project folder, then restore.`
@@ -23618,6 +23996,7 @@ __export(index_exports, {
   classifyWorktreeColumn: () => classifyWorktreeColumn,
   claudeAdapter: () => claudeAdapter,
   claudeChromeEnabled: () => claudeChromeEnabled,
+  claudeUsageOverLimitWindows: () => claudeUsageOverLimitWindows,
   claudeUserSettingsPath: () => claudeUserSettingsPath,
   cleanupOrphanWorktrees: () => cleanupOrphanWorktrees,
   clearBoardPins: () => clearBoardPins,
@@ -23637,6 +24016,7 @@ __export(index_exports, {
   computeNextRunAt: () => computeNextRunAt,
   conductorBundledBinDir: () => conductorBundledBinDir,
   conductorDbPath: () => conductorDbPath,
+  confirmClaudeUsageOverLimitEnabled: () => confirmClaudeUsageOverLimitEnabled,
   confirmLand: () => confirmLand,
   connectBrightsyTeam: () => connectBrightsyTeam,
   connectOptionalService: () => connectOptionalService,
@@ -23736,6 +24116,13 @@ __export(index_exports, {
   formatAccountProfilePlaybookLine: () => formatAccountProfilePlaybookLine,
   formatArtifactDirective: () => formatArtifactDirective,
   formatBrightsyFetchError: () => formatBrightsyFetchError,
+  formatClaudeExtraUsageDetail: () => formatClaudeExtraUsageDetail,
+  formatClaudeUsageCompact: () => formatClaudeUsageCompact,
+  formatClaudeUsageFetchedAt: () => formatClaudeUsageFetchedAt,
+  formatClaudeUsageOverLimitConfirm: () => formatClaudeUsageOverLimitConfirm,
+  formatClaudeUsageReset: () => formatClaudeUsageReset,
+  formatClaudeUsageResetClock: () => formatClaudeUsageResetClock,
+  formatClaudeUsageTooltip: () => formatClaudeUsageTooltip,
   formatDetachedJobInvoke: () => formatDetachedJobInvoke,
   formatFetchError: () => formatFetchError,
   formatGhLandError: () => formatGhLandError,
@@ -23785,6 +24172,7 @@ __export(index_exports, {
   getAgentSetupInfo: () => getAgentSetupInfo,
   getBrightsySession: () => getBrightsySession,
   getCaffeinateHold: () => getCaffeinateHold,
+  getClaudePlanUsage: () => getClaudePlanUsage,
   getDefaultAgent: () => getDefaultAgent,
   getDefaultEffort: () => getDefaultEffort,
   getDefaultFast: () => getDefaultFast,
@@ -23834,6 +24222,7 @@ __export(index_exports, {
   hasRepoHook: () => hasRepoHook,
   hasWorkspaceHook: () => hasWorkspaceHook,
   healOrchestrationSoccerTitles: () => healOrchestrationSoccerTitles,
+  hottestClaudeWindow: () => hottestClaudeWindow,
   httpFetch: () => httpFetch,
   importConductorWorkspace: () => importConductorWorkspace,
   importConductorWorkspaceAsync: () => importConductorWorkspaceAsync,
@@ -23997,6 +24386,7 @@ __export(index_exports, {
   originFetchBranch: () => originFetchBranch,
   originGhRepoEnv: () => originGhRepoEnv,
   packagedDetachedJobPath: () => packagedDetachedJobPath,
+  parseClaudeUsagePayload: () => parseClaudeUsagePayload,
   parseCursorRunnerLine: () => parseCursorRunnerLine,
   parseDurationMs: () => parseDurationMs,
   parseForceStopMessage: () => parseForceStopMessage,
@@ -26579,7 +26969,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod9 = require("zod");
 var import_node_crypto14 = require("crypto");
-var import_node_path52 = require("path");
+var import_node_path53 = require("path");
 init_orchestrator();
 init_worktree();
 init_global_workspace();
@@ -28299,27 +28689,27 @@ init_gh_errors();
 init_git_auth_mode();
 
 // src/board/load-home-board.ts
-var import_node_fs55 = require("fs");
-var import_node_path51 = require("path");
+var import_node_fs56 = require("fs");
+var import_node_path52 = require("path");
 init_worktree();
 init_paths();
 
 // src/board/board-pins.ts
 var import_node_crypto13 = require("crypto");
-var import_node_fs54 = require("fs");
-var import_node_path50 = require("path");
+var import_node_fs55 = require("fs");
+var import_node_path51 = require("path");
 init_paths();
 init_home_board();
 var FILE = "home-board-pins.json";
 var VERSION = 1;
 function pinsFile() {
-  return (0, import_node_path50.join)(appDataDir(), FILE);
+  return (0, import_node_path51.join)(appDataDir(), FILE);
 }
 function readDisk() {
   const path2 = pinsFile();
-  if (!(0, import_node_fs54.existsSync)(path2)) return [];
+  if (!(0, import_node_fs55.existsSync)(path2)) return [];
   try {
-    const raw = JSON.parse((0, import_node_fs54.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs55.readFileSync)(path2, "utf8"));
     if (raw?.version !== VERSION || !Array.isArray(raw.items)) return [];
     return raw.items.filter((item) => item?.id && item.kind && item.ref);
   } catch {
@@ -28327,8 +28717,8 @@ function readDisk() {
   }
 }
 function writeDisk(items) {
-  (0, import_node_fs54.mkdirSync)(appDataDir(), { recursive: true });
-  (0, import_node_fs54.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
+  (0, import_node_fs55.mkdirSync)(appDataDir(), { recursive: true });
+  (0, import_node_fs55.writeFileSync)(pinsFile(), JSON.stringify({ version: VERSION, items }, null, 2), "utf8");
 }
 function listBoardPins() {
   return readDisk();
@@ -28380,7 +28770,7 @@ function replaceBoardPins(items) {
 }
 function clearBoardPins() {
   try {
-    (0, import_node_fs54.unlinkSync)(pinsFile());
+    (0, import_node_fs55.unlinkSync)(pinsFile());
   } catch {
   }
 }
@@ -28389,7 +28779,7 @@ function clearBoardPins() {
 init_home_board();
 var CACHE_VERSION = 1;
 var memory2 = null;
-var inflight = null;
+var inflight2 = null;
 function errText(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -28397,7 +28787,7 @@ function homeBoardWorkspaceKey(workspaces) {
   return workspaces.map((w) => w.path).filter(Boolean).sort().join("\n");
 }
 function cacheFile() {
-  return (0, import_node_path51.join)(appDataDir(), "home-board-cache.json");
+  return (0, import_node_path52.join)(appDataDir(), "home-board-cache.json");
 }
 function emptyInputs() {
   return {
@@ -28423,9 +28813,9 @@ function shouldCacheHomeBoardInputs(inputs) {
 }
 function readDiskCache() {
   const path2 = cacheFile();
-  if (!(0, import_node_fs55.existsSync)(path2)) return null;
+  if (!(0, import_node_fs56.existsSync)(path2)) return null;
   try {
-    const raw = JSON.parse((0, import_node_fs55.readFileSync)(path2, "utf8"));
+    const raw = JSON.parse((0, import_node_fs56.readFileSync)(path2, "utf8"));
     if (raw?.version !== CACHE_VERSION || typeof raw.fetchedAt !== "number") {
       return null;
     }
@@ -28439,20 +28829,20 @@ function readDiskCache() {
 }
 function writeDiskCache(entry) {
   try {
-    (0, import_node_fs55.mkdirSync)(appDataDir(), { recursive: true });
-    (0, import_node_fs55.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
+    (0, import_node_fs56.mkdirSync)(appDataDir(), { recursive: true });
+    (0, import_node_fs56.writeFileSync)(cacheFile(), JSON.stringify(entry), "utf8");
   } catch {
   }
 }
 function deleteDiskCache() {
   try {
-    (0, import_node_fs55.unlinkSync)(cacheFile());
+    (0, import_node_fs56.unlinkSync)(cacheFile());
   } catch {
   }
 }
 function resetHomeBoardMemory() {
   memory2 = null;
-  inflight = null;
+  inflight2 = null;
 }
 function clearHomeBoardCache() {
   resetHomeBoardMemory();
@@ -28551,8 +28941,8 @@ async function getHomeBoardInputs(workspaces, opts) {
       return asLoaded(best, true);
     }
   }
-  if (inflight && inflight.key === key) {
-    return inflight.promise;
+  if (inflight2 && inflight2.key === key) {
+    return inflight2.promise;
   }
   const promise = (async () => {
     const inputs = await loadHomeBoardInputs(workspaces);
@@ -28572,11 +28962,11 @@ async function getHomeBoardInputs(workspaces, opts) {
     }
     return loaded;
   })();
-  inflight = { key, promise };
+  inflight2 = { key, promise };
   try {
     return await promise;
   } finally {
-    if (inflight?.promise === promise) inflight = null;
+    if (inflight2?.promise === promise) inflight2 = null;
   }
 }
 
@@ -28796,7 +29186,7 @@ async function startMcpServer() {
       async () => {
         const threads = orch.getThreads(true);
         const lines = threads.map((t) => {
-          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path52.basename)(t.repoPath) || t.repoPath;
+          const repo = t.repoPath === GLOBAL_WORKSPACE_ID ? "Orchestration" : (0, import_node_path53.basename)(t.repoPath) || t.repoPath;
           const live = orch.threadLooksLive(t) ? readTurnLive(t.id) : null;
           const parent = t.parentThreadId ? `  parent:${t.parentThreadId.slice(0, 8)}` : "";
           const preview = lastMessagePreview(t.messages, 80);
@@ -31763,9 +32153,9 @@ var import_node_http3 = require("http");
 var import_ws3 = require("ws");
 
 // src/slack/relay-static.ts
-var import_node_fs56 = require("fs");
+var import_node_fs57 = require("fs");
 var import_promises = require("fs/promises");
-var import_node_path53 = __toESM(require("path"), 1);
+var import_node_path54 = __toESM(require("path"), 1);
 var TYPES = {
   ".css": "text/css; charset=utf-8",
   ".html": "text/html; charset=utf-8",
@@ -31796,9 +32186,9 @@ function resolveStaticPath(root, requestUrl) {
     return null;
   }
   if (!pathname.startsWith("/") || pathname.includes("\0")) return null;
-  const rootResolved = import_node_path53.default.resolve(root);
-  const candidate = import_node_path53.default.resolve(rootResolved, `.${pathname}`);
-  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path53.default.sep)) {
+  const rootResolved = import_node_path54.default.resolve(root);
+  const candidate = import_node_path54.default.resolve(rootResolved, `.${pathname}`);
+  if (candidate !== rootResolved && !candidate.startsWith(rootResolved + import_node_path54.default.sep)) {
     return null;
   }
   return candidate;
@@ -31812,7 +32202,7 @@ async function fileSize(file) {
   }
 }
 function sendFile(req, res, file, size) {
-  const ext = import_node_path53.default.extname(file).toLowerCase();
+  const ext = import_node_path54.default.extname(file).toLowerCase();
   res.writeHead(200, {
     "Content-Type": TYPES[ext] ?? "application/octet-stream",
     "Content-Length": size,
@@ -31822,7 +32212,7 @@ function sendFile(req, res, file, size) {
     res.end();
     return true;
   }
-  (0, import_node_fs56.createReadStream)(file).pipe(res);
+  (0, import_node_fs57.createReadStream)(file).pipe(res);
   return true;
 }
 async function tryServeStatic(req, res, root) {
@@ -31831,7 +32221,7 @@ async function tryServeStatic(req, res, root) {
   if (!candidate) return false;
   const direct = await fileSize(candidate);
   if (direct != null) return sendFile(req, res, candidate, direct);
-  const asIndex = import_node_path53.default.join(candidate, "index.html");
+  const asIndex = import_node_path54.default.join(candidate, "index.html");
   const indexSize = await fileSize(asIndex);
   if (indexSize != null) return sendFile(req, res, asIndex, indexSize);
   return false;
@@ -32236,6 +32626,7 @@ init_outbound_watch();
   classifyWorktreeColumn,
   claudeAdapter,
   claudeChromeEnabled,
+  claudeUsageOverLimitWindows,
   claudeUserSettingsPath,
   cleanupOrphanWorktrees,
   clearBoardPins,
@@ -32255,6 +32646,7 @@ init_outbound_watch();
   computeNextRunAt,
   conductorBundledBinDir,
   conductorDbPath,
+  confirmClaudeUsageOverLimitEnabled,
   confirmLand,
   connectBrightsyTeam,
   connectOptionalService,
@@ -32354,6 +32746,13 @@ init_outbound_watch();
   formatAccountProfilePlaybookLine,
   formatArtifactDirective,
   formatBrightsyFetchError,
+  formatClaudeExtraUsageDetail,
+  formatClaudeUsageCompact,
+  formatClaudeUsageFetchedAt,
+  formatClaudeUsageOverLimitConfirm,
+  formatClaudeUsageReset,
+  formatClaudeUsageResetClock,
+  formatClaudeUsageTooltip,
   formatDetachedJobInvoke,
   formatFetchError,
   formatGhLandError,
@@ -32403,6 +32802,7 @@ init_outbound_watch();
   getAgentSetupInfo,
   getBrightsySession,
   getCaffeinateHold,
+  getClaudePlanUsage,
   getDefaultAgent,
   getDefaultEffort,
   getDefaultFast,
@@ -32452,6 +32852,7 @@ init_outbound_watch();
   hasRepoHook,
   hasWorkspaceHook,
   healOrchestrationSoccerTitles,
+  hottestClaudeWindow,
   httpFetch,
   importConductorWorkspace,
   importConductorWorkspaceAsync,
@@ -32615,6 +33016,7 @@ init_outbound_watch();
   originFetchBranch,
   originGhRepoEnv,
   packagedDetachedJobPath,
+  parseClaudeUsagePayload,
   parseCursorRunnerLine,
   parseDurationMs,
   parseForceStopMessage,