fleetlens 0.15.3 → 0.15.4

package/dist/index.js

@@ -675,7 +675,7 @@ function getAgentMetadata(kind) {
 function isAgentKind(s) {
   return typeof s === "string" && KNOWN_AGENT_KINDS.has(s);
 }
-var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, ANTIGRAVITY_METADATA, COWORK_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
+var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, ANTIGRAVITY_METADATA, COWORK_METADATA, ZAI_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
 var init_agent_metadata = __esm({
   "../parser/dist/agent-metadata.js"() {
     "use strict";
@@ -714,12 +714,20 @@ var init_agent_metadata = __esm({
       accentColor: "rgb(217, 119, 87)",
       iconChar: "\u2318"
     };
+    ZAI_METADATA = {
+      kind: "zai",
+      displayName: "Z.ai",
+      shortLabel: "Z.ai",
+      accentColor: "rgb(59, 130, 246)",
+      iconChar: "Z"
+    };
     agentMetadata = [
       CLAUDE_CODE_METADATA,
       CODEX_METADATA,
       GEMINI_METADATA,
       ANTIGRAVITY_METADATA,
-      COWORK_METADATA
+      COWORK_METADATA,
+      ZAI_METADATA
     ];
     KNOWN_AGENT_KINDS = new Set(agentMetadata.map((m) => m.kind));
   }
@@ -3172,13 +3180,16 @@ async function getLatestCodexUsage(opts = {}) {
       const fiveResetUnix = numberOf(primary?.resets_at);
       const sevenResetUnix = numberOf(secondary?.resets_at);
       const planType = typeof rl.plan_type === "string" ? rl.plan_type : null;
+      const nowMs = Date.now();
+      const fiveExpired = fiveResetUnix !== void 0 && nowMs > fiveResetUnix * 1e3;
+      const sevenExpired = sevenResetUnix !== void 0 && nowMs > sevenResetUnix * 1e3;
       return {
         five_hour: {
-          utilization: fivePct ?? null,
+          utilization: fiveExpired ? 0 : fivePct ?? null,
           resets_at: fiveResetUnix !== void 0 ? new Date(fiveResetUnix * 1e3).toISOString() : null
         },
         seven_day: {
-          utilization: sevenPct ?? null,
+          utilization: sevenExpired ? 0 : sevenPct ?? null,
           resets_at: sevenResetUnix !== void 0 ? new Date(sevenResetUnix * 1e3).toISOString() : null
         },
         plan_type: planType,
@@ -4516,6 +4527,7 @@ __export(fs_exports, {
   RICH_ROLLUP_SCHEMA_VERSION: () => RICH_ROLLUP_SCHEMA_VERSION,
   agentSources: () => agentSources,
   antigravitySessionLocalDay: () => antigravitySessionLocalDay,
+  appendUsageSnapshot: () => appendUsageSnapshot,
   buildCalibrationCurve: () => buildCalibrationCurve,
   cacheStats: () => cacheStats,
   cclensHome: () => cclensHome,
@@ -4549,6 +4561,7 @@ __export(fs_exports, {
   loadTeamForSession: () => loadTeamForSession,
   loadUsageByDay: () => loadUsageByDay,
   loadWorkflowAgentDetail: () => loadWorkflowAgentDetail,
+  pruneUsageAgent: () => pruneUsageAgent,
   readGitFolder: () => readGitFolder,
   readJsonlFile: () => readJsonlFile,
   readTeamConfig: () => readTeamConfig,
@@ -4558,7 +4571,7 @@ __export(fs_exports, {
   walkJsonlFiles: () => walkJsonlFiles,
   writeTeamConfig: () => writeTeamConfig
 });
-import { promises as fs6 } from "node:fs";
+import { promises as fs6, existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
 import os6 from "node:os";
 import path6 from "node:path";
 function cclensHome() {
@@ -4604,6 +4617,27 @@ async function getAnySession(id) {
 function usageLogPath() {
   return cclensPath("usage.jsonl");
 }
+function appendUsageSnapshot(snapshot) {
+  const p = usageLogPath();
+  mkdirSync3(path6.dirname(p), { recursive: true });
+  appendFileSync(p, JSON.stringify(snapshot) + "\n", "utf8");
+}
+function pruneUsageAgent(agent) {
+  const p = usageLogPath();
+  if (!existsSync2(p))
+    return;
+  const kept = readFileSync4(p, "utf8").split("\n").filter((line) => {
+    if (!line.trim())
+      return false;
+    try {
+      return JSON.parse(line).agent !== agent;
+    } catch {
+      return true;
+    }
+  });
+  mkdirSync3(path6.dirname(p), { recursive: true });
+  writeFileSync3(p, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
+}
 async function loadUsageByDay(start2, end) {
   let raw;
   try {
@@ -4909,7 +4943,7 @@ __export(server_exports, {
 import { spawn } from "node:child_process";
 import { join as join3, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 function appDir() {
   const here = dirname3(fileURLToPath(import.meta.url));
@@ -4924,7 +4958,7 @@ function getServerStatus() {
   return { running: false };
 }
 function isServerStale(status2) {
-  return status2.running === true && status2.version !== "0.15.3";
+  return status2.running === true && status2.version !== "0.15.4";
 }
 async function ensureCurrentServer(opts = {}) {
   const status2 = getServerStatus();
@@ -4958,7 +4992,7 @@ async function ensureCurrentServer(opts = {}) {
 async function startServer(opts = {}) {
   const port = opts.port ?? (parseInt(process.env.CCLENS_PORT ?? "", 10) || DEFAULT_PORT);
   const serverJs = join3(appDir(), "server.js");
-  if (!existsSync2(serverJs)) {
+  if (!existsSync3(serverJs)) {
     throw new Error(`Server not found at ${serverJs}. Reinstall with: npm install -g fleetlens`);
   }
   const portInUse = await checkPort(port);
@@ -4980,7 +5014,7 @@ async function startServer(opts = {}) {
   });
   child.unref();
   const pid = child.pid;
-  writePid(PID_FILE, pid, port, "0.15.3");
+  writePid(PID_FILE, pid, port, "0.15.4");
   await waitForHealth(`http://localhost:${port}`, 3e4);
   return { pid, port };
 }
@@ -5049,17 +5083,18 @@ __export(storage_exports, {
   appendSnapshot: () => appendSnapshot,
   latestClaudeCodeSnapshot: () => latestClaudeCodeSnapshot,
   latestSnapshot: () => latestSnapshot,
+  pruneAgent: () => pruneAgent,
   readSnapshots: () => readSnapshots
 });
-import { appendFileSync, mkdirSync as mkdirSync3, readFileSync as readFileSync4, existsSync as existsSync3 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync4 } from "node:fs";
 import { dirname as dirname4 } from "node:path";
 function appendSnapshot(filePath, snapshot) {
-  mkdirSync3(dirname4(filePath), { recursive: true });
-  appendFileSync(filePath, JSON.stringify(snapshot) + "\n", "utf8");
+  mkdirSync4(dirname4(filePath), { recursive: true });
+  appendFileSync2(filePath, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function readSnapshots(filePath) {
-  if (!existsSync3(filePath)) return [];
-  const content = readFileSync4(filePath, "utf8");
+  if (!existsSync4(filePath)) return [];
+  const content = readFileSync5(filePath, "utf8");
   const snapshots = [];
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -5074,6 +5109,19 @@ function latestSnapshot(filePath) {
   const all = readSnapshots(filePath);
   return all.length > 0 ? all[all.length - 1] : null;
 }
+function pruneAgent(filePath, agent) {
+  if (!existsSync4(filePath)) return;
+  const kept = readFileSync5(filePath, "utf8").split("\n").filter((line) => {
+    if (!line.trim()) return false;
+    try {
+      return JSON.parse(line).agent !== agent;
+    } catch {
+      return true;
+    }
+  });
+  mkdirSync4(dirname4(filePath), { recursive: true });
+  writeFileSync4(filePath, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
+}
 function latestClaudeCodeSnapshot(filePath) {
   const all = readSnapshots(filePath);
   for (let i = all.length - 1; i >= 0; i--) {
@@ -5099,7 +5147,7 @@ __export(daemon_exports, {
 import { spawn as spawn2 } from "node:child_process";
 import { join as join4, dirname as dirname5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { existsSync as existsSync4, statSync as statSync2, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync5, statSync as statSync2, readFileSync as readFileSync6 } from "node:fs";
 function startDaemonSilent() {
   cleanStalePid(DAEMON_PID, DAEMON_MARKERS);
   const existing = readPid(DAEMON_PID);
@@ -5107,7 +5155,7 @@ function startDaemonSilent() {
     return { started: false, pid: existing.pid, alreadyRunning: true };
   }
   const script = workerPath();
-  if (!existsSync4(script)) {
+  if (!existsSync5(script)) {
     return {
       started: false,
       pid: null,
@@ -5141,7 +5189,7 @@ function getDaemonStatusInfo() {
   const running = entry !== null && isProcessAlive(entry.pid, DAEMON_MARKERS);
   const latest = latestSnapshot(USAGE_LOG);
   const lastSnapshotAgeMs = latest ? Date.now() - new Date(latest.captured_at).getTime() : null;
-  const usageLogSize = existsSync4(USAGE_LOG) ? statSync2(USAGE_LOG).size : null;
+  const usageLogSize = existsSync5(USAGE_LOG) ? statSync2(USAGE_LOG).size : null;
   return {
     running,
     pid: running ? entry.pid : null,
@@ -5217,11 +5265,11 @@ function daemonStatus() {
   }
 }
 function daemonLogs() {
-  if (!existsSync4(DAEMON_LOG)) {
+  if (!existsSync5(DAEMON_LOG)) {
     console.log("No daemon logs yet.");
     return;
   }
-  const content = readFileSync5(DAEMON_LOG, "utf8");
+  const content = readFileSync6(DAEMON_LOG, "utf8");
   const lines = content.trim().split("\n").slice(-20);
   for (const line of lines) process.stdout.write(line + "\n");
 }
@@ -5241,7 +5289,7 @@ var init_daemon = __esm({
 
 // src/updater.ts
 import { execSync, spawnSync } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync6, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync7, realpathSync as realpathSync2 } from "node:fs";
 import { dirname as dirname6, join as join5 } from "node:path";
 function shouldUpdate(local, remote) {
   const l = local.split(".").map(Number);
@@ -5285,7 +5333,7 @@ function verifyInstalledVersion() {
       timeout: 5e3
     }).trim();
     const pkgPath = join5(globalRoot, PACKAGE_NAME, "package.json");
-    const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync7(pkgPath, "utf8"));
     if (!pkg.version) {
       return { ok: false, reason: `no version field in ${pkgPath}` };
     }
@@ -5349,9 +5397,9 @@ Installed: ${PACKAGE_NAME}@${verify.installedVersion}  at ${verify.installedPath
     console.warn(
       `    \u2022 reinstall in the correct Node env: 'npm install -g ${PACKAGE_NAME}@latest'`
     );
-  } else if (verify.installedVersion !== "0.15.3") {
+  } else if (verify.installedVersion !== "0.15.4") {
     console.log(
-      `  \u2192 This process is still running ${"0.15.3"}. Next invocation will use ${verify.installedVersion}.`
+      `  \u2192 This process is still running ${"0.15.4"}. Next invocation will use ${verify.installedVersion}.`
     );
   }
 }
@@ -5370,7 +5418,7 @@ function reExec() {
   let script = process.argv[1] ?? "";
   if (verify.ok) {
     const candidate = join5(verify.installedPath, "dist", "index.js");
-    if (existsSync5(candidate)) script = candidate;
+    if (existsSync6(candidate)) script = candidate;
   }
   const result = spawnSync(process.argv[0], [script, ...process.argv.slice(2)], {
     stdio: "inherit",
@@ -5386,14 +5434,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.15.3",
+    current: "0.15.4",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.15.3",
+    current: "0.15.4",
     latest,
-    updateAvailable: shouldUpdate("0.15.3", latest)
+    updateAvailable: shouldUpdate("0.15.4", latest)
   };
 }
 async function checkForUpdate() {
@@ -5483,7 +5531,7 @@ async function restartServices(state) {
 }
 async function forceUpdate() {
   const latest = await fetchLatestVersion();
-  const current = "0.15.3";
+  const current = "0.15.4";
   if (latest === null) {
     console.error("Could not reach npm registry. Check your network.");
     process.exit(1);
@@ -5535,7 +5583,7 @@ __export(autostart_exports, {
   maybePromptAutostart: () => maybePromptAutostart,
   recordOptOut: () => recordOptOut
 });
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, rmSync, readFileSync as readFileSync7, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, rmSync, readFileSync as readFileSync8, realpathSync as realpathSync3 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join6, dirname as dirname7 } from "node:path";
 import { execFile } from "node:child_process";
@@ -5548,14 +5596,14 @@ function isMac() {
   return process.platform === "darwin";
 }
 function isAutostartInstalled() {
-  return isMac() && existsSync6(plistPath());
+  return isMac() && existsSync7(plistPath());
 }
 function isStalePlistContent(content) {
   return content.includes("<string>daemon</string>");
 }
 function installedPlistIsStale() {
   try {
-    return isStalePlistContent(readFileSync7(plistPath(), "utf8"));
+    return isStalePlistContent(readFileSync8(plistPath(), "utf8"));
   } catch {
     return false;
   }
@@ -5606,8 +5654,8 @@ async function installAutostart() {
   const scriptPath = resolveScriptPath();
   const logPath = cclensPath("daemon-autostart.log");
   const p = plistPath();
-  mkdirSync4(dirname7(p), { recursive: true });
-  writeFileSync3(p, buildPlist({ nodePath, scriptPath, logPath }), "utf8");
+  mkdirSync5(dirname7(p), { recursive: true });
+  writeFileSync5(p, buildPlist({ nodePath, scriptPath, logPath }), "utf8");
   await runLaunchctl(["unload", p]).catch(() => {
   });
   await runLaunchctl(["load", "-w", p]);
@@ -5627,7 +5675,7 @@ async function uninstallAutostart() {
   }
   const p = plistPath();
   recordOptOut();
-  if (!existsSync6(p)) {
+  if (!existsSync7(p)) {
     console.log("Autostart is not installed \u2014 nothing to remove. Noted your opt-out; team join won't enable it.");
     return;
   }
@@ -5660,7 +5708,7 @@ async function statusAutostart() {
     return;
   }
   const p = plistPath();
-  const present = existsSync6(p);
+  const present = existsSync7(p);
   let loaded = false;
   try {
     const { stdout } = await execFileAsync("launchctl", ["list"]);
@@ -5675,7 +5723,7 @@ function promptFlagPath() {
 }
 function readFlags() {
   try {
-    return JSON.parse(readFileSync7(promptFlagPath(), "utf8"));
+    return JSON.parse(readFileSync8(promptFlagPath(), "utf8"));
   } catch {
     return {};
   }
@@ -5683,8 +5731,8 @@ function readFlags() {
 function writeFlags(patch) {
   const p = promptFlagPath();
   try {
-    mkdirSync4(dirname7(p), { recursive: true });
-    writeFileSync3(p, JSON.stringify({ ...readFlags(), ...patch }, null, 2), "utf8");
+    mkdirSync5(dirname7(p), { recursive: true });
+    writeFileSync5(p, JSON.stringify({ ...readFlags(), ...patch }, null, 2), "utf8");
   } catch {
   }
 }
@@ -5896,7 +5944,7 @@ async function status() {
     console.log(`Server:  running on ${url} (PID ${server.pid}, v${ver})`);
     if (isServerStale(server)) {
       console.log(
-        `  \u26A0  serving stale ${ver} (CLI is ${"0.15.3"}) \u2014 run 'fleetlens start' to restart on the current version`
+        `  \u26A0  serving stale ${ver} (CLI is ${"0.15.4"}) \u2014 run 'fleetlens start' to restart on the current version`
       );
     }
   } else {
@@ -5978,7 +6026,7 @@ var init_update = __esm({
 
 // src/usage/token.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir4, platform } from "node:os";
 import { join as join7 } from "node:path";
 function readOAuthCredentials() {
@@ -6006,7 +6054,7 @@ function readFromCredentialsFile() {
   ];
   for (const path7 of candidates) {
     try {
-      const blob = readFileSync8(path7, "utf8");
+      const blob = readFileSync9(path7, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -7001,6 +7049,7 @@ __export(dist_exports, {
   RATE_PER_PCT: () => RATE_PER_PCT,
   RATE_PER_PCT_5H: () => RATE_PER_PCT_5H,
   RATE_PER_PCT_7D: () => RATE_PER_PCT_7D,
+  ZAI_METADATA: () => ZAI_METADATA,
   agentMetadata: () => agentMetadata,
   aggregateConcurrency: () => aggregateConcurrency,
   buildGanttDay: () => buildGanttDay,
@@ -7830,11 +7879,11 @@ var init_dist2 = __esm({
 });
 
 // ../entries/dist/digest-fs.js
-import { readFileSync as readFileSync9, readdirSync, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync5, existsSync as existsSync7 } from "node:fs";
+import { readFileSync as readFileSync10, readdirSync, writeFileSync as writeFileSync6, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync6, existsSync as existsSync8 } from "node:fs";
 import { dirname as dirname8, join as join8 } from "node:path";
 function parseDigestFile(path7, expectedVersion) {
   try {
-    const parsed = JSON.parse(readFileSync9(path7, "utf8"));
+    const parsed = JSON.parse(readFileSync10(path7, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -7855,9 +7904,9 @@ function digestsDir() {
 }
 function __setDigestsDirForTest(path7) {
   digestsDirCached = path7;
-  mkdirSync5(join8(path7, "day"), { recursive: true });
-  mkdirSync5(join8(path7, "week"), { recursive: true });
-  mkdirSync5(join8(path7, "month"), { recursive: true });
+  mkdirSync6(join8(path7, "day"), { recursive: true });
+  mkdirSync6(join8(path7, "week"), { recursive: true });
+  mkdirSync6(join8(path7, "month"), { recursive: true });
 }
 function dayDigestPath(date) {
   return join8(digestsDir(), "day", `${date}.json`);
@@ -7870,9 +7919,9 @@ function monthDigestPath(yearMonth) {
 }
 function writeDayDigest(digest2) {
   const final = dayDigestPath(digest2.key);
-  mkdirSync5(dirname8(final), { recursive: true });
+  mkdirSync6(dirname8(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(digest2, null, 2), "utf8");
+  writeFileSync6(tmp, JSON.stringify(digest2, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -7883,7 +7932,7 @@ function writeDayDigest(digest2) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -7906,9 +7955,9 @@ function __clearTodayCacheForTest() {
 }
 function writeWeekDigest(digest2) {
   const final = weekDigestPath(digest2.key);
-  mkdirSync5(dirname8(final), { recursive: true });
+  mkdirSync6(dirname8(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(digest2, null, 2), "utf8");
+  writeFileSync6(tmp, JSON.stringify(digest2, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -7919,13 +7968,13 @@ function writeWeekDigest(digest2) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
 function listWeekDigestKeys() {
   const dir = join8(digestsDir(), "week");
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     return [];
   return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length)).filter((k) => /^\d{4}-\d{2}-\d{2}$/.test(k));
 }
@@ -7943,9 +7992,9 @@ function setCurrentWeekDigestInCache(monday, digest2, nowMs) {
 }
 function writeMonthDigest(digest2) {
   const final = monthDigestPath(digest2.key);
-  mkdirSync5(dirname8(final), { recursive: true });
+  mkdirSync6(dirname8(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(digest2, null, 2), "utf8");
+  writeFileSync6(tmp, JSON.stringify(digest2, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -7956,13 +8005,13 @@ function writeMonthDigest(digest2) {
 }
 function readMonthDigest(yearMonth) {
   const p = monthDigestPath(yearMonth);
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return null;
   return parseDigestFile(p, CURRENT_MONTH_DIGEST_SCHEMA_VERSION);
 }
 function listMonthDigestKeys() {
   const dir = join8(digestsDir(), "month");
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     return [];
   return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length)).filter((k) => /^\d{4}-\d{2}$/.test(k));
 }
@@ -8024,7 +8073,7 @@ __export(fs_exports2, {
   writeMonthDigest: () => writeMonthDigest,
   writeWeekDigest: () => writeWeekDigest
 });
-import { readFileSync as readFileSync10, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, renameSync as renameSync3, existsSync as existsSync8 } from "node:fs";
+import { readFileSync as readFileSync11, readdirSync as readdirSync2, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, renameSync as renameSync3, existsSync as existsSync9 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join as join9 } from "node:path";
 function entriesDir() {
@@ -8036,7 +8085,7 @@ function entriesDir() {
 }
 function __setEntriesDirForTest(path7) {
   entriesDirCached = path7;
-  mkdirSync6(path7, { recursive: true });
+  mkdirSync7(path7, { recursive: true });
 }
 function pathFor(sessionId, localDay2) {
   return join9(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
@@ -8046,11 +8095,11 @@ function tmpPathFor(final) {
 }
 function writeEntry(entry) {
   const dir = entriesDir();
-  mkdirSync6(dir, { recursive: true });
+  mkdirSync7(dir, { recursive: true });
   const final = pathFor(entry.session_id, entry.local_day);
   const tmp = tmpPathFor(final);
   const json = JSON.stringify(entry, null, 2);
-  writeFileSync5(tmp, json, { encoding: "utf8" });
+  writeFileSync7(tmp, json, { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 function enrichmentInputHash(e) {
@@ -8070,7 +8119,7 @@ function enrichmentInputHash(e) {
 }
 function writeEntryPreservingEnrichment(fresh) {
   const dir = entriesDir();
-  mkdirSync6(dir, { recursive: true });
+  mkdirSync7(dir, { recursive: true });
   const final = pathFor(fresh.session_id, fresh.local_day);
   const existing = readEntry(fresh.session_id, fresh.local_day);
   let toWrite = fresh;
@@ -8078,22 +8127,22 @@ function writeEntryPreservingEnrichment(fresh) {
     toWrite = { ...fresh, enrichment: existing.enrichment };
   }
   const tmp = tmpPathFor(final);
-  writeFileSync5(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
+  writeFileSync7(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 function readEntry(sessionId, localDay2) {
   const p = pathFor(sessionId, localDay2);
-  if (!existsSync8(p))
+  if (!existsSync9(p))
     return null;
-  const raw = readFileSync10(p, "utf8");
+  const raw = readFileSync11(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync8(pathFor(sessionId, localDay2));
+  return existsSync9(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -12372,7 +12421,7 @@ RESPOND WITH ONLY VALID JSON (no prose, no code fence):
 });
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6, existsSync as existsSync9, readdirSync as readdirSync3, realpathSync as realpathSync4, readFileSync as readFileSync11, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, existsSync as existsSync10, readdirSync as readdirSync3, realpathSync as realpathSync4, readFileSync as readFileSync12, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
 import { join as join10 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -12391,15 +12440,15 @@ function tmuxRunnerAvailable() {
 }
 function runtimeCwd() {
   const dir = join10(homedir5(), ".cclens", "runtime");
-  if (!existsSync9(dir))
-    mkdirSync7(dir, { recursive: true });
+  if (!existsSync10(dir))
+    mkdirSync8(dir, { recursive: true });
   return realpathSync4(dir);
 }
 function ensureRuntimeCwdTrusted(cwd) {
   const cfgPath = join10(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync11(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync12(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -12414,7 +12463,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   cfg.projects = projects;
   const tmp = `${cfgPath}.cclens-tmp-${process.pid}`;
   try {
-    writeFileSync6(tmp, JSON.stringify(cfg, null, 2));
+    writeFileSync8(tmp, JSON.stringify(cfg, null, 2));
     renameSync4(tmp, cfgPath);
   } catch {
     try {
@@ -12444,13 +12493,13 @@ async function runClaudeUnderTmuxImpl(args2) {
   const systemFile = join10(cwd, `system-${runId}.txt`);
   const userFile = join10(cwd, `user-${runId}.txt`);
   const wrapper = join10(cwd, `run-${runId}.sh`);
-  writeFileSync6(systemFile, args2.systemPrompt);
-  writeFileSync6(userFile, args2.reminder ? `${args2.userPrompt}
+  writeFileSync8(systemFile, args2.systemPrompt);
+  writeFileSync8(userFile, args2.reminder ? `${args2.userPrompt}
 
 ---
 
 ${args2.reminder}` : args2.userPrompt);
-  writeFileSync6(wrapper, `#!/bin/bash
+  writeFileSync8(wrapper, `#!/bin/bash
 SYS="$(cat ${shellEscape(systemFile)})"
 USR="$(cat ${shellEscape(userFile)})"
 exec ${shellEscape(claudeBin)} \\
@@ -12549,7 +12598,7 @@ function snapshotAllTranscripts() {
 function readJsonlCwd(path7, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync11(path7, "utf8");
+    raw = readFileSync12(path7, "utf8");
   } catch {
     return void 0;
   }
@@ -12606,7 +12655,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
 function parseTranscript2(path7, defaultModel) {
   let raw;
   try {
-    raw = readFileSync11(path7, "utf8");
+    raw = readFileSync12(path7, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -12700,13 +12749,13 @@ var init_tmux_runner = __esm({
 
 // ../entries/dist/llm-runner.js
 import { spawn as spawn3 } from "node:child_process";
-import { mkdirSync as mkdirSync8, appendFileSync as appendFileSync2, writeFileSync as writeFileSync7, existsSync as existsSync10 } from "node:fs";
+import { mkdirSync as mkdirSync9, appendFileSync as appendFileSync3, writeFileSync as writeFileSync9, existsSync as existsSync11 } from "node:fs";
 import { join as join11 } from "node:path";
 import { randomUUID } from "node:crypto";
 function ensureRunsDir() {
-  if (!existsSync10(RUNS_DIR)) {
+  if (!existsSync11(RUNS_DIR)) {
     try {
-      mkdirSync8(RUNS_DIR, { recursive: true });
+      mkdirSync9(RUNS_DIR, { recursive: true });
     } catch {
     }
   }
@@ -12737,13 +12786,13 @@ function tracePath(runId) {
 }
 function safeAppend(path7, line) {
   try {
-    appendFileSync2(path7, line);
+    appendFileSync3(path7, line);
   } catch {
   }
 }
 function safeWrite(path7, line) {
   try {
-    writeFileSync7(path7, line);
+    writeFileSync9(path7, line);
   } catch {
   }
 }
@@ -13149,7 +13198,7 @@ var init_enrich2 = __esm({
 });
 
 // ../entries/dist/budget.js
-import { appendFileSync as appendFileSync3, readFileSync as readFileSync12, existsSync as existsSync11, mkdirSync as mkdirSync9 } from "node:fs";
+import { appendFileSync as appendFileSync4, readFileSync as readFileSync13, existsSync as existsSync12, mkdirSync as mkdirSync10 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 function spendPath() {
   if (spendPathCached)
@@ -13162,17 +13211,17 @@ function __setSpendPathForTest(path7) {
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync9(dirname9(p), { recursive: true });
-  appendFileSync3(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
+  mkdirSync10(dirname9(p), { recursive: true });
+  appendFileSync4(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync11(p))
+  if (!existsSync12(p))
     return 0;
   const year = now.getUTCFullYear();
   const month2 = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync12(p, "utf8");
+  const raw = readFileSync13(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -13201,7 +13250,7 @@ var init_budget = __esm({
 });
 
 // ../entries/dist/pipeline-lock.js
-import { writeFileSync as writeFileSync8, unlinkSync as unlinkSync4, existsSync as existsSync12, readFileSync as readFileSync13, statSync as statSync3 } from "node:fs";
+import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync13, readFileSync as readFileSync14, statSync as statSync3 } from "node:fs";
 function lockPath() {
   if (lockPathCached)
     return lockPathCached;
@@ -13212,7 +13261,7 @@ function __setInteractiveLockPathForTest(path7) {
   lockPathCached = path7;
 }
 function touchLock() {
-  writeFileSync8(lockPath(), String(process.pid), "utf8");
+  writeFileSync10(lockPath(), String(process.pid), "utf8");
 }
 function writeInteractiveLock() {
   touchLock();
@@ -13246,13 +13295,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync12(p))
+  if (!existsSync13(p))
     return false;
   try {
     const mtime = statSync3(p).mtimeMs;
     if (nowMs - mtime > STALE_MS)
       return false;
-    const pid = Number(readFileSync13(p, "utf8").trim());
+    const pid = Number(readFileSync14(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -13358,7 +13407,7 @@ var init_queue = __esm({
 });
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync10, existsSync as existsSync13 } from "node:fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 function settingsPath() {
   if (settingsPathCached)
@@ -13394,10 +13443,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync13(p))
+  if (!existsSync14(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync14(p, "utf8");
+    const raw = readFileSync15(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -13405,9 +13454,9 @@ function readSettings() {
 }
 function writeSettings(s) {
   const p = settingsPath();
-  mkdirSync10(dirname10(p), { recursive: true });
+  mkdirSync11(dirname10(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  writeFileSync9(tmp, JSON.stringify(toDisk(s), null, 2), { encoding: "utf8" });
+  writeFileSync11(tmp, JSON.stringify(toDisk(s), null, 2), { encoding: "utf8" });
   if (process.platform !== "win32") {
     chmodSync2(tmp, 384);
   }
@@ -16586,6 +16635,142 @@ var init_digest_month_pipeline = __esm({
   }
 });
 
+// ../entries/dist/credentials.js
+import { writeFileSync as writeFileSync12, readFileSync as readFileSync16, renameSync as renameSync6, chmodSync as chmodSync3, mkdirSync as mkdirSync12, existsSync as existsSync15, unlinkSync as unlinkSync5 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
+async function fetchZaiUsage(candidate) {
+  const key = candidate.trim();
+  if (!key)
+    throw new Error("empty key");
+  const res = await fetch(ZAI_QUOTA_ENDPOINT, {
+    headers: { Authorization: key, "Accept-Language": "en-US,en" }
+  });
+  if (!res.ok) {
+    throw new Error(`Z.ai rejected the key (${res.status} ${res.statusText})`);
+  }
+  const body = await res.json().catch(() => {
+    throw new Error("Z.ai returned an unparseable response");
+  });
+  if (body.code !== void 0 && body.code !== 200) {
+    throw new Error(`Z.ai rejected the key (code ${body.code})`);
+  }
+  if (body.success === false) {
+    throw new Error("Z.ai rejected the key");
+  }
+  const limits = body.data?.limits ?? [];
+  let fiveHour = null;
+  let sevenDay = null;
+  let webSearch = null;
+  for (const limit of limits) {
+    const type = limit.type;
+    if (type === "TIME_LIMIT") {
+      const pct2 = typeof limit.percentage === "number" ? limit.percentage : null;
+      webSearch = { used: pct2, limit: pct2 !== null ? 100 : null };
+      continue;
+    }
+    if (type !== "TOKENS_LIMIT")
+      continue;
+    const unit = limit.unit;
+    const pct = typeof limit.percentage === "number" ? limit.percentage : null;
+    const resetsAt = typeof limit.nextResetTime === "number" ? new Date(limit.nextResetTime).toISOString() : null;
+    const window = { utilization: pct, resets_at: resetsAt };
+    if (unit === 6)
+      sevenDay = sevenDay ?? window;
+    else
+      fiveHour = fiveHour ?? window;
+  }
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    agent: "zai",
+    five_hour: fiveHour ?? { utilization: null, resets_at: null },
+    seven_day: sevenDay ?? { utilization: null, resets_at: null },
+    seven_day_opus: null,
+    seven_day_sonnet: null,
+    seven_day_oauth_apps: null,
+    seven_day_cowork: null,
+    extra_usage: null,
+    plan_type: body.data?.level ?? null,
+    web_search_quota: webSearch ?? null
+  };
+}
+async function validateAndSnapshotZaiKey(key) {
+  const snap = await fetchZaiUsage(key);
+  appendUsageSnapshot(snap);
+  return snap;
+}
+function deleteZaiKeyAndPrune() {
+  deleteZaiKey();
+  pruneUsageAgent("zai");
+}
+function credentialsPath() {
+  return cclensPath("credentials.json");
+}
+function readCredentials() {
+  const p = credentialsPath();
+  if (!existsSync15(p))
+    return {};
+  try {
+    const raw = readFileSync16(p, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function readCredentialsMasked() {
+  const store = readCredentials();
+  if (!store.zai?.apiKey)
+    return {};
+  const key = store.zai.apiKey;
+  const hint = key.length > 12 ? `${key.slice(0, 6)}\u2026${key.slice(-6)}` : `${key.slice(0, 6)}\u2026`;
+  return { zai: { configured: true, hint } };
+}
+function writeZaiKey(apiKey) {
+  apiKey = apiKey.trim();
+  if (!apiKey) {
+    deleteZaiKey();
+    return;
+  }
+  const store = readCredentials();
+  store.zai = { ...store.zai ?? {}, apiKey };
+  const p = credentialsPath();
+  mkdirSync12(dirname11(p), { recursive: true });
+  const tmp = `${p}.tmp`;
+  writeFileSync12(tmp, JSON.stringify(store, null, 2), { encoding: "utf8" });
+  if (process.platform !== "win32") {
+    chmodSync3(tmp, 384);
+  }
+  renameSync6(tmp, p);
+}
+function deleteZaiKey() {
+  const store = readCredentials();
+  delete store.zai;
+  const p = credentialsPath();
+  if (Object.keys(store).length === 0) {
+    try {
+      unlinkSync5(p);
+    } catch {
+    }
+    return;
+  }
+  const tmp = `${p}.tmp`;
+  writeFileSync12(tmp, JSON.stringify(store, null, 2), { encoding: "utf8" });
+  if (process.platform !== "win32") {
+    chmodSync3(tmp, 384);
+  }
+  renameSync6(tmp, p);
+}
+function hasZaiKey() {
+  return !!readCredentials().zai?.apiKey;
+}
+var ZAI_QUOTA_ENDPOINT;
+var init_credentials = __esm({
+  "../entries/dist/credentials.js"() {
+    "use strict";
+    init_fs();
+    ZAI_QUOTA_ENDPOINT = "https://api.z.ai/api/monitor/usage/quota/limit";
+  }
+});
+
 // ../entries/dist/node.js
 var node_exports = {};
 __export(node_exports, {
@@ -16616,19 +16801,25 @@ __export(node_exports, {
   computeInteractionGrammar: () => computeInteractionGrammar,
   computeInteractionModes: () => computeInteractionModes,
   computeWorkingShapes: () => computeWorkingShapes,
+  deleteZaiKey: () => deleteZaiKey,
+  deleteZaiKeyAndPrune: () => deleteZaiKeyAndPrune,
   enrichEntry: () => enrichEntry,
+  fetchZaiUsage: () => fetchZaiUsage,
   generateDayDigest: () => generateDayDigest,
   generateMonthDigest: () => generateMonthDigest,
   generateWeekDigest: () => generateWeekDigest,
   getCurrentMonthDigestFromCache: () => getCurrentMonthDigestFromCache,
   getCurrentWeekDigestFromCache: () => getCurrentWeekDigestFromCache,
   getTodayDigestFromCache: () => getTodayDigestFromCache,
+  hasZaiKey: () => hasZaiKey,
   interactiveLockFresh: () => interactiveLockFresh,
   listMonthDigestKeys: () => listMonthDigestKeys,
   listWeekDigestKeys: () => listWeekDigestKeys,
   mondayFor: () => mondayFor,
   mondaysInMonth: () => mondaysInMonth,
   monthToDateSpend: () => monthToDateSpend,
+  readCredentials: () => readCredentials,
+  readCredentialsMasked: () => readCredentialsMasked,
   readDayDigest: () => readDayDigest,
   readMonthDigest: () => readMonthDigest,
   readSettings: () => readSettings,
@@ -16643,12 +16834,14 @@ __export(node_exports, {
   setCurrentWeekDigestInCache: () => setCurrentWeekDigestInCache,
   setTodayDigestInCache: () => setTodayDigestInCache,
   tmuxRunnerAvailable: () => tmuxRunnerAvailable,
+  validateAndSnapshotZaiKey: () => validateAndSnapshotZaiKey,
   weekDates: () => weekDates,
   writeDayDigest: () => writeDayDigest,
   writeInteractiveLock: () => writeInteractiveLock,
   writeMonthDigest: () => writeMonthDigest,
   writeSettings: () => writeSettings,
-  writeWeekDigest: () => writeWeekDigest
+  writeWeekDigest: () => writeWeekDigest,
+  writeZaiKey: () => writeZaiKey
 });
 var init_node = __esm({
   "../entries/dist/node.js"() {
@@ -16670,6 +16863,7 @@ var init_node = __esm({
     init_digest_month_pipeline();
     init_tmux_runner();
     init_digest_fs();
+    init_credentials();
   }
 });
 
@@ -17139,6 +17333,230 @@ var init_digest = __esm({
   }
 });
 
+// src/commands/menubar.ts
+var menubar_exports = {};
+__export(menubar_exports, {
+  menubar: () => menubar
+});
+import { existsSync as existsSync16, mkdirSync as mkdirSync13, cpSync, rmSync as rmSync2, readdirSync as readdirSync4, writeFileSync as writeFileSync13, realpathSync as realpathSync5 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
+import { join as join12, dirname as dirname12 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+function isMac2() {
+  return process.platform === "darwin";
+}
+function bundledAppPath() {
+  const here = dirname12(fileURLToPath3(import.meta.url));
+  return join12(here, "..", "menubar", APP_BUNDLE);
+}
+function resolveScriptPath2() {
+  const argv1 = process.argv[1] ?? "";
+  try {
+    return realpathSync5(argv1);
+  } catch {
+    return argv1;
+  }
+}
+function writeCliLaunchFile() {
+  try {
+    writeFileSync13(
+      cclensPath("cli-launch.json"),
+      JSON.stringify({ node: process.execPath, script: resolveScriptPath2() }),
+      "utf8"
+    );
+  } catch {
+  }
+}
+function installedAppPath() {
+  return join12(homedir6(), "Applications", APP_BUNDLE);
+}
+async function isRunning() {
+  try {
+    const { stdout } = await execFileAsync2("pgrep", ["-x", BUNDLE_EXEC]);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function launchApp(path7) {
+  await execFileAsync2("open", ["-a", path7]);
+}
+async function quitApp() {
+  await execFileAsync2("osascript", ["-e", `tell application "${BUNDLE_EXEC}" to quit`]).catch(
+    () => {
+    }
+  );
+  await execFileAsync2("pkill", ["-x", BUNDLE_EXEC]).catch(() => {
+  });
+}
+async function setLoginItem(enabled, appPath) {
+  const script = enabled ? `tell application "System Events" to make login item at end with properties {path:"${appPath}", hidden:false}` : `tell application "System Events" to delete login item "${APP_BUNDLE.replace(".app", "")}"`;
+  await execFileAsync2("osascript", ["-e", script]).catch(() => {
+  });
+}
+async function installMenubar(opts) {
+  if (!isMac2()) {
+    console.log(NON_MAC_MSG2);
+    return;
+  }
+  const src = bundledAppPath();
+  if (!existsSync16(src)) {
+    console.error(
+      `Bundled widget not found at ${src}.
+This install was probably built without the menubar artifact. Run \`node apps/menubar/build-app.sh && cp -R apps/menubar/dist/FleetlensMenubar.app packages/cli/menubar/\` and rebuild.`
+    );
+    process.exit(1);
+  }
+  const destDir = join12(homedir6(), "Applications");
+  mkdirSync13(destDir, { recursive: true });
+  const dest = installedAppPath();
+  if (await isRunning()) {
+    console.log("Stopping the running widget\u2026");
+    await quitApp();
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  rmSync2(dest, { recursive: true, force: true });
+  cpSync(src, dest, { recursive: true });
+  writeCliLaunchFile();
+  console.log(`Installed \u2192 ${dest}`);
+  if (opts.login) {
+    await setLoginItem(true, dest);
+    console.log("Login item enabled (launches at login).");
+  }
+  if (opts.open) {
+    await launchApp(dest);
+    console.log("Opened \u2014 check your menu bar (gauge icon on the right side).");
+  } else {
+    console.log(`Launch with:  open -a "${dest}"`);
+  }
+}
+async function uninstallMenubar() {
+  if (!isMac2()) {
+    console.log(NON_MAC_MSG2);
+    return;
+  }
+  await setLoginItem(false, installedAppPath());
+  if (await isRunning()) {
+    console.log("Quitting the running widget\u2026");
+    await quitApp();
+    await new Promise((r) => setTimeout(r, 300));
+  }
+  const dest = installedAppPath();
+  if (existsSync16(dest)) {
+    rmSync2(dest, { recursive: true, force: true });
+    console.log(`Removed ${dest}`);
+  } else {
+    console.log("Widget is not installed \u2014 nothing to remove.");
+  }
+  console.log("Login item cleared (if it was set).");
+}
+async function openMenubar() {
+  if (!isMac2()) {
+    console.log(NON_MAC_MSG2);
+    return;
+  }
+  const dest = installedAppPath();
+  if (!existsSync16(dest)) {
+    console.log("Widget not installed yet. Run `fleetlens menubar install` first.");
+    return;
+  }
+  if (await isRunning()) {
+    console.log("Widget is already running.");
+    return;
+  }
+  await launchApp(dest);
+  console.log("Opened \u2014 check your menu bar.");
+}
+async function statusMenubar() {
+  if (!isMac2()) {
+    console.log(`Menu bar widget: macOS-only (not available on ${process.platform}).`);
+    return;
+  }
+  const dest = installedAppPath();
+  const installed = existsSync16(dest);
+  const running = await isRunning();
+  const bundled = existsSync16(bundledAppPath());
+  console.log(`Menu bar widget: ${installed ? "installed" : "not installed"}${installed ? ` (${dest})` : ""}`);
+  console.log(`Running:         ${running ? "yes" : "no"}`);
+  console.log(`Bundled in CLI:  ${bundled ? "yes" : "no \u2014 this build ships without the widget"}`);
+  if (installed) {
+    try {
+      const apps = readdirSync4(join12(homedir6(), "Applications"));
+      const ours = apps.find((a) => a === APP_BUNDLE);
+      console.log(`App bundle:      ${ours ? "present in ~/Applications" : "missing"}`);
+    } catch {
+    }
+  }
+}
+async function menubar(args2) {
+  const sub = args2[0] ?? "status";
+  const flags = args2.slice(1);
+  const noOpen = flags.includes("--no-open");
+  const noLogin = flags.includes("--no-login");
+  switch (sub) {
+    case "install": {
+      await installMenubar({ open: !noOpen, login: !noLogin });
+      break;
+    }
+    case "uninstall":
+    case "remove":
+      await uninstallMenubar();
+      break;
+    case "open":
+    case "start":
+      await openMenubar();
+      break;
+    case "stop":
+    case "quit":
+      if (await isRunning()) {
+        await quitApp();
+        console.log("Stopped.");
+      } else {
+        console.log("Widget is not running.");
+      }
+      break;
+    case "status":
+      await statusMenubar();
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      console.log(`Usage: fleetlens menubar <install|uninstall|open|stop|status>
+
+  install [--no-open] [--no-login]   Copy the native macOS menu bar widget to
+                                     ~/Applications and launch it. Registers a
+                                     login item by default.
+  uninstall                          Quit + remove the widget, clear login item.
+  open                               Launch the installed widget.
+  stop                               Quit the running widget.
+  status                             Show install/running/bundled state.
+
+The widget tails ~/.cclens/usage.jsonl and shows live Claude Code / Codex
+plan utilization in the menu bar. Click it for a popover, or "Dashboard" to
+open http://localhost:3321.`);
+      break;
+    default:
+      console.error(
+        `Unknown menubar subcommand: ${sub}
+Usage: fleetlens menubar <install|uninstall|open|stop|status>`
+      );
+      process.exit(1);
+  }
+}
+var execFileAsync2, APP_BUNDLE, BUNDLE_EXEC, NON_MAC_MSG2;
+var init_menubar = __esm({
+  "src/commands/menubar.ts"() {
+    "use strict";
+    init_fs();
+    execFileAsync2 = promisify2(execFile2);
+    APP_BUNDLE = "FleetlensMenubar.app";
+    BUNDLE_EXEC = "FleetlensMenubar";
+    NON_MAC_MSG2 = "The Fleetlens menu bar widget is a native macOS app and is macOS-only. On Linux/Windows, keep using the dashboard at the printed URL.";
+  }
+});
+
 // src/team/config.ts
 var init_config = __esm({
   "src/team/config.ts"() {
@@ -17148,8 +17566,8 @@ var init_config = __esm({
 });
 
 // src/perception/build-entries.ts
-import { statSync as statSync4, readFileSync as readFileSync15 } from "node:fs";
-import { basename as basename2, dirname as dirname11 } from "node:path";
+import { statSync as statSync4, readFileSync as readFileSync17 } from "node:fs";
+import { basename as basename2, dirname as dirname13 } from "node:path";
 function decodeProjectDirName(projectDir) {
   if (projectDir.startsWith("-")) {
     return "/" + projectDir.slice(1).replace(/-/g, "/");
@@ -17158,7 +17576,7 @@ function decodeProjectDirName(projectDir) {
 }
 function buildEntriesForFile(filePath) {
   const stat = statSync4(filePath);
-  const raw = readFileSync15(filePath, "utf8");
+  const raw = readFileSync17(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -17169,7 +17587,7 @@ function buildEntriesForFile(filePath) {
   if (rawLines.length === 0) return null;
   const { meta, events } = parseTranscript(rawLines);
   const fileName = basename2(filePath);
-  const projectDir = basename2(dirname11(filePath));
+  const projectDir = basename2(dirname13(filePath));
   const sessionId = fileName.replace(/\.jsonl$/, "");
   const sd = {
     ...meta,
@@ -17423,7 +17841,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID2(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "0.15.3",
+    cliVersion: "0.15.4",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -17464,8 +17882,8 @@ var init_push = __esm({
 });
 
 // src/team/git-remote.ts
-import { existsSync as existsSync14, readFileSync as readFileSync16, statSync as statSync5 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute2, join as join12, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync18, statSync as statSync5 } from "node:fs";
+import { dirname as dirname14, isAbsolute as isAbsolute2, join as join13, resolve as resolve2 } from "node:path";
 function parseGithubRemote(url) {
   const m = url.trim().match(GITHUB_URL_RE);
   return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
@@ -17485,19 +17903,19 @@ function originUrl2(configText) {
   return null;
 }
 function gitConfigPathFor(dir) {
-  const dotGit = join12(dir, ".git");
+  const dotGit = join13(dir, ".git");
   const st = statSync5(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
-  if (st.isDirectory()) return join12(dotGit, "config");
-  const m = readFileSync16(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  if (st.isDirectory()) return join13(dotGit, "config");
+  const m = readFileSync18(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
   const gd = isAbsolute2(m[1]) ? m[1] : resolve2(dir, m[1]);
-  const commondirFile = join12(gd, "commondir");
-  if (existsSync14(commondirFile)) {
-    const common = readFileSync16(commondirFile, "utf8").trim();
-    return join12(isAbsolute2(common) ? common : resolve2(gd, common), "config");
+  const commondirFile = join13(gd, "commondir");
+  if (existsSync17(commondirFile)) {
+    const common = readFileSync18(commondirFile, "utf8").trim();
+    return join13(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
-  return join12(gd, "config");
+  return join13(gd, "config");
 }
 function createRepoResolver() {
   const cache = /* @__PURE__ */ new Map();
@@ -17507,14 +17925,14 @@ function createRepoResolver() {
     if (hit !== void 0) return hit;
     let repo = null;
     try {
-      for (let d = dir; ; d = dirname12(d)) {
+      for (let d = dir; ; d = dirname14(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync14(config)) {
-          const url = originUrl2(readFileSync16(config, "utf8"));
+        if (config && existsSync17(config)) {
+          const url = originUrl2(readFileSync18(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
-        if (d === dirname12(d)) break;
+        if (d === dirname14(d)) break;
       }
     } catch {
       repo = null;
@@ -17532,12 +17950,12 @@ var init_git_remote = __esm({
 });
 
 // src/team/queue.ts
-import { readFileSync as readFileSync17, writeFileSync as writeFileSync10, appendFileSync as appendFileSync4, statSync as statSync6, mkdirSync as mkdirSync11 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync14, appendFileSync as appendFileSync5, statSync as statSync6, mkdirSync as mkdirSync14 } from "node:fs";
+import { dirname as dirname15 } from "node:path";
 function enqueuePayload(payload, queuePath = QUEUE_PATH) {
-  mkdirSync11(dirname13(queuePath), { recursive: true });
+  mkdirSync14(dirname15(queuePath), { recursive: true });
   const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  appendFileSync4(queuePath, JSON.stringify(entry) + "\n", "utf8");
+  appendFileSync5(queuePath, JSON.stringify(entry) + "\n", "utf8");
   try {
     const { size } = statSync6(queuePath);
     if (size > MAX_SIZE_BYTES) {
@@ -17549,7 +17967,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync17(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync19(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -17564,18 +17982,18 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
     } catch {
     }
   }
-  writeFileSync10(queuePath, "", "utf8");
+  writeFileSync14(queuePath, "", "utf8");
   return valid.map((e) => e.payload);
 }
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync17(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync19(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
   const keep = lines.slice(Math.floor(lines.length / 2));
-  writeFileSync10(queuePath, keep.join("\n") + "\n", "utf8");
+  writeFileSync14(queuePath, keep.join("\n") + "\n", "utf8");
 }
 var QUEUE_PATH, MAX_SIZE_BYTES, MAX_AGE_MS;
 var init_queue2 = __esm({
@@ -17589,8 +18007,8 @@ var init_queue2 = __esm({
 });
 
 // src/usage/profile.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync15, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname16 } from "node:path";
 function mapRateLimitTier(rateLimitTier) {
   switch (rateLimitTier) {
     case "default_claude_pro":
@@ -17630,9 +18048,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync15(cachePath)) return null;
+  if (!existsSync18(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync18(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync20(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -17640,8 +18058,8 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync12(dirname14(cachePath), { recursive: true });
-  writeFileSync11(
+  mkdirSync15(dirname16(cachePath), { recursive: true });
+  writeFileSync15(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
     { mode: 384 }
@@ -17821,11 +18239,11 @@ var init_backfill = __esm({
 });
 
 // src/team/sync-log.ts
-import { readFileSync as readFileSync19 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 function readPendingSyncLog(watermark) {
   let raw;
   try {
-    raw = readFileSync19(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync21(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -17853,12 +18271,12 @@ var init_sync_log = __esm({
 });
 
 // src/team/last-push.ts
-import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync5, mkdirSync as mkdirSync13 } from "node:fs";
-import { join as join13 } from "node:path";
+import { writeFileSync as writeFileSync16, unlinkSync as unlinkSync6, mkdirSync as mkdirSync16 } from "node:fs";
+import { join as join14 } from "node:path";
 function write(record, dir) {
   const d = dir ?? cclensHome();
-  mkdirSync13(d, { recursive: true });
-  writeFileSync12(join13(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
+  mkdirSync16(d, { recursive: true });
+  writeFileSync16(join14(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
 }
 function writeLastPushSuccess(payload, dir) {
   write({ pushedAt: (/* @__PURE__ */ new Date()).toISOString(), ok: true, payload }, dir);
@@ -17869,7 +18287,7 @@ function writeLastPushFailure(payload, error, dir) {
 function clearLastPush(dir) {
   const d = dir ?? cclensHome();
   try {
-    unlinkSync5(join13(d, LAST_PUSH_FILE));
+    unlinkSync6(join14(d, LAST_PUSH_FILE));
   } catch {
   }
 }
@@ -17889,35 +18307,35 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync16, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
-import { join as join14, relative, resolve as resolve3, sep } from "node:path";
+import { existsSync as existsSync19, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { homedir as homedir7 } from "node:os";
+import { join as join15, relative, resolve as resolve3, sep } from "node:path";
 import { execFileSync as execFileSync3 } from "node:child_process";
 function pathHash(relPath) {
   return createHash("sha256").update(relPath.split(sep).join("/")).digest("hex").slice(0, 32);
 }
 function defaultScanRoots(extraRoots = []) {
   const roots = [];
-  const home = join14(homedir6(), ".claude");
-  if (existsSync16(home)) roots.push({ root: home, label: "user" });
+  const home = join15(homedir7(), ".claude");
+  if (existsSync19(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
     const r = resolve3(e, ".claude");
-    if (existsSync16(r) && r !== home) roots.push({ root: r, label: "project" });
+    if (existsSync19(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync16(dir)) return [];
+  if (!existsSync19(dir)) return [];
   const out = [];
   let entries2;
   try {
-    entries2 = readdirSync4(dir);
+    entries2 = readdirSync5(dir);
   } catch {
     return [];
   }
   for (const name of entries2) {
     if (name.startsWith(".")) continue;
-    const full = join14(dir, name);
+    const full = join15(dir, name);
     let stat;
     try {
       stat = statSync7(full);
@@ -17937,7 +18355,7 @@ function firstSeenDateOf(file) {
     const out = execFileSync3(
       "git",
       ["log", "--diff-filter=A", "--follow", "--format=%cs", "--", file],
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname15(file) }
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname17(file) }
     ).trim().split("\n").filter(Boolean);
     if (out.length > 0) return out[out.length - 1];
   } catch {
@@ -17949,7 +18367,7 @@ function firstSeenDateOf(file) {
     return todayLocal();
   }
 }
-function dirname15(p) {
+function dirname17(p) {
   const i = p.lastIndexOf(sep);
   return i < 0 ? "." : p.slice(0, i);
 }
@@ -17976,8 +18394,8 @@ function todayLocal() {
 function scanAuthored(roots, subdir, day2) {
   const out = [];
   for (const r of roots) {
-    const dir = join14(r.root, subdir);
-    if (!existsSync16(dir)) continue;
+    const dir = join15(r.root, subdir);
+    if (!existsSync19(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day2) continue;
@@ -17990,8 +18408,8 @@ function scanAuthored(roots, subdir, day2) {
 function scanEdited(roots, day2) {
   const out = [];
   for (const r of roots) {
-    const dir = join14(r.root, "skills");
-    if (!existsSync16(dir)) continue;
+    const dir = join15(r.root, "skills");
+    if (!existsSync19(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day2) continue;
@@ -18014,16 +18432,16 @@ function claudemdLineDelta(extraRoots, authorEmail, day2) {
   const candidates = [];
   for (const e of extraRoots) {
     const f = resolve3(e, "CLAUDE.md");
-    if (existsSync16(f)) candidates.push(f);
+    if (existsSync19(f)) candidates.push(f);
   }
-  const homeClaudeMd = join14(homedir6(), "CLAUDE.md");
-  if (existsSync16(homeClaudeMd)) candidates.push(homeClaudeMd);
+  const homeClaudeMd = join15(homedir7(), "CLAUDE.md");
+  if (existsSync19(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync3(
         "git",
         ["log", "--numstat", "--format=COMMIT %cs %ae", "--", file],
-        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname15(file) }
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname17(file) }
       );
       let currentDate = "";
       let currentEmail = "";
@@ -18674,10 +19092,10 @@ var daemon_log_exports = {};
 __export(daemon_log_exports, {
   appendDaemonLogLine: () => appendDaemonLogLine
 });
-import { appendFileSync as appendFileSync5 } from "node:fs";
+import { appendFileSync as appendFileSync6 } from "node:fs";
 function appendDaemonLogLine(level, msg) {
   try {
-    appendFileSync5(
+    appendFileSync6(
       cclensPath("daemon.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${level.toUpperCase()} ${msg}
 `,
@@ -18890,11 +19308,11 @@ var logs_exports = {};
 __export(logs_exports, {
   teamLogs: () => teamLogs
 });
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync22 } from "node:fs";
 async function teamLogs() {
   const logPath = cclensPath("daemon.log");
   try {
-    const lines = readFileSync20(logPath, "utf8").trim().split("\n");
+    const lines = readFileSync22(logPath, "utf8").trim().split("\n");
     const teamLines = lines.filter((l) => l.includes("[sync] ") || l.includes("team "));
     if (teamLines.length === 0) {
       console.log("No team-related log entries found.");
@@ -19022,8 +19440,8 @@ __export(runs_exports, {
   runs: () => runs
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync17, readFileSync as readFileSync21, readdirSync as readdirSync5, statSync as statSync8 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync23, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
+import { join as join16 } from "node:path";
 async function runs(args2) {
   const json = args2.includes("--json");
   const watch = args2.includes("--watch");
@@ -19107,8 +19525,8 @@ function listActiveRuns() {
   return runs2.sort((a, b) => a.elapsed_s - b.elapsed_s);
 }
 function readSpend(sinceMs) {
-  if (!existsSync17(SPEND_PATH)) return [];
-  const lines = readFileSync21(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
+  if (!existsSync20(SPEND_PATH)) return [];
+  const lines = readFileSync23(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
   const out = [];
   for (const line of lines) {
     try {
@@ -19229,23 +19647,23 @@ function ageLabel(ms) {
   return `${Math.floor(ms / 864e5)}d`;
 }
 function listTraceFiles() {
-  if (!existsSync17(RUNS_DIR2)) return [];
-  const entries2 = readdirSync5(RUNS_DIR2).filter((f) => f.endsWith(".jsonl"));
+  if (!existsSync20(RUNS_DIR2)) return [];
+  const entries2 = readdirSync6(RUNS_DIR2).filter((f) => f.endsWith(".jsonl"));
   return entries2.map((f) => {
-    const path7 = join15(RUNS_DIR2, f);
+    const path7 = join16(RUNS_DIR2, f);
     const st = statSync8(path7);
     return { runId: f.replace(/\.jsonl$/, ""), path: path7, mtimeMs: st.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 function resolveRunId(arg) {
-  if (!existsSync17(RUNS_DIR2)) return null;
+  if (!existsSync20(RUNS_DIR2)) return null;
   if (arg === "latest") {
     const all2 = listTraceFiles();
     if (all2.length === 0) return null;
     return { runId: all2[0].runId, path: all2[0].path };
   }
-  const exact = join15(RUNS_DIR2, `${arg}.jsonl`);
-  if (existsSync17(exact)) return { runId: arg, path: exact };
+  const exact = join16(RUNS_DIR2, `${arg}.jsonl`);
+  if (existsSync20(exact)) return { runId: arg, path: exact };
   const all = listTraceFiles();
   const matches = all.filter((r) => r.runId.includes(arg));
   if (matches.length === 1) return { runId: matches[0].runId, path: matches[0].path };
@@ -19257,7 +19675,7 @@ function resolveRunId(arg) {
   return null;
 }
 function readTrace(path7) {
-  return readFileSync21(path7, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
+  return readFileSync23(path7, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
     } catch {
@@ -19269,7 +19687,7 @@ async function inspect(arg, follow, json) {
   const r = resolveRunId(arg);
   if (!r) {
     console.error(`run not found: ${arg}`);
-    if (existsSync17(RUNS_DIR2)) {
+    if (existsSync20(RUNS_DIR2)) {
       const all = listTraceFiles().slice(0, 5);
       if (all.length > 0) {
         console.error(`
@@ -19431,6 +19849,11 @@ async function main() {
       await autostart2(args.slice(1));
       break;
     }
+    case "menubar": {
+      const { menubar: menubar2 } = await Promise.resolve().then(() => (init_menubar(), menubar_exports));
+      await menubar2(args.slice(1));
+      break;
+    }
     case "team": {
       const { team: team2 } = await Promise.resolve().then(() => (init_team2(), team_exports));
       await team2(args.slice(1));
@@ -19444,7 +19867,7 @@ async function main() {
     case "version":
     case "--version":
     case "-v":
-      console.log(`fleetlens ${"0.15.3"}`);
+      console.log(`fleetlens ${"0.15.4"}`);
       break;
     case "help":
     case "--help":
@@ -19471,6 +19894,7 @@ Advanced:
   start --no-daemon                 Start only the web server (no daemon)
   daemon <start|stop|status|logs>   Manage the usage daemon by itself
   autostart <install|uninstall|status>   Run the usage daemon at login (macOS launchd)
+  menubar <install|uninstall|open|status>   Native macOS menu bar widget (Claude/Codex/Z.ai usage)
 
 Team:
   team join <url> <token>           Pair with a team server (browser setup)