fleetlens 0.16.0 → 0.16.2

package/dist/daemon-worker.js

@@ -607,7 +607,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";
@@ -653,13 +653,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));
   }
@@ -1516,11 +1525,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);
@@ -2776,6 +2785,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)
@@ -2796,6 +2810,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") {
@@ -2999,7 +3023,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;
@@ -3037,28 +3061,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);
@@ -3066,17 +3174,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,
@@ -4401,6 +4533,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 entries = await safeReaddir5(groupDir);
+    for (const entry of entries) {
+      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(update) {
+  const items = update.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 = update.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(update) {
+  const meta = update._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 update.title === "string" && update.title) {
+    if (!update.title.includes(" ") && !update.title.includes("`"))
+      return update.title;
+    return update.title;
+  }
+  return "tool";
+}
+function statusOf(update) {
+  const s = update.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 update = obj.params?.update;
+    if (!update || typeof update !== "object")
+      continue;
+    const st = update.sessionUpdate;
+    if (!st)
+      continue;
+    const ts = lineTimestampIso(obj);
+    const lineMeta = obj.params?._meta ?? {};
+    const updateMeta = update._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(update.content);
+      appendChunk("user", text, ts, promptId, modelId, obj);
+      continue;
+    }
+    if (st === "agent_message_chunk") {
+      const text = textFromContent2(update.content);
+      appendChunk("agent", text, ts, promptId, modelId, obj);
+      continue;
+    }
+    if (st === "agent_thought_chunk") {
+      const text = textFromContent2(update.content);
+      appendChunk("thought", text, ts, promptId, modelId, obj);
+      continue;
+    }
+    flushBuf();
+    if (st === "tool_call") {
+      const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : `grok-${idx}`;
+      const name = toolNameOf(update);
+      const input = update.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 status = statusOf(update);
+      if (status !== "completed" && status !== "failed" && status !== "error" && status !== "cancelled") {
+        continue;
+      }
+      const toolCallId = typeof update.toolCallId === "string" ? update.toolCallId : "";
+      if (toolCallId && completedToolResults.has(toolCallId))
+        continue;
+      if (toolCallId)
+        completedToolResults.add(toolCallId);
+      const resultText = toolResultText(update);
+      const isError = status === "failed" || status === "error" || status === "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 entries = await safeReaddir5(subRoot);
+  let n = 0;
+  for (const e of entries) {
+    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 entries = await safeReaddir5(subRoot);
+  const groupDir = path6.dirname(parentDir.dirPath);
+  const runs = [];
+  for (const entry of entries) {
+    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 usage = emptyUsage4();
+    if (childSignals?.contextTokensUsed)
+      usage.input = childSignals.contextTokensUsed;
+    runs.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: usage,
+      prompt: typeof meta.prompt === "string" ? meta.prompt : void 0,
+      model: childSummary?.current_model_id ?? childSignals?.primaryModelId,
+      toolCallCount: childSignals?.toolCallCount
+    });
+  }
+  runs.sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
+  return runs;
+}
+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, unlinkSync, mkdirSync, renameSync } from "node:fs";
 import { join as join3 } from "node:path";
@@ -4460,6 +5258,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,
@@ -4470,6 +5269,7 @@ __export(fs_exports, {
   cclensHome: () => cclensHome,
   cclensPath: () => cclensPath,
   clearCaches: () => clearCaches,
+  clearGrokCaches: () => clearGrokCaches,
   clearTeamConfig: () => clearTeamConfig,
   codexSessionLocalDay: () => codexSessionLocalDay,
   decodeProjectName: () => decodeProjectName,
@@ -4481,8 +5281,10 @@ __export(fs_exports, {
   getCodexSession: () => getCodexSession,
   getCoworkSession: () => getCoworkSession,
   getGeminiSession: () => getGeminiSession,
+  getGrokSession: () => getGrokSession,
   getLatestCodexUsage: () => getLatestCodexUsage,
   getSession: () => getSession,
+  grokSessionLocalDay: () => grokSessionLocalDay,
   invalidateFile: () => invalidateFile,
   isFleetlensRuntimeDir: () => isFleetlensRuntimeDir,
   listAllSessions: () => listAllSessions,
@@ -4490,6 +5292,7 @@ __export(fs_exports, {
   listCodexSessions: () => listCodexSessions,
   listCoworkSessions: () => listCoworkSessions,
   listGeminiSessions: () => listGeminiSessions,
+  listGrokSessions: () => listGrokSessions,
   listProjects: () => listProjects,
   listSessions: () => listSessions,
   loadCalibrationCurve: () => loadCalibrationCurve,
@@ -4502,20 +5305,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 writeFileSync2, appendFileSync, mkdirSync as mkdirSync2 } 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 writeFileSync2, appendFileSync, mkdirSync as mkdirSync2 } 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();
@@ -4526,6 +5330,7 @@ function clearCaches() {
   clearGeminiCaches();
   clearAntigravityCaches();
   clearCoworkCaches();
+  clearGrokCaches();
 }
 function invalidateFile(fullPath) {
   invalidateClaudeCodeFile(fullPath);
@@ -4556,7 +5361,7 @@ function usageLogPath() {
 }
 function appendUsageSnapshot(snapshot) {
   const p = usageLogPath();
-  mkdirSync2(path6.dirname(p), { recursive: true });
+  mkdirSync2(path7.dirname(p), { recursive: true });
   appendFileSync(p, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function pruneUsageAgent(agent) {
@@ -4572,13 +5377,13 @@ function pruneUsageAgent(agent) {
       return true;
     }
   });
-  mkdirSync2(path6.dirname(p), { recursive: true });
+  mkdirSync2(path7.dirname(p), { recursive: true });
   writeFileSync2(p, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
 }
 async function loadUsageByDay(start, end) {
   let raw;
   try {
-    raw = await fs6.readFile(usageLogPath(), "utf8");
+    raw = await fs7.readFile(usageLogPath(), "utf8");
   } catch {
     return { by_day: [] };
   }
@@ -4623,7 +5428,7 @@ async function loadUsageByDay(start, end) {
 async function loadCalibrationSnapshots() {
   let raw;
   try {
-    raw = await fs6.readFile(usageLogPath(), "utf8");
+    raw = await fs7.readFile(usageLogPath(), "utf8");
   } catch {
     return [];
   }
@@ -4787,7 +5592,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";
@@ -4799,12 +5604,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 = {
@@ -4858,26 +5665,38 @@ 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
     ];
   }
 });
 
 // src/usage/storage.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "node:fs";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "node:fs";
 import { dirname as dirname2 } from "node:path";
 function appendSnapshot(filePath, snapshot) {
   mkdirSync3(dirname2(filePath), { recursive: true });
   appendFileSync2(filePath, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function readSnapshots(filePath) {
-  if (!existsSync4(filePath)) return [];
-  const content = readFileSync6(filePath, "utf8");
+  if (!existsSync5(filePath)) return [];
+  const content = readFileSync7(filePath, "utf8");
   const snapshots = [];
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -4889,8 +5708,8 @@ function readSnapshots(filePath) {
   return snapshots;
 }
 function pruneAgent(filePath, agent) {
-  if (!existsSync4(filePath)) return;
-  const kept = readFileSync6(filePath, "utf8").split("\n").filter((line) => {
+  if (!existsSync5(filePath)) return;
+  const kept = readFileSync7(filePath, "utf8").split("\n").filter((line) => {
     if (!line.trim()) return false;
     try {
       return JSON.parse(line).agent !== agent;
@@ -5328,6 +6147,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,
@@ -5401,7 +6221,7 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync10, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join8, relative, resolve as resolve3, sep } from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -5411,15 +6231,15 @@ function pathHash(relPath) {
 function defaultScanRoots(extraRoots = []) {
   const roots = [];
   const home = join8(homedir3(), ".claude");
-  if (existsSync9(home)) roots.push({ root: home, label: "user" });
+  if (existsSync10(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
     const r = resolve3(e, ".claude");
-    if (existsSync9(r) && r !== home) roots.push({ root: r, label: "project" });
+    if (existsSync10(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync9(dir)) return [];
+  if (!existsSync10(dir)) return [];
   const out = [];
   let entries;
   try {
@@ -5489,7 +6309,7 @@ function scanAuthored(roots, subdir, day) {
   const out = [];
   for (const r of roots) {
     const dir = join8(r.root, subdir);
-    if (!existsSync9(dir)) continue;
+    if (!existsSync10(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day) continue;
@@ -5503,7 +6323,7 @@ function scanEdited(roots, day) {
   const out = [];
   for (const r of roots) {
     const dir = join8(r.root, "skills");
-    if (!existsSync9(dir)) continue;
+    if (!existsSync10(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day) continue;
@@ -5526,10 +6346,10 @@ function claudemdLineDelta(extraRoots, authorEmail, day) {
   const candidates = [];
   for (const e of extraRoots) {
     const f = resolve3(e, "CLAUDE.md");
-    if (existsSync9(f)) candidates.push(f);
+    if (existsSync10(f)) candidates.push(f);
   }
   const homeClaudeMd = join8(homedir3(), "CLAUDE.md");
-  if (existsSync9(homeClaudeMd)) candidates.push(homeClaudeMd);
+  if (existsSync10(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync2(
@@ -5586,7 +6406,7 @@ var init_file_probe = __esm({
 
 // src/daemon-worker.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync, existsSync as existsSync16, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "node:fs";
+import { closeSync, existsSync as existsSync17, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "node:fs";
 import { dirname as dirname11, join as join12 } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -5618,9 +6438,9 @@ function readFromCredentialsFile() {
     join(homedir(), ".claude", ".credentials.json"),
     join(homedir(), ".config", "claude", "credentials.json")
   ];
-  for (const path7 of candidates) {
+  for (const path9 of candidates) {
     try {
-      const blob = readFileSync(path7, "utf8");
+      const blob = readFileSync(path9, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -5832,6 +6652,218 @@ async function fetchZaiUsage() {
   };
 }
 
+// src/usage/grok.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
+import os8 from "node:os";
+import path8 from "node:path";
+var CREDITS_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+var SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
+var REFRESH_URL = "https://auth.x.ai/oauth2/token";
+var TOKEN_AUTH = "xai-grok-cli";
+var DEFAULT_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+var WEEKLY_PERIOD = "USAGE_PERIOD_TYPE_WEEKLY";
+var REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+var GrokApiError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+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 (!existsSync4(p)) {
+    throw new GrokApiError("Grok not logged in. Run `grok login`.", "no_auth");
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync6(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(readFileSync6(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: writeFileSync15 } = await import("node:fs");
+      writeFileSync15(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, body } = await fetchJson(CREDITS_URL, token);
+  if (status === 401 || status === 403) {
+    const refreshed = await refreshAccessToken(entry);
+    if (refreshed) {
+      token = refreshed;
+      ({ status, body } = await fetchJson(CREDITS_URL, token));
+    }
+  }
+  if (status < 200 || status >= 300) {
+    throw new GrokApiError(
+      `Grok billing returned HTTP ${status}`,
+      status === 401 || status === 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
+  };
+}
+
 // src/daemon-worker.ts
 init_storage();
 init_fs();
@@ -5873,7 +6905,7 @@ import { randomUUID } from "node:crypto";
 
 // ../entries/dist/fs.js
 init_fs();
-import { readFileSync as readFileSync8, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, renameSync as renameSync3, existsSync as existsSync6 } from "node:fs";
+import { readFileSync as readFileSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, renameSync as renameSync3, existsSync as existsSync7 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join as join5 } from "node:path";
 
@@ -5948,12 +6980,12 @@ var PROMPT_FRAME_ORIGIN = {
 
 // ../entries/dist/digest-fs.js
 init_fs();
-import { readFileSync as readFileSync7, readdirSync, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "node:fs";
+import { readFileSync as readFileSync8, readdirSync, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "node:fs";
 import { dirname as dirname3, join as join4 } from "node:path";
 var digestsDirCached = null;
-function parseDigestFile(path7, expectedVersion) {
+function parseDigestFile(path9, expectedVersion) {
   try {
-    const parsed = JSON.parse(readFileSync7(path7, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path9, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -5993,7 +7025,7 @@ function writeDayDigest(digest) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync5(p))
+  if (!existsSync6(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -6026,7 +7058,7 @@ function writeWeekDigest(digest) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync5(p))
+  if (!existsSync6(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
@@ -6104,17 +7136,17 @@ function writeEntryPreservingEnrichment(fresh) {
 }
 function readEntry(sessionId, localDay2) {
   const p = pathFor(sessionId, localDay2);
-  if (!existsSync6(p))
+  if (!existsSync7(p))
     return null;
-  const raw = readFileSync8(p, "utf8");
+  const raw = readFileSync9(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync6(pathFor(sessionId, localDay2));
+  return existsSync7(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -6133,7 +7165,7 @@ function listEntriesForDay(localDay2) {
 
 // src/perception/build-entries.ts
 init_dist();
-import { statSync as statSync2, readFileSync as readFileSync9 } from "node:fs";
+import { statSync as statSync2, readFileSync as readFileSync10 } from "node:fs";
 import { basename as basename2, dirname as dirname4 } from "node:path";
 
 // ../entries/dist/signals.js
@@ -6367,7 +7399,7 @@ function viewEvent(ev) {
     cwd: rawCwd
   };
 }
-var IDLE_GAP_MS4 = 3 * 60 * 1e3;
+var IDLE_GAP_MS5 = 3 * 60 * 1e3;
 var INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
 var PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
 var BASH_CHAIN_SPLIT_RE = /\|\||&&|;|\|/;
@@ -6479,7 +7511,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({
@@ -6676,7 +7708,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();
@@ -6873,7 +7905,7 @@ function decodeProjectDirName(projectDir) {
 }
 function buildEntriesForFile(filePath) {
   const stat = statSync2(filePath);
-  const raw = readFileSync9(filePath, "utf8");
+  const raw = readFileSync10(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -7134,7 +8166,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID(),
     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 } : {},
@@ -7161,7 +8193,7 @@ async function pushToTeamServer(config, payload) {
 }
 
 // src/team/git-remote.ts
-import { existsSync as existsSync7, readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync8, readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
 import { dirname as dirname5, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "node:path";
 var GITHUB_URL_RE = /github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
 function parseGithubRemote(url) {
@@ -7187,12 +8219,12 @@ function gitConfigPathFor(dir) {
   const st = statSync3(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
   if (st.isDirectory()) return join6(dotGit, "config");
-  const m = readFileSync10(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  const m = readFileSync11(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
   const gd = isAbsolute2(m[1]) ? m[1] : resolve2(dir, m[1]);
   const commondirFile = join6(gd, "commondir");
-  if (existsSync7(commondirFile)) {
-    const common = readFileSync10(commondirFile, "utf8").trim();
+  if (existsSync8(commondirFile)) {
+    const common = readFileSync11(commondirFile, "utf8").trim();
     return join6(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
   return join6(gd, "config");
@@ -7207,8 +8239,8 @@ function createRepoResolver() {
     try {
       for (let d = dir; ; d = dirname5(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync7(config)) {
-          const url = originUrl2(readFileSync10(config, "utf8"));
+        if (config && existsSync8(config)) {
+          const url = originUrl2(readFileSync11(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
@@ -7224,7 +8256,7 @@ function createRepoResolver() {
 
 // src/team/queue.ts
 init_fs();
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync6 } from "node:fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname as dirname6 } from "node:path";
 var QUEUE_PATH = cclensPath("ingest-queue.jsonl");
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
@@ -7244,7 +8276,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync11(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync12(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -7265,7 +8297,7 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync11(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync12(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
@@ -7278,7 +8310,7 @@ init_storage();
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/usage/profile.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 var PROFILE_ENDPOINT = "https://api.anthropic.com/api/oauth/profile";
 var BETA_HEADER2 = "oauth-2025-04-20";
@@ -7322,9 +8354,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync8(cachePath)) return null;
+  if (!existsSync9(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync12(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync13(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -7493,13 +8525,13 @@ async function runTeamBackfill(log3 = noopLog, filePath = USAGE_LOG, configOverr
 
 // src/team/sync-log.ts
 init_fs();
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 var MAX_LINES = 300;
 var MAX_MSG_CHARS = 1900;
 function readPendingSyncLog(watermark) {
   let raw;
   try {
-    raw = readFileSync13(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync14(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -8125,7 +9157,7 @@ init_fs();
 
 // src/perception/state.ts
 init_fs();
-import { existsSync as existsSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, renameSync as renameSync4 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, renameSync as renameSync4 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 var STALE_MS = 15 * 60 * 1e3;
 var pathCached = null;
@@ -8136,7 +9168,7 @@ function statePath() {
 }
 function readState() {
   const p = statePath();
-  if (!existsSync10(p)) {
+  if (!existsSync11(p)) {
     return {
       sweep_in_progress: false,
       last_sweep_started_at: null,
@@ -8144,7 +9176,7 @@ function readState() {
       file_checkpoints: {}
     };
   }
-  const raw = readFileSync14(p, "utf8");
+  const raw = readFileSync15(p, "utf8");
   return JSON.parse(raw);
 }
 function writeState(s) {
@@ -8752,8 +9784,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var 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
@@ -8869,11 +9901,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var 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() {
@@ -12407,12 +13439,12 @@ var ENRICHMENT_SYSTEM_PROMPT = SYSTEM_PROMPT;
 // ../entries/dist/llm-runner.js
 init_fs();
 import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync11, existsSync as existsSync12 } from "node:fs";
+import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "node:fs";
 import { join as join11 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, existsSync as existsSync11, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync15, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, existsSync as existsSync12, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync16, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
 import { join as join10 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -12443,7 +13475,7 @@ function tmuxRunnerAvailable() {
 }
 function runtimeCwd() {
   const dir = join10(homedir5(), ".cclens", "runtime");
-  if (!existsSync11(dir))
+  if (!existsSync12(dir))
     mkdirSync10(dir, { recursive: true });
   return realpathSync2(dir);
 }
@@ -12451,7 +13483,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   const cfgPath = join10(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync15(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync16(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -12600,10 +13632,10 @@ function snapshotAllTranscripts() {
   }
   return out;
 }
-function readJsonlCwd(path7, maxLines = 8) {
+function readJsonlCwd(path9, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync15(path7, "utf8");
+    raw = readFileSync16(path9, "utf8");
   } catch {
     return void 0;
   }
@@ -12657,10 +13689,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 = readFileSync15(path7, "utf8");
+    raw = readFileSync16(path9, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -12735,7 +13767,7 @@ function shellEscape(s) {
 // ../entries/dist/llm-runner.js
 var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync12(RUNS_DIR)) {
+  if (!existsSync13(RUNS_DIR)) {
     try {
       mkdirSync11(RUNS_DIR, { recursive: true });
     } catch {
@@ -12766,15 +13798,15 @@ function newRunId(kind) {
 function tracePath(runId) {
   return join11(RUNS_DIR, `${runId}.jsonl`);
 }
-function safeAppend(path7, line) {
+function safeAppend(path9, line) {
   try {
-    appendFileSync5(path7, line);
+    appendFileSync5(path9, line);
   } catch {
   }
 }
-function safeWrite(path7, line) {
+function safeWrite(path9, line) {
   try {
-    writeFileSync11(path7, line);
+    writeFileSync11(path9, line);
   } catch {
   }
 }
@@ -13163,7 +14195,7 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 
 // ../entries/dist/budget.js
 init_fs();
-import { appendFileSync as appendFileSync6, readFileSync as readFileSync16, existsSync as existsSync13, mkdirSync as mkdirSync12 } from "node:fs";
+import { appendFileSync as appendFileSync6, readFileSync as readFileSync17, existsSync as existsSync14, mkdirSync as mkdirSync12 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 var spendPathCached = null;
 function spendPath() {
@@ -13179,12 +14211,12 @@ function appendSpend(record) {
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync13(p))
+  if (!existsSync14(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync16(p, "utf8");
+  const raw = readFileSync17(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -13206,7 +14238,7 @@ function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
 
 // ../entries/dist/pipeline-lock.js
 init_fs();
-import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync14, readFileSync as readFileSync17, statSync as statSync7 } from "node:fs";
+import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync15, readFileSync as readFileSync18, statSync as statSync7 } from "node:fs";
 var STALE_MS2 = 60 * 1e3;
 var HEARTBEAT_MS = 30 * 1e3;
 var lockPathCached = null;
@@ -13252,13 +14284,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync14(p))
+  if (!existsSync15(p))
     return false;
   try {
     const mtime = statSync7(p).mtimeMs;
     if (nowMs - mtime > STALE_MS2)
       return false;
-    const pid = Number(readFileSync17(p, "utf8").trim());
+    const pid = Number(readFileSync18(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -13273,7 +14305,7 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync13, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync15 } from "node:fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync16 } from "node:fs";
 init_fs();
 var DEFAULT_SETTINGS = {
   ai_features: {
@@ -13305,10 +14337,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync15(p))
+  if (!existsSync16(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync18(p, "utf8");
+    const raw = readFileSync19(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -13481,7 +14513,7 @@ function rollupOutcomeDay(entries) {
     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";
@@ -13537,7 +14569,7 @@ function computeDaySignals(entries) {
     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) {
@@ -13556,7 +14588,7 @@ function computeDaySignals(entries) {
     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;
@@ -14399,7 +15431,7 @@ function computeInteractionModes(entries) {
       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 = [];
@@ -14416,7 +15448,7 @@ function computeInteractionModes(entries) {
       skillExamples.push({
         date: e.local_day,
         skill,
-        first_user_preview: truncate6(e.first_user, 200)
+        first_user_preview: truncate7(e.first_user, 200)
       });
     }
   }
@@ -14433,7 +15465,7 @@ function computeInteractionModes(entries) {
     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";
@@ -14464,7 +15496,7 @@ function computeInteractionModes(entries) {
     }
   };
 }
-function truncate6(s, max) {
+function truncate7(s, max) {
   if (s.length <= max)
     return s;
   return s.slice(0, max - 1).trimEnd() + "\u2026";
@@ -14521,7 +15553,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 ?? "";
@@ -14532,7 +15564,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
       };
     });
@@ -14607,7 +15639,7 @@ function computeInteractionGrammar(dayDigests, entriesByDay = /* @__PURE__ */ ne
         date: day,
         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;
@@ -14679,7 +15711,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: {
@@ -14979,7 +16011,7 @@ var MonthDigestResponseSchema = external_exports.object({
 }).passthrough();
 
 // ../entries/dist/top-sessions.js
-var IDLE_GAP_MS5 = 3 * 60 * 1e3;
+var IDLE_GAP_MS6 = 3 * 60 * 1e3;
 var LONG_AUTONOMOUS_MIN = 20;
 var N_USER = 150;
 var N_FIRST_AGENT = 150;
@@ -15010,7 +16042,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;
@@ -15184,7 +16216,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)
@@ -16068,14 +17100,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)
   };
 }
 
@@ -16123,7 +17155,7 @@ var perceptionHandle = setInterval(async () => {
 }, PERCEPTION_INTERVAL_MS);
 function readUpdateState() {
   try {
-    return JSON.parse(readFileSync19(UPDATE_STATE, "utf8"));
+    return JSON.parse(readFileSync20(UPDATE_STATE, "utf8"));
   } catch {
     return null;
   }
@@ -16175,7 +17207,7 @@ async function runDaemonUpdateCheck() {
       return;
     }
     const entry = cliEntryPath();
-    if (!existsSync16(entry)) {
+    if (!existsSync17(entry)) {
       log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
       return;
     }
@@ -16252,6 +17284,24 @@ async function tick() {
       log2("warn", `zai poll failed: ${err.message}`);
     }
   }
+  try {
+    const grokSnapshot = await fetchGrokUsage();
+    appendSnapshot(USAGE_LOG3, grokSnapshot);
+    log2(
+      "info",
+      `grok snapshot 5h=\u2014 7d=${grokSnapshot.seven_day.utilization}%`
+    );
+  } catch (err) {
+    if (err instanceof GrokApiError && (err.code === "no_auth" || err.code === "not_weekly")) {
+      pruneAgent(USAGE_LOG3, "grok");
+      if (err.code === "no_auth") {
+      } else {
+        log2("warn", `grok poll skipped: ${err.message}`);
+      }
+    } else {
+      log2("warn", `grok poll failed: ${err.message}`);
+    }
+  }
   try {
     const snapshot = await fetchUsage();
     appendSnapshot(USAGE_LOG3, snapshot);