@phenx-inc/ctlsurf 0.16.1 → 0.17.1

package/out/main/index.js

@@ -180,6 +180,10 @@ class PtyManager {
       this.process = null;
     });
   }
+  /** OS pid of the spawned agent (or ssh), null once it has exited. */
+  get pid() {
+    return this.process?.pid ?? null;
+  }
   write(data) {
     this.process?.write(data);
   }
@@ -6038,16 +6042,16 @@ class ConversationBridge {
     this.outputFlushTimer = null;
     if (this.outputBuffer.length === 0) return;
     const candidate = this.terminalCapture.currentCandidate();
-    const now = Date.now();
+    const now2 = Date.now();
     if (candidate.length === 0) {
       this.outputBuffer = "";
       return;
     }
     if (candidate !== this.pendingCandidate) {
       this.pendingCandidate = candidate;
-      this.pendingCandidateChangedAt = now;
+      this.pendingCandidateChangedAt = now2;
     }
-    if (now - this.pendingCandidateChangedAt >= OUTPUT_STABLE_MS) {
+    if (now2 - this.pendingCandidateChangedAt >= OUTPUT_STABLE_MS) {
       this.flush();
       return;
     }
@@ -6557,8 +6561,8 @@ function mostRecentClaudeFile(cwd, root) {
 }
 function recentCodexRollouts(root) {
   const dirs = /* @__PURE__ */ new Set();
-  const now = Date.now();
-  for (const ms of [now, now - 24 * 60 * 60 * 1e3]) {
+  const now2 = Date.now();
+  for (const ms of [now2, now2 - 24 * 60 * 60 * 1e3]) {
     const d = new Date(ms);
     const yyyy = String(d.getFullYear());
     const mm = String(d.getMonth() + 1).padStart(2, "0");
@@ -6670,9 +6674,9 @@ class AgentStateMonitor {
   tabs = /* @__PURE__ */ new Map();
   timer = null;
   lastAnyAwaiting = false;
-  constructor(sink, now = Date.now) {
+  constructor(sink, now2 = Date.now) {
     this.sink = sink;
-    this.now = now;
+    this.now = now2;
   }
   start() {
     if (this.timer) return;
@@ -6688,14 +6692,14 @@ class AgentStateMonitor {
   }
   /** Register a tab so its raw PTY output can be classified. */
   trackTab(tabId, agentId, cwd) {
-    const now = this.now();
+    const now2 = this.now();
     this.tabs.set(tabId, {
       agentId,
       cwd,
       state: "idle",
       everBusy: false,
       lastBusyAt: 0,
-      lastOutputAt: now,
+      lastOutputAt: now2,
       lastDecisionAt: 0,
       hookState: null,
       hookAt: 0,
@@ -6709,16 +6713,16 @@ class AgentStateMonitor {
   feed(tabId, data) {
     const rec = this.tabs.get(tabId);
     if (!rec) return;
-    const now = this.now();
-    rec.lastOutputAt = now;
+    const now2 = this.now();
+    rec.lastOutputAt = now2;
     const text = rec.tail + stripAnsi(data);
     rec.tail = text.length > TAIL_KEEP_CHARS ? text.slice(-TAIL_KEEP_CHARS) : text;
     if (hasBusyMarker(text)) {
-      rec.lastBusyAt = now;
+      rec.lastBusyAt = now2;
       rec.everBusy = true;
     }
     if (hasApprovalMarker(text)) {
-      rec.lastDecisionAt = now;
+      rec.lastDecisionAt = now2;
     }
   }
   /**
@@ -6735,9 +6739,9 @@ class AgentStateMonitor {
     if (!/[\r\n]/.test(data)) return;
     const rec = this.tabs.get(tabId);
     if (!rec) return;
-    const now = this.now();
+    const now2 = this.now();
     rec.everBusy = false;
-    rec.lastBusyAt = now;
+    rec.lastBusyAt = now2;
     rec.lastDecisionAt = 0;
     rec.hookState = null;
     this.setState(rec, tabId, "busy");
@@ -6751,28 +6755,28 @@ class AgentStateMonitor {
    */
   applyHookEvent(cwd, kind) {
     const target = stripTrailingSep$1(cwd);
-    const now = this.now();
+    const now2 = this.now();
     for (const [tabId, rec] of this.tabs) {
       if (stripTrailingSep$1(rec.cwd) !== target) continue;
       rec.hookState = kind;
-      rec.hookAt = now;
+      rec.hookAt = now2;
       if (kind === "busy") {
         rec.everBusy = false;
-        rec.lastBusyAt = now;
+        rec.lastBusyAt = now2;
       }
       this.setState(rec, tabId, kind);
     }
   }
   tick() {
-    const now = this.now();
+    const now2 = this.now();
     for (const [tabId, rec] of this.tabs) {
-      if (rec.hookState && now - rec.hookAt < HOOK_AUTHORITY_MS) {
+      if (rec.hookState && now2 - rec.hookAt < HOOK_AUTHORITY_MS) {
         this.setState(rec, tabId, rec.hookState);
         continue;
       }
-      const busyRecently = rec.lastBusyAt > 0 && now - rec.lastBusyAt < BUSY_GRACE_MS;
-      const settled = now - rec.lastOutputAt >= SETTLE_MS;
-      const decisionRecent = rec.lastDecisionAt > 0 && now - rec.lastDecisionAt < DECISION_TTL_MS;
+      const busyRecently = rec.lastBusyAt > 0 && now2 - rec.lastBusyAt < BUSY_GRACE_MS;
+      const settled = now2 - rec.lastOutputAt >= SETTLE_MS;
+      const decisionRecent = rec.lastDecisionAt > 0 && now2 - rec.lastDecisionAt < DECISION_TTL_MS;
       let next = null;
       if (busyRecently) {
         next = "busy";
@@ -11095,16 +11099,16 @@ class TimeTracker {
   recordActivity(tabId) {
     const s = this.sessions.get(tabId);
     if (!s || s.ended) return;
-    const now = Date.now();
-    if (!isSameLocalDay(s.startedAt, now)) {
+    const now2 = Date.now();
+    if (!isSameLocalDay(s.startedAt, now2)) {
       void this.rollover(tabId);
       return;
     }
-    const delta = now - s.lastActivity;
+    const delta = now2 - s.lastActivity;
     if (delta < s.idleTimeoutMs) {
       s.activeMs += delta;
     }
-    s.lastActivity = now;
+    s.lastActivity = now2;
   }
   async rollover(tabId) {
     if (this.rollingOver.has(tabId)) return;
@@ -11730,10 +11734,10 @@ class SpanTracker {
   lastAccountAt = 0;
   activityMs = { agent: 0, human: 0, idle: 0 };
   started = false;
-  constructor(session, sink, now = Date.now) {
+  constructor(session, sink, now2 = Date.now) {
     this.session = session;
     this.sink = sink;
-    this.now = now;
+    this.now = now2;
   }
   /** Begin attribution at session start. */
   begin() {
@@ -12180,10 +12184,10 @@ class ObserverBudget {
   capUsd;
   date;
   spentUsd = 0;
-  constructor(dir, capUsd, now = () => /* @__PURE__ */ new Date()) {
+  constructor(dir, capUsd, now2 = () => /* @__PURE__ */ new Date()) {
     this.filePath = path$1.join(dir, "budget.json");
     this.capUsd = capUsd;
-    this.date = localDay(now());
+    this.date = localDay(now2());
     try {
       const raw = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
       if (raw?.date === this.date && typeof raw.spentUsd === "number") {
@@ -12192,8 +12196,8 @@ class ObserverBudget {
     } catch {
     }
   }
-  addUsage(model, usage, now = () => /* @__PURE__ */ new Date()) {
-    const today = localDay(now());
+  addUsage(model, usage, now2 = () => /* @__PURE__ */ new Date()) {
+    const today = localDay(now2());
     if (today !== this.date) {
       this.date = today;
       this.spentUsd = 0;
@@ -12205,8 +12209,8 @@ class ObserverBudget {
     } catch {
     }
   }
-  overCap(now = () => /* @__PURE__ */ new Date()) {
-    if (localDay(now()) !== this.date) return false;
+  overCap(now2 = () => /* @__PURE__ */ new Date()) {
+    if (localDay(now2()) !== this.date) return false;
     return this.spentUsd >= this.capUsd;
   }
   get spent() {
@@ -16235,15 +16239,15 @@ function requireDist() {
       return `v1,${expectedSignature}`;
     }
     verifyTimestamp(timestampHeader) {
-      const now = Math.floor(Date.now() / 1e3);
+      const now2 = Math.floor(Date.now() / 1e3);
       const timestamp = parseInt(timestampHeader, 10);
       if (isNaN(timestamp)) {
         throw new WebhookVerificationError("Invalid Signature Headers");
       }
-      if (now - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
+      if (now2 - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
         throw new WebhookVerificationError("Message timestamp too old");
       }
-      if (timestamp > now + WEBHOOK_TOLERANCE_IN_SECONDS) {
+      if (timestamp > now2 + WEBHOOK_TOLERANCE_IN_SECONDS) {
         throw new WebhookVerificationError("Message timestamp too new");
       }
       return new Date(timestamp * 1e3);
@@ -23306,6 +23310,15 @@ class Orchestrator {
   getTabIds() {
     return [...this.tabs.keys()];
   }
+  // Every open tab's agent and PTY pid, for the resource monitor (monitor.ts).
+  getTabProcesses() {
+    return [...this.tabs].map(([tabId, tab]) => ({
+      tabId,
+      agent: tab.agent,
+      pid: tab.ptyManager.pid,
+      active: tabId === this.activeTabId
+    }));
+  }
   // ─── Tracking control (active tab) ──────────────
   isActiveTabTracking() {
     if (!this.activeTabId) return false;
@@ -23479,6 +23492,368 @@ class Orchestrator {
     this.workerWs.disconnect();
   }
 }
+const FAST_MS = 3e3;
+const SLOW_MS = 1e4;
+const IDLE_STOP_MS = 12e4;
+const HISTORY_MS = 6e5;
+const FAST_HOLD_MS = 15e3;
+const USAGE_SLOW_MS = 3e5;
+const USAGE_FAST_MS = 6e4;
+const CODEX_TAIL_BYTES = 512 * 1024;
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function round(x, digits = 1) {
+  const f = 10 ** digits;
+  return Math.round(x * f) / f;
+}
+function run(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    child_process.execFile(cmd, args, { timeout: opts.timeout ?? 5e3, cwd: opts.cwd, maxBuffer: 16 * 1024 * 1024 }, (err, stdout) => {
+      if (err && !stdout) reject(err);
+      else resolve(stdout);
+    });
+  });
+}
+function serviceFor(agent) {
+  const cmd = isRemoteAgent(agent) ? agent.args.slice(2).join(" ") : path$1.basename(agent.command);
+  if (/\bcodex\b/.test(cmd)) return "codex";
+  if (/\bclaude\b/.test(cmd)) return "claude";
+  return null;
+}
+function cpuTimes() {
+  let idle = 0;
+  let total = 0;
+  for (const c of os.cpus()) {
+    const t = c.times;
+    idle += t.idle;
+    total += t.user + t.nice + t.sys + t.idle + t.irq;
+  }
+  return { idle, total };
+}
+async function memory() {
+  const total = os.totalmem();
+  let avail = os.freemem();
+  try {
+    if (process.platform === "darwin") {
+      const out = await run("vm_stat", []);
+      const page = Number(/page size of (\d+) bytes/.exec(out)?.[1]) || 4096;
+      const pages = (name) => Number(new RegExp(`Pages ${name}:\\s+(\\d+)`).exec(out)?.[1] ?? 0);
+      avail = (pages("free") + pages("inactive") + pages("speculative")) * page;
+    } else if (process.platform === "linux") {
+      const m2 = /MemAvailable:\s+(\d+) kB/.exec(await fs.promises.readFile("/proc/meminfo", "utf-8"));
+      if (m2) avail = Number(m2[1]) * 1024;
+    }
+  } catch {
+  }
+  avail = Math.min(avail, total);
+  return { total, used: total - avail, pct: round(100 * (total - avail) / total) };
+}
+async function diskUsage() {
+  if (typeof fs.promises.statfs !== "function") return null;
+  try {
+    const s = await fs.promises.statfs(os.homedir());
+    return { total: s.blocks * s.bsize, free: s.bavail * s.bsize };
+  } catch {
+    return null;
+  }
+}
+async function appleGpu() {
+  if (process.platform !== "darwin") return null;
+  try {
+    const out = await run("ioreg", ["-r", "-d", "1", "-w", "0", "-c", "IOAccelerator"], { timeout: 3e3 });
+    const m2 = /"Device Utilization %"=(\d+)/.exec(out);
+    return m2 ? Number(m2[1]) : null;
+  } catch {
+    return null;
+  }
+}
+async function processTable() {
+  const table = /* @__PURE__ */ new Map();
+  if (process.platform === "win32") return table;
+  try {
+    const out = await run("ps", ["-A", "-o", "pid=,ppid=,pcpu=,rss="]);
+    for (const line of out.split("\n")) {
+      const [pid, ppid, cpu, rss] = line.trim().split(/\s+/).map(Number);
+      if (pid) table.set(pid, { ppid, cpu: cpu || 0, rss: (rss || 0) * 1024 });
+    }
+  } catch {
+  }
+  return table;
+}
+function agentProcess(tab, table) {
+  const base = {
+    tabId: tab.tabId,
+    name: tab.agent.name,
+    active: tab.active,
+    remote: isRemoteAgent(tab.agent),
+    service: serviceFor(tab.agent),
+    pid: tab.pid
+  };
+  if (tab.pid == null || !table.has(tab.pid)) return { ...base, cpu: null, mem: null, procs: 0 };
+  const children = /* @__PURE__ */ new Map();
+  for (const [pid, row] of table) {
+    const list = children.get(row.ppid);
+    if (list) list.push(pid);
+    else children.set(row.ppid, [pid]);
+  }
+  let cpu = 0;
+  let mem = 0;
+  let procs = 0;
+  const queue = [tab.pid];
+  while (queue.length) {
+    const pid = queue.pop();
+    const row = table.get(pid);
+    if (!row) continue;
+    cpu += row.cpu;
+    mem += row.rss;
+    procs++;
+    queue.push(...children.get(pid) ?? []);
+  }
+  return { ...base, cpu: round(cpu), mem, procs };
+}
+function parseClaudeUsage(text) {
+  const windows = [];
+  for (const line of text.split("\n")) {
+    let m2 = /^\s*Current session:\s*([\d.]+)% used(?:\s*·\s*resets (.+))?/.exec(line);
+    if (m2) {
+      windows.push({ label: "session (5h)", short: "5h", pct: Number(m2[1]), resets: m2[2]?.trim() || null });
+      continue;
+    }
+    m2 = /^\s*Current week \((.+?)\):\s*([\d.]+)% used(?:\s*·\s*resets (.+))?/.exec(line);
+    if (m2) {
+      const all = m2[1].trim().toLowerCase() === "all models";
+      windows.push({
+        label: all ? "week, all models" : `week, ${m2[1].trim()}`,
+        short: all ? "wk" : null,
+        pct: Number(m2[2]),
+        resets: m2[3]?.trim() || null
+      });
+    }
+  }
+  return windows;
+}
+async function claudeUsage() {
+  const source = "claude /usage";
+  let text = "";
+  try {
+    const out = await run(
+      "claude",
+      ["-p", "/usage", "--output-format", "json", "--no-session-persistence"],
+      { cwd: os.tmpdir(), timeout: 4e4 }
+    );
+    text = String(JSON.parse(out || "{}").result ?? "");
+  } catch (err) {
+    const msg = err.code === "ENOENT" ? "claude not found on PATH" : String(err);
+    return { ok: false, windows: [], source, ts: now(), error: msg.slice(0, 200) };
+  }
+  const windows = parseClaudeUsage(text);
+  return windows.length ? { ok: true, windows, source, ts: now() } : { ok: false, windows: [], source, ts: now(), error: text.trim().slice(0, 200) || "no usage reported" };
+}
+function findKey(obj, key) {
+  if (Array.isArray(obj)) {
+    for (const v2 of obj) {
+      const found = findKey(v2, key);
+      if (found) return found;
+    }
+  } else if (obj && typeof obj === "object") {
+    const rec = obj;
+    if (rec[key] && typeof rec[key] === "object") return rec[key];
+    for (const v2 of Object.values(rec)) {
+      const found = findKey(v2, key);
+      if (found) return found;
+    }
+  }
+  return null;
+}
+function codexWindow(minutes) {
+  const m2 = Number(minutes);
+  if (!Number.isFinite(m2)) return { label: "window", short: "win" };
+  if (m2 === 300) return { label: "5h", short: "5h" };
+  if (m2 === 1440) return { label: "day", short: "day" };
+  if (m2 === 10080) return { label: "week", short: "wk" };
+  const s = m2 < 1440 ? `${Math.floor(m2 / 60)}h` : `${Math.floor(m2 / 1440)}d`;
+  return { label: s, short: s };
+}
+async function readTail(file, bytes) {
+  const fh = await fs.promises.open(file, "r");
+  try {
+    const { size } = await fh.stat();
+    const start = Math.max(0, size - bytes);
+    const buf = Buffer.alloc(size - start);
+    await fh.read(buf, 0, buf.length, start);
+    return buf.toString("utf-8");
+  } finally {
+    await fh.close();
+  }
+}
+async function codexSessionFiles(root, limit2) {
+  const sortedDirs = async (dir) => (await fs.promises.readdir(dir, { withFileTypes: true }).catch(() => [])).filter((d) => d.isDirectory()).map((d) => path$1.join(dir, d.name)).sort().reverse();
+  const days = [];
+  for (const y2 of await sortedDirs(root)) {
+    for (const m2 of await sortedDirs(y2)) {
+      days.push(...await sortedDirs(m2));
+      if (days.length >= 14) break;
+    }
+    if (days.length >= 14) break;
+  }
+  const files = [];
+  for (const day of days.slice(0, 14)) {
+    for (const name of await fs.promises.readdir(day).catch(() => [])) {
+      if (!name.startsWith("rollout-") || !name.endsWith(".jsonl")) continue;
+      const file = path$1.join(day, name);
+      try {
+        files.push({ file, mtime: (await fs.promises.stat(file)).mtimeMs });
+      } catch {
+      }
+    }
+  }
+  return files.sort((a, b2) => b2.mtime - a.mtime).slice(0, limit2).map((f) => f.file);
+}
+async function codexUsage(home = os.homedir()) {
+  const source = "your most recent Codex session";
+  for (const file of await codexSessionFiles(path$1.join(home, ".codex", "sessions"), 5)) {
+    let lines;
+    try {
+      lines = (await readTail(file, CODEX_TAIL_BYTES)).split("\n");
+    } catch {
+      continue;
+    }
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"rate_limits"')) continue;
+      let rl;
+      try {
+        rl = findKey(JSON.parse(lines[i]), "rate_limits");
+      } catch {
+        continue;
+      }
+      if (!rl) continue;
+      const windows = [];
+      for (const key of ["primary", "secondary"]) {
+        const w2 = rl[key];
+        if (!w2 || typeof w2 !== "object" || w2.used_percent == null) continue;
+        const { label, short } = codexWindow(w2.window_minutes);
+        const resets = typeof w2.resets_at === "number" ? new Date(w2.resets_at * 1e3).toLocaleString(void 0, { month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }) : null;
+        windows.push({ label, short, pct: Number(w2.used_percent), resets });
+      }
+      if (windows.length) {
+        const ts = new Date((await fs.promises.stat(file)).mtimeMs).toISOString();
+        return { ok: true, windows, plan: rl.plan_type ?? null, source, ts };
+      }
+    }
+  }
+  return { ok: false, windows: [], source, ts: now(), error: "no Codex session with usage yet" };
+}
+const FETCH_USAGE = {
+  claude: claudeUsage,
+  codex: () => codexUsage()
+};
+class ResourceMonitor {
+  constructor(tabs) {
+    this.tabs = tabs;
+  }
+  machine = { ok: false, ts: now(), error: "sampling…" };
+  history = [];
+  agents = [];
+  usage = {};
+  usageAt = {};
+  usageBusy = /* @__PURE__ */ new Set();
+  prevCpu = cpuTimes();
+  lastAsk = 0;
+  fastUntil = 0;
+  timer = null;
+  inflight = null;
+  /** Latest sample plus 10 minutes of history. `fast` = the panel is open:
+   *  sample every ~3 s and refresh quota every minute. */
+  async snapshot(fast = false) {
+    const t = Date.now();
+    this.lastAsk = t;
+    const speedUp = fast && t >= this.fastUntil;
+    if (fast) this.fastUntil = t + FAST_HOLD_MS;
+    if (!this.timer && !this.inflight || speedUp) await this.tick();
+    else this.refreshUsage(this.tabs());
+    return this.build(fast);
+  }
+  stop() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    this.lastAsk = 0;
+  }
+  tick() {
+    if (!this.inflight) {
+      if (this.timer) clearTimeout(this.timer);
+      this.timer = null;
+      this.inflight = this.sample().catch((err) => log$5(`[monitor] sample failed: ${err}`)).finally(() => {
+        this.inflight = null;
+        if (Date.now() - this.lastAsk >= IDLE_STOP_MS) return;
+        this.timer = setTimeout(() => {
+          void this.tick();
+        }, Date.now() < this.fastUntil ? FAST_MS : SLOW_MS);
+        this.timer.unref?.();
+      });
+    }
+    return this.inflight;
+  }
+  async sample() {
+    const tabs = this.tabs();
+    this.refreshUsage(tabs);
+    try {
+      const [mem, disk, gpu, table] = await Promise.all([memory(), diskUsage(), appleGpu(), processTable()]);
+      const cur = cpuTimes();
+      const dTotal = cur.total - this.prevCpu.total;
+      const cpuPct = dTotal > 0 ? round(100 * (1 - (cur.idle - this.prevCpu.idle) / dTotal)) : null;
+      this.prevCpu = cur;
+      this.machine = {
+        ok: true,
+        ts: now(),
+        cpu: { pct: cpuPct, cores: os.cpus().length, load: os.loadavg().map((x) => round(x, 2)) },
+        mem,
+        disk,
+        gpu
+      };
+      this.agents = tabs.map((tab) => agentProcess(tab, table));
+      const t = Date.now();
+      this.history.push({ t, cpu: cpuPct, mem: mem.pct, gpu });
+      while (this.history.length && this.history[0].t < t - HISTORY_MS) this.history.shift();
+    } catch (err) {
+      this.machine = { ok: false, ts: now(), error: String(err).slice(0, 200) };
+    }
+  }
+  refreshUsage(tabs) {
+    const every = Date.now() < this.fastUntil ? USAGE_FAST_MS : USAGE_SLOW_MS;
+    for (const s of this.servicesInUse(tabs)) {
+      if (this.usageBusy.has(s) || Date.now() - (this.usageAt[s] ?? 0) < every) continue;
+      this.usageBusy.add(s);
+      FETCH_USAGE[s]().catch((err) => ({ ok: false, windows: [], source: s, ts: now(), error: String(err).slice(0, 200) })).then((u) => {
+        this.usage[s] = u;
+        this.usageAt[s] = Date.now();
+        if (!u.ok) log$5(`[monitor] ${s} usage unavailable: ${u.error}`);
+      }).finally(() => this.usageBusy.delete(s));
+    }
+  }
+  servicesInUse(tabs) {
+    return [...new Set(tabs.map((t) => serviceFor(t.agent)).filter((s) => s !== null))];
+  }
+  build(fast) {
+    const tabs = this.tabs();
+    const active = tabs.find((t) => t.active);
+    const usage = {};
+    for (const s of this.servicesInUse(tabs)) {
+      if (this.usage[s]) usage[s] = this.usage[s];
+    }
+    return {
+      machine: {
+        ...this.machine,
+        label: process.platform === "darwin" ? "This Mac" : os.hostname(),
+        history: [...this.history]
+      },
+      agents: this.agents,
+      activeService: active ? serviceFor(active.agent) : null,
+      usage,
+      interval: fast ? FAST_MS : SLOW_MS
+    };
+  }
+}
 electron.app.setName("ctlsurf");
 process.title = "ctlsurf";
 process.stdout?.on?.("error", () => {
@@ -23822,6 +24197,8 @@ async function checkForUpdate() {
 }
 electron.ipcMain.handle("app:getVersion", () => electron.app.getVersion());
 electron.ipcMain.handle("app:getUpdateInfo", () => updateInfo);
+const resourceMonitor = new ResourceMonitor(() => orchestrator.getTabProcesses());
+electron.ipcMain.handle("monitor:snapshot", (_event, fast) => resourceMonitor.snapshot(!!fast));
 electron.ipcMain.handle("fs:readDir", async (_event, dirPath) => {
   try {
     const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
@@ -24083,6 +24460,7 @@ let shutdownStarted = false;
 function shutdownThenQuit() {
   if (shutdownStarted) return;
   shutdownStarted = true;
+  resourceMonitor.stop();
   void Promise.race([
     orchestrator.shutdown(),
     new Promise((resolve) => setTimeout(resolve, 1e4))

package/out/preload/index.js

@@ -58,6 +58,9 @@ const api = {
     electron.ipcRenderer.on("app:updateInfo", listener);
     return () => electron.ipcRenderer.removeListener("app:updateInfo", listener);
   },
+  // Resources + plan quota for the status bar (shape: MonitorSnapshot in
+  // src/main/monitor.ts). `fast` = the details panel is open.
+  getResourceSnapshot: (fast) => electron.ipcRenderer.invoke("monitor:snapshot", fast),
   // Settings (legacy)
   getSetting: (key) => electron.ipcRenderer.invoke("settings:get", key),
   setSetting: (key, value) => electron.ipcRenderer.invoke("settings:set", key, value),

package/out/renderer/assets/{cssMode-DwHD6JSn.js → cssMode-BtQxI2Eb.js}

@@ -1,6 +1,6 @@
-import { c as createWebWorker, l as languages } from "./index-HoDaBul3.js";
-import { C as CompletionAdapter, H as HoverAdapter, D as DocumentHighlightAdapter, a as DefinitionAdapter, R as ReferenceAdapter, b as DocumentSymbolAdapter, c as RenameAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, e as DiagnosticsAdapter, S as SelectionRangeAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider } from "./lspLanguageFeatures-Bb27EY8c.js";
-import { h, i, j, t, k } from "./lspLanguageFeatures-Bb27EY8c.js";
+import { c as createWebWorker, l as languages } from "./index-Dm70hk5s.js";
+import { C as CompletionAdapter, H as HoverAdapter, D as DocumentHighlightAdapter, a as DefinitionAdapter, R as ReferenceAdapter, b as DocumentSymbolAdapter, c as RenameAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, e as DiagnosticsAdapter, S as SelectionRangeAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider } from "./lspLanguageFeatures-Ckqu5ubG.js";
+import { h, i, j, t, k } from "./lspLanguageFeatures-Ckqu5ubG.js";
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
 class WorkerManager {
   constructor(defaults) {

package/out/renderer/assets/{freemarker2-Na9-bXYw.js → freemarker2-DRW5dmY5.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-HoDaBul3.js";
+import { l as languages } from "./index-Dm70hk5s.js";
 const EMPTY_ELEMENTS = [
   "assign",
   "flush",

package/out/renderer/assets/{handlebars-D7gzKLS8.js → handlebars-CFLF3cP7.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-HoDaBul3.js";
+import { l as languages } from "./index-Dm70hk5s.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{html-DDK7xN27.js → html-DtnBOkwp.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-HoDaBul3.js";
+import { l as languages } from "./index-Dm70hk5s.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{htmlMode-BfbLv-NB.js → htmlMode-DMVysDCg.js}

@@ -1,6 +1,6 @@
-import { c as createWebWorker, l as languages } from "./index-HoDaBul3.js";
-import { H as HoverAdapter, D as DocumentHighlightAdapter, h as DocumentLinkAdapter, F as FoldingRangeAdapter, b as DocumentSymbolAdapter, S as SelectionRangeAdapter, c as RenameAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter } from "./lspLanguageFeatures-Bb27EY8c.js";
-import { a, e, d, R, i, j, t, k } from "./lspLanguageFeatures-Bb27EY8c.js";
+import { c as createWebWorker, l as languages } from "./index-Dm70hk5s.js";
+import { H as HoverAdapter, D as DocumentHighlightAdapter, h as DocumentLinkAdapter, F as FoldingRangeAdapter, b as DocumentSymbolAdapter, S as SelectionRangeAdapter, c as RenameAdapter, f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter } from "./lspLanguageFeatures-Ckqu5ubG.js";
+import { a, e, d, R, i, j, t, k } from "./lspLanguageFeatures-Ckqu5ubG.js";
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
 class WorkerManager {
   constructor(defaults) {