fleetlens 0.16.0 → 0.16.2

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, ZAI_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
+var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, ANTIGRAVITY_METADATA, COWORK_METADATA, ZAI_METADATA, GROK_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
 var init_agent_metadata = __esm({
   "../parser/dist/agent-metadata.js"() {
     "use strict";
@@ -721,13 +721,22 @@ var init_agent_metadata = __esm({
       accentColor: "rgb(59, 130, 246)",
       iconChar: "Z"
     };
+    GROK_METADATA = {
+      kind: "grok",
+      displayName: "Grok Build",
+      shortLabel: "Grok",
+      // Slate-400 — visible on dark Fleetlens chrome and still fine on light.
+      accentColor: "rgb(100, 116, 139)",
+      iconChar: "\u25C8"
+    };
     agentMetadata = [
       CLAUDE_CODE_METADATA,
       CODEX_METADATA,
       GEMINI_METADATA,
       ANTIGRAVITY_METADATA,
       COWORK_METADATA,
-      ZAI_METADATA
+      ZAI_METADATA,
+      GROK_METADATA
     ];
     KNOWN_AGENT_KINDS = new Set(agentMetadata.map((m) => m.kind));
   }
@@ -1584,11 +1593,11 @@ function defaultBranch(commonDir) {
   }
   return void 0;
 }
-function readGitFolder(path7) {
-  if (!existsSync(path7))
+function readGitFolder(path9) {
+  if (!existsSync(path9))
     return { exists: false, isWorktree: false };
   try {
-    const git = nearestDotGit(realpathOrSelf(path7));
+    const git = nearestDotGit(realpathOrSelf(path9));
     if (!git)
       return { exists: true, isWorktree: false };
     const projectRoot = projectRootFromCommonDir(git.commonDir);
@@ -2844,6 +2853,11 @@ function parseRollout(file, lines) {
   let lastUserPreview;
   let lastAgentPreview;
   const tsMs = [];
+  let threadSource;
+  let rootSessionId;
+  let parentThreadId;
+  let agentNickname;
+  let agentPath;
   let idx = 0;
   for (const line of lines) {
     if (typeof line !== "object" || line === null)
@@ -2864,6 +2878,16 @@ function parseRollout(file, lines) {
     if (type === "session_meta") {
       if (typeof payload.cwd === "string")
         cwd = payload.cwd;
+      if (threadSource === void 0 && typeof payload.thread_source === "string")
+        threadSource = payload.thread_source;
+      if (rootSessionId === void 0 && typeof payload.session_id === "string")
+        rootSessionId = payload.session_id;
+      if (parentThreadId === void 0 && typeof payload.parent_thread_id === "string")
+        parentThreadId = payload.parent_thread_id;
+      if (agentNickname === void 0 && typeof payload.agent_nickname === "string")
+        agentNickname = payload.agent_nickname;
+      if (agentPath === void 0 && typeof payload.agent_path === "string")
+        agentPath = payload.agent_path;
       continue;
     }
     if (type === "turn_context") {
@@ -3067,7 +3091,7 @@ function parseRollout(file, lines) {
     airTimeMs,
     activeSegments
   };
-  return { meta, events };
+  return { meta, events, threadSource, rootSessionId, parentThreadId, agentNickname, agentPath };
 }
 function numberOf(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : void 0;
@@ -3105,28 +3129,112 @@ function clearCodexCaches() {
   metaCache2.clear();
   detailCache2.clear();
 }
-async function listCodexSessions(opts = {}) {
-  const root = opts.root ?? DEFAULT_CODEX_ROOT;
+async function scanAllCodex(root) {
   const files = await listRolloutFiles(root);
   const out = [];
   for (const file of files) {
     const cached = metaCache2.get(file.filePath);
     if (cached && cached.mtimeMs === file.mtimeMs && cached.sizeBytes === file.sizeBytes) {
-      out.push(cached.meta);
+      out.push({
+        file,
+        meta: cached.meta,
+        threadSource: cached.threadSource,
+        rootSessionId: cached.rootSessionId,
+        parentThreadId: cached.parentThreadId,
+        agentNickname: cached.agentNickname,
+        agentPath: cached.agentPath
+      });
       continue;
     }
     try {
       const lines = await readJsonl(file.filePath);
-      const { meta } = parseRollout(file, lines);
+      const parsed = parseRollout(file, lines);
       metaCache2.set(file.filePath, {
-        meta,
+        meta: parsed.meta,
         mtimeMs: file.mtimeMs,
-        sizeBytes: file.sizeBytes
+        sizeBytes: file.sizeBytes,
+        threadSource: parsed.threadSource,
+        rootSessionId: parsed.rootSessionId,
+        parentThreadId: parsed.parentThreadId,
+        agentNickname: parsed.agentNickname,
+        agentPath: parsed.agentPath
+      });
+      out.push({
+        file,
+        meta: parsed.meta,
+        threadSource: parsed.threadSource,
+        rootSessionId: parsed.rootSessionId,
+        parentThreadId: parsed.parentThreadId,
+        agentNickname: parsed.agentNickname,
+        agentPath: parsed.agentPath
       });
-      out.push(meta);
     } catch {
     }
   }
+  return out;
+}
+function buildSubagentRun(entry, parentStartMs) {
+  const meta = entry.meta;
+  const startMs = meta.firstTimestamp ? Date.parse(meta.firstTimestamp) : void 0;
+  const endMs = meta.lastTimestamp ? Date.parse(meta.lastTimestamp) : void 0;
+  const startOk = startMs !== void 0 && Number.isFinite(startMs) ? startMs : void 0;
+  const endOk = endMs !== void 0 && Number.isFinite(endMs) ? endMs : void 0;
+  return {
+    agentId: meta.id,
+    agentType: entry.agentNickname ?? entry.agentPath ?? "subagent",
+    description: entry.agentPath ?? entry.agentNickname ?? meta.id,
+    startMs: startOk,
+    endMs: endOk,
+    durationMs: meta.durationMs,
+    startTOffsetMs: parentStartMs !== void 0 && startOk !== void 0 ? Math.max(0, startOk - parentStartMs) : void 0,
+    endTOffsetMs: parentStartMs !== void 0 && endOk !== void 0 ? Math.max(0, endOk - parentStartMs) : void 0,
+    eventCount: meta.eventCount,
+    totalUsage: meta.totalUsage,
+    model: meta.model,
+    toolCallCount: meta.toolCallCount,
+    finalPreview: meta.lastAgentPreview
+  };
+}
+async function listCodexSessions(opts = {}) {
+  const root = opts.root ?? DEFAULT_CODEX_ROOT;
+  const all = await scanAllCodex(root);
+  const subagentsByRoot = /* @__PURE__ */ new Map();
+  for (const entry of all) {
+    if (entry.threadSource !== "subagent" || !entry.rootSessionId)
+      continue;
+    const list = subagentsByRoot.get(entry.rootSessionId);
+    if (list)
+      list.push(entry);
+    else
+      subagentsByRoot.set(entry.rootSessionId, [entry]);
+  }
+  const out = [];
+  for (const entry of all) {
+    if (entry.threadSource === "subagent")
+      continue;
+    const children = subagentsByRoot.get(entry.meta.id);
+    if (!children || children.length === 0) {
+      out.push(entry.meta);
+      continue;
+    }
+    const merged = {
+      ...entry.meta,
+      spawnedAgentCount: children.length,
+      totalUsage: {
+        input: entry.meta.totalUsage.input + children.reduce((s, c) => s + c.meta.totalUsage.input, 0),
+        output: entry.meta.totalUsage.output + children.reduce((s, c) => s + c.meta.totalUsage.output, 0),
+        cacheRead: entry.meta.totalUsage.cacheRead + children.reduce((s, c) => s + c.meta.totalUsage.cacheRead, 0),
+        cacheWrite: entry.meta.totalUsage.cacheWrite + children.reduce((s, c) => s + c.meta.totalUsage.cacheWrite, 0)
+      },
+      toolCallCount: (entry.meta.toolCallCount ?? 0) + children.reduce((s, c) => s + (c.meta.toolCallCount ?? 0), 0)
+    };
+    for (const c of children) {
+      if (c.meta.lastTimestamp && (!merged.lastTimestamp || c.meta.lastTimestamp > merged.lastTimestamp)) {
+        merged.lastTimestamp = c.meta.lastTimestamp;
+      }
+    }
+    out.push(merged);
+  }
   out.sort((a, b) => (b.firstTimestamp ?? "").localeCompare(a.firstTimestamp ?? ""));
   if (opts.limit !== void 0)
     return out.slice(0, opts.limit);
@@ -3134,17 +3242,41 @@ async function listCodexSessions(opts = {}) {
 }
 async function getCodexSession(id, opts = {}) {
   const root = opts.root ?? DEFAULT_CODEX_ROOT;
-  const files = await listRolloutFiles(root);
-  const file = files.find((f) => f.sessionId === id);
-  if (!file)
-    return null;
+  const all = await scanAllCodex(root);
+  const rootEntry = all.find((a) => a.meta.id === id && a.threadSource !== "subagent");
+  if (!rootEntry) {
+    const direct = all.find((a) => a.meta.id === id);
+    if (!direct)
+      return null;
+    const cached2 = detailCache2.get(direct.file.filePath);
+    if (cached2 && cached2.mtimeMs === direct.file.mtimeMs && cached2.sizeBytes === direct.file.sizeBytes) {
+      return cached2.detail;
+    }
+    const lines2 = await readJsonl(direct.file.filePath);
+    const { meta: meta2, events: events2 } = parseRollout(direct.file, lines2);
+    const detail2 = { ...meta2, events: events2 };
+    detailCache2.set(direct.file.filePath, {
+      detail: detail2,
+      mtimeMs: direct.file.mtimeMs,
+      sizeBytes: direct.file.sizeBytes
+    });
+    return detail2;
+  }
+  const file = rootEntry.file;
   const cached = detailCache2.get(file.filePath);
   if (cached && cached.mtimeMs === file.mtimeMs && cached.sizeBytes === file.sizeBytes) {
     return cached.detail;
   }
   const lines = await readJsonl(file.filePath);
   const { meta, events } = parseRollout(file, lines);
-  const detail = { ...meta, events };
+  const children = all.filter((a) => a.threadSource === "subagent" && a.rootSessionId === id);
+  const parentStartMs = meta.firstTimestamp ? Date.parse(meta.firstTimestamp) : void 0;
+  const subagents = children.map((c) => buildSubagentRun(c, parentStartMs)).sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
+  const detail = {
+    ...meta,
+    events,
+    ...subagents.length > 0 ? { subagents, spawnedAgentCount: subagents.length } : {}
+  };
   detailCache2.set(file.filePath, {
     detail,
     mtimeMs: file.mtimeMs,
@@ -4469,6 +4601,672 @@ var init_cowork = __esm({
   }
 });
 
+// ../parser/dist/grok.js
+import { promises as fs6 } from "node:fs";
+import os6 from "node:os";
+import path6 from "node:path";
+function resolveDefaultGrokRoot() {
+  const home = process.env.GROK_HOME || path6.join(os6.homedir(), ".grok");
+  return path6.join(home, "sessions");
+}
+async function safeReaddir5(p) {
+  return fs6.readdir(p).catch(() => []);
+}
+async function safeReadJson(p) {
+  const raw = await fs6.readFile(p, "utf8").catch(() => null);
+  if (raw == null)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function resolveEncodedCwd(groupDir, encoded) {
+  const cwdFile = path6.join(groupDir, ".cwd");
+  const fromFile = await fs6.readFile(cwdFile, "utf8").catch(() => null);
+  if (fromFile && fromFile.trim())
+    return fromFile.trim();
+  try {
+    return decodeURIComponent(encoded);
+  } catch {
+    return encoded;
+  }
+}
+async function listSessionDirs(root) {
+  const out = [];
+  const groups = await safeReaddir5(root);
+  for (const group of groups) {
+    if (group === "session_search.sqlite" || group.startsWith("."))
+      continue;
+    const groupDir = path6.join(root, group);
+    const groupStat = await fs6.stat(groupDir).catch(() => null);
+    if (!groupStat?.isDirectory())
+      continue;
+    const decodedCwd = await resolveEncodedCwd(groupDir, group);
+    const entries2 = await safeReaddir5(groupDir);
+    for (const entry of entries2) {
+      if (entry === "prompt_history.jsonl" || entry.startsWith("."))
+        continue;
+      const dirPath = path6.join(groupDir, entry);
+      const summaryPath = path6.join(dirPath, "summary.json");
+      const updatesPath = path6.join(dirPath, "updates.jsonl");
+      const signalsCandidate = path6.join(dirPath, "signals.json");
+      const [summaryStat, updatesStat, signalsStat] = await Promise.all([
+        fs6.stat(summaryPath).catch(() => null),
+        fs6.stat(updatesPath).catch(() => null),
+        fs6.stat(signalsCandidate).catch(() => null)
+      ]);
+      if (!summaryStat?.isFile())
+        continue;
+      const mtimeMs = Math.max(summaryStat.mtimeMs, updatesStat?.mtimeMs ?? 0);
+      const sizeBytes = (updatesStat?.size ?? 0) + summaryStat.size;
+      out.push({
+        dirPath,
+        updatesPath,
+        summaryPath,
+        signalsPath: signalsStat?.isFile() ? signalsCandidate : null,
+        sessionId: entry,
+        groupName: group,
+        decodedCwd,
+        mtimeMs,
+        sizeBytes
+      });
+    }
+  }
+  return out;
+}
+function emptyUsage4() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+function previewOf4(text) {
+  return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function truncate5(s, n) {
+  return s.length <= n ? s : s.slice(0, n - 1) + "\u2026";
+}
+function textFromContent2(content) {
+  if (!content)
+    return "";
+  if (typeof content === "string")
+    return content;
+  if (typeof content.text === "string")
+    return content.text;
+  return "";
+}
+function toolResultText(update2) {
+  const items = update2.content;
+  if (Array.isArray(items)) {
+    const parts = [];
+    for (const item of items) {
+      if (!item || typeof item !== "object")
+        continue;
+      if (typeof item.text === "string" && item.text) {
+        parts.push(item.text);
+        continue;
+      }
+      const inner = item.content;
+      if (typeof inner === "string" && inner)
+        parts.push(inner);
+      else if (inner && typeof inner === "object" && typeof inner.text === "string") {
+        parts.push(inner.text);
+      }
+    }
+    if (parts.length)
+      return parts.join("\n");
+  }
+  const raw = update2.rawOutput;
+  if (raw == null)
+    return "";
+  if (typeof raw === "string")
+    return raw;
+  if (typeof raw === "object") {
+    const r = raw;
+    if (typeof r.output_for_prompt === "string")
+      return r.output_for_prompt;
+    if (typeof r.summary_for_prompt === "string")
+      return r.summary_for_prompt;
+    if (r.Content && typeof r.Content === "object") {
+      const c = r.Content;
+      if (typeof c.content === "string")
+        return c.content;
+    }
+    if (r.TodosUpdated && typeof r.TodosUpdated === "object") {
+      const t = r.TodosUpdated;
+      if (typeof t.summary_for_prompt === "string")
+        return t.summary_for_prompt;
+    }
+    if (Array.isArray(r.stdout) || Array.isArray(r.output)) {
+      try {
+        return JSON.stringify({
+          type: r.type,
+          exit_code: r.exit_code,
+          note: "binary/stdout omitted"
+        });
+      } catch {
+        return "";
+      }
+    }
+    try {
+      return JSON.stringify(raw);
+    } catch {
+      return "";
+    }
+  }
+  return String(raw);
+}
+function toolNameOf(update2) {
+  const meta = update2._meta;
+  if (meta && typeof meta === "object") {
+    const xai = meta["x.ai/tool"];
+    if (xai && typeof xai === "object") {
+      const name = xai.name;
+      if (typeof name === "string" && name)
+        return name;
+    }
+  }
+  if (typeof update2.title === "string" && update2.title) {
+    if (!update2.title.includes(" ") && !update2.title.includes("`"))
+      return update2.title;
+    return update2.title;
+  }
+  return "tool";
+}
+function statusOf(update2) {
+  const s = update2.status;
+  if (typeof s === "string")
+    return s;
+  if (s && typeof s === "object" && typeof s.status === "string")
+    return s.status;
+  return void 0;
+}
+function lineTimestampIso(line) {
+  const meta = line.params?._meta;
+  const agentMs = meta && typeof meta.agentTimestampMs === "number" ? meta.agentTimestampMs : void 0;
+  if (agentMs != null && Number.isFinite(agentMs)) {
+    return new Date(agentMs).toISOString();
+  }
+  const ts = line.timestamp;
+  if (typeof ts === "number" && Number.isFinite(ts)) {
+    const ms = ts > 1e12 ? ts : ts * 1e3;
+    return new Date(ms).toISOString();
+  }
+  return void 0;
+}
+function computeActiveSegments5(tsMs) {
+  if (tsMs.length === 0)
+    return [];
+  const sorted = [...tsMs].sort((a, b) => a - b);
+  const out = [];
+  let segStart = sorted[0];
+  let segEnd = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    const t = sorted[i];
+    if (t - segEnd > IDLE_GAP_MS4) {
+      out.push({ startMs: segStart, endMs: segEnd });
+      segStart = t;
+    }
+    segEnd = t;
+  }
+  out.push({ startMs: segStart, endMs: segEnd });
+  return out;
+}
+async function parseSession3(dir) {
+  const [summary, signals, updatesRaw] = await Promise.all([
+    safeReadJson(dir.summaryPath),
+    dir.signalsPath ? safeReadJson(dir.signalsPath) : Promise.resolve(null),
+    fs6.readFile(dir.updatesPath, "utf8").catch(() => "")
+  ]);
+  const sessionId = summary?.info?.id ?? dir.sessionId;
+  const cwd = summary?.info?.cwd ?? dir.decodedCwd;
+  let model = summary?.current_model_id ?? signals?.primaryModelId ?? signals?.modelsUsed?.[0];
+  const events = [];
+  const totalUsage = emptyUsage4();
+  if (signals?.contextTokensUsed && signals.contextTokensUsed > 0) {
+    totalUsage.input = signals.contextTokensUsed;
+  }
+  let firstTimestamp;
+  let lastTimestamp;
+  let toolCallCount = 0;
+  let turnCount = 0;
+  let firstUserPreview;
+  let lastUserPreview;
+  let lastAgentPreview;
+  const tsMs = [];
+  let idx = 0;
+  const completedToolResults = /* @__PURE__ */ new Set();
+  let maxTotalTokens = 0;
+  function noteTs(ts, role) {
+    if (!ts || role === "meta")
+      return;
+    if (!firstTimestamp)
+      firstTimestamp = ts;
+    lastTimestamp = ts;
+    const ms = Date.parse(ts);
+    if (Number.isFinite(ms))
+      tsMs.push(ms);
+  }
+  function pushEvent(e) {
+    events.push(e);
+    noteTs(e.timestamp, e.role);
+  }
+  let buf = null;
+  function flushBuf() {
+    if (!buf)
+      return;
+    const text = buf.texts.join("");
+    const preview = previewOf4(text);
+    if (buf.kind === "user") {
+      const isHidden = !text || isFrameworkInjectedUserInput(text);
+      if (text && !isHidden) {
+        if (!firstUserPreview)
+          firstUserPreview = preview;
+        lastUserPreview = preview;
+        turnCount += 1;
+      }
+      if (text) {
+        pushEvent({
+          index: idx++,
+          timestamp: buf.firstTs,
+          role: "user",
+          rawType: "grok/user_message",
+          preview,
+          blocks: [{ type: "text", text }],
+          messageId: buf.promptId,
+          raw: buf.raw.length === 1 ? buf.raw[0] : buf.raw
+        });
+      }
+    } else if (buf.kind === "agent") {
+      if (text)
+        lastAgentPreview = preview;
+      if (text) {
+        pushEvent({
+          index: idx++,
+          timestamp: buf.firstTs,
+          role: "agent",
+          rawType: "grok/agent_message",
+          preview,
+          blocks: [{ type: "text", text }],
+          messageId: buf.promptId,
+          model: buf.model ?? model,
+          raw: buf.raw.length === 1 ? buf.raw[0] : buf.raw
+        });
+      }
+    } else if (buf.kind === "thought") {
+      if (text) {
+        pushEvent({
+          index: idx++,
+          timestamp: buf.firstTs,
+          role: "agent-thinking",
+          rawType: "grok/agent_thought",
+          preview,
+          blocks: [{ type: "thinking", thinking: text }],
+          messageId: buf.promptId,
+          model: buf.model ?? model,
+          raw: buf.raw.length === 1 ? buf.raw[0] : buf.raw
+        });
+      }
+    }
+    buf = null;
+  }
+  function appendChunk(kind, text, ts, promptId, modelId, raw) {
+    if (!text && kind === "user")
+      return;
+    if (buf && buf.kind !== kind)
+      flushBuf();
+    if (!buf) {
+      buf = {
+        kind,
+        texts: [],
+        firstTs: ts,
+        lastTs: ts,
+        model: modelId,
+        promptId,
+        raw: []
+      };
+    }
+    if (text)
+      buf.texts.push(text);
+    buf.lastTs = ts ?? buf.lastTs;
+    if (modelId)
+      buf.model = modelId;
+    if (promptId)
+      buf.promptId = promptId;
+    buf.raw.push(raw);
+  }
+  const lines = updatesRaw.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const update2 = obj.params?.update;
+    if (!update2 || typeof update2 !== "object")
+      continue;
+    const st = update2.sessionUpdate;
+    if (!st)
+      continue;
+    const ts = lineTimestampIso(obj);
+    const lineMeta = obj.params?._meta ?? {};
+    const updateMeta = update2._meta ?? {};
+    const promptId = typeof lineMeta.promptId === "string" && lineMeta.promptId || typeof updateMeta.promptId === "string" && updateMeta.promptId || void 0;
+    const modelId = typeof updateMeta.modelId === "string" && updateMeta.modelId || typeof lineMeta.modelId === "string" && lineMeta.modelId || void 0;
+    if (modelId)
+      model = modelId;
+    const totalTok = lineMeta.totalTokens;
+    if (typeof totalTok === "number" && totalTok > maxTotalTokens) {
+      maxTotalTokens = totalTok;
+    }
+    if (st === "user_message_chunk") {
+      const text = textFromContent2(update2.content);
+      appendChunk("user", text, ts, promptId, modelId, obj);
+      continue;
+    }
+    if (st === "agent_message_chunk") {
+      const text = textFromContent2(update2.content);
+      appendChunk("agent", text, ts, promptId, modelId, obj);
+      continue;
+    }
+    if (st === "agent_thought_chunk") {
+      const text = textFromContent2(update2.content);
+      appendChunk("thought", text, ts, promptId, modelId, obj);
+      continue;
+    }
+    flushBuf();
+    if (st === "tool_call") {
+      const toolCallId = typeof update2.toolCallId === "string" ? update2.toolCallId : `grok-${idx}`;
+      const name = toolNameOf(update2);
+      const input = update2.rawInput ?? {};
+      const argsStr = input ? JSON.stringify(input) : "";
+      toolCallCount += 1;
+      pushEvent({
+        index: idx++,
+        timestamp: ts,
+        role: "tool-call",
+        rawType: "grok/tool_call",
+        preview: `${name}(${truncate5(argsStr, 80)})`,
+        blocks: [{ type: "tool_use", id: toolCallId, name, input }],
+        toolName: name,
+        toolUseId: toolCallId,
+        model,
+        raw: obj
+      });
+      continue;
+    }
+    if (st === "tool_call_update") {
+      const status2 = statusOf(update2);
+      if (status2 !== "completed" && status2 !== "failed" && status2 !== "error" && status2 !== "cancelled") {
+        continue;
+      }
+      const toolCallId = typeof update2.toolCallId === "string" ? update2.toolCallId : "";
+      if (toolCallId && completedToolResults.has(toolCallId))
+        continue;
+      if (toolCallId)
+        completedToolResults.add(toolCallId);
+      const resultText = toolResultText(update2);
+      const isError = status2 === "failed" || status2 === "error" || status2 === "cancelled";
+      pushEvent({
+        index: idx++,
+        timestamp: ts,
+        role: "tool-result",
+        rawType: "grok/tool_result",
+        preview: previewOf4(resultText),
+        blocks: [
+          {
+            type: "tool_result",
+            tool_use_id: toolCallId,
+            content: resultText,
+            is_error: isError || void 0
+          }
+        ],
+        toolUseId: toolCallId || void 0,
+        toolResult: resultText,
+        raw: obj
+      });
+      continue;
+    }
+    if (st === "turn_completed") {
+      continue;
+    }
+  }
+  flushBuf();
+  if (totalUsage.input === 0 && maxTotalTokens > 0) {
+    totalUsage.input = maxTotalTokens;
+  }
+  if (!firstTimestamp && summary?.created_at)
+    firstTimestamp = summary.created_at;
+  if (!lastTimestamp) {
+    lastTimestamp = summary?.last_active_at ?? summary?.updated_at ?? firstTimestamp;
+  }
+  if (signals?.toolCallCount != null && signals.toolCallCount > toolCallCount) {
+    toolCallCount = signals.toolCallCount;
+  }
+  if (signals?.turnCount != null && signals.turnCount > turnCount) {
+    turnCount = signals.turnCount;
+  }
+  const startMs = firstTimestamp ? Date.parse(firstTimestamp) : void 0;
+  if (startMs !== void 0 && Number.isFinite(startMs)) {
+    let prevMs;
+    for (const ev of events) {
+      if (!ev.timestamp)
+        continue;
+      const ms = Date.parse(ev.timestamp);
+      if (!Number.isFinite(ms))
+        continue;
+      ev.tOffsetMs = Math.max(0, ms - startMs);
+      if (prevMs !== void 0)
+        ev.gapMs = Math.max(0, ms - prevMs);
+      prevMs = ms;
+    }
+  }
+  const activeSegments = computeActiveSegments5(tsMs);
+  const airTimeMs = activeSegments.reduce((acc, s) => acc + (s.endMs - s.startMs), 0);
+  const durationMs = firstTimestamp && lastTimestamp ? Date.parse(lastTimestamp) - Date.parse(firstTimestamp) : void 0;
+  const project = cwd ? resolveProjectIdentity(cwd) : void 0;
+  const projectName = project?.projectName ?? cwd ?? dir.decodedCwd;
+  const projectDir = dir.groupName || (cwd ? encodeURIComponent(cwd) : "(unknown)");
+  if (!firstUserPreview) {
+    const title = summary?.generated_title || summary?.session_summary;
+    if (title)
+      firstUserPreview = previewOf4(title);
+  }
+  const spawnedAgentCount = await countSubagentChildren(dir.dirPath);
+  const meta = {
+    agent: "grok",
+    id: sessionId,
+    filePath: dir.updatesPath,
+    projectName,
+    worktreeName: project?.worktreeName,
+    repoName: project?.repoName,
+    projectDir,
+    sessionId,
+    firstTimestamp,
+    lastTimestamp,
+    lastActivityMs: lastTimestamp ? Date.parse(lastTimestamp) : void 0,
+    durationMs: durationMs && Number.isFinite(durationMs) ? durationMs : void 0,
+    eventCount: events.length,
+    model,
+    cwd,
+    gitBranch: summary?.head_branch,
+    agentName: summary?.agent_name,
+    totalUsage,
+    status: "idle",
+    firstUserPreview,
+    lastUserPreview,
+    lastAgentPreview,
+    toolCallCount,
+    turnCount,
+    linesAdded: signals?.agentLinesAdded,
+    linesRemoved: signals?.agentLinesRemoved,
+    airTimeMs,
+    activeSegments,
+    ...spawnedAgentCount > 0 ? { spawnedAgentCount } : {}
+  };
+  return { meta, events, sessionKind: summary?.session_kind };
+}
+async function countSubagentChildren(dirPath) {
+  const subRoot = path6.join(dirPath, "subagents");
+  const entries2 = await safeReaddir5(subRoot);
+  let n = 0;
+  for (const e of entries2) {
+    const st = await fs6.stat(path6.join(subRoot, e)).catch(() => null);
+    if (st?.isDirectory())
+      n += 1;
+  }
+  return n;
+}
+async function loadGrokSubagents(parentDir, parentStartMs) {
+  const subRoot = path6.join(parentDir.dirPath, "subagents");
+  const entries2 = await safeReaddir5(subRoot);
+  const groupDir = path6.dirname(parentDir.dirPath);
+  const runs2 = [];
+  for (const entry of entries2) {
+    const metaPath = path6.join(subRoot, entry, "meta.json");
+    const meta = await safeReadJson(metaPath);
+    if (!meta)
+      continue;
+    const childId = meta.child_session_id ?? meta.subagent_id ?? entry;
+    const childDir = path6.join(groupDir, childId);
+    const [childSummary, childSignals] = await Promise.all([
+      safeReadJson(path6.join(childDir, "summary.json")),
+      safeReadJson(path6.join(childDir, "signals.json"))
+    ]);
+    const startMs = childSummary?.created_at ? Date.parse(childSummary.created_at) : void 0;
+    const endIso = childSummary?.last_active_at ?? childSummary?.updated_at;
+    const endMs = endIso ? Date.parse(endIso) : void 0;
+    const startOk = startMs !== void 0 && Number.isFinite(startMs) ? startMs : void 0;
+    const endOk = endMs !== void 0 && Number.isFinite(endMs) ? endMs : void 0;
+    const usage2 = emptyUsage4();
+    if (childSignals?.contextTokensUsed)
+      usage2.input = childSignals.contextTokensUsed;
+    runs2.push({
+      agentId: childId,
+      agentType: meta.subagent_type ?? childSummary?.agent_name ?? "subagent",
+      description: meta.description && meta.description.trim() || childSummary?.generated_title || childSummary?.session_summary || childId,
+      startMs: startOk,
+      endMs: endOk,
+      durationMs: startOk !== void 0 && endOk !== void 0 ? Math.max(0, endOk - startOk) : void 0,
+      startTOffsetMs: parentStartMs !== void 0 && startOk !== void 0 ? Math.max(0, startOk - parentStartMs) : void 0,
+      endTOffsetMs: parentStartMs !== void 0 && endOk !== void 0 ? Math.max(0, endOk - parentStartMs) : void 0,
+      eventCount: childSummary?.num_messages ?? childSummary?.num_chat_messages ?? 0,
+      totalUsage: usage2,
+      prompt: typeof meta.prompt === "string" ? meta.prompt : void 0,
+      model: childSummary?.current_model_id ?? childSignals?.primaryModelId,
+      toolCallCount: childSignals?.toolCallCount
+    });
+  }
+  runs2.sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
+  return runs2;
+}
+function clearGrokCaches() {
+  metaCache6.clear();
+  detailCache6.clear();
+}
+async function listGrokSessions(opts = {}) {
+  const root = opts.root ?? resolveDefaultGrokRoot();
+  const dirs = await listSessionDirs(root);
+  const out = [];
+  for (const dir of dirs) {
+    const summaryPeek = await safeReadJson(dir.summaryPath);
+    if (summaryPeek?.session_kind === "subagent")
+      continue;
+    const cached = metaCache6.get(dir.dirPath);
+    if (cached && cached.mtimeMs === dir.mtimeMs && cached.sizeBytes === dir.sizeBytes) {
+      out.push(cached.meta);
+      continue;
+    }
+    try {
+      const { meta, sessionKind } = await parseSession3(dir);
+      if (sessionKind === "subagent")
+        continue;
+      metaCache6.set(dir.dirPath, {
+        meta,
+        mtimeMs: dir.mtimeMs,
+        sizeBytes: dir.sizeBytes
+      });
+      out.push(meta);
+    } catch {
+    }
+  }
+  out.sort((a, b) => (b.firstTimestamp ?? "").localeCompare(a.firstTimestamp ?? ""));
+  if (opts.limit !== void 0)
+    return out.slice(0, opts.limit);
+  return out;
+}
+async function getGrokSession(id, opts = {}) {
+  const root = opts.root ?? resolveDefaultGrokRoot();
+  const dirs = await listSessionDirs(root);
+  const chosen = dirs.find((d) => d.sessionId === id);
+  if (!chosen) {
+    for (const dir of dirs) {
+      try {
+        const { meta: meta2, events: events2 } = await parseSession3(dir);
+        if (meta2.id === id) {
+          const detail2 = { ...meta2, events: events2 };
+          detailCache6.set(dir.dirPath, {
+            detail: detail2,
+            mtimeMs: dir.mtimeMs,
+            sizeBytes: dir.sizeBytes
+          });
+          return detail2;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  const cached = detailCache6.get(chosen.dirPath);
+  if (cached && cached.mtimeMs === chosen.mtimeMs && cached.sizeBytes === chosen.sizeBytes) {
+    return cached.detail;
+  }
+  const { meta, events } = await parseSession3(chosen);
+  const parentStartMs = meta.firstTimestamp ? Date.parse(meta.firstTimestamp) : void 0;
+  const subagents = await loadGrokSubagents(chosen, parentStartMs !== void 0 && Number.isFinite(parentStartMs) ? parentStartMs : void 0);
+  const detail = {
+    ...meta,
+    events,
+    ...subagents.length > 0 ? { subagents, spawnedAgentCount: subagents.length } : {}
+  };
+  detailCache6.set(chosen.dirPath, {
+    detail,
+    mtimeMs: chosen.mtimeMs,
+    sizeBytes: chosen.sizeBytes
+  });
+  metaCache6.set(chosen.dirPath, {
+    meta: {
+      ...meta,
+      ...subagents.length > 0 ? { spawnedAgentCount: subagents.length } : {}
+    },
+    mtimeMs: chosen.mtimeMs,
+    sizeBytes: chosen.sizeBytes
+  });
+  return detail;
+}
+function grokSessionLocalDay(meta) {
+  if (!meta.firstTimestamp)
+    return void 0;
+  const ms = Date.parse(meta.firstTimestamp);
+  return Number.isFinite(ms) ? toLocalDay(ms) : void 0;
+}
+var DEFAULT_GROK_ROOT, IDLE_GAP_MS4, metaCache6, detailCache6;
+var init_grok = __esm({
+  "../parser/dist/grok.js"() {
+    "use strict";
+    init_analytics();
+    init_git_project();
+    init_user_input();
+    DEFAULT_GROK_ROOT = path6.join(os6.homedir(), ".grok", "sessions");
+    IDLE_GAP_MS4 = 3 * 60 * 1e3;
+    metaCache6 = /* @__PURE__ */ new Map();
+    detailCache6 = /* @__PURE__ */ new Map();
+  }
+});
+
 // ../parser/dist/team-config.js
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, renameSync } from "node:fs";
 import { join as join2 } from "node:path";
@@ -4528,6 +5326,7 @@ __export(fs_exports, {
   DEFAULT_CODEX_ROOT: () => DEFAULT_CODEX_ROOT,
   DEFAULT_COWORK_ROOT: () => DEFAULT_COWORK_ROOT,
   DEFAULT_GEMINI_ROOT: () => DEFAULT_GEMINI_ROOT,
+  DEFAULT_GROK_ROOT: () => DEFAULT_GROK_ROOT,
   DEFAULT_ROOT: () => DEFAULT_ROOT,
   RICH_ROLLUP_SCHEMA_VERSION: () => RICH_ROLLUP_SCHEMA_VERSION,
   agentSources: () => agentSources,
@@ -4538,6 +5337,7 @@ __export(fs_exports, {
   cclensHome: () => cclensHome,
   cclensPath: () => cclensPath,
   clearCaches: () => clearCaches,
+  clearGrokCaches: () => clearGrokCaches,
   clearTeamConfig: () => clearTeamConfig,
   codexSessionLocalDay: () => codexSessionLocalDay,
   decodeProjectName: () => decodeProjectName,
@@ -4549,8 +5349,10 @@ __export(fs_exports, {
   getCodexSession: () => getCodexSession,
   getCoworkSession: () => getCoworkSession,
   getGeminiSession: () => getGeminiSession,
+  getGrokSession: () => getGrokSession,
   getLatestCodexUsage: () => getLatestCodexUsage,
   getSession: () => getSession,
+  grokSessionLocalDay: () => grokSessionLocalDay,
   invalidateFile: () => invalidateFile,
   isFleetlensRuntimeDir: () => isFleetlensRuntimeDir,
   listAllSessions: () => listAllSessions,
@@ -4558,6 +5360,7 @@ __export(fs_exports, {
   listCodexSessions: () => listCodexSessions,
   listCoworkSessions: () => listCoworkSessions,
   listGeminiSessions: () => listGeminiSessions,
+  listGrokSessions: () => listGrokSessions,
   listProjects: () => listProjects,
   listSessions: () => listSessions,
   loadCalibrationCurve: () => loadCalibrationCurve,
@@ -4570,20 +5373,21 @@ __export(fs_exports, {
   readGitFolder: () => readGitFolder,
   readJsonlFile: () => readJsonlFile,
   readTeamConfig: () => readTeamConfig,
+  resolveDefaultGrokRoot: () => resolveDefaultGrokRoot,
   resolveProjectIdentity: () => resolveProjectIdentity,
   sessionIdFromFileName: () => sessionIdFromFileName,
   shouldSyncProject: () => shouldSyncProject,
   walkJsonlFiles: () => walkJsonlFiles,
   writeTeamConfig: () => writeTeamConfig
 });
-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";
+import { promises as fs7, existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
+import os7 from "node:os";
+import path7 from "node:path";
 function cclensHome() {
-  return process.env.CCLENS_HOME || path6.join(os6.homedir(), ".cclens");
+  return process.env.CCLENS_HOME || path7.join(os7.homedir(), ".cclens");
 }
 function cclensPath(...parts) {
-  return path6.join(cclensHome(), ...parts);
+  return path7.join(cclensHome(), ...parts);
 }
 function cacheStats() {
   return claudeCodeCacheStats();
@@ -4594,6 +5398,7 @@ function clearCaches() {
   clearGeminiCaches();
   clearAntigravityCaches();
   clearCoworkCaches();
+  clearGrokCaches();
 }
 function invalidateFile(fullPath) {
   invalidateClaudeCodeFile(fullPath);
@@ -4624,7 +5429,7 @@ function usageLogPath() {
 }
 function appendUsageSnapshot(snapshot) {
   const p = usageLogPath();
-  mkdirSync3(path6.dirname(p), { recursive: true });
+  mkdirSync3(path7.dirname(p), { recursive: true });
   appendFileSync(p, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function pruneUsageAgent(agent) {
@@ -4640,13 +5445,13 @@ function pruneUsageAgent(agent) {
       return true;
     }
   });
-  mkdirSync3(path6.dirname(p), { recursive: true });
+  mkdirSync3(path7.dirname(p), { recursive: true });
   writeFileSync3(p, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
 }
 async function loadUsageByDay(start2, end) {
   let raw;
   try {
-    raw = await fs6.readFile(usageLogPath(), "utf8");
+    raw = await fs7.readFile(usageLogPath(), "utf8");
   } catch {
     return { by_day: [] };
   }
@@ -4691,7 +5496,7 @@ async function loadUsageByDay(start2, end) {
 async function loadCalibrationSnapshots() {
   let raw;
   try {
-    raw = await fs6.readFile(usageLogPath(), "utf8");
+    raw = await fs7.readFile(usageLogPath(), "utf8");
   } catch {
     return [];
   }
@@ -4855,7 +5660,7 @@ async function loadCalibrationCurve(tier = "pro-max-20x", root = DEFAULT_ROOT, g
   ]);
   return buildCalibrationCurve(events, snapshots, tier, granularityMin);
 }
-var codexSource, geminiSource, antigravitySource, coworkSource, agentSources;
+var codexSource, geminiSource, antigravitySource, coworkSource, grokSource, agentSources;
 var init_fs = __esm({
   "../parser/dist/fs.js"() {
     "use strict";
@@ -4867,12 +5672,14 @@ var init_fs = __esm({
     init_gemini();
     init_antigravity();
     init_cowork();
+    init_grok();
     init_claude_code();
     init_git_project();
     init_codex();
     init_gemini();
     init_antigravity();
     init_cowork();
+    init_grok();
     init_team_config();
     init_team_wire();
     codexSource = {
@@ -4926,12 +5733,24 @@ var init_fs = __esm({
         return getCoworkSession(id);
       }
     };
+    grokSource = {
+      ...GROK_METADATA,
+      // Display default; list/get re-resolve GROK_HOME at call time internally.
+      defaultRoot: DEFAULT_GROK_ROOT,
+      async listSessions(opts) {
+        return listGrokSessions(opts);
+      },
+      async getSession(id, opts) {
+        return getGrokSession(id, opts);
+      }
+    };
     agentSources = [
       claudeCodeSource,
       codexSource,
       geminiSource,
       antigravitySource,
-      coworkSource
+      coworkSource,
+      grokSource
     ];
   }
 });
@@ -4967,9 +5786,9 @@ function onDiskVersion() {
   try {
     const here = dirname3(fileURLToPath(import.meta.url));
     const pkg = JSON.parse(readFileSync5(join3(here, "..", "package.json"), "utf8"));
-    return pkg.version ?? "0.16.0";
+    return pkg.version ?? "0.16.2";
   } catch {
-    return "0.16.0";
+    return "0.16.2";
   }
 }
 function getServerStatus() {
@@ -4981,7 +5800,7 @@ function getServerStatus() {
   return { running: false };
 }
 function isServerStale(status2) {
-  return status2.running === true && status2.version !== "0.16.0";
+  return status2.running === true && status2.version !== "0.16.2";
 }
 async function ensureCurrentServer(opts = {}) {
   const status2 = getServerStatus();
@@ -5420,9 +6239,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.16.0") {
+  } else if (verify.installedVersion !== "0.16.2") {
     console.log(
-      `  \u2192 This process is still running ${"0.16.0"}. Next invocation will use ${verify.installedVersion}.`
+      `  \u2192 This process is still running ${"0.16.2"}. Next invocation will use ${verify.installedVersion}.`
     );
   }
 }
@@ -5457,14 +6276,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.16.0",
+    current: "0.16.2",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.16.0",
+    current: "0.16.2",
     latest,
-    updateAvailable: shouldUpdate("0.16.0", latest)
+    updateAvailable: shouldUpdate("0.16.2", latest)
   };
 }
 async function checkForUpdate() {
@@ -5554,7 +6373,7 @@ async function restartServices(state) {
 }
 async function forceUpdate() {
   const latest = await fetchLatestVersion();
-  const current = "0.16.0";
+  const current = "0.16.2";
   if (latest === null) {
     console.error("Could not reach npm registry. Check your network.");
     process.exit(1);
@@ -5967,7 +6786,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.16.0"}) \u2014 run 'fleetlens start' to restart on the current version`
+        `  \u26A0  serving stale ${ver} (CLI is ${"0.16.2"}) \u2014 run 'fleetlens start' to restart on the current version`
       );
     }
   } else {
@@ -6006,7 +6825,7 @@ async function web(args2) {
   const open = args2.includes("--open");
   const positional = args2.filter((a) => !a.startsWith("--"));
   const rawPath = positional[0] ?? "";
-  const path7 = rawPath.startsWith("/") ? rawPath : rawPath ? `/${rawPath}` : "";
+  const path9 = rawPath.startsWith("/") ? rawPath : rawPath ? `/${rawPath}` : "";
   let result;
   try {
     result = await ensureCurrentServer({});
@@ -6014,7 +6833,7 @@ async function web(args2) {
     console.error(`Failed to start: ${err.message}`);
     process.exit(1);
   }
-  const url = `http://localhost:${result.port}${path7}`;
+  const url = `http://localhost:${result.port}${path9}`;
   if (result.restarted) {
     console.log(`fleetlens restarted on http://localhost:${result.port} (PID ${result.pid}) \u2014 replaced stale ${result.previousVersion ?? "unknown"} server`);
   }
@@ -6075,9 +6894,9 @@ function readFromCredentialsFile() {
     join7(homedir4(), ".claude", ".credentials.json"),
     join7(homedir4(), ".config", "claude", "credentials.json")
   ];
-  for (const path7 of candidates) {
+  for (const path9 of candidates) {
     try {
-      const blob = readFileSync10(path7, "utf8");
+      const blob = readFileSync10(path9, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -6199,6 +7018,224 @@ var init_api = __esm({
   }
 });
 
+// src/usage/grok.ts
+import { existsSync as existsSync8, readFileSync as readFileSync11 } from "node:fs";
+import os8 from "node:os";
+import path8 from "node:path";
+function grokHome() {
+  return process.env.GROK_HOME || path8.join(os8.homedir(), ".grok");
+}
+function authPath() {
+  return path8.join(grokHome(), "auth.json");
+}
+function loadAuthEntry() {
+  const p = authPath();
+  if (!existsSync8(p)) {
+    throw new GrokApiError("Grok not logged in. Run `grok login`.", "no_auth");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync11(p, "utf8"));
+  } catch {
+    throw new GrokApiError("Grok auth.json is unreadable. Run `grok login`.", "no_auth");
+  }
+  for (const [entryKey2, entry] of Object.entries(raw)) {
+    const token = typeof entry?.key === "string" ? entry.key.trim() : "";
+    if (token) return { token, entry, entryKey: entryKey2 };
+  }
+  throw new GrokApiError("Grok auth has no access token. Run `grok login`.", "no_auth");
+}
+function needsRefresh(entry) {
+  const exp = entry.expires_at;
+  if (!exp) return false;
+  const ms = Date.parse(exp);
+  if (!Number.isFinite(ms)) return false;
+  return Date.now() >= ms - REFRESH_BUFFER_MS;
+}
+async function refreshAccessToken(entry) {
+  const refresh = entry.refresh_token?.trim();
+  if (!refresh) return null;
+  const clientId = entry.oidc_client_id?.trim() || DEFAULT_CLIENT_ID;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: clientId,
+    refresh_token: refresh
+  });
+  let res;
+  try {
+    res = await fetch(REFRESH_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+  try {
+    const j = await res.json();
+    if (typeof j.access_token !== "string" || !j.access_token) return null;
+    try {
+      const p = authPath();
+      const raw = JSON.parse(readFileSync11(p, "utf8"));
+      for (const key of Object.keys(raw)) {
+        if (raw[key]?.key === entry.key || raw[key]?.refresh_token === refresh) {
+          raw[key] = {
+            ...raw[key],
+            key: j.access_token,
+            refresh_token: j.refresh_token ?? raw[key].refresh_token,
+            expires_at: typeof j.expires_in === "number" ? new Date(Date.now() + j.expires_in * 1e3).toISOString() : raw[key].expires_at
+          };
+          break;
+        }
+      }
+      const { writeFileSync: writeFileSync17 } = await import("node:fs");
+      writeFileSync17(p, JSON.stringify(raw, null, 2), "utf8");
+    } catch {
+    }
+    return j.access_token;
+  } catch {
+    return null;
+  }
+}
+function authHeaders(token) {
+  return {
+    Authorization: `Bearer ${token.trim()}`,
+    "X-XAI-Token-Auth": TOKEN_AUTH,
+    Accept: "application/json",
+    "User-Agent": "fleetlens"
+  };
+}
+function parseGrokCreditsConfig(body) {
+  if (!body || typeof body !== "object") {
+    throw new GrokApiError("Grok billing response missing body", "parse");
+  }
+  const config = body.config;
+  if (!config || typeof config !== "object") {
+    throw new GrokApiError("Grok billing response missing config", "parse");
+  }
+  const period = config.currentPeriod;
+  if (!period || typeof period !== "object") {
+    throw new GrokApiError("Grok billing response missing currentPeriod", "parse");
+  }
+  const periodType = typeof period.type === "string" ? period.type.trim() : "";
+  if (!periodType) {
+    throw new GrokApiError("Grok billing period type missing", "parse");
+  }
+  let utilization = 0;
+  if (config.creditUsagePercent !== void 0 && config.creditUsagePercent !== null) {
+    const n = Number(config.creditUsagePercent);
+    if (!Number.isFinite(n)) {
+      throw new GrokApiError("Grok creditUsagePercent is not a number", "parse");
+    }
+    utilization = Math.min(100, Math.max(0, n));
+  }
+  const end = typeof period.end === "string" && period.end ? new Date(period.end).toISOString() : null;
+  let onDemandCap = 0;
+  const cap = config.onDemandCap;
+  if (cap && typeof cap === "object" && "val" in cap) {
+    const v = Number(cap.val);
+    if (Number.isFinite(v)) onDemandCap = v;
+  }
+  return {
+    utilization,
+    resets_at: end && !Number.isNaN(Date.parse(end)) ? end : null,
+    period_type: periodType,
+    on_demand_cap: onDemandCap
+  };
+}
+async function fetchJson(url, token) {
+  let res;
+  try {
+    res = await fetch(url, { headers: authHeaders(token) });
+  } catch (err) {
+    throw new GrokApiError(
+      `Network error reaching Grok billing: ${err.message}`,
+      "network"
+    );
+  }
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  return { status: res.status, body };
+}
+async function fetchGrokUsage() {
+  const loaded = loadAuthEntry();
+  const entry = loaded.entry;
+  let token = loaded.token;
+  if (needsRefresh(entry)) {
+    const refreshed = await refreshAccessToken(entry);
+    if (refreshed) token = refreshed;
+  }
+  let { status: status2, body } = await fetchJson(CREDITS_URL, token);
+  if (status2 === 401 || status2 === 403) {
+    const refreshed = await refreshAccessToken(entry);
+    if (refreshed) {
+      token = refreshed;
+      ({ status: status2, body } = await fetchJson(CREDITS_URL, token));
+    }
+  }
+  if (status2 < 200 || status2 >= 300) {
+    throw new GrokApiError(
+      `Grok billing returned HTTP ${status2}`,
+      status2 === 401 || status2 === 403 ? "no_auth" : "http"
+    );
+  }
+  const credits = parseGrokCreditsConfig(body);
+  if (credits.period_type !== WEEKLY_PERIOD) {
+    throw new GrokApiError(
+      `Grok period is ${credits.period_type}, not weekly`,
+      "not_weekly"
+    );
+  }
+  let planType = null;
+  try {
+    const settings = await fetchJson(SETTINGS_URL, token);
+    if (settings.status >= 200 && settings.status < 300 && settings.body && typeof settings.body === "object") {
+      const tier = settings.body.subscription_tier_display;
+      if (typeof tier === "string" && tier.trim()) planType = tier.trim();
+    }
+  } catch {
+  }
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    agent: "grok",
+    // No 5-hour window — menubar / strip show "—" on the top line.
+    five_hour: { utilization: null, resets_at: null },
+    seven_day: {
+      utilization: credits.utilization,
+      resets_at: credits.resets_at
+    },
+    seven_day_opus: null,
+    seven_day_sonnet: null,
+    seven_day_oauth_apps: null,
+    seven_day_cowork: null,
+    extra_usage: null,
+    plan_type: planType
+  };
+}
+var CREDITS_URL, SETTINGS_URL, REFRESH_URL, TOKEN_AUTH, DEFAULT_CLIENT_ID, WEEKLY_PERIOD, REFRESH_BUFFER_MS, GrokApiError;
+var init_grok2 = __esm({
+  "src/usage/grok.ts"() {
+    "use strict";
+    CREDITS_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+    SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
+    REFRESH_URL = "https://auth.x.ai/oauth2/token";
+    TOKEN_AUTH = "xai-grok-cli";
+    DEFAULT_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+    WEEKLY_PERIOD = "USAGE_PERIOD_TYPE_WEEKLY";
+    REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+    GrokApiError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+      }
+    };
+  }
+});
+
 // src/usage/format.ts
 function formatUsage(snapshot) {
   const rows = [
@@ -6558,6 +7595,30 @@ Usage:
     const snapshot = await fetchUsage();
     if (save) appendSnapshot(USAGE_LOG2, snapshot);
     process.stdout.write(formatUsage(snapshot));
+    if (save) {
+      for (const source of agentSources) {
+        if (source.kind === "claude-code" || !source.usagePoller) continue;
+        try {
+          const partial = await source.usagePoller();
+          if (!partial) continue;
+          appendSnapshot(USAGE_LOG2, {
+            ...partial,
+            seven_day_opus: null,
+            seven_day_sonnet: null,
+            seven_day_oauth_apps: null,
+            seven_day_cowork: null,
+            extra_usage: null
+          });
+        } catch {
+        }
+      }
+      try {
+        appendSnapshot(USAGE_LOG2, await fetchGrokUsage());
+      } catch (err) {
+        if (!(err instanceof GrokApiError && err.code === "no_auth")) {
+        }
+      }
+    }
     process.stdout.write("\n  (tip: run with --history for the daily token/cost table)\n");
   } catch (err) {
     if (err instanceof UsageApiError) {
@@ -6572,6 +7633,7 @@ var init_usage = __esm({
   "src/commands/usage.ts"() {
     "use strict";
     init_api();
+    init_grok2();
     init_format();
     init_storage();
     init_fs();
@@ -7068,6 +8130,7 @@ __export(dist_exports, {
   CODEX_METADATA: () => CODEX_METADATA,
   COWORK_METADATA: () => COWORK_METADATA,
   GEMINI_METADATA: () => GEMINI_METADATA,
+  GROK_METADATA: () => GROK_METADATA,
   PRICES: () => PRICES,
   RATE_PER_PCT: () => RATE_PER_PCT,
   RATE_PER_PCT_5H: () => RATE_PER_PCT_5H,
@@ -7481,7 +8544,7 @@ function closeTurn(t, closed, cwd) {
   let active = 0;
   for (let i = 1; i < ts.length; i++) {
     const dt = ts[i] - ts[i - 1];
-    if (dt < IDLE_GAP_MS4)
+    if (dt < IDLE_GAP_MS5)
       active += dt;
   }
   closed.push({
@@ -7678,7 +8741,7 @@ function aggregateDay(dayEvents, _sessionFallbackProject) {
   let activeMs2 = 0;
   for (let i = 1; i < tsSorted.length; i++) {
     const dt = tsSorted[i] - tsSorted[i - 1];
-    if (dt < IDLE_GAP_MS4)
+    if (dt < IDLE_GAP_MS5)
       activeMs2 += dt;
   }
   const tsSortedStrings = dayEvents.map((e) => e.timestamp).filter((t) => !!t).sort();
@@ -7865,7 +8928,7 @@ function buildEntries(sessionDetail) {
   entries2.sort((a, b) => a.local_day.localeCompare(b.local_day));
   return entries2;
 }
-var IDLE_GAP_MS4, INTERRUPT_RE2, PR_TITLE_RE, BASH_CHAIN_SPLIT_RE, SHELL_NOISE, IMAGE_BLOCK_RE;
+var IDLE_GAP_MS5, INTERRUPT_RE2, PR_TITLE_RE, BASH_CHAIN_SPLIT_RE, SHELL_NOISE, IMAGE_BLOCK_RE;
 var init_build = __esm({
   "../entries/dist/build.js"() {
     "use strict";
@@ -7873,7 +8936,7 @@ var init_build = __esm({
     init_types();
     init_signals();
     init_trivial();
-    IDLE_GAP_MS4 = 3 * 60 * 1e3;
+    IDLE_GAP_MS5 = 3 * 60 * 1e3;
     INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
     PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
     BASH_CHAIN_SPLIT_RE = /\|\||&&|;|\|/;
@@ -7902,11 +8965,11 @@ var init_dist2 = __esm({
 });
 
 // ../entries/dist/digest-fs.js
-import { readFileSync as readFileSync11, readdirSync, writeFileSync as writeFileSync6, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync6, existsSync as existsSync8 } from "node:fs";
+import { readFileSync as readFileSync12, readdirSync, writeFileSync as writeFileSync6, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync6, existsSync as existsSync9 } from "node:fs";
 import { dirname as dirname8, join as join8 } from "node:path";
-function parseDigestFile(path7, expectedVersion) {
+function parseDigestFile(path9, expectedVersion) {
   try {
-    const parsed = JSON.parse(readFileSync11(path7, "utf8"));
+    const parsed = JSON.parse(readFileSync12(path9, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -7925,11 +8988,11 @@ function digestsDir() {
   digestsDirCached = envOverride ?? cclensPath("digests");
   return digestsDirCached;
 }
-function __setDigestsDirForTest(path7) {
-  digestsDirCached = path7;
-  mkdirSync6(join8(path7, "day"), { recursive: true });
-  mkdirSync6(join8(path7, "week"), { recursive: true });
-  mkdirSync6(join8(path7, "month"), { recursive: true });
+function __setDigestsDirForTest(path9) {
+  digestsDirCached = path9;
+  mkdirSync6(join8(path9, "day"), { recursive: true });
+  mkdirSync6(join8(path9, "week"), { recursive: true });
+  mkdirSync6(join8(path9, "month"), { recursive: true });
 }
 function dayDigestPath(date) {
   return join8(digestsDir(), "day", `${date}.json`);
@@ -7955,7 +9018,7 @@ function writeDayDigest(digest2) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync8(p))
+  if (!existsSync9(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -7991,13 +9054,13 @@ function writeWeekDigest(digest2) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync8(p))
+  if (!existsSync9(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
 function listWeekDigestKeys() {
   const dir = join8(digestsDir(), "week");
-  if (!existsSync8(dir))
+  if (!existsSync9(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));
 }
@@ -8028,13 +9091,13 @@ function writeMonthDigest(digest2) {
 }
 function readMonthDigest(yearMonth) {
   const p = monthDigestPath(yearMonth);
-  if (!existsSync8(p))
+  if (!existsSync9(p))
     return null;
   return parseDigestFile(p, CURRENT_MONTH_DIGEST_SCHEMA_VERSION);
 }
 function listMonthDigestKeys() {
   const dir = join8(digestsDir(), "month");
-  if (!existsSync8(dir))
+  if (!existsSync9(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));
 }
@@ -8096,7 +9159,7 @@ __export(fs_exports2, {
   writeMonthDigest: () => writeMonthDigest,
   writeWeekDigest: () => writeWeekDigest
 });
-import { readFileSync as readFileSync12, readdirSync as readdirSync2, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, renameSync as renameSync3, existsSync as existsSync9 } from "node:fs";
+import { readFileSync as readFileSync13, readdirSync as readdirSync2, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, renameSync as renameSync3, existsSync as existsSync10 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join as join9 } from "node:path";
 function entriesDir() {
@@ -8106,9 +9169,9 @@ function entriesDir() {
   entriesDirCached = envOverride ?? cclensPath("entries");
   return entriesDirCached;
 }
-function __setEntriesDirForTest(path7) {
-  entriesDirCached = path7;
-  mkdirSync7(path7, { recursive: true });
+function __setEntriesDirForTest(path9) {
+  entriesDirCached = path9;
+  mkdirSync7(path9, { recursive: true });
 }
 function pathFor(sessionId, localDay2) {
   return join9(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
@@ -8155,17 +9218,17 @@ function writeEntryPreservingEnrichment(fresh) {
 }
 function readEntry(sessionId, localDay2) {
   const p = pathFor(sessionId, localDay2);
-  if (!existsSync9(p))
+  if (!existsSync10(p))
     return null;
-  const raw = readFileSync12(p, "utf8");
+  const raw = readFileSync13(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync9(pathFor(sessionId, localDay2));
+  return existsSync10(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync9(dir))
+  if (!existsSync10(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -8647,8 +9710,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path7, errorMaps, issueData } = params;
-      const fullPath = [...path7, ...issueData.path || []];
+      const { data, path: path9, errorMaps, issueData } = params;
+      const fullPath = [...path9, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -8956,11 +10019,11 @@ var init_types3 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path7, key) {
+      constructor(parent, value, path9, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path7;
+        this._path = path9;
         this._key = key;
       }
       get path() {
@@ -12444,7 +13507,7 @@ RESPOND WITH ONLY VALID JSON (no prose, no code fence):
 });
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, existsSync as existsSync10, readdirSync as readdirSync3, realpathSync as realpathSync5, readFileSync as readFileSync13, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync8, existsSync as existsSync11, readdirSync as readdirSync3, realpathSync as realpathSync5, readFileSync as readFileSync14, 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";
@@ -12463,7 +13526,7 @@ function tmuxRunnerAvailable() {
 }
 function runtimeCwd() {
   const dir = join10(homedir5(), ".cclens", "runtime");
-  if (!existsSync10(dir))
+  if (!existsSync11(dir))
     mkdirSync8(dir, { recursive: true });
   return realpathSync5(dir);
 }
@@ -12471,7 +13534,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   const cfgPath = join10(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync13(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync14(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -12618,10 +13681,10 @@ function snapshotAllTranscripts() {
   }
   return out;
 }
-function readJsonlCwd(path7, maxLines = 8) {
+function readJsonlCwd(path9, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync13(path7, "utf8");
+    raw = readFileSync14(path9, "utf8");
   } catch {
     return void 0;
   }
@@ -12675,10 +13738,10 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
   }
   throw new TmuxRunError(`timeout waiting for claude to create the session transcript (cwd: ${targetCwd})`);
 }
-function parseTranscript2(path7, defaultModel) {
+function parseTranscript2(path9, defaultModel) {
   let raw;
   try {
-    raw = readFileSync13(path7, "utf8");
+    raw = readFileSync14(path9, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -12772,11 +13835,11 @@ var init_tmux_runner = __esm({
 
 // ../entries/dist/llm-runner.js
 import { spawn as spawn3 } from "node:child_process";
-import { mkdirSync as mkdirSync9, appendFileSync as appendFileSync3, writeFileSync as writeFileSync9, existsSync as existsSync11 } from "node:fs";
+import { mkdirSync as mkdirSync9, appendFileSync as appendFileSync3, writeFileSync as writeFileSync9, existsSync as existsSync12 } from "node:fs";
 import { join as join11 } from "node:path";
 import { randomUUID } from "node:crypto";
 function ensureRunsDir() {
-  if (!existsSync11(RUNS_DIR)) {
+  if (!existsSync12(RUNS_DIR)) {
     try {
       mkdirSync9(RUNS_DIR, { recursive: true });
     } catch {
@@ -12807,15 +13870,15 @@ function newRunId(kind) {
 function tracePath(runId) {
   return join11(RUNS_DIR, `${runId}.jsonl`);
 }
-function safeAppend(path7, line) {
+function safeAppend(path9, line) {
   try {
-    appendFileSync3(path7, line);
+    appendFileSync3(path9, line);
   } catch {
   }
 }
-function safeWrite(path7, line) {
+function safeWrite(path9, line) {
   try {
-    writeFileSync9(path7, line);
+    writeFileSync9(path9, line);
   } catch {
   }
 }
@@ -13221,7 +14284,7 @@ var init_enrich2 = __esm({
 });
 
 // ../entries/dist/budget.js
-import { appendFileSync as appendFileSync4, readFileSync as readFileSync14, existsSync as existsSync12, mkdirSync as mkdirSync10 } from "node:fs";
+import { appendFileSync as appendFileSync4, readFileSync as readFileSync15, existsSync as existsSync13, mkdirSync as mkdirSync10 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 function spendPath() {
   if (spendPathCached)
@@ -13229,8 +14292,8 @@ function spendPath() {
   spendPathCached = cclensPath("llm-spend.jsonl");
   return spendPathCached;
 }
-function __setSpendPathForTest(path7) {
-  spendPathCached = path7;
+function __setSpendPathForTest(path9) {
+  spendPathCached = path9;
 }
 function appendSpend(record) {
   const p = spendPath();
@@ -13239,12 +14302,12 @@ function appendSpend(record) {
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync12(p))
+  if (!existsSync13(p))
     return 0;
   const year = now.getUTCFullYear();
   const month2 = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync14(p, "utf8");
+  const raw = readFileSync15(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -13273,15 +14336,15 @@ var init_budget = __esm({
 });
 
 // ../entries/dist/pipeline-lock.js
-import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync13, readFileSync as readFileSync15, statSync as statSync3 } from "node:fs";
+import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync14, readFileSync as readFileSync16, statSync as statSync3 } from "node:fs";
 function lockPath() {
   if (lockPathCached)
     return lockPathCached;
   lockPathCached = cclensPath("llm-interactive.lock");
   return lockPathCached;
 }
-function __setInteractiveLockPathForTest(path7) {
-  lockPathCached = path7;
+function __setInteractiveLockPathForTest(path9) {
+  lockPathCached = path9;
 }
 function touchLock() {
   writeFileSync10(lockPath(), String(process.pid), "utf8");
@@ -13318,13 +14381,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync13(p))
+  if (!existsSync14(p))
     return false;
   try {
     const mtime = statSync3(p).mtimeMs;
     if (nowMs - mtime > STALE_MS)
       return false;
-    const pid = Number(readFileSync15(p, "utf8").trim());
+    const pid = Number(readFileSync16(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -13430,7 +14493,7 @@ var init_queue = __esm({
 });
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync11, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "node:fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync11, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync11, existsSync as existsSync15 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 function settingsPath() {
   if (settingsPathCached)
@@ -13438,8 +14501,8 @@ function settingsPath() {
   settingsPathCached = cclensPath("settings.json");
   return settingsPathCached;
 }
-function __setSettingsPathForTest(path7) {
-  settingsPathCached = path7;
+function __setSettingsPathForTest(path9) {
+  settingsPathCached = path9;
 }
 function toDisk(s) {
   return {
@@ -13466,10 +14529,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync14(p))
+  if (!existsSync15(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync16(p, "utf8");
+    const raw = readFileSync17(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -13676,7 +14739,7 @@ function rollupOutcomeDay(entries2) {
     return "exploratory";
   return "trivial";
 }
-function truncate5(s, max) {
+function truncate6(s, max) {
   if (s.length <= max)
     return s;
   return s.slice(0, max - 1).trimEnd() + "\u2026";
@@ -13732,7 +14795,7 @@ function computeDaySignals(entries2) {
     type,
     count: v.count,
     sample_description: v.sample_description,
-    sample_prompt_preview: truncate5(v.sample_prompt_preview, 200)
+    sample_prompt_preview: truncate6(v.sample_prompt_preview, 200)
   }));
   const frameCounts = /* @__PURE__ */ new Map();
   for (const s of signalsList) {
@@ -13751,7 +14814,7 @@ function computeDaySignals(entries2) {
     if ((e.first_user ?? "").length > 0)
       verbosity_distribution[s.verbosity] += 1;
     for (const ref of s.external_refs) {
-      external_refs.push({ session_id: e.session_id, kind: ref.kind, preview: truncate5(ref.preview, 200) });
+      external_refs.push({ session_id: e.session_id, kind: ref.kind, preview: truncate6(ref.preview, 200) });
     }
     const ints = e.numbers.interrupts ?? 0;
     interrupts += ints;
@@ -14624,7 +15687,7 @@ function computeInteractionModes(entries2) {
       date: entry.local_day,
       project_display: prettyProject3(entry.project),
       type: sa.type,
-      prompt_preview: truncate6(sa.prompt_preview, 200)
+      prompt_preview: truncate7(sa.prompt_preview, 200)
     });
   }
   const skillExamples = [];
@@ -14641,7 +15704,7 @@ function computeInteractionModes(entries2) {
       skillExamples.push({
         date: e.local_day,
         skill,
-        first_user_preview: truncate6(e.first_user, 200)
+        first_user_preview: truncate7(e.first_user, 200)
       });
     }
   }
@@ -14658,7 +15721,7 @@ function computeInteractionModes(entries2) {
     project_display: prettyProject3(longestTurnEntry.project),
     active_min: longestTurnEntry.numbers.active_min,
     top_tools: longestTurnEntry.top_tools.slice(0, 5),
-    first_user_preview: truncate6(longestTurnEntry.first_user, 200)
+    first_user_preview: truncate7(longestTurnEntry.first_user, 200)
   } : null;
   const tools_per_turn = turn_count > 0 ? tools_total / turn_count : 0;
   const label = tools_per_turn < 5 ? "rapid" : tools_per_turn < 15 ? "mixed" : "batch";
@@ -14689,7 +15752,7 @@ function computeInteractionModes(entries2) {
     }
   };
 }
-function truncate6(s, max) {
+function truncate7(s, max) {
   if (s.length <= max)
     return s;
   return s.slice(0, max - 1).trimEnd() + "\u2026";
@@ -14736,7 +15799,7 @@ function computeWorkingShapes(dayDigests, entriesByDay = /* @__PURE__ */ new Map
         evidence_subagent = {
           type: sa.type,
           description: sa.description,
-          prompt_preview: truncate6(sa.prompt_preview, 200)
+          prompt_preview: truncate7(sa.prompt_preview, 200)
         };
       }
       const project_display = repEntry ? prettyProject3(repEntry.project) : dd.projects[0]?.display_name ?? "";
@@ -14747,7 +15810,7 @@ function computeWorkingShapes(dayDigests, entriesByDay = /* @__PURE__ */ new Map
         outcome: dayOutcome.get(dd.key) ?? null,
         helpfulness: dayHelp.get(dd.key) ?? null,
         evidence_subagent,
-        evidence_first_user: repEntry?.first_user ? truncate6(repEntry.first_user, 200) : null,
+        evidence_first_user: repEntry?.first_user ? truncate7(repEntry.first_user, 200) : null,
         day_signature: dd.day_signature ?? null
       };
     });
@@ -14822,7 +15885,7 @@ function computeInteractionGrammar(dayDigests, entriesByDay = /* @__PURE__ */ ne
         date: day2,
         session_id: ref.session_id,
         ref_kind: ref.kind,
-        preview: truncate6(ref.preview, 200)
+        preview: truncate7(ref.preview, 200)
       });
     }
     total_interrupts += signals.comm_style.steering.interrupts;
@@ -14894,7 +15957,7 @@ function computeInteractionGrammar(dayDigests, entriesByDay = /* @__PURE__ */ ne
       count: v.count,
       days: [...v.days].sort(),
       sample_description: v.sample_description,
-      sample_prompt_preview: truncate6(v.sample_prompt_preview, 200)
+      sample_prompt_preview: truncate7(v.sample_prompt_preview, 200)
     })),
     threads,
     communication_style: {
@@ -15542,7 +16605,7 @@ function activeMs(timestamps) {
   let active = 0;
   for (let i = 1; i < ts.length; i++) {
     const dt = ts[i] - ts[i - 1];
-    if (dt < IDLE_GAP_MS5)
+    if (dt < IDLE_GAP_MS6)
       active += dt;
   }
   return active;
@@ -15713,7 +16776,7 @@ function buildSessionSlice(entry, events, daySignature) {
     let intEnd = sortedTs[0];
     for (let i = 1; i < sortedTs.length; i++) {
       const dt = sortedTs[i] - intEnd;
-      if (dt >= IDLE_GAP_MS5) {
+      if (dt >= IDLE_GAP_MS6) {
         intervals.push({
           start_min: fmtMin(intStart - sliceStartMs),
           end_min: fmtMin(intEnd - sliceStartMs)
@@ -16110,14 +17173,14 @@ async function generateTopSession(slice, opts = {}) {
     void lastModel;
   }
 }
-var IDLE_GAP_MS5, LONG_AUTONOMOUS_MIN, N_USER, N_FIRST_AGENT, N_LAST_AGENT, N_USER_TURN1, N_SUBAGENT, SHELL_NOISE2, INTERRUPT_RE3, PR_TITLE_RE2, PinResponseSchema, TopSessionResponseSchema, SYSTEM_PROMPT5, TOP_SESSION_SYSTEM_PROMPT, DEFAULT_MODEL5, defaultCallLLMTopSession, validateTopSession;
+var IDLE_GAP_MS6, LONG_AUTONOMOUS_MIN, N_USER, N_FIRST_AGENT, N_LAST_AGENT, N_USER_TURN1, N_SUBAGENT, SHELL_NOISE2, INTERRUPT_RE3, PR_TITLE_RE2, PinResponseSchema, TopSessionResponseSchema, SYSTEM_PROMPT5, TOP_SESSION_SYSTEM_PROMPT, DEFAULT_MODEL5, defaultCallLLMTopSession, validateTopSession;
 var init_top_sessions = __esm({
   "../entries/dist/top-sessions.js"() {
     "use strict";
     init_zod();
     init_signals();
     init_llm_runner();
-    IDLE_GAP_MS5 = 3 * 60 * 1e3;
+    IDLE_GAP_MS6 = 3 * 60 * 1e3;
     LONG_AUTONOMOUS_MIN = 20;
     N_USER = 150;
     N_FIRST_AGENT = 150;
@@ -16659,7 +17722,7 @@ var init_digest_month_pipeline = __esm({
 });
 
 // ../entries/dist/credentials.js
-import { writeFileSync as writeFileSync12, readFileSync as readFileSync17, renameSync as renameSync6, chmodSync as chmodSync3, mkdirSync as mkdirSync12, existsSync as existsSync15, unlinkSync as unlinkSync5 } from "node:fs";
+import { writeFileSync as writeFileSync12, readFileSync as readFileSync18, renameSync as renameSync6, chmodSync as chmodSync3, mkdirSync as mkdirSync12, existsSync as existsSync16, unlinkSync as unlinkSync5 } from "node:fs";
 import { dirname as dirname11 } from "node:path";
 async function fetchZaiUsage(candidate) {
   const key = candidate.trim();
@@ -16730,10 +17793,10 @@ function credentialsPath() {
 }
 function readCredentials() {
   const p = credentialsPath();
-  if (!existsSync15(p))
+  if (!existsSync16(p))
     return {};
   try {
-    const raw = readFileSync17(p, "utf8");
+    const raw = readFileSync18(p, "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -17363,7 +18426,7 @@ 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 realpathSync6 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, cpSync, rmSync as rmSync2, readdirSync as readdirSync4, writeFileSync as writeFileSync13, realpathSync as realpathSync6 } 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";
@@ -17405,8 +18468,8 @@ async function isRunning() {
     return false;
   }
 }
-async function launchApp(path7) {
-  await execFileAsync2("open", ["-a", path7]);
+async function launchApp(path9) {
+  await execFileAsync2("open", ["-a", path9]);
 }
 async function quitApp() {
   await execFileAsync2("osascript", ["-e", `tell application "${BUNDLE_EXEC}" to quit`]).catch(
@@ -17427,7 +18490,7 @@ async function installMenubar(opts) {
     return;
   }
   const src = bundledAppPath();
-  if (!existsSync16(src)) {
+  if (!existsSync17(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.`
@@ -17469,7 +18532,7 @@ async function uninstallMenubar() {
     await new Promise((r) => setTimeout(r, 300));
   }
   const dest = installedAppPath();
-  if (existsSync16(dest)) {
+  if (existsSync17(dest)) {
     rmSync2(dest, { recursive: true, force: true });
     console.log(`Removed ${dest}`);
   } else {
@@ -17483,7 +18546,7 @@ async function openMenubar() {
     return;
   }
   const dest = installedAppPath();
-  if (!existsSync16(dest)) {
+  if (!existsSync17(dest)) {
     console.log("Widget not installed yet. Run `fleetlens menubar install` first.");
     return;
   }
@@ -17500,9 +18563,9 @@ async function statusMenubar() {
     return;
   }
   const dest = installedAppPath();
-  const installed = existsSync16(dest);
+  const installed = existsSync17(dest);
   const running = await isRunning();
-  const bundled = existsSync16(bundledAppPath());
+  const bundled = existsSync17(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"}`);
@@ -17591,7 +18654,7 @@ var init_config = __esm({
 });
 
 // src/perception/build-entries.ts
-import { statSync as statSync4, readFileSync as readFileSync18 } from "node:fs";
+import { statSync as statSync4, readFileSync as readFileSync19 } from "node:fs";
 import { basename as basename2, dirname as dirname13 } from "node:path";
 function decodeProjectDirName(projectDir) {
   if (projectDir.startsWith("-")) {
@@ -17601,7 +18664,7 @@ function decodeProjectDirName(projectDir) {
 }
 function buildEntriesForFile(filePath) {
   const stat = statSync4(filePath);
-  const raw = readFileSync18(filePath, "utf8");
+  const raw = readFileSync19(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -17866,7 +18929,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID2(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "0.16.0",
+    cliVersion: "0.16.2",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -17907,7 +18970,7 @@ var init_push = __esm({
 });
 
 // src/team/git-remote.ts
-import { existsSync as existsSync17, readFileSync as readFileSync19, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync18, readFileSync as readFileSync20, 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);
@@ -17932,12 +18995,12 @@ function gitConfigPathFor(dir) {
   const st = statSync5(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
   if (st.isDirectory()) return join13(dotGit, "config");
-  const m = readFileSync19(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  const m = readFileSync20(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
   const gd = isAbsolute2(m[1]) ? m[1] : resolve2(dir, m[1]);
   const commondirFile = join13(gd, "commondir");
-  if (existsSync17(commondirFile)) {
-    const common = readFileSync19(commondirFile, "utf8").trim();
+  if (existsSync18(commondirFile)) {
+    const common = readFileSync20(commondirFile, "utf8").trim();
     return join13(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
   return join13(gd, "config");
@@ -17952,8 +19015,8 @@ function createRepoResolver() {
     try {
       for (let d = dir; ; d = dirname14(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync17(config)) {
-          const url = originUrl2(readFileSync19(config, "utf8"));
+        if (config && existsSync18(config)) {
+          const url = originUrl2(readFileSync20(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
@@ -17975,7 +19038,7 @@ var init_git_remote = __esm({
 });
 
 // src/team/queue.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, appendFileSync as appendFileSync5, statSync as statSync6, mkdirSync as mkdirSync14 } from "node:fs";
+import { readFileSync as readFileSync21, 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) {
   mkdirSync14(dirname15(queuePath), { recursive: true });
@@ -17992,7 +19055,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync20(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync21(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -18013,7 +19076,7 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync20(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync21(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
@@ -18032,7 +19095,7 @@ var init_queue2 = __esm({
 });
 
 // src/usage/profile.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync15, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname16 } from "node:path";
 function mapRateLimitTier(rateLimitTier) {
   switch (rateLimitTier) {
@@ -18073,9 +19136,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync18(cachePath)) return null;
+  if (!existsSync19(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync21(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync22(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -18264,11 +19327,11 @@ var init_backfill = __esm({
 });
 
 // src/team/sync-log.ts
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync23 } from "node:fs";
 function readPendingSyncLog(watermark) {
   let raw;
   try {
-    raw = readFileSync22(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync23(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -18332,7 +19395,7 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync19, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync20, 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";
@@ -18342,15 +19405,15 @@ function pathHash(relPath) {
 function defaultScanRoots(extraRoots = []) {
   const roots = [];
   const home = join15(homedir7(), ".claude");
-  if (existsSync19(home)) roots.push({ root: home, label: "user" });
+  if (existsSync20(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
     const r = resolve3(e, ".claude");
-    if (existsSync19(r) && r !== home) roots.push({ root: r, label: "project" });
+    if (existsSync20(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync19(dir)) return [];
+  if (!existsSync20(dir)) return [];
   const out = [];
   let entries2;
   try {
@@ -18420,7 +19483,7 @@ function scanAuthored(roots, subdir, day2) {
   const out = [];
   for (const r of roots) {
     const dir = join15(r.root, subdir);
-    if (!existsSync19(dir)) continue;
+    if (!existsSync20(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day2) continue;
@@ -18434,7 +19497,7 @@ function scanEdited(roots, day2) {
   const out = [];
   for (const r of roots) {
     const dir = join15(r.root, "skills");
-    if (!existsSync19(dir)) continue;
+    if (!existsSync20(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day2) continue;
@@ -18457,10 +19520,10 @@ function claudemdLineDelta(extraRoots, authorEmail, day2) {
   const candidates = [];
   for (const e of extraRoots) {
     const f = resolve3(e, "CLAUDE.md");
-    if (existsSync19(f)) candidates.push(f);
+    if (existsSync20(f)) candidates.push(f);
   }
   const homeClaudeMd = join15(homedir7(), "CLAUDE.md");
-  if (existsSync19(homeClaudeMd)) candidates.push(homeClaudeMd);
+  if (existsSync20(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync3(
@@ -19350,11 +20413,11 @@ var logs_exports = {};
 __export(logs_exports, {
   teamLogs: () => teamLogs
 });
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 async function teamLogs() {
   const logPath = cclensPath("daemon.log");
   try {
-    const lines = readFileSync23(logPath, "utf8").trim().split("\n");
+    const lines = readFileSync24(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.");
@@ -19482,7 +20545,7 @@ __export(runs_exports, {
   runs: () => runs
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync24, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync25, 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");
@@ -19567,8 +20630,8 @@ function listActiveRuns() {
   return runs2.sort((a, b) => a.elapsed_s - b.elapsed_s);
 }
 function readSpend(sinceMs) {
-  if (!existsSync20(SPEND_PATH)) return [];
-  const lines = readFileSync24(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
+  if (!existsSync21(SPEND_PATH)) return [];
+  const lines = readFileSync25(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
   const out = [];
   for (const line of lines) {
     try {
@@ -19689,23 +20752,23 @@ function ageLabel(ms) {
   return `${Math.floor(ms / 864e5)}d`;
 }
 function listTraceFiles() {
-  if (!existsSync20(RUNS_DIR2)) return [];
+  if (!existsSync21(RUNS_DIR2)) return [];
   const entries2 = readdirSync6(RUNS_DIR2).filter((f) => f.endsWith(".jsonl"));
   return entries2.map((f) => {
-    const path7 = join16(RUNS_DIR2, f);
-    const st = statSync8(path7);
-    return { runId: f.replace(/\.jsonl$/, ""), path: path7, mtimeMs: st.mtimeMs };
+    const path9 = join16(RUNS_DIR2, f);
+    const st = statSync8(path9);
+    return { runId: f.replace(/\.jsonl$/, ""), path: path9, mtimeMs: st.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 function resolveRunId(arg) {
-  if (!existsSync20(RUNS_DIR2)) return null;
+  if (!existsSync21(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 = join16(RUNS_DIR2, `${arg}.jsonl`);
-  if (existsSync20(exact)) return { runId: arg, path: exact };
+  if (existsSync21(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 };
@@ -19716,8 +20779,8 @@ function resolveRunId(arg) {
   }
   return null;
 }
-function readTrace(path7) {
-  return readFileSync24(path7, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
+function readTrace(path9) {
+  return readFileSync25(path9, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
     } catch {
@@ -19729,7 +20792,7 @@ async function inspect(arg, follow, json) {
   const r = resolveRunId(arg);
   if (!r) {
     console.error(`run not found: ${arg}`);
-    if (existsSync20(RUNS_DIR2)) {
+    if (existsSync21(RUNS_DIR2)) {
       const all = listTraceFiles().slice(0, 5);
       if (all.length > 0) {
         console.error(`
@@ -19909,7 +20972,7 @@ async function main() {
     case "version":
     case "--version":
     case "-v":
-      console.log(`fleetlens ${"0.16.0"}`);
+      console.log(`fleetlens ${"0.16.2"}`);
       break;
     case "help":
     case "--help":
@@ -19936,7 +20999,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)
+  menubar <install|uninstall|open|status>   Native macOS menu bar widget (Claude/Codex/Z.ai plan usage; Grok sessions on the dashboard)
 
 Team:
   team join <url> <token>           Pair with a team server (browser setup)