tokmon 0.28.2 → 0.28.3

package/dist/{chunk-LKYOWBD4.js → chunk-P5JN5DDX.js}

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
 import {
-  isAlive,
-  probeHealth,
   readLock,
-  reclaimDeadLock,
+  retireIncompatibleCliOwner,
   verifyLock
-} from "./chunk-J3JW3RFP.js";
+} from "./chunk-USKOQIE3.js";
+import {
+  daemonChannelFromWire,
+  resolveDaemonChannel
+} from "./chunk-UYPDMVW5.js";
 import {
   TOKMON_PROTOCOL_VERSION
-} from "./chunk-WUK3MQUB.js";
+} from "./chunk-JZSZEHVD.js";
 
 // src/client/daemon-handle.ts
 import { spawn } from "child_process";
 import { extname } from "path";
 var HANDSHAKE_TIMEOUT_MS = process.platform === "win32" ? 15e3 : 1e4;
-var UPGRADE_SHUTDOWN_TIMEOUT_MS = 5e3;
 function runtimeExecArgv(entry, override) {
   if (override) return override;
   const ext = extname(entry).toLowerCase();
@@ -37,7 +38,7 @@ function runtimeExecArgv(entry, override) {
 function parseHandshake(line) {
   try {
     const value = JSON.parse(line);
-    return value?.ready === 1 && typeof value.url === "string" && typeof value.wsToken === "string" && typeof value.version === "string" && typeof value.protocolVersion === "number" && Array.isArray(value.capabilities) && value.capabilities.every((capability) => typeof capability === "string") && (value.ownerKind === "cli" || value.ownerKind === "desktop") ? value : null;
+    return value?.ready === 1 && typeof value.url === "string" && typeof value.wsToken === "string" && typeof value.version === "string" && typeof value.protocolVersion === "number" && Array.isArray(value.capabilities) && value.capabilities.every((capability) => typeof capability === "string") && (value.ownerKind === "cli" || value.ownerKind === "desktop") && daemonChannelFromWire(value.channel) !== null ? { ...value, channel: daemonChannelFromWire(value.channel) } : null;
   } catch {
     return null;
   }
@@ -50,48 +51,26 @@ async function attach(opts, protocolVersion) {
   const lock = await verifyLock(readLock(opts), protocolVersion);
   return lock ? connected(lock.url) : null;
 }
-var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function retireIncompatibleDaemon(opts, protocolVersion, timeoutMs) {
-  const lock = readLock(opts);
-  if (!lock || lock.state !== "ready" || lock.protocolVersion === protocolVersion || lock.ownerKind === "desktop" || lock.pid === process.pid || !isAlive(lock.pid)) return;
-  const authenticated = await probeHealth(
-    lock.url,
-    lock.wsToken,
-    lock,
-    Math.min(1e3, timeoutMs)
-  );
-  if (!authenticated) return;
-  try {
-    process.kill(lock.pid, "SIGTERM");
-  } catch {
-    if (!isAlive(lock.pid)) reclaimDeadLock(opts);
-    return;
-  }
-  const deadline = Date.now() + Math.min(timeoutMs, UPGRADE_SHUTDOWN_TIMEOUT_MS);
-  while (Date.now() < deadline) {
-    const current = readLock(opts);
-    if (!current || current.ownerId !== lock.ownerId) return;
-    if (!isAlive(lock.pid)) {
-      reclaimDeadLock(opts);
-      return;
-    }
-    await delay(50);
-  }
-}
 async function attachOrSpawn(opts = {}) {
   const protocolVersion = TOKMON_PROTOCOL_VERSION;
   const timeoutMs = opts.timeoutMs ?? HANDSHAKE_TIMEOUT_MS;
-  const existing = await attach(opts, protocolVersion);
+  const baseEnv = opts.env ?? process.env;
+  const channel = resolveDaemonChannel(opts.channel, baseEnv);
+  const lockOpts = { cachePath: opts.cachePath, channel };
+  const existing = await attach(lockOpts, protocolVersion);
   if (existing) return existing;
-  await retireIncompatibleDaemon(opts, protocolVersion, timeoutMs);
-  const upgraded = await attach(opts, protocolVersion);
+  await retireIncompatibleCliOwner(lockOpts, protocolVersion, timeoutMs);
+  const upgraded = await attach(lockOpts, protocolVersion);
   if (upgraded) return upgraded;
   const entry = opts.entry ?? process.argv[1];
   if (!entry) return degraded();
   const execPath = opts.execPath ?? process.execPath;
   const args = ["__daemon", "--port", "0", "--no-open"];
-  const baseEnv = opts.env ?? process.env;
-  const env = opts.cachePath ? { ...baseEnv, TOKMON_DAEMON_CACHE_DIR: opts.cachePath } : baseEnv;
+  const env = {
+    ...baseEnv,
+    TOKMON_CHANNEL: channel,
+    ...opts.cachePath ? { TOKMON_DAEMON_CACHE_DIR: opts.cachePath } : {}
+  };
   return new Promise((resolve) => {
     let child;
     try {
@@ -117,7 +96,7 @@ async function attachOrSpawn(opts = {}) {
       resolve(handle);
     };
     const tryAttach = (final = false) => {
-      void attach(opts, protocolVersion).then((found) => {
+      void attach(lockOpts, protocolVersion).then((found) => {
         if (found) {
           finish(found);
           return;
@@ -143,7 +122,7 @@ async function attachOrSpawn(opts = {}) {
         const line = stdout.slice(0, newline).trim();
         stdout = stdout.slice(newline + 1);
         const handshake = parseHandshake(line);
-        if (!handshake || handshake.protocolVersion !== protocolVersion) continue;
+        if (!handshake || handshake.protocolVersion !== protocolVersion || handshake.channel !== channel) continue;
         tryAttach();
         return;
       }

package/dist/chunk-TN6V7XSL.js

@@ -0,0 +1,512 @@
+#!/usr/bin/env node
+import {
+  PROVIDERS,
+  PROVIDER_ORDER,
+  identityFromIdToken,
+  readClaudeIdentity,
+  readJson
+} from "./chunk-CFKUZCMB.js";
+import {
+  containsEmail,
+  expandHome,
+  redactEmail,
+  slugify
+} from "./chunk-HNWEJ6MS.js";
+
+// src/accounts.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { homedir } from "os";
+import { basename, join as join2, resolve } from "path";
+
+// src/providers/codex/identity.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function codexAuthPaths(homeDir) {
+  return [join(homeDir, ".codex", "auth.json"), join(homeDir, "auth.json")];
+}
+function readCodexIdentity(homeDir) {
+  for (const path of codexAuthPaths(homeDir)) {
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8"));
+      const { email, displayName, payload } = identityFromIdToken(parsed?.tokens?.id_token);
+      if (!payload) continue;
+      return { email, displayName };
+    } catch {
+    }
+  }
+  return {};
+}
+
+// src/accounts.ts
+function accountKey(providerId, homeDir) {
+  return `${providerId}:${homeDir ? resolve(expandHome(homeDir)) : homedir()}`;
+}
+function uniqueId(base, used) {
+  let id = slugify(base) || "account";
+  if (!used.has(id)) {
+    used.add(id);
+    return id;
+  }
+  for (let i = 2; i < 1e3; i++) {
+    const next = `${id}_${i}`;
+    if (!used.has(next)) {
+      used.add(next);
+      return next;
+    }
+  }
+  id = `${id}_${Date.now()}`;
+  used.add(id);
+  return id;
+}
+function hasClaudeState(homeDir) {
+  return existsSync(join2(homeDir, ".claude.json")) || existsSync(join2(homeDir, ".claude", ".credentials.json")) || existsSync(join2(homeDir, ".claude", "projects")) || existsSync(join2(homeDir, ".config", "claude", ".credentials.json")) || existsSync(join2(homeDir, ".config", "claude", "projects"));
+}
+function candidateAlternateHomes(prefix) {
+  const home = homedir();
+  let entries;
+  try {
+    entries = readdirSync(home);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const pattern = new RegExp(`^\\.${prefix}[_-]`);
+  for (const name of entries) {
+    if (!pattern.test(name)) continue;
+    const path = join2(home, name);
+    try {
+      if (!statSync(path).isDirectory()) continue;
+      out.push(path);
+    } catch {
+    }
+  }
+  return out.sort();
+}
+function labelForClaudeHome(homeDir) {
+  const identity = readClaudeIdentity(homeDir);
+  if (identity.email) return `Claude ${identity.email}`;
+  if (identity.displayName) return `Claude ${identity.displayName}`;
+  const raw = basename(homeDir).replace(/^\.claude[_-]?/, "").replace(/[_-]+/g, " ").trim();
+  return raw ? `Claude ${raw}` : "Claude";
+}
+function hasCodexAuth(homeDir) {
+  for (const path of codexAuthPaths(homeDir)) {
+    try {
+      const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+      const accessToken = parsed?.tokens?.access_token;
+      if (typeof accessToken === "string" && accessToken.trim()) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function labelForCodexHome(homeDir) {
+  const identity = readCodexIdentity(homeDir);
+  if (identity.email) return `Codex ${identity.email}`;
+  if (identity.displayName) return `Codex ${identity.displayName}`;
+  const raw = basename(homeDir).replace(/^\.codex[_-]?/, "").replace(/[_-]+/g, " ").trim();
+  return raw ? `Codex ${raw}` : "Codex";
+}
+function discoverClaudeAccounts(usedIds) {
+  const provider = PROVIDERS.claude;
+  const out = [];
+  for (const homeDir of candidateAlternateHomes("claude")) {
+    if (!hasClaudeState(homeDir)) continue;
+    const suffix = basename(homeDir).replace(/^\.claude[_-]?/, "") || basename(homeDir);
+    out.push({
+      id: uniqueId(`claude_${suffix}`, usedIds),
+      providerId: "claude",
+      name: labelForClaudeHome(homeDir),
+      color: provider.color,
+      homeDir
+    });
+  }
+  return out;
+}
+function discoverCodexAccounts(usedIds) {
+  const provider = PROVIDERS.codex;
+  const out = [];
+  for (const homeDir of candidateAlternateHomes("codex")) {
+    if (!hasCodexAuth(homeDir)) continue;
+    const suffix = basename(homeDir).replace(/^\.codex[_-]?/, "") || basename(homeDir);
+    out.push({
+      id: uniqueId(`codex_${suffix}`, usedIds),
+      providerId: "codex",
+      name: labelForCodexHome(homeDir),
+      color: provider.color,
+      homeDir
+    });
+  }
+  return out;
+}
+function discoverProviderAccounts(providerId, usedIds) {
+  if (providerId === "claude") return discoverClaudeAccounts(usedIds);
+  if (providerId === "codex") return discoverCodexAccounts(usedIds);
+  return [];
+}
+function buildAccounts(config, detected) {
+  const out = [];
+  const usedIds = new Set(config.accounts.map((a) => a.id));
+  const seenKeys = /* @__PURE__ */ new Set();
+  const excludedKeys = new Set(
+    config.accountDetection.excludedAccounts.map((ref) => accountKey(ref.providerId, ref.homeDir))
+  );
+  const add = (account) => {
+    const key = accountKey(account.providerId, account.homeDir);
+    if (seenKeys.has(key)) return;
+    seenKeys.add(key);
+    out.push(account);
+  };
+  for (const pid of PROVIDER_ORDER) {
+    if (config.disabledProviders.includes(pid)) continue;
+    const provider = PROVIDERS[pid];
+    const configured = config.accounts.filter((a) => a.providerId === pid);
+    for (const a of configured) {
+      add({
+        id: a.id,
+        providerId: pid,
+        name: a.name,
+        color: a.color || provider.color,
+        homeDir: a.homeDir && a.homeDir !== "~" ? expandHome(a.homeDir) : void 0
+      });
+    }
+    if (!config.accountDetection.enabled || config.accountDetection.disabledProviders.includes(pid)) continue;
+    const discovered = discoverProviderAccounts(pid, usedIds);
+    if (detected.includes(pid)) {
+      const account = { id: pid, providerId: pid, name: provider.name, color: provider.color, homeDir: void 0 };
+      if (!excludedKeys.has(accountKey(pid))) add(account);
+    }
+    for (const account of discovered) {
+      if (excludedKeys.has(accountKey(account.providerId, account.homeDir))) continue;
+      add(account);
+    }
+  }
+  return out;
+}
+function accountsByProvider(accounts) {
+  const groups = [];
+  for (const pid of PROVIDER_ORDER) {
+    const list = accounts.filter((a) => a.providerId === pid);
+    if (list.length > 0) groups.push({ provider: pid, accounts: list });
+  }
+  return groups;
+}
+
+// src/shared/colors.ts
+var FALLBACK_HEX = "#8d9090";
+var NAMED_HEX = {
+  green: "#6caa71",
+  greenBright: "#79be7e",
+  cyan: "#7ccbcd",
+  cyanBright: "#84dde0",
+  blue: "#6d96b4",
+  blueBright: "#67b5ed",
+  magenta: "#bd7bcd",
+  magentaBright: "#d389e5",
+  yellow: "#c4ac62",
+  yellowBright: "#d9c074",
+  red: "#b45648",
+  redBright: "#cf6a5a",
+  white: "#dee5eb",
+  whiteBright: "#f3f5f5",
+  gray: FALLBACK_HEX,
+  grey: FALLBACK_HEX
+};
+var PROVIDER_HEX = {
+  claude: NAMED_HEX.green,
+  codex: NAMED_HEX.cyan,
+  cursor: NAMED_HEX.magenta,
+  copilot: NAMED_HEX.white,
+  pi: NAMED_HEX.blue,
+  opencode: NAMED_HEX.yellow,
+  antigravity: NAMED_HEX.red,
+  gemini: NAMED_HEX.greenBright,
+  grok: NAMED_HEX.yellowBright
+};
+function namedHex(name) {
+  if (!name) return FALLBACK_HEX;
+  if (name.startsWith("#")) return name;
+  return NAMED_HEX[name] ?? FALLBACK_HEX;
+}
+function colorHex(accountColor, providerColorName) {
+  if (accountColor) {
+    if (accountColor.startsWith("#")) return accountColor;
+    const named = NAMED_HEX[accountColor];
+    if (named) return named;
+  }
+  return namedHex(providerColorName);
+}
+var MODEL_PALETTE = [
+  "#00d7ff",
+  "#00d787",
+  "#e6b450",
+  "#d75f87",
+  "#5f87ff",
+  "#af87ff",
+  "#5fd7a7",
+  "#ff8787",
+  "#d7af5f",
+  "#87d7ff",
+  "#d787d7",
+  "#9ee493",
+  "#ffb454",
+  "#7aa2f7",
+  "#bb9af7"
+];
+var modelColorCache = /* @__PURE__ */ new Map();
+function modelColor(name) {
+  const cached = modelColorCache.get(name);
+  if (cached) return cached;
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) hash = hash * 31 + name.charCodeAt(i) >>> 0;
+  const color = MODEL_PALETTE[hash % MODEL_PALETTE.length];
+  modelColorCache.set(name, color);
+  return color;
+}
+var TOKEN_BUCKET = {
+  input: NAMED_HEX.blue,
+  output: NAMED_HEX.green,
+  cacheCreate: NAMED_HEX.yellow,
+  cacheRead: NAMED_HEX.cyan
+};
+
+// src/usage-semantics.ts
+var clampPct = (value) => Math.max(0, Math.min(100, value));
+function inferRole(metric) {
+  if (metric.role) return metric.role;
+  if (metric.format.kind !== "percent" && !(metric.limit != null && metric.limit > 0)) return "unbounded";
+  const label = metric.label.trim().toLowerCase();
+  if (label === "session" || label.includes("five hour")) return "session";
+  if (label === "weekly" || label.includes("seven day") || label.includes("weekly all")) return "weekly";
+  if (metric.modelId || !metric.primary && metric.format.kind === "percent" && !["usage", "api", "auto"].includes(label)) return "model";
+  return "other";
+}
+function valueText(metric, usedPct) {
+  if (usedPct !== null) return `${Math.round(usedPct)}% used`;
+  if (!Number.isFinite(metric.used)) return "\u2014";
+  if (metric.format.kind === "dollars") {
+    try {
+      return new Intl.NumberFormat("en-US", { style: "currency", currency: metric.format.currency ?? "USD", maximumFractionDigits: 2 }).format(metric.used);
+    } catch {
+      return `$${metric.used.toFixed(2)}`;
+    }
+  }
+  if (metric.format.kind === "count") {
+    const suffix = metric.format.suffix?.trim();
+    return `${Math.round(metric.used).toLocaleString("en-US")}${suffix ? ` ${suffix}` : ""}`;
+  }
+  return `${Math.round(metric.used)}% used`;
+}
+var roleOrder = (role) => role === "session" ? 0 : role === "weekly" ? 1 : role === "model" ? 2 : role === "other" ? 3 : 4;
+function deriveQuotaView(metric, sourceIndex = 0) {
+  const bounded = metric.format.kind === "percent" || metric.limit != null && Number.isFinite(metric.limit) && metric.limit > 0;
+  const usedPct = metric.format.kind === "percent" ? metric.used : metric.limit != null && metric.limit > 0 ? metric.used / metric.limit * 100 : null;
+  const finiteUsedPct = usedPct == null || !Number.isFinite(usedPct) ? null : clampPct(usedPct);
+  const resets = metric.resetsAt ? Date.parse(metric.resetsAt) : Number.NaN;
+  return {
+    key: metric.key ?? `${metric.label}:${sourceIndex}`,
+    label: metric.label.replace(/\s*(limit|usage)$/i, "").trim() || metric.label,
+    role: inferRole(metric),
+    modelId: metric.modelId ?? null,
+    usedPct: finiteUsedPct,
+    remainingPct: bounded && finiteUsedPct != null ? clampPct(100 - finiteUsedPct) : null,
+    resetsAt: Number.isFinite(resets) ? resets : null,
+    bounded,
+    primary: metric.primary === true,
+    active: metric.active === true,
+    displayOrder: sourceIndex,
+    valueText: valueText(metric, finiteUsedPct)
+  };
+}
+function deriveQuotaViews(metrics) {
+  return metrics.map(deriveQuotaView).sort((a, b) => roleOrder(a.role) - roleOrder(b.role) || (a.role === "model" ? a.label.localeCompare(b.label) : a.displayOrder - b.displayOrder) || a.key.localeCompare(b.key)).map((quota, displayOrder) => ({ ...quota, displayOrder }));
+}
+function resolveQuotaViews(input) {
+  return input.quotas == null ? deriveQuotaViews(input.metrics ?? []) : [...input.quotas];
+}
+function usageFromHeadroom(value) {
+  return value === null || !Number.isFinite(value) ? null : clampPct(100 - value);
+}
+function severity(remaining) {
+  if (remaining === null || !Number.isFinite(remaining)) return "unknown";
+  if (remaining <= 10) return "crit";
+  if (remaining <= 25) return "warn";
+  return "ok";
+}
+function deriveAccountIdentity(input) {
+  const registered = input.name.trim() || input.providerName;
+  const email = input.email?.trim() || null;
+  const displayName = input.displayName?.trim() || null;
+  if (input.privacyMode && (containsEmail(registered) || containsEmail(email))) {
+    const title2 = `${input.providerName} account ${input.ordinal}`;
+    return { title: title2, subtitle: null, accessibleLabel: title2, redacted: true };
+  }
+  const title = input.privacyMode ? redactEmail(registered) : registered;
+  const subtitleCandidate = !input.privacyMode ? email && !registered.toLowerCase().includes(email.toLowerCase()) ? email : displayName : displayName && !containsEmail(displayName) ? displayName : null;
+  const subtitle = subtitleCandidate && subtitleCandidate !== title ? subtitleCandidate : null;
+  return { title, subtitle, accessibleLabel: subtitle ? `${title}, ${subtitle}` : title, redacted: input.privacyMode && title !== registered };
+}
+function accountIdentityText(account, providerName) {
+  const identity = account.identity;
+  if (!identity) return account.name || providerName;
+  const parts = [identity.title, identity.subtitle].filter((value) => !!value?.trim()).filter((value, index, values) => values.indexOf(value) === index).filter((value) => value.toLocaleLowerCase() !== providerName.toLocaleLowerCase());
+  return parts.join(" \xB7 ") || identity.title || providerName;
+}
+function blendHeadroom(a, b) {
+  const low = Math.min(clampPct(a), clampPct(b));
+  const high = Math.max(clampPct(a), clampPct(b));
+  return low * (0.9 + 0.1 * high / 100);
+}
+function tightestQuotaView(quotas) {
+  return quotas.filter((q) => q.remainingPct !== null).sort((a, b) => a.remainingPct - b.remainingPct || (a.resetsAt ?? Infinity) - (b.resetsAt ?? Infinity) || a.key.localeCompare(b.key))[0] ?? null;
+}
+function accountHeadroom(account) {
+  const session = account.quotas.find((q) => q.role === "session" && q.remainingPct !== null);
+  const models = account.quotas.filter((q) => q.role === "model" && q.remainingPct !== null);
+  const activeModel = models.find((q) => q.active) ?? null;
+  const weekly = account.quotas.find((q) => q.role === "weekly" && q.remainingPct !== null);
+  const factors = [];
+  let value = null;
+  let mode = "unavailable";
+  if (session && activeModel) {
+    value = blendHeadroom(session.remainingPct, activeModel.remainingPct);
+    mode = "smart";
+    factors.push(
+      { key: session.key, label: session.label, role: session.role, remainingPct: session.remainingPct, included: true, reason: "session" },
+      { key: activeModel.key, label: activeModel.label, role: activeModel.role, remainingPct: activeModel.remainingPct, included: true, reason: "active-model" }
+    );
+  } else if (session || activeModel) {
+    const only = session ?? activeModel;
+    value = only.remainingPct;
+    mode = "single-window";
+    factors.push({ key: only.key, label: only.label, role: only.role, remainingPct: only.remainingPct, included: true, reason: session ? "session" : "active-model" });
+  } else {
+    const primary = account.quotas.find((q) => q.primary && q.remainingPct !== null) ?? null;
+    if (primary) {
+      value = primary.remainingPct;
+      mode = "single-window";
+      factors.push({ key: primary.key, label: primary.label, role: primary.role, remainingPct: primary.remainingPct, included: true, reason: "primary" });
+    } else {
+      const floor = tightestQuotaView(account.quotas);
+      if (floor) {
+        value = floor.remainingPct;
+        mode = "fallback-floor";
+        factors.push({ key: floor.key, label: floor.label, role: floor.role, remainingPct: floor.remainingPct, included: true, reason: "fallback-floor" });
+      }
+    }
+  }
+  if (value !== null && weekly) {
+    const close = weekly.remainingPct <= 30 || weekly.remainingPct <= value + 10;
+    value = Math.min(value, weekly.remainingPct);
+    factors.push({ key: weekly.key, label: weekly.label, role: weekly.role, remainingPct: weekly.remainingPct, included: close, reason: "weekly-cap" });
+  }
+  const included = factors.filter((f) => f.included);
+  return {
+    value,
+    unit: "index-100",
+    mode,
+    factors,
+    explanation: value === null ? "No bounded quota data" : `Based on ${included.map((f) => f.label).join(" + ") || "available quota data"}`
+  };
+}
+function cumulativeQuotaViews(accounts) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const account of accounts) {
+    for (const quota of account.quotas) {
+      if (quota.remainingPct === null) continue;
+      const identity = quota.role === "session" || quota.role === "weekly" ? quota.role : quota.role === "model" ? `${quota.role}:${quota.modelId ?? quota.label.toLowerCase()}` : `${quota.role}:${quota.key}`;
+      const rows = groups.get(identity) ?? [];
+      rows.push(quota);
+      groups.set(identity, rows);
+    }
+  }
+  return [...groups.values()].filter((rows) => rows[0].role !== "model" || rows.length > 1 || accounts.length === 1).map((rows) => {
+    const first = rows[0];
+    const remainingPct = rows.reduce((sum, quota) => sum + quota.remainingPct, 0) / rows.length;
+    const usedPct = 100 - remainingPct;
+    const resets = rows.map((quota) => quota.resetsAt).filter((value) => value !== null);
+    return {
+      ...first,
+      usedPct,
+      remainingPct,
+      resetsAt: resets.length > 0 ? Math.min(...resets) : null,
+      primary: rows.some((quota) => quota.primary),
+      active: rows.some((quota) => quota.active),
+      displayOrder: Math.min(...rows.map((quota) => quota.displayOrder)),
+      valueText: `${Math.round(usedPct)}% used`
+    };
+  }).sort((a, b) => roleOrder(a.role) - roleOrder(b.role) || a.displayOrder - b.displayOrder || a.key.localeCompare(b.key));
+}
+function deriveProviderHeadroom(accounts, activeTimeoutMin, now, displayMetric = "smartHeadroom") {
+  const activeCutoff = now - activeTimeoutMin * 6e4;
+  const activeIds = accounts.filter((a) => a.lastActivityAt !== null && a.lastActivityAt >= activeCutoff).map((a) => a.id);
+  if (displayMetric === "smartHeadroom" && accounts.length > 1) {
+    const pooled = accountHeadroom({ id: "cumulative", lastActivityAt: null, quotas: cumulativeQuotaViews(accounts) });
+    if (pooled.value === null) return { ...pooled, basis: "unavailable", representativeAccountId: null, activeAccountIds: activeIds };
+    const dataCount = accounts.filter((account) => account.quotas.some((quota) => quota.remainingPct !== null)).length;
+    return {
+      ...pooled,
+      basis: activeIds.length > 0 ? "active" : "idle-runway",
+      representativeAccountId: null,
+      activeAccountIds: activeIds,
+      explanation: `${pooled.explanation}; ${dataCount} accounts combined`
+    };
+  }
+  const rows = accounts.map((account) => {
+    const smart = accountHeadroom(account);
+    if (displayMetric === "smartHeadroom") return { account, value: smart.value, view: smart };
+    const floor = tightestQuotaView(account.quotas);
+    const value = floor?.remainingPct ?? null;
+    return { account, value, view: { value, unit: "index-100", mode: floor ? "fallback-floor" : "unavailable", factors: floor ? [{ key: floor.key, label: floor.label, role: floor.role, remainingPct: value, included: true, reason: "fallback-floor" }] : [], explanation: floor ? `Based on ${floor.label}` : "No bounded quota data" } };
+  }).filter((row) => row.value !== null);
+  if (rows.length === 0) return { value: null, unit: "index-100", mode: "unavailable", basis: "unavailable", representativeAccountId: null, activeAccountIds: activeIds, factors: [], explanation: "No bounded quota data" };
+  const active = rows.filter((row) => activeIds.includes(row.account.id));
+  const candidates = active.length > 0 ? active : rows;
+  candidates.sort((a, b) => a.value !== b.value ? active.length > 0 ? a.value - b.value : b.value - a.value : active.length > 0 && a.account.lastActivityAt !== b.account.lastActivityAt ? (b.account.lastActivityAt ?? 0) - (a.account.lastActivityAt ?? 0) : a.account.id.localeCompare(b.account.id));
+  const selected = candidates[0];
+  const basis = active.length > 0 ? "active" : "idle-runway";
+  return { ...selected.view, basis, representativeAccountId: selected.account.id, activeAccountIds: activeIds, explanation: `${selected.view.explanation}; ${basis === "active" ? "active account" : "best available account"}` };
+}
+
+// src/peak.ts
+async function fetchPeak() {
+  try {
+    const res = await fetch("https://promoclock.co/api/status", {
+      headers: { "Accept": "application/json", "User-Agent": "tokmon" },
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const data = await readJson(res);
+    if (!data) return null;
+    let state;
+    if (data.isPeak === true || data.status === "peak") state = "peak";
+    else if (data.isWeekend === true || data.status === "weekend") state = "weekend";
+    else if (data.isOffPeak === true || data.status === "off_peak" || data.status === "off-peak") state = "off-peak";
+    else return null;
+    const minutesUntilChange = typeof data.minutesUntilChange === "number" && Number.isFinite(data.minutesUntilChange) ? data.minutesUntilChange : null;
+    return {
+      state,
+      label: state === "peak" ? "Peak" : state === "weekend" ? "Weekend" : "Off-Peak",
+      minutesUntilChange,
+      changesAt: minutesUntilChange !== null ? new Date(Date.now() + minutesUntilChange * 6e4).toISOString() : null
+    };
+  } catch {
+    return null;
+  }
+}
+
+export {
+  buildAccounts,
+  accountsByProvider,
+  namedHex,
+  colorHex,
+  modelColor,
+  deriveQuotaViews,
+  resolveQuotaViews,
+  usageFromHeadroom,
+  severity,
+  deriveAccountIdentity,
+  accountIdentityText,
+  deriveProviderHeadroom,
+  fetchPeak
+};