fleetlens 0.16.4 → 0.16.7

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, GROK_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
+var CLAUDE_CODE_METADATA, CODEX_METADATA, COPILOT_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";
@@ -693,6 +693,13 @@ var init_agent_metadata = __esm({
       accentColor: "rgb(16, 163, 127)",
       iconChar: "\u25C6"
     };
+    COPILOT_METADATA = {
+      kind: "copilot",
+      displayName: "GitHub Copilot CLI",
+      shortLabel: "Copilot",
+      accentColor: "rgb(137, 87, 229)",
+      iconChar: "\u221E"
+    };
     GEMINI_METADATA = {
       kind: "gemini",
       displayName: "Gemini CLI",
@@ -732,6 +739,7 @@ var init_agent_metadata = __esm({
     agentMetadata = [
       CLAUDE_CODE_METADATA,
       CODEX_METADATA,
+      COPILOT_METADATA,
       GEMINI_METADATA,
       ANTIGRAVITY_METADATA,
       COWORK_METADATA,
@@ -1593,11 +1601,11 @@ function defaultBranch(commonDir) {
   }
   return void 0;
 }
-function readGitFolder(path9) {
-  if (!existsSync(path9))
+function readGitFolder(path11) {
+  if (!existsSync(path11))
     return { exists: false, isWorktree: false };
   try {
-    const git = nearestDotGit(realpathOrSelf(path9));
+    const git = nearestDotGit(realpathOrSelf(path11));
     if (!git)
       return { exists: true, isWorktree: false };
     const projectRoot = projectRootFromCommonDir(git.commonDir);
@@ -3379,24 +3387,442 @@ var init_codex = __esm({
   }
 });
 
-// ../parser/dist/gemini.js
+// ../parser/dist/copilot.js
 import { promises as fs3 } from "node:fs";
 import os3 from "node:os";
 import path3 from "node:path";
-async function safeReaddir2(p) {
-  return fs3.readdir(p).catch(() => []);
+function recordOf(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function stringOf(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function numberOf2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function emptyUsage2() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+function previewOf2(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
+  return text.replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function tokenCount(details, key) {
+  return numberOf2(recordOf(details?.[key])?.tokenCount);
+}
+function syntheticProjectDir(cwd) {
+  return cwd ? cwd.replace(/^\//, "-").replace(/\//g, "-") : "(unknown)";
 }
 async function listSessionFiles(root) {
+  const entries2 = await fs3.readdir(root, { withFileTypes: true }).catch(() => []);
+  const out = [];
+  for (const entry of entries2) {
+    if (!entry.isDirectory())
+      continue;
+    const filePath = path3.join(root, entry.name, "events.jsonl");
+    const stat = await fs3.stat(filePath).catch(() => null);
+    if (!stat?.isFile())
+      continue;
+    out.push({
+      filePath,
+      sessionId: entry.name,
+      mtimeMs: stat.mtimeMs,
+      sizeBytes: stat.size
+    });
+  }
+  return out;
+}
+async function readJsonl2(filePath) {
+  const raw = await fs3.readFile(filePath, "utf8");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+function computeActiveSegments3(timestamps) {
+  const sorted = [...new Set(timestamps)].sort((a, b) => a - b);
+  if (sorted.length === 0)
+    return [];
+  const segments = [];
+  let start2 = sorted[0];
+  let end = start2;
+  for (let i = 1; i < sorted.length; i++) {
+    const next = sorted[i];
+    if (next - end > IDLE_GAP_MS2) {
+      segments.push({ startMs: start2, endMs: end });
+      start2 = next;
+    }
+    end = next;
+  }
+  segments.push({ startMs: start2, endMs: end });
+  return segments;
+}
+function parseSession(file, lines) {
+  const records = lines.map(recordOf).filter((line) => line !== void 0);
+  const executionCallIds = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    if (record.type !== "tool.execution_start")
+      continue;
+    const callId = stringOf(recordOf(record.data)?.toolCallId);
+    if (callId)
+      executionCallIds.add(callId);
+  }
+  const events = [];
+  const timestamps = [];
+  const totalUsage = emptyUsage2();
+  let firstMs;
+  let lastMs;
+  let cwd;
+  let repository;
+  let gitBranch;
+  let model;
+  let firstUserPreview;
+  let lastUserPreview;
+  let lastAgentPreview;
+  let toolCallCount = 0;
+  let turnCount = 0;
+  let observedOutput = 0;
+  let sawShutdown = false;
+  let linesAdded;
+  let linesRemoved;
+  let filesEdited;
+  let idx = 0;
+  function push(event) {
+    events.push({ index: idx++, ...event });
+  }
+  for (const obj of records) {
+    const type = stringOf(obj.type) ?? "";
+    const data = recordOf(obj.data) ?? {};
+    const timestamp = stringOf(obj.timestamp);
+    if (timestamp) {
+      const ms = Date.parse(timestamp);
+      if (Number.isFinite(ms)) {
+        timestamps.push(ms);
+        firstMs = firstMs === void 0 ? ms : Math.min(firstMs, ms);
+        lastMs = lastMs === void 0 ? ms : Math.max(lastMs, ms);
+      }
+    }
+    if (type === "session.start") {
+      const context = recordOf(data.context);
+      cwd = stringOf(context?.cwd) ?? cwd;
+      repository = stringOf(context?.repository) ?? repository;
+      gitBranch = stringOf(context?.branch) ?? gitBranch;
+      push({
+        timestamp,
+        role: "meta",
+        rawType: type,
+        preview: "Copilot session started",
+        blocks: [],
+        raw: obj
+      });
+      continue;
+    }
+    if (type === "session.model_change") {
+      const selected = stringOf(data.newModel);
+      if (selected && selected !== "auto")
+        model = selected;
+    } else if (type === "session.auto_mode_resolved") {
+      model = stringOf(data.chosenModel) ?? model;
+    } else if (type === "assistant.turn_start" || type === "assistant.message") {
+      model = stringOf(data.model) ?? model;
+    }
+    if (type === "system.message") {
+      push({
+        timestamp,
+        role: "system",
+        rawType: type,
+        preview: "Copilot system instructions",
+        blocks: [],
+        raw: obj
+      });
+      continue;
+    }
+    if (type === "user.message") {
+      const text = stringOf(data.content) ?? "";
+      const preview = previewOf2(text);
+      if (text && !isFrameworkInjectedUserInput(text)) {
+        firstUserPreview ??= preview;
+        lastUserPreview = preview;
+        turnCount += 1;
+      }
+      push({
+        timestamp,
+        role: "user",
+        rawType: type,
+        preview,
+        blocks: text ? [{ type: "text", text }] : [],
+        raw: obj
+      });
+      continue;
+    }
+    if (type === "assistant.message") {
+      const text = stringOf(data.content) ?? "";
+      const outputTokens = numberOf2(data.outputTokens) ?? 0;
+      observedOutput += outputTokens;
+      if (text) {
+        const preview = previewOf2(text);
+        lastAgentPreview = preview;
+        push({
+          timestamp,
+          role: "agent",
+          rawType: type,
+          messageId: stringOf(data.messageId),
+          preview,
+          blocks: [{ type: "text", text }],
+          model,
+          raw: obj
+        });
+      }
+      const requests = Array.isArray(data.toolRequests) ? data.toolRequests : [];
+      for (const requestValue of requests) {
+        const request = recordOf(requestValue);
+        if (!request)
+          continue;
+        const callId = stringOf(request.toolCallId);
+        if (callId && executionCallIds.has(callId))
+          continue;
+        const name = stringOf(request.name) ?? "(unknown)";
+        const input = recordOf(request.arguments) ?? request.arguments ?? null;
+        toolCallCount += 1;
+        push({
+          timestamp,
+          role: "tool-call",
+          rawType: "assistant.message/tool_request",
+          preview: `${name}(${previewOf2(input).slice(0, 80)})`,
+          blocks: [{ type: "tool_use", id: callId ?? `copilot-${idx}`, name, input }],
+          toolName: name,
+          toolUseId: callId,
+          model,
+          raw: obj
+        });
+      }
+      continue;
+    }
+    if (type === "tool.execution_start") {
+      const callId = stringOf(data.toolCallId);
+      const name = stringOf(data.toolName) ?? "(unknown)";
+      const input = data.arguments ?? null;
+      toolCallCount += 1;
+      push({
+        timestamp,
+        role: "tool-call",
+        rawType: type,
+        preview: `${name}(${previewOf2(input).slice(0, 80)})`,
+        blocks: [{ type: "tool_use", id: callId ?? `copilot-${idx}`, name, input }],
+        toolName: name,
+        toolUseId: callId,
+        model: stringOf(data.model) ?? model,
+        raw: obj
+      });
+      continue;
+    }
+    if (type === "tool.execution_complete") {
+      const callId = stringOf(data.toolCallId);
+      const resultRecord = recordOf(data.result);
+      const result = resultRecord && "content" in resultRecord ? resultRecord.content : data.result;
+      const success = data.success !== false;
+      push({
+        timestamp,
+        role: "tool-result",
+        rawType: type,
+        preview: previewOf2(result),
+        blocks: [{ type: "tool_result", tool_use_id: callId ?? "", content: result, is_error: !success }],
+        toolUseId: callId,
+        toolResult: data.result,
+        raw: obj
+      });
+      continue;
+    }
+    if (type === "assistant.reasoning") {
+      const text = stringOf(data.content) ?? "";
+      push({
+        timestamp,
+        role: "agent-thinking",
+        rawType: type,
+        preview: previewOf2(text),
+        blocks: text ? [{ type: "thinking", thinking: text }] : [],
+        model,
+        raw: obj
+      });
+      continue;
+    }
+    if (type === "session.shutdown") {
+      sawShutdown = true;
+      model = stringOf(data.currentModel) ?? model;
+      const details = recordOf(data.tokenDetails);
+      totalUsage.input = tokenCount(details, "input") ?? totalUsage.input;
+      totalUsage.output = tokenCount(details, "output") ?? observedOutput;
+      totalUsage.cacheRead = tokenCount(details, "cache_read") ?? totalUsage.cacheRead;
+      totalUsage.cacheWrite = tokenCount(details, "cache_write") ?? totalUsage.cacheWrite;
+      const changes = recordOf(data.codeChanges);
+      linesAdded = numberOf2(changes?.linesAdded);
+      linesRemoved = numberOf2(changes?.linesRemoved);
+      const modified = changes?.filesModified;
+      filesEdited = Array.isArray(modified) ? modified.length : void 0;
+    }
+    push({
+      timestamp,
+      role: "meta",
+      rawType: type,
+      preview: "",
+      blocks: [],
+      raw: obj
+    });
+  }
+  if (totalUsage.output === 0)
+    totalUsage.output = observedOutput;
+  if (totalUsage.input || totalUsage.output || totalUsage.cacheRead || totalUsage.cacheWrite) {
+    const usageEvent = [...events].reverse().find((event) => event.role === "agent" || event.role === "agent-thinking" || event.role === "tool-call");
+    if (usageEvent) {
+      usageEvent.messageId = `copilot-${file.sessionId}-total`;
+      usageEvent.usage = { ...totalUsage };
+    }
+  }
+  const firstTimestamp = firstMs === void 0 ? void 0 : new Date(firstMs).toISOString();
+  const lastTimestamp = lastMs === void 0 ? void 0 : new Date(lastMs).toISOString();
+  if (firstMs !== void 0) {
+    let previousMs;
+    for (const event of events) {
+      if (!event.timestamp)
+        continue;
+      const ms = Date.parse(event.timestamp);
+      if (!Number.isFinite(ms))
+        continue;
+      event.tOffsetMs = Math.max(0, ms - firstMs);
+      if (previousMs !== void 0)
+        event.gapMs = Math.max(0, ms - previousMs);
+      previousMs = ms;
+    }
+  }
+  const activeSegments = computeActiveSegments3(timestamps);
+  const airTimeMs = activeSegments.reduce((sum, segment) => sum + segment.endMs - segment.startMs, 0);
+  const project = cwd ? resolveProjectIdentity(cwd) : void 0;
+  const repoName = project?.repoName ?? repository?.split("/").filter(Boolean).at(-1);
+  const meta = {
+    agent: "copilot",
+    id: file.sessionId,
+    filePath: file.filePath,
+    projectName: project?.projectName ?? cwd ?? "(unknown)",
+    worktreeName: project?.worktreeName,
+    repoName,
+    projectDir: syntheticProjectDir(cwd),
+    sessionId: file.sessionId,
+    firstTimestamp,
+    lastTimestamp,
+    lastActivityMs: file.mtimeMs,
+    durationMs: firstMs !== void 0 && lastMs !== void 0 ? lastMs - firstMs : void 0,
+    eventCount: events.length,
+    model,
+    cwd,
+    gitBranch,
+    totalUsage,
+    status: sawShutdown || Date.now() - file.mtimeMs > IDLE_GAP_MS2 ? "idle" : "running",
+    firstUserPreview,
+    lastUserPreview,
+    lastAgentPreview,
+    toolCallCount,
+    turnCount,
+    linesAdded,
+    linesRemoved,
+    filesEdited,
+    airTimeMs,
+    activeSegments
+  };
+  return { meta, events };
+}
+function clearCopilotCaches() {
+  metaCache3.clear();
+  detailCache3.clear();
+}
+async function scanCopilot(root) {
+  const files = await listSessionFiles(root);
+  const out = [];
+  for (const file of files) {
+    const cached = metaCache3.get(file.filePath);
+    if (cached && cached.mtimeMs === file.mtimeMs && cached.sizeBytes === file.sizeBytes) {
+      out.push({ file, meta: cached.meta });
+      continue;
+    }
+    try {
+      const lines = await readJsonl2(file.filePath);
+      const { meta } = parseSession(file, lines);
+      metaCache3.set(file.filePath, { meta, mtimeMs: file.mtimeMs, sizeBytes: file.sizeBytes });
+      out.push({ file, meta });
+    } catch {
+    }
+  }
+  return out;
+}
+async function listCopilotSessions(opts = {}) {
+  const root = opts.root ?? DEFAULT_COPILOT_ROOT;
+  const sessions = (await scanCopilot(root)).map((entry) => entry.meta);
+  sessions.sort((a, b) => (b.firstTimestamp ?? "").localeCompare(a.firstTimestamp ?? ""));
+  return opts.limit === void 0 ? sessions : sessions.slice(0, opts.limit);
+}
+async function getCopilotSession(id, opts = {}) {
+  const root = opts.root ?? DEFAULT_COPILOT_ROOT;
+  const entry = (await scanCopilot(root)).find((candidate) => candidate.meta.id === id);
+  if (!entry)
+    return null;
+  const cached = detailCache3.get(entry.file.filePath);
+  if (cached && cached.mtimeMs === entry.file.mtimeMs && cached.sizeBytes === entry.file.sizeBytes) {
+    return cached.detail;
+  }
+  const lines = await readJsonl2(entry.file.filePath);
+  const { meta, events } = parseSession(entry.file, lines);
+  const detail = { ...meta, events };
+  detailCache3.set(entry.file.filePath, {
+    detail,
+    mtimeMs: entry.file.mtimeMs,
+    sizeBytes: entry.file.sizeBytes
+  });
+  return detail;
+}
+function copilotSessionLocalDay(meta) {
+  if (!meta.firstTimestamp)
+    return void 0;
+  const ms = Date.parse(meta.firstTimestamp);
+  return Number.isFinite(ms) ? toLocalDay(ms) : void 0;
+}
+var DEFAULT_COPILOT_ROOT, IDLE_GAP_MS2, metaCache3, detailCache3;
+var init_copilot = __esm({
+  "../parser/dist/copilot.js"() {
+    "use strict";
+    init_analytics();
+    init_git_project();
+    init_user_input();
+    DEFAULT_COPILOT_ROOT = path3.join(os3.homedir(), ".copilot", "session-state");
+    IDLE_GAP_MS2 = 3 * 60 * 1e3;
+    metaCache3 = /* @__PURE__ */ new Map();
+    detailCache3 = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../parser/dist/gemini.js
+import { promises as fs4 } from "node:fs";
+import os4 from "node:os";
+import path4 from "node:path";
+async function safeReaddir2(p) {
+  return fs4.readdir(p).catch(() => []);
+}
+async function listSessionFiles2(root) {
   const out = [];
   const slugs = await safeReaddir2(root);
   for (const slug of slugs) {
-    const chatsDir = path3.join(root, slug, "chats");
+    const chatsDir = path4.join(root, slug, "chats");
     const entries2 = await safeReaddir2(chatsDir);
     for (const entry of entries2) {
       if (!SESSION_FILE_RE.test(entry))
         continue;
-      const full = path3.join(chatsDir, entry);
-      const stat = await fs3.stat(full).catch(() => null);
+      const full = path4.join(chatsDir, entry);
+      const stat = await fs4.stat(full).catch(() => null);
       if (!stat || !stat.isFile())
         continue;
       const filenameId = entry.replace(/\.(jsonl|json)$/, "").split("-").pop() ?? entry;
@@ -3413,13 +3839,13 @@ async function listSessionFiles(root) {
   return out;
 }
 async function loadSlugToCwd() {
-  const stat = await fs3.stat(GEMINI_PROJECTS_FILE).catch(() => null);
+  const stat = await fs4.stat(GEMINI_PROJECTS_FILE).catch(() => null);
   if (!stat)
     return /* @__PURE__ */ new Map();
   if (projectsCache && projectsCache.mtimeMs === stat.mtimeMs) {
     return projectsCache.slugToCwd;
   }
-  const raw = await fs3.readFile(GEMINI_PROJECTS_FILE, "utf8").catch(() => "");
+  const raw = await fs4.readFile(GEMINI_PROJECTS_FILE, "utf8").catch(() => "");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -3444,7 +3870,7 @@ function isMessageRecord(o) {
   return !!o && typeof o === "object" && typeof o.id === "string" && typeof o.type === "string";
 }
 async function readAndReplay(file) {
-  const raw = await fs3.readFile(file.filePath, "utf8");
+  const raw = await fs4.readFile(file.filePath, "utf8");
   if (file.format === "legacy-json") {
     let blob;
     try {
@@ -3519,10 +3945,10 @@ async function readAndReplay(file) {
   }
   return { meta, messages };
 }
-function emptyUsage2() {
+function emptyUsage3() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
-function previewOf2(text) {
+function previewOf3(text) {
   return text.replace(/\s+/g, " ").trim().slice(0, 200);
 }
 function flattenContent(c) {
@@ -3561,12 +3987,12 @@ function flattenContent(c) {
 function truncate3(s, n) {
   return s.length <= n ? s : s.slice(0, n - 1) + "\u2026";
 }
-async function parseSession(file) {
+async function parseSession2(file) {
   const { meta: metaRec, messages } = await readAndReplay(file);
   const slugToCwd = await loadSlugToCwd();
   const cwd = slugToCwd.get(file.slug);
   const events = [];
-  const totalUsage = emptyUsage2();
+  const totalUsage = emptyUsage3();
   let firstTimestamp;
   let lastTimestamp;
   let model;
@@ -3592,7 +4018,7 @@ async function parseSession(file) {
     const ts = msg.timestamp;
     if (msg.type === "user") {
       const text = flattenContent(msg.displayContent ?? msg.content);
-      const preview = previewOf2(text);
+      const preview = previewOf3(text);
       const isHidden = isFrameworkInjectedUserInput(text);
       if (text && !isHidden) {
         if (!firstUserPreview)
@@ -3616,7 +4042,7 @@ async function parseSession(file) {
       if (typeof msg.model === "string")
         model = msg.model;
       const text = flattenContent(msg.content);
-      const preview = previewOf2(text);
+      const preview = previewOf3(text);
       if (text)
         lastAgentPreview = preview;
       let usage2;
@@ -3642,7 +4068,7 @@ async function parseSession(file) {
           timestamp: th.timestamp ?? ts,
           role: "agent-thinking",
           rawType: "gemini/thought",
-          preview: previewOf2(thText),
+          preview: previewOf3(thText),
           blocks: [{ type: "thinking", thinking: thText }],
           model,
           raw: th
@@ -3699,7 +4125,7 @@ async function parseSession(file) {
             timestamp: tc.timestamp ?? ts,
             role: "tool-result",
             rawType: "gemini/tool_result",
-            preview: previewOf2(resultText),
+            preview: previewOf3(resultText),
             blocks: [
               {
                 type: "tool_result",
@@ -3723,7 +4149,7 @@ async function parseSession(file) {
         timestamp: ts,
         role: "meta",
         rawType: `gemini/${msg.type}`,
-        preview: previewOf2(text),
+        preview: previewOf3(text),
         blocks: text ? [{ type: "text", text }] : [],
         raw: msg
       });
@@ -3745,7 +4171,7 @@ async function parseSession(file) {
       prevMs = ms;
     }
   }
-  const activeSegments = computeActiveSegments3(tsMs);
+  const activeSegments = computeActiveSegments4(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 sessionId = metaRec.sessionId ?? file.filenameId;
@@ -3779,7 +4205,7 @@ async function parseSession(file) {
   };
   return { meta, events };
 }
-function computeActiveSegments3(tsMs) {
+function computeActiveSegments4(tsMs) {
   if (tsMs.length === 0)
     return [];
   const sorted = [...tsMs].sort((a, b) => a - b);
@@ -3787,7 +4213,7 @@ function computeActiveSegments3(tsMs) {
   let segStart = sorted[0];
   let segEnd = sorted[0];
   for (let i = 1; i < sorted.length; i++) {
-    if (sorted[i] - segEnd > IDLE_GAP_MS2) {
+    if (sorted[i] - segEnd > IDLE_GAP_MS3) {
       out.push({ startMs: segStart, endMs: segEnd });
       segStart = sorted[i];
     }
@@ -3797,23 +4223,23 @@ function computeActiveSegments3(tsMs) {
   return out;
 }
 function clearGeminiCaches() {
-  metaCache3.clear();
-  detailCache3.clear();
+  metaCache4.clear();
+  detailCache4.clear();
   projectsCache = null;
 }
 async function listGeminiSessions(opts = {}) {
   const root = opts.root ?? DEFAULT_GEMINI_ROOT;
-  const files = await listSessionFiles(root);
+  const files = await listSessionFiles2(root);
   const out = [];
   for (const file of files) {
-    const cached = metaCache3.get(file.filePath);
+    const cached = metaCache4.get(file.filePath);
     if (cached && cached.mtimeMs === file.mtimeMs && cached.sizeBytes === file.sizeBytes) {
       out.push(cached.meta);
       continue;
     }
     try {
-      const { meta } = await parseSession(file);
-      metaCache3.set(file.filePath, {
+      const { meta } = await parseSession2(file);
+      metaCache4.set(file.filePath, {
         meta,
         mtimeMs: file.mtimeMs,
         sizeBytes: file.sizeBytes
@@ -3829,7 +4255,7 @@ async function listGeminiSessions(opts = {}) {
 }
 async function getGeminiSession(id, opts = {}) {
   const root = opts.root ?? DEFAULT_GEMINI_ROOT;
-  const files = await listSessionFiles(root);
+  const files = await listSessionFiles2(root);
   let chosen;
   for (const file of files) {
     if (file.filenameId === id || id.startsWith(file.filenameId)) {
@@ -3839,7 +4265,7 @@ async function getGeminiSession(id, opts = {}) {
   }
   if (!chosen) {
     for (const file of files) {
-      const { meta: meta2 } = await parseSession(file).catch(() => ({ meta: { id: "" } }));
+      const { meta: meta2 } = await parseSession2(file).catch(() => ({ meta: { id: "" } }));
       if (meta2.id === id) {
         chosen = file;
         break;
@@ -3848,13 +4274,13 @@ async function getGeminiSession(id, opts = {}) {
   }
   if (!chosen)
     return null;
-  const cached = detailCache3.get(chosen.filePath);
+  const cached = detailCache4.get(chosen.filePath);
   if (cached && cached.mtimeMs === chosen.mtimeMs && cached.sizeBytes === chosen.sizeBytes) {
     return cached.detail;
   }
-  const { meta, events } = await parseSession(chosen);
+  const { meta, events } = await parseSession2(chosen);
   const detail = { ...meta, events };
-  detailCache3.set(chosen.filePath, {
+  detailCache4.set(chosen.filePath, {
     detail,
     mtimeMs: chosen.mtimeMs,
     sizeBytes: chosen.sizeBytes
@@ -3867,39 +4293,39 @@ function geminiSessionLocalDay(meta) {
   const ms = Date.parse(meta.firstTimestamp);
   return Number.isFinite(ms) ? toLocalDay(ms) : void 0;
 }
-var DEFAULT_GEMINI_ROOT, GEMINI_PROJECTS_FILE, SESSION_FILE_RE, IDLE_GAP_MS2, projectsCache, metaCache3, detailCache3;
+var DEFAULT_GEMINI_ROOT, GEMINI_PROJECTS_FILE, SESSION_FILE_RE, IDLE_GAP_MS3, projectsCache, metaCache4, detailCache4;
 var init_gemini = __esm({
   "../parser/dist/gemini.js"() {
     "use strict";
     init_analytics();
     init_git_project();
     init_user_input();
-    DEFAULT_GEMINI_ROOT = path3.join(os3.homedir(), ".gemini", "tmp");
-    GEMINI_PROJECTS_FILE = path3.join(os3.homedir(), ".gemini", "projects.json");
+    DEFAULT_GEMINI_ROOT = path4.join(os4.homedir(), ".gemini", "tmp");
+    GEMINI_PROJECTS_FILE = path4.join(os4.homedir(), ".gemini", "projects.json");
     SESSION_FILE_RE = /^session-.+\.(jsonl|json)$/;
-    IDLE_GAP_MS2 = 3 * 60 * 1e3;
+    IDLE_GAP_MS3 = 3 * 60 * 1e3;
     projectsCache = null;
-    metaCache3 = /* @__PURE__ */ new Map();
-    detailCache3 = /* @__PURE__ */ new Map();
+    metaCache4 = /* @__PURE__ */ new Map();
+    detailCache4 = /* @__PURE__ */ new Map();
   }
 });
 
 // ../parser/dist/antigravity.js
-import { promises as fs4 } from "node:fs";
-import os4 from "node:os";
-import path4 from "node:path";
+import { promises as fs5 } from "node:fs";
+import os5 from "node:os";
+import path5 from "node:path";
 async function safeReaddir3(p) {
-  return fs4.readdir(p).catch(() => []);
+  return fs5.readdir(p).catch(() => []);
 }
 async function loadSlugToCwd2(root) {
-  const historyFile = path4.join(root, "history.jsonl");
-  const stat = await fs4.stat(historyFile).catch(() => null);
+  const historyFile = path5.join(root, "history.jsonl");
+  const stat = await fs5.stat(historyFile).catch(() => null);
   if (!stat)
     return /* @__PURE__ */ new Map();
   if (historyCache && historyCache.mtimeMs === stat.mtimeMs) {
     return historyCache.slugToCwd;
   }
-  const raw = await fs4.readFile(historyFile, "utf8").catch(() => "");
+  const raw = await fs5.readFile(historyFile, "utf8").catch(() => "");
   const slugToCwd = /* @__PURE__ */ new Map();
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -3916,14 +4342,14 @@ async function loadSlugToCwd2(root) {
   historyCache = { mtimeMs: stat.mtimeMs, slugToCwd };
   return slugToCwd;
 }
-async function listSessionFiles2(root) {
+async function listSessionFiles3(root) {
   const slugToCwd = await loadSlugToCwd2(root);
   const out = [];
-  const brainDir = path4.join(root, "brain");
+  const brainDir = path5.join(root, "brain");
   const entries2 = await safeReaddir3(brainDir);
   for (const entry of entries2) {
-    const transcriptPath = path4.join(brainDir, entry, ".system_generated", "logs", "transcript.jsonl");
-    const stat = await fs4.stat(transcriptPath).catch(() => null);
+    const transcriptPath = path5.join(brainDir, entry, ".system_generated", "logs", "transcript.jsonl");
+    const stat = await fs5.stat(transcriptPath).catch(() => null);
     if (stat && stat.isFile()) {
       out.push({
         filePath: transcriptPath,
@@ -3936,19 +4362,19 @@ async function listSessionFiles2(root) {
   }
   return out;
 }
-function emptyUsage3() {
+function emptyUsage4() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
-function previewOf3(text) {
+function previewOf4(text) {
   return text.replace(/\s+/g, " ").trim().slice(0, 200);
 }
 function truncate4(s, n) {
   return s.length <= n ? s : s.slice(0, n - 1) + "\u2026";
 }
-async function parseSession2(file) {
-  const raw = await fs4.readFile(file.filePath, "utf8");
+async function parseSession3(file) {
+  const raw = await fs5.readFile(file.filePath, "utf8");
   const events = [];
-  const totalUsage = emptyUsage3();
+  const totalUsage = emptyUsage4();
   let firstTimestamp;
   let lastTimestamp;
   let model;
@@ -4020,7 +4446,7 @@ async function parseSession2(file) {
       if (requestMatch) {
         text2 = requestMatch[1].trim();
       }
-      const preview = previewOf3(text2);
+      const preview = previewOf4(text2);
       const isHidden = isFrameworkInjectedUserInput(text2);
       if (text2 && !isHidden) {
         if (!firstUserPreview)
@@ -4049,14 +4475,14 @@ async function parseSession2(file) {
           timestamp: ts,
           role: "agent-thinking",
           rawType: "antigravity/thought",
-          preview: previewOf3(thinking),
+          preview: previewOf4(thinking),
           blocks: [{ type: "thinking", thinking }],
           model,
           raw: eventObj
         });
       }
       if (content) {
-        const preview = previewOf3(content);
+        const preview = previewOf4(content);
         lastAgentPreview = preview;
         pushEvent({
           index: idx++,
@@ -4102,7 +4528,7 @@ async function parseSession2(file) {
         timestamp: ts,
         role: "tool-result",
         rawType: "antigravity/tool_result",
-        preview: previewOf3(contentStr),
+        preview: previewOf4(contentStr),
         blocks: [{
           type: "tool_result",
           tool_use_id: toolUseId,
@@ -4121,7 +4547,7 @@ async function parseSession2(file) {
       timestamp: ts,
       role: "meta",
       rawType: `antigravity/${eventObj.type?.toLowerCase() || "unknown"}`,
-      preview: previewOf3(text),
+      preview: previewOf4(text),
       blocks: text ? [{ type: "text", text }] : [],
       raw: eventObj
     });
@@ -4141,7 +4567,7 @@ async function parseSession2(file) {
       prevMs = ms;
     }
   }
-  const activeSegments = computeActiveSegments4(tsMs);
+  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 sessionId = file.conversationId;
@@ -4176,7 +4602,7 @@ async function parseSession2(file) {
   };
   return { meta, events };
 }
-function computeActiveSegments4(tsMs) {
+function computeActiveSegments5(tsMs) {
   if (tsMs.length === 0)
     return [];
   const sorted = [...tsMs].sort((a, b) => a - b);
@@ -4184,7 +4610,7 @@ function computeActiveSegments4(tsMs) {
   let segStart = sorted[0];
   let segEnd = sorted[0];
   for (let i = 1; i < sorted.length; i++) {
-    if (sorted[i] - segEnd > IDLE_GAP_MS3) {
+    if (sorted[i] - segEnd > IDLE_GAP_MS4) {
       out.push({ startMs: segStart, endMs: segEnd });
       segStart = sorted[i];
     }
@@ -4194,23 +4620,23 @@ function computeActiveSegments4(tsMs) {
   return out;
 }
 function clearAntigravityCaches() {
-  metaCache4.clear();
-  detailCache4.clear();
+  metaCache5.clear();
+  detailCache5.clear();
   historyCache = null;
 }
 async function listAntigravitySessions(opts = {}) {
   const root = opts.root ?? DEFAULT_ANTIGRAVITY_ROOT;
-  const files = await listSessionFiles2(root);
+  const files = await listSessionFiles3(root);
   const out = [];
   for (const file of files) {
-    const cached = metaCache4.get(file.filePath);
+    const cached = metaCache5.get(file.filePath);
     if (cached && cached.mtimeMs === file.mtimeMs && cached.sizeBytes === file.sizeBytes && cached.cwd === file.cwd) {
       out.push(cached.meta);
       continue;
     }
     try {
-      const { meta } = await parseSession2(file);
-      metaCache4.set(file.filePath, {
+      const { meta } = await parseSession3(file);
+      metaCache5.set(file.filePath, {
         meta,
         mtimeMs: file.mtimeMs,
         sizeBytes: file.sizeBytes,
@@ -4227,7 +4653,7 @@ async function listAntigravitySessions(opts = {}) {
 }
 async function getAntigravitySession(id, opts = {}) {
   const root = opts.root ?? DEFAULT_ANTIGRAVITY_ROOT;
-  const files = await listSessionFiles2(root);
+  const files = await listSessionFiles3(root);
   let chosen;
   for (const file of files) {
     if (file.conversationId === id) {
@@ -4237,13 +4663,13 @@ async function getAntigravitySession(id, opts = {}) {
   }
   if (!chosen)
     return null;
-  const cached = detailCache4.get(chosen.filePath);
+  const cached = detailCache5.get(chosen.filePath);
   if (cached && cached.mtimeMs === chosen.mtimeMs && cached.sizeBytes === chosen.sizeBytes && cached.cwd === chosen.cwd) {
     return cached.detail;
   }
-  const { meta, events } = await parseSession2(chosen);
+  const { meta, events } = await parseSession3(chosen);
   const detail = { ...meta, events };
-  detailCache4.set(chosen.filePath, {
+  detailCache5.set(chosen.filePath, {
     detail,
     mtimeMs: chosen.mtimeMs,
     sizeBytes: chosen.sizeBytes,
@@ -4257,61 +4683,61 @@ function antigravitySessionLocalDay(meta) {
   const ms = Date.parse(meta.firstTimestamp);
   return Number.isFinite(ms) ? toLocalDay(ms) : void 0;
 }
-var DEFAULT_ANTIGRAVITY_ROOT, IDLE_GAP_MS3, historyCache, metaCache4, detailCache4;
+var DEFAULT_ANTIGRAVITY_ROOT, IDLE_GAP_MS4, historyCache, metaCache5, detailCache5;
 var init_antigravity = __esm({
   "../parser/dist/antigravity.js"() {
     "use strict";
     init_analytics();
     init_git_project();
     init_user_input();
-    DEFAULT_ANTIGRAVITY_ROOT = path4.join(os4.homedir(), ".gemini", "antigravity-cli");
-    IDLE_GAP_MS3 = 3 * 60 * 1e3;
+    DEFAULT_ANTIGRAVITY_ROOT = path5.join(os5.homedir(), ".gemini", "antigravity-cli");
+    IDLE_GAP_MS4 = 3 * 60 * 1e3;
     historyCache = null;
-    metaCache4 = /* @__PURE__ */ new Map();
-    detailCache4 = /* @__PURE__ */ new Map();
+    metaCache5 = /* @__PURE__ */ new Map();
+    detailCache5 = /* @__PURE__ */ new Map();
   }
 });
 
 // ../parser/dist/cowork.js
-import { promises as fs5 } from "node:fs";
-import os5 from "node:os";
-import path5 from "node:path";
+import { promises as fs6 } from "node:fs";
+import os6 from "node:os";
+import path6 from "node:path";
 function defaultCoworkRoot() {
-  const home = os5.homedir();
+  const home = os6.homedir();
   if (process.platform === "darwin") {
-    return path5.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+    return path6.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions");
   }
   if (process.platform === "win32") {
-    const appData = process.env.APPDATA ?? path5.join(home, "AppData", "Roaming");
-    return path5.join(appData, "Claude", "local-agent-mode-sessions");
+    const appData = process.env.APPDATA ?? path6.join(home, "AppData", "Roaming");
+    return path6.join(appData, "Claude", "local-agent-mode-sessions");
   }
-  return path5.join(home, ".config", "Claude", "local-agent-mode-sessions");
+  return path6.join(home, ".config", "Claude", "local-agent-mode-sessions");
 }
 async function safeReaddir4(p) {
-  return fs5.readdir(p).catch(() => []);
+  return fs6.readdir(p).catch(() => []);
 }
 async function statMs(p) {
-  const s = await fs5.stat(p).catch(() => null);
+  const s = await fs6.stat(p).catch(() => null);
   return s ? s.mtimeMs : 0;
 }
-async function listSessionFiles3(root) {
+async function listSessionFiles4(root) {
   const out = [];
   const accounts = await safeReaddir4(root);
   for (const accountId of accounts) {
-    const accountDir = path5.join(root, accountId);
+    const accountDir = path6.join(root, accountId);
     const workspaces = await safeReaddir4(accountDir);
     for (const workspaceId of workspaces) {
-      const workspaceDir = path5.join(accountDir, workspaceId);
-      const spacesMtimeMs = await statMs(path5.join(workspaceDir, "spaces.json"));
+      const workspaceDir = path6.join(accountDir, workspaceId);
+      const spacesMtimeMs = await statMs(path6.join(workspaceDir, "spaces.json"));
       const entries2 = await safeReaddir4(workspaceDir);
       for (const entry of entries2) {
         if (!SESSION_ID_RE.test(entry))
           continue;
-        const auditPath = path5.join(workspaceDir, entry, "audit.jsonl");
-        const auditStat = await fs5.stat(auditPath).catch(() => null);
+        const auditPath = path6.join(workspaceDir, entry, "audit.jsonl");
+        const auditStat = await fs6.stat(auditPath).catch(() => null);
         if (!auditStat || !auditStat.isFile() || auditStat.size === 0)
           continue;
-        const metaPath = path5.join(workspaceDir, `${entry}.json`);
+        const metaPath = path6.join(workspaceDir, `${entry}.json`);
         const metaMtimeMs = await statMs(metaPath);
         out.push({
           sessionId: entry,
@@ -4329,14 +4755,14 @@ async function listSessionFiles3(root) {
   return out;
 }
 async function loadSpacesForWorkspace(workspaceDir) {
-  const spacesPath = path5.join(workspaceDir, "spaces.json");
-  const stat = await fs5.stat(spacesPath).catch(() => null);
+  const spacesPath = path6.join(workspaceDir, "spaces.json");
+  const stat = await fs6.stat(spacesPath).catch(() => null);
   if (!stat)
     return /* @__PURE__ */ new Map();
   const cached = spacesCache.get(workspaceDir);
   if (cached && cached.mtimeMs === stat.mtimeMs)
     return cached.spaceIdToPath;
-  const raw = await fs5.readFile(spacesPath, "utf8").catch(() => "");
+  const raw = await fs6.readFile(spacesPath, "utf8").catch(() => "");
   const out = /* @__PURE__ */ new Map();
   try {
     const parsed = JSON.parse(raw);
@@ -4354,7 +4780,7 @@ async function loadSpacesForWorkspace(workspaceDir) {
   return out;
 }
 async function readCoworkMeta(metaPath) {
-  const raw = await fs5.readFile(metaPath, "utf8").catch(() => "");
+  const raw = await fs6.readFile(metaPath, "utf8").catch(() => "");
   if (!raw)
     return {};
   try {
@@ -4390,8 +4816,8 @@ function resolveProject(meta, spaceIdToPath) {
     cwd: projectPath
   };
 }
-async function readJsonl2(filePath) {
-  const raw = await fs5.readFile(filePath, "utf8");
+async function readJsonl3(filePath) {
+  const raw = await fs6.readFile(filePath, "utf8");
   const out = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -4527,7 +4953,7 @@ function buildCoworkSubagents(subagentGroups, allLines, sessionStartMs) {
 }
 async function parseCoworkSession(file) {
   const [lines, coworkMeta, spaceIdToPath] = await Promise.all([
-    readJsonl2(file.auditPath),
+    readJsonl3(file.auditPath),
     readCoworkMeta(file.metaPath),
     loadSpacesForWorkspace(file.workspaceDir)
   ]);
@@ -4562,24 +4988,24 @@ function cacheKeyMatches(a, b) {
   return a.auditMtimeMs === b.auditMtimeMs && a.auditSize === b.auditSize && a.metaMtimeMs === b.metaMtimeMs && a.spacesMtimeMs === b.spacesMtimeMs;
 }
 function clearCoworkCaches() {
-  metaCache5.clear();
-  detailCache5.clear();
+  metaCache6.clear();
+  detailCache6.clear();
   spacesCache.clear();
 }
 async function listCoworkSessions(opts = {}) {
   const root = opts.root ?? DEFAULT_COWORK_ROOT;
-  const files = await listSessionFiles3(root);
+  const files = await listSessionFiles4(root);
   const out = [];
   for (const file of files) {
     const key = cacheKeyFor(file);
-    const cached = metaCache5.get(file.auditPath);
+    const cached = metaCache6.get(file.auditPath);
     if (cached && cacheKeyMatches(cached.key, key)) {
       out.push(cached.meta);
       continue;
     }
     try {
       const { meta } = await parseCoworkSession(file);
-      metaCache5.set(file.auditPath, { meta, key });
+      metaCache6.set(file.auditPath, { meta, key });
       out.push(meta);
     } catch {
     }
@@ -4591,12 +5017,12 @@ async function listCoworkSessions(opts = {}) {
 }
 async function getCoworkSession(id, opts = {}) {
   const root = opts.root ?? DEFAULT_COWORK_ROOT;
-  const files = await listSessionFiles3(root);
+  const files = await listSessionFiles4(root);
   const file = files.find((f) => f.sessionId === id);
   if (!file)
     return null;
   const key = cacheKeyFor(file);
-  const cached = detailCache5.get(file.auditPath);
+  const cached = detailCache6.get(file.auditPath);
   if (cached && cacheKeyMatches(cached.key, key))
     return cached.detail;
   const { meta, events, subagents } = await parseCoworkSession(file);
@@ -4605,10 +5031,10 @@ async function getCoworkSession(id, opts = {}) {
     events,
     ...subagents.length ? { subagents } : {}
   };
-  detailCache5.set(file.auditPath, { detail, key });
+  detailCache6.set(file.auditPath, { detail, key });
   return detail;
 }
-var DEFAULT_COWORK_ROOT, SESSION_ID_RE, spacesCache, metaCache5, detailCache5;
+var DEFAULT_COWORK_ROOT, SESSION_ID_RE, spacesCache, metaCache6, detailCache6;
 var init_cowork = __esm({
   "../parser/dist/cowork.js"() {
     "use strict";
@@ -4618,24 +5044,24 @@ var init_cowork = __esm({
     DEFAULT_COWORK_ROOT = defaultCoworkRoot();
     SESSION_ID_RE = /^local_[0-9a-f-]+$/;
     spacesCache = /* @__PURE__ */ new Map();
-    metaCache5 = /* @__PURE__ */ new Map();
-    detailCache5 = /* @__PURE__ */ new Map();
+    metaCache6 = /* @__PURE__ */ new Map();
+    detailCache6 = /* @__PURE__ */ new Map();
   }
 });
 
 // ../parser/dist/grok.js
-import { promises as fs6 } from "node:fs";
-import os6 from "node:os";
-import path6 from "node:path";
+import { promises as fs7 } from "node:fs";
+import os7 from "node:os";
+import path7 from "node:path";
 function resolveDefaultGrokRoot() {
-  const home = process.env.GROK_HOME || path6.join(os6.homedir(), ".grok");
-  return path6.join(home, "sessions");
+  const home = process.env.GROK_HOME || path7.join(os7.homedir(), ".grok");
+  return path7.join(home, "sessions");
 }
 async function safeReaddir5(p) {
-  return fs6.readdir(p).catch(() => []);
+  return fs7.readdir(p).catch(() => []);
 }
 async function safeReadJson(p) {
-  const raw = await fs6.readFile(p, "utf8").catch(() => null);
+  const raw = await fs7.readFile(p, "utf8").catch(() => null);
   if (raw == null)
     return null;
   try {
@@ -4645,8 +5071,8 @@ async function safeReadJson(p) {
   }
 }
 async function resolveEncodedCwd(groupDir, encoded) {
-  const cwdFile = path6.join(groupDir, ".cwd");
-  const fromFile = await fs6.readFile(cwdFile, "utf8").catch(() => null);
+  const cwdFile = path7.join(groupDir, ".cwd");
+  const fromFile = await fs7.readFile(cwdFile, "utf8").catch(() => null);
   if (fromFile && fromFile.trim())
     return fromFile.trim();
   try {
@@ -4661,8 +5087,8 @@ async function listSessionDirs(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);
+    const groupDir = path7.join(root, group);
+    const groupStat = await fs7.stat(groupDir).catch(() => null);
     if (!groupStat?.isDirectory())
       continue;
     const decodedCwd = await resolveEncodedCwd(groupDir, group);
@@ -4670,14 +5096,14 @@ async function listSessionDirs(root) {
     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 dirPath = path7.join(groupDir, entry);
+      const summaryPath = path7.join(dirPath, "summary.json");
+      const updatesPath = path7.join(dirPath, "updates.jsonl");
+      const signalsCandidate = path7.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)
+        fs7.stat(summaryPath).catch(() => null),
+        fs7.stat(updatesPath).catch(() => null),
+        fs7.stat(signalsCandidate).catch(() => null)
       ]);
       if (!summaryStat?.isFile())
         continue;
@@ -4698,10 +5124,10 @@ async function listSessionDirs(root) {
   }
   return out;
 }
-function emptyUsage4() {
+function emptyUsage5() {
   return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 }
-function previewOf4(text) {
+function previewOf5(text) {
   return text.replace(/\s+/g, " ").trim().slice(0, 200);
 }
 function truncate5(s, n) {
@@ -4815,7 +5241,7 @@ function lineTimestampIso(line) {
   }
   return void 0;
 }
-function computeActiveSegments5(tsMs) {
+function computeActiveSegments6(tsMs) {
   if (tsMs.length === 0)
     return [];
   const sorted = [...tsMs].sort((a, b) => a - b);
@@ -4824,7 +5250,7 @@ function computeActiveSegments5(tsMs) {
   let segEnd = sorted[0];
   for (let i = 1; i < sorted.length; i++) {
     const t = sorted[i];
-    if (t - segEnd > IDLE_GAP_MS4) {
+    if (t - segEnd > IDLE_GAP_MS5) {
       out.push({ startMs: segStart, endMs: segEnd });
       segStart = t;
     }
@@ -4833,17 +5259,17 @@ function computeActiveSegments5(tsMs) {
   out.push({ startMs: segStart, endMs: segEnd });
   return out;
 }
-async function parseSession3(dir) {
+async function parseSession4(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(() => "")
+    fs7.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();
+  const totalUsage = emptyUsage5();
   if (signals?.contextTokensUsed && signals.contextTokensUsed > 0) {
     totalUsage.input = signals.contextTokensUsed;
   }
@@ -4877,7 +5303,7 @@ async function parseSession3(dir) {
     if (!buf)
       return;
     const text = buf.texts.join("");
-    const preview = previewOf4(text);
+    const preview = previewOf5(text);
     if (buf.kind === "user") {
       const isHidden = !text || isFrameworkInjectedUserInput(text);
       if (text && !isHidden) {
@@ -5037,7 +5463,7 @@ async function parseSession3(dir) {
         timestamp: ts,
         role: "tool-result",
         rawType: "grok/tool_result",
-        preview: previewOf4(resultText),
+        preview: previewOf5(resultText),
         blocks: [
           {
             type: "tool_result",
@@ -5086,7 +5512,7 @@ async function parseSession3(dir) {
       prevMs = ms;
     }
   }
-  const activeSegments = computeActiveSegments5(tsMs);
+  const activeSegments = computeActiveSegments6(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;
@@ -5095,7 +5521,7 @@ async function parseSession3(dir) {
   if (!firstUserPreview) {
     const title = summary?.generated_title || summary?.session_summary;
     if (title)
-      firstUserPreview = previewOf4(title);
+      firstUserPreview = previewOf5(title);
   }
   const spawnedAgentCount = await countSubagentChildren(dir.dirPath);
   const meta = {
@@ -5132,38 +5558,38 @@ async function parseSession3(dir) {
   return { meta, events, sessionKind: summary?.session_kind };
 }
 async function countSubagentChildren(dirPath) {
-  const subRoot = path6.join(dirPath, "subagents");
+  const subRoot = path7.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);
+    const st = await fs7.stat(path7.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 subRoot = path7.join(parentDir.dirPath, "subagents");
   const entries2 = await safeReaddir5(subRoot);
-  const groupDir = path6.dirname(parentDir.dirPath);
+  const groupDir = path7.dirname(parentDir.dirPath);
   const runs2 = [];
   for (const entry of entries2) {
-    const metaPath = path6.join(subRoot, entry, "meta.json");
+    const metaPath = path7.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 childDir = path7.join(groupDir, childId);
     const [childSummary, childSignals] = await Promise.all([
-      safeReadJson(path6.join(childDir, "summary.json")),
-      safeReadJson(path6.join(childDir, "signals.json"))
+      safeReadJson(path7.join(childDir, "summary.json")),
+      safeReadJson(path7.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();
+    const usage2 = emptyUsage5();
     if (childSignals?.contextTokensUsed)
       usage2.input = childSignals.contextTokensUsed;
     runs2.push({
@@ -5186,8 +5612,8 @@ async function loadGrokSubagents(parentDir, parentStartMs) {
   return runs2;
 }
 function clearGrokCaches() {
-  metaCache6.clear();
-  detailCache6.clear();
+  metaCache7.clear();
+  detailCache7.clear();
 }
 async function listGrokSessions(opts = {}) {
   const root = opts.root ?? resolveDefaultGrokRoot();
@@ -5197,16 +5623,16 @@ async function listGrokSessions(opts = {}) {
     const summaryPeek = await safeReadJson(dir.summaryPath);
     if (summaryPeek?.session_kind === "subagent")
       continue;
-    const cached = metaCache6.get(dir.dirPath);
+    const cached = metaCache7.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);
+      const { meta, sessionKind } = await parseSession4(dir);
       if (sessionKind === "subagent")
         continue;
-      metaCache6.set(dir.dirPath, {
+      metaCache7.set(dir.dirPath, {
         meta,
         mtimeMs: dir.mtimeMs,
         sizeBytes: dir.sizeBytes
@@ -5227,10 +5653,10 @@ async function getGrokSession(id, opts = {}) {
   if (!chosen) {
     for (const dir of dirs) {
       try {
-        const { meta: meta2, events: events2 } = await parseSession3(dir);
+        const { meta: meta2, events: events2 } = await parseSession4(dir);
         if (meta2.id === id) {
           const detail2 = { ...meta2, events: events2 };
-          detailCache6.set(dir.dirPath, {
+          detailCache7.set(dir.dirPath, {
             detail: detail2,
             mtimeMs: dir.mtimeMs,
             sizeBytes: dir.sizeBytes
@@ -5242,11 +5668,11 @@ async function getGrokSession(id, opts = {}) {
     }
     return null;
   }
-  const cached = detailCache6.get(chosen.dirPath);
+  const cached = detailCache7.get(chosen.dirPath);
   if (cached && cached.mtimeMs === chosen.mtimeMs && cached.sizeBytes === chosen.sizeBytes) {
     return cached.detail;
   }
-  const { meta, events } = await parseSession3(chosen);
+  const { meta, events } = await parseSession4(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 = {
@@ -5254,12 +5680,12 @@ async function getGrokSession(id, opts = {}) {
     events,
     ...subagents.length > 0 ? { subagents, spawnedAgentCount: subagents.length } : {}
   };
-  detailCache6.set(chosen.dirPath, {
+  detailCache7.set(chosen.dirPath, {
     detail,
     mtimeMs: chosen.mtimeMs,
     sizeBytes: chosen.sizeBytes
   });
-  metaCache6.set(chosen.dirPath, {
+  metaCache7.set(chosen.dirPath, {
     meta: {
       ...meta,
       ...subagents.length > 0 ? { spawnedAgentCount: subagents.length } : {}
@@ -5275,17 +5701,17 @@ function grokSessionLocalDay(meta) {
   const ms = Date.parse(meta.firstTimestamp);
   return Number.isFinite(ms) ? toLocalDay(ms) : void 0;
 }
-var DEFAULT_GROK_ROOT, IDLE_GAP_MS4, metaCache6, detailCache6;
+var DEFAULT_GROK_ROOT, IDLE_GAP_MS5, metaCache7, detailCache7;
 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();
+    DEFAULT_GROK_ROOT = path7.join(os7.homedir(), ".grok", "sessions");
+    IDLE_GAP_MS5 = 3 * 60 * 1e3;
+    metaCache7 = /* @__PURE__ */ new Map();
+    detailCache7 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -5346,6 +5772,7 @@ var fs_exports = {};
 __export(fs_exports, {
   DEFAULT_ANTIGRAVITY_ROOT: () => DEFAULT_ANTIGRAVITY_ROOT,
   DEFAULT_CODEX_ROOT: () => DEFAULT_CODEX_ROOT,
+  DEFAULT_COPILOT_ROOT: () => DEFAULT_COPILOT_ROOT,
   DEFAULT_COWORK_ROOT: () => DEFAULT_COWORK_ROOT,
   DEFAULT_GEMINI_ROOT: () => DEFAULT_GEMINI_ROOT,
   DEFAULT_GROK_ROOT: () => DEFAULT_GROK_ROOT,
@@ -5362,6 +5789,7 @@ __export(fs_exports, {
   clearGrokCaches: () => clearGrokCaches,
   clearTeamConfig: () => clearTeamConfig,
   codexSessionLocalDay: () => codexSessionLocalDay,
+  copilotSessionLocalDay: () => copilotSessionLocalDay,
   decodeProjectName: () => decodeProjectName,
   findTeamLead: () => findTeamLead,
   geminiSessionLocalDay: () => geminiSessionLocalDay,
@@ -5369,6 +5797,7 @@ __export(fs_exports, {
   getAntigravitySession: () => getAntigravitySession,
   getAnySession: () => getAnySession,
   getCodexSession: () => getCodexSession,
+  getCopilotSession: () => getCopilotSession,
   getCoworkSession: () => getCoworkSession,
   getGeminiSession: () => getGeminiSession,
   getGrokSession: () => getGrokSession,
@@ -5380,6 +5809,7 @@ __export(fs_exports, {
   listAllSessions: () => listAllSessions,
   listAntigravitySessions: () => listAntigravitySessions,
   listCodexSessions: () => listCodexSessions,
+  listCopilotSessions: () => listCopilotSessions,
   listCoworkSessions: () => listCoworkSessions,
   listGeminiSessions: () => listGeminiSessions,
   listGrokSessions: () => listGrokSessions,
@@ -5402,14 +5832,14 @@ __export(fs_exports, {
   walkJsonlFiles: () => walkJsonlFiles,
   writeTeamConfig: () => writeTeamConfig
 });
-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";
+import { promises as fs8, existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3, appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
+import os8 from "node:os";
+import path8 from "node:path";
 function cclensHome() {
-  return process.env.CCLENS_HOME || path7.join(os7.homedir(), ".cclens");
+  return process.env.CCLENS_HOME || path8.join(os8.homedir(), ".cclens");
 }
 function cclensPath(...parts) {
-  return path7.join(cclensHome(), ...parts);
+  return path8.join(cclensHome(), ...parts);
 }
 function cacheStats() {
   return claudeCodeCacheStats();
@@ -5417,6 +5847,7 @@ function cacheStats() {
 function clearCaches() {
   clearClaudeCodeCaches();
   clearCodexCaches();
+  clearCopilotCaches();
   clearGeminiCaches();
   clearAntigravityCaches();
   clearCoworkCaches();
@@ -5451,7 +5882,7 @@ function usageLogPath() {
 }
 function appendUsageSnapshot(snapshot) {
   const p = usageLogPath();
-  mkdirSync3(path7.dirname(p), { recursive: true });
+  mkdirSync3(path8.dirname(p), { recursive: true });
   appendFileSync(p, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function pruneUsageAgent(agent) {
@@ -5467,13 +5898,13 @@ function pruneUsageAgent(agent) {
       return true;
     }
   });
-  mkdirSync3(path7.dirname(p), { recursive: true });
+  mkdirSync3(path8.dirname(p), { recursive: true });
   writeFileSync3(p, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
 }
 async function loadUsageByDay(start2, end) {
   let raw;
   try {
-    raw = await fs7.readFile(usageLogPath(), "utf8");
+    raw = await fs8.readFile(usageLogPath(), "utf8");
   } catch {
     return { by_day: [] };
   }
@@ -5518,7 +5949,7 @@ async function loadUsageByDay(start2, end) {
 async function loadCalibrationSnapshots() {
   let raw;
   try {
-    raw = await fs7.readFile(usageLogPath(), "utf8");
+    raw = await fs8.readFile(usageLogPath(), "utf8");
   } catch {
     return [];
   }
@@ -5682,7 +6113,7 @@ async function loadCalibrationCurve(tier = "pro-max-20x", root = DEFAULT_ROOT, g
   ]);
   return buildCalibrationCurve(events, snapshots, tier, granularityMin);
 }
-var codexSource, geminiSource, antigravitySource, coworkSource, grokSource, agentSources;
+var codexSource, copilotSource, geminiSource, antigravitySource, coworkSource, grokSource, agentSources;
 var init_fs = __esm({
   "../parser/dist/fs.js"() {
     "use strict";
@@ -5691,6 +6122,7 @@ var init_fs = __esm({
     init_calibration();
     init_claude_code();
     init_codex();
+    init_copilot();
     init_gemini();
     init_antigravity();
     init_cowork();
@@ -5698,6 +6130,7 @@ var init_fs = __esm({
     init_claude_code();
     init_git_project();
     init_codex();
+    init_copilot();
     init_gemini();
     init_antigravity();
     init_cowork();
@@ -5712,18 +6145,16 @@ var init_fs = __esm({
       },
       async getSession(id) {
         return getCodexSession(id);
+      }
+    };
+    copilotSource = {
+      ...COPILOT_METADATA,
+      defaultRoot: DEFAULT_COPILOT_ROOT,
+      async listSessions(opts) {
+        return listCopilotSessions(opts);
       },
-      async usagePoller() {
-        const w = await getLatestCodexUsage();
-        if (!w)
-          return null;
-        return {
-          captured_at: (/* @__PURE__ */ new Date()).toISOString(),
-          agent: "codex",
-          five_hour: w.five_hour,
-          seven_day: w.seven_day,
-          plan_type: w.plan_type
-        };
+      async getSession(id, opts) {
+        return getCopilotSession(id, opts);
       }
     };
     geminiSource = {
@@ -5770,6 +6201,7 @@ var init_fs = __esm({
     agentSources = [
       claudeCodeSource,
       codexSource,
+      copilotSource,
       geminiSource,
       antigravitySource,
       coworkSource,
@@ -5809,9 +6241,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.4";
+    return pkg.version ?? "0.16.7";
   } catch {
-    return "0.16.4";
+    return "0.16.7";
   }
 }
 function getServerStatus() {
@@ -5823,7 +6255,7 @@ function getServerStatus() {
   return { running: false };
 }
 function isServerStale(status2) {
-  return status2.running === true && status2.version !== "0.16.4";
+  return status2.running === true && status2.version !== "0.16.7";
 }
 async function ensureCurrentServer(opts = {}) {
   const status2 = getServerStatus();
@@ -6262,9 +6694,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.4") {
+  } else if (verify.installedVersion !== "0.16.7") {
     console.log(
-      `  \u2192 This process is still running ${"0.16.4"}. Next invocation will use ${verify.installedVersion}.`
+      `  \u2192 This process is still running ${"0.16.7"}. Next invocation will use ${verify.installedVersion}.`
     );
   }
 }
@@ -6299,14 +6731,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.16.4",
+    current: "0.16.7",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.16.4",
+    current: "0.16.7",
     latest,
-    updateAvailable: shouldUpdate("0.16.4", latest)
+    updateAvailable: shouldUpdate("0.16.7", latest)
   };
 }
 async function checkForUpdate() {
@@ -6396,7 +6828,7 @@ async function restartServices(state) {
 }
 async function forceUpdate() {
   const latest = await fetchLatestVersion();
-  const current = "0.16.4";
+  const current = "0.16.7";
   if (latest === null) {
     console.error("Could not reach npm registry. Check your network.");
     process.exit(1);
@@ -6809,7 +7241,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.4"}) \u2014 run 'fleetlens start' to restart on the current version`
+        `  \u26A0  serving stale ${ver} (CLI is ${"0.16.7"}) \u2014 run 'fleetlens start' to restart on the current version`
       );
     }
   } else {
@@ -6848,7 +7280,7 @@ async function web(args2) {
   const open = args2.includes("--open");
   const positional = args2.filter((a) => !a.startsWith("--"));
   const rawPath = positional[0] ?? "";
-  const path9 = rawPath.startsWith("/") ? rawPath : rawPath ? `/${rawPath}` : "";
+  const path11 = rawPath.startsWith("/") ? rawPath : rawPath ? `/${rawPath}` : "";
   let result;
   try {
     result = await ensureCurrentServer({});
@@ -6856,7 +7288,7 @@ async function web(args2) {
     console.error(`Failed to start: ${err.message}`);
     process.exit(1);
   }
-  const url = `http://localhost:${result.port}${path9}`;
+  const url = `http://localhost:${result.port}${path11}`;
   if (result.restarted) {
     console.log(`fleetlens restarted on http://localhost:${result.port} (PID ${result.pid}) \u2014 replaced stale ${result.previousVersion ?? "unknown"} server`);
   }
@@ -6917,9 +7349,9 @@ function readFromCredentialsFile() {
     join7(homedir4(), ".claude", ".credentials.json"),
     join7(homedir4(), ".config", "claude", "credentials.json")
   ];
-  for (const path9 of candidates) {
+  for (const path11 of candidates) {
     try {
-      const blob = readFileSync10(path9, "utf8");
+      const blob = readFileSync10(path11, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -7043,13 +7475,13 @@ 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";
+import os9 from "node:os";
+import path9 from "node:path";
 function grokHome() {
-  return process.env.GROK_HOME || path8.join(os8.homedir(), ".grok");
+  return process.env.GROK_HOME || path9.join(os9.homedir(), ".grok");
 }
 function authPath() {
-  return path8.join(grokHome(), "auth.json");
+  return path9.join(grokHome(), "auth.json");
 }
 function loadAuthEntry() {
   const p = authPath();
@@ -7112,8 +7544,8 @@ async function refreshAccessToken(entry) {
           break;
         }
       }
-      const { writeFileSync: writeFileSync17 } = await import("node:fs");
-      writeFileSync17(p, JSON.stringify(raw, null, 2), "utf8");
+      const { writeFileSync: writeFileSync18 } = await import("node:fs");
+      writeFileSync18(p, JSON.stringify(raw, null, 2), "utf8");
     } catch {
     }
     return j.access_token;
@@ -7259,6 +7691,500 @@ var init_grok2 = __esm({
   }
 });
 
+// src/usage/codex.ts
+import {
+  existsSync as existsSync9,
+  readFileSync as readFileSync12,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import os10 from "node:os";
+import path10 from "node:path";
+function codexHome() {
+  const env = process.env.CODEX_HOME?.trim();
+  if (env) return env;
+  return path10.join(os10.homedir(), ".codex");
+}
+function authPath2() {
+  return path10.join(codexHome(), "auth.json");
+}
+function loadAuth() {
+  const p = authPath2();
+  if (!existsSync9(p)) {
+    throw new CodexApiError(
+      "Codex not logged in. Run `codex` to authenticate.",
+      "no_auth"
+    );
+  }
+  let auth;
+  try {
+    auth = JSON.parse(readFileSync12(p, "utf8"));
+  } catch {
+    throw new CodexApiError(
+      "Codex auth.json is unreadable. Run `codex` to log in again.",
+      "no_auth"
+    );
+  }
+  const access = auth.tokens?.access_token?.trim();
+  if (!access) {
+    if (auth.OPENAI_API_KEY?.trim()) {
+      throw new CodexApiError(
+        "Codex usage is not available for API-key-only auth. Sign in with a ChatGPT account via `codex`.",
+        "api_key_only"
+      );
+    }
+    throw new CodexApiError(
+      "Codex auth has no access token. Run `codex` to log in.",
+      "no_auth"
+    );
+  }
+  return { auth, path: p };
+}
+function accessTokenExpiresAtMs(token) {
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  try {
+    const pad2 = "=".repeat((4 - parts[1].length % 4) % 4);
+    const json = Buffer.from(parts[1] + pad2, "base64url").toString("utf8");
+    const payload = JSON.parse(json);
+    if (typeof payload.exp !== "number" || !Number.isFinite(payload.exp)) {
+      return null;
+    }
+    return payload.exp * 1e3;
+  } catch {
+    return null;
+  }
+}
+function needsRefresh2(accessToken, lastRefresh, nowMs = Date.now()) {
+  const expMs = accessTokenExpiresAtMs(accessToken);
+  if (expMs !== null) {
+    return nowMs >= expMs - REFRESH_BUFFER_MS2;
+  }
+  if (!lastRefresh) return false;
+  const ms = Date.parse(lastRefresh);
+  if (!Number.isFinite(ms)) return false;
+  return nowMs - ms > 8 * 24 * 60 * 60 * 1e3;
+}
+async function refreshAccessToken2(auth, filePath) {
+  const refresh = auth.tokens?.refresh_token?.trim();
+  if (!refresh) return null;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: CLIENT_ID,
+    refresh_token: refresh
+  });
+  let res;
+  try {
+    res = await fetch(REFRESH_URL2, {
+      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;
+    const next = {
+      ...auth,
+      tokens: {
+        ...auth.tokens,
+        access_token: j.access_token,
+        refresh_token: j.refresh_token ?? auth.tokens?.refresh_token,
+        id_token: j.id_token ?? auth.tokens?.id_token
+      },
+      last_refresh: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      writeFileSync6(filePath, `${JSON.stringify(next, null, 2)}
+`, {
+        encoding: "utf8",
+        mode: 384
+      });
+    } catch {
+    }
+    return { accessToken: j.access_token, auth: next };
+  } catch {
+    return null;
+  }
+}
+function authHeaders2(accessToken, accountId) {
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    Accept: "application/json",
+    "User-Agent": "fleetlens"
+  };
+  if (accountId?.trim()) {
+    headers["ChatGPT-Account-Id"] = accountId.trim();
+  }
+  return headers;
+}
+function numberOf3(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim()) {
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+function windowSeconds(raw) {
+  if (!raw) return void 0;
+  const sec = numberOf3(raw.limit_window_seconds);
+  if (sec !== void 0) return sec;
+  const minutes = numberOf3(raw.window_minutes);
+  if (minutes !== void 0) return minutes * 60;
+  return void 0;
+}
+function normalizeWindow2(raw, headerPercent, nowMs) {
+  const used = numberOf3(raw?.used_percent) ?? headerPercent;
+  if (used === void 0) return null;
+  let resetsAt = null;
+  const resetUnix = numberOf3(raw?.reset_at) ?? numberOf3(raw?.resets_at);
+  if (resetUnix !== void 0) {
+    resetsAt = new Date(resetUnix * 1e3).toISOString();
+  } else {
+    const after = numberOf3(raw?.reset_after_seconds);
+    if (after !== void 0) {
+      resetsAt = new Date(nowMs + after * 1e3).toISOString();
+    }
+  }
+  return {
+    utilization: Math.min(100, Math.max(0, used)),
+    resets_at: resetsAt
+  };
+}
+function parseCodexWhamUsage(body, headers = {}, nowMs = Date.now()) {
+  if (!body || typeof body !== "object") {
+    throw new CodexApiError("Codex usage response missing body", "parse");
+  }
+  const b = body;
+  const rateLimit = b.rate_limit && typeof b.rate_limit === "object" ? b.rate_limit : {};
+  const headerPrimary = numberOf3(headers["x-codex-primary-used-percent"]);
+  const headerSecondary = numberOf3(headers["x-codex-secondary-used-percent"]);
+  const primary = rateLimit.primary_window && typeof rateLimit.primary_window === "object" ? rateLimit.primary_window : null;
+  const secondary = rateLimit.secondary_window && typeof rateLimit.secondary_window === "object" ? rateLimit.secondary_window : null;
+  const candidates = [
+    { raw: primary, headerPercent: headerPrimary, fallback: "five_hour" },
+    { raw: secondary, headerPercent: headerSecondary, fallback: "seven_day" }
+  ];
+  let fiveHour = null;
+  let sevenDay = null;
+  for (const c of candidates) {
+    const secs = windowSeconds(c.raw);
+    const window = normalizeWindow2(c.raw, c.headerPercent, nowMs);
+    if (!window) continue;
+    if (secs === FIVE_HOUR_SECONDS) fiveHour = window;
+    else if (secs === SEVEN_DAY_SECONDS) sevenDay = window;
+  }
+  if (!fiveHour || !sevenDay) {
+    for (const c of candidates) {
+      const secs = windowSeconds(c.raw);
+      if (secs === FIVE_HOUR_SECONDS || secs === SEVEN_DAY_SECONDS) continue;
+      const window = normalizeWindow2(c.raw, c.headerPercent, nowMs);
+      if (!window) continue;
+      if (c.fallback === "five_hour" && !fiveHour) fiveHour = window;
+      else if (c.fallback === "seven_day" && !sevenDay) sevenDay = window;
+    }
+  }
+  const planRaw = b.plan_type;
+  const planType = typeof planRaw === "string" && planRaw.trim() ? planRaw.trim() : null;
+  return {
+    five_hour: fiveHour ?? { utilization: null, resets_at: null },
+    seven_day: sevenDay ?? { utilization: null, resets_at: null },
+    plan_type: planType
+  };
+}
+async function fetchUsageResponse(accessToken, accountId) {
+  let res;
+  try {
+    res = await fetch(USAGE_URL, {
+      headers: authHeaders2(accessToken, accountId)
+    });
+  } catch (err) {
+    throw new CodexApiError(
+      `Network error reaching Codex usage: ${err.message}`,
+      "network"
+    );
+  }
+  const headers = {};
+  res.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+  }
+  return { status: res.status, body, headers };
+}
+async function fetchCodexUsage() {
+  const loaded = loadAuth();
+  let auth = loaded.auth;
+  let access = auth.tokens.access_token.trim();
+  const accountId = auth.tokens?.account_id;
+  if (needsRefresh2(access, auth.last_refresh)) {
+    const refreshed = await refreshAccessToken2(auth, loaded.path);
+    if (refreshed) {
+      access = refreshed.accessToken;
+      auth = refreshed.auth;
+    }
+  }
+  let { status: status2, body, headers } = await fetchUsageResponse(access, accountId);
+  if (status2 === 401 || status2 === 403) {
+    const refreshed = await refreshAccessToken2(auth, loaded.path);
+    if (refreshed) {
+      access = refreshed.accessToken;
+      ({ status: status2, body, headers } = await fetchUsageResponse(access, accountId));
+    }
+  }
+  if (status2 < 200 || status2 >= 300) {
+    throw new CodexApiError(
+      `Codex usage returned HTTP ${status2}`,
+      status2 === 401 || status2 === 403 ? "no_auth" : "http"
+    );
+  }
+  const windows = parseCodexWhamUsage(body, headers);
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    agent: "codex",
+    five_hour: windows.five_hour,
+    seven_day: windows.seven_day,
+    seven_day_opus: null,
+    seven_day_sonnet: null,
+    seven_day_oauth_apps: null,
+    seven_day_cowork: null,
+    extra_usage: null,
+    plan_type: windows.plan_type
+  };
+}
+var USAGE_URL, REFRESH_URL2, CLIENT_ID, FIVE_HOUR_SECONDS, SEVEN_DAY_SECONDS, REFRESH_BUFFER_MS2, CodexApiError;
+var init_codex2 = __esm({
+  "src/usage/codex.ts"() {
+    "use strict";
+    USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+    REFRESH_URL2 = "https://auth.openai.com/oauth/token";
+    CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+    FIVE_HOUR_SECONDS = 5 * 60 * 60;
+    SEVEN_DAY_SECONDS = 7 * 24 * 60 * 60;
+    REFRESH_BUFFER_MS2 = 5 * 60 * 1e3;
+    CodexApiError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/usage/copilot.ts
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync10 } from "node:fs";
+import { dirname as dirname8, join as join8 } from "node:path";
+function recordOf2(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function numberOf4(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function clampPercent(value) {
+  return Math.min(100, Math.max(0, value));
+}
+function nextCopilotMonthlyReset(nowMs = Date.now()) {
+  const now = new Date(nowMs);
+  return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() + 1, 1)).toISOString();
+}
+function quotaResetDate(value, nowMs) {
+  const parsed = typeof value === "string" ? Date.parse(value) : Number.NaN;
+  return Number.isFinite(parsed) && parsed > nowMs + 6e4 ? new Date(parsed).toISOString() : nextCopilotMonthlyReset(nowMs);
+}
+function parseCopilotQuota(body, nowMs = Date.now()) {
+  const root = recordOf2(body);
+  const snapshots = recordOf2(root?.quotaSnapshots);
+  if (!snapshots) {
+    throw new CopilotApiError("Copilot quota response missing quotaSnapshots", "parse");
+  }
+  const chat = recordOf2(snapshots.chat);
+  const legacy = recordOf2(snapshots.premium_interactions);
+  const chatLimit = numberOf4(chat?.entitlementRequests);
+  const quota = chat && (chatLimit !== void 0 && chatLimit > 0 || chat.isUnlimitedEntitlement === true) ? chat : legacy;
+  if (!quota) {
+    throw new CopilotApiError("Copilot quota response has no chat allowance", "parse");
+  }
+  const unlimited = quota.isUnlimitedEntitlement === true;
+  const remainingPercent = numberOf4(quota.remainingPercentage);
+  const utilization = unlimited ? null : remainingPercent === void 0 ? null : clampPercent(100 - remainingPercent);
+  const limit = numberOf4(quota.entitlementRequests) ?? null;
+  const used = numberOf4(quota.usedRequests) ?? null;
+  const unit = quota.tokenBasedBilling === true ? "ai-credits" : "premium-requests";
+  return {
+    captured_at: new Date(nowMs).toISOString(),
+    agent: "copilot",
+    five_hour: { utilization: null, resets_at: null },
+    seven_day: { utilization: null, resets_at: null },
+    monthly: {
+      utilization,
+      resets_at: quotaResetDate(quota.resetDate, nowMs)
+    },
+    monthly_quota: {
+      used,
+      limit,
+      remaining: used !== null && limit !== null ? Math.max(0, limit - used) : null,
+      unit,
+      unlimited
+    },
+    seven_day_opus: null,
+    seven_day_sonnet: null,
+    seven_day_oauth_apps: null,
+    seven_day_cowork: null,
+    extra_usage: null,
+    plan_type: unit === "ai-credits" ? "AI credits" : "premium requests"
+  };
+}
+function rpcFrame(message) {
+  const body = Buffer.from(JSON.stringify(message), "utf8");
+  return Buffer.concat([
+    Buffer.from(`Content-Length: ${body.length}\r
+\r
+`, "ascii"),
+    body
+  ]);
+}
+function resolveCopilotCliPath() {
+  const configured = process.env.COPILOT_CLI_PATH?.trim();
+  if (configured) return configured;
+  const sibling = join8(dirname8(process.execPath), process.platform === "win32" ? "copilot.cmd" : "copilot");
+  return existsSync10(sibling) ? sibling : process.platform === "win32" ? "copilot.cmd" : "copilot";
+}
+async function requestQuota(child) {
+  const decoder = new ContentLengthDecoder();
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  const rejectAll = (error) => {
+    for (const waiter of pending.values()) waiter.reject(error);
+    pending.clear();
+  };
+  child.stdout.on("data", (chunk2) => {
+    try {
+      for (const value of decoder.push(chunk2)) {
+        const message = recordOf2(value);
+        const id = numberOf4(message?.id);
+        if (id === void 0) continue;
+        const waiter = pending.get(id);
+        if (!waiter) continue;
+        pending.delete(id);
+        const rpcError = recordOf2(message?.error);
+        if (rpcError) {
+          waiter.reject(new CopilotApiError(
+            typeof rpcError.message === "string" ? rpcError.message : "Copilot RPC request failed",
+            "protocol"
+          ));
+        } else {
+          waiter.resolve(message?.result);
+        }
+      }
+    } catch (error) {
+      rejectAll(error);
+    }
+  });
+  const exited = new Promise((_, reject) => {
+    child.once("error", (error) => {
+      reject(new CopilotApiError(
+        error.message,
+        error.code === "ENOENT" ? "no_cli" : "protocol"
+      ));
+    });
+    child.once("exit", (code) => {
+      reject(new CopilotApiError(`Copilot RPC exited before responding (code ${code ?? "unknown"})`, "protocol"));
+    });
+  });
+  const request = (method, params = {}) => {
+    const id = nextId++;
+    const response = new Promise((resolve4, reject) => {
+      pending.set(id, { resolve: resolve4, reject });
+      child.stdin.write(rpcFrame({ jsonrpc: "2.0", id, method, params }));
+    });
+    return Promise.race([response, exited]);
+  };
+  await request("connect", {});
+  return request("account.getQuota", {});
+}
+async function fetchCopilotUsage() {
+  const cliPath = resolveCopilotCliPath();
+  const child = spawn3(cliPath, ["--headless", "--no-auto-update", "--stdio", "--log-level", "none"], {
+    cwd: process.cwd(),
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+    shell: process.platform === "win32"
+  });
+  let stderr = "";
+  child.stderr.on("data", (chunk2) => {
+    stderr = (stderr + chunk2.toString("utf8")).slice(-2e3);
+  });
+  const timeout = new Promise((_, reject) => {
+    const handle = setTimeout(() => {
+      reject(new CopilotApiError("Timed out reading Copilot quota", "timeout"));
+    }, RPC_TIMEOUT_MS);
+    handle.unref();
+  });
+  try {
+    const body = await Promise.race([requestQuota(child), timeout]);
+    return parseCopilotQuota(body);
+  } catch (error) {
+    if (error instanceof CopilotApiError) {
+      const message = `${error.message} ${stderr}`.toLowerCase();
+      if (message.includes("not logged") || message.includes("authentication")) {
+        throw new CopilotApiError("Copilot not logged in. Run `copilot login`.", "no_auth");
+      }
+      throw error;
+    }
+    throw new CopilotApiError(error.message, "protocol");
+  } finally {
+    child.kill();
+  }
+}
+var RPC_TIMEOUT_MS, CopilotApiError, ContentLengthDecoder;
+var init_copilot2 = __esm({
+  "src/usage/copilot.ts"() {
+    "use strict";
+    RPC_TIMEOUT_MS = 1e4;
+    CopilotApiError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+      }
+    };
+    ContentLengthDecoder = class {
+      buffer = Buffer.alloc(0);
+      push(chunk2) {
+        this.buffer = Buffer.concat([this.buffer, chunk2]);
+        const messages = [];
+        while (true) {
+          const headerEnd = this.buffer.indexOf("\r\n\r\n");
+          if (headerEnd === -1) break;
+          const header = this.buffer.subarray(0, headerEnd).toString("ascii");
+          const match = header.match(/(?:^|\r\n)Content-Length:\s*(\d+)/i);
+          if (!match) {
+            throw new CopilotApiError("Copilot RPC response missing Content-Length", "protocol");
+          }
+          const length = Number(match[1]);
+          const bodyStart = headerEnd + 4;
+          if (this.buffer.length < bodyStart + length) break;
+          const body = this.buffer.subarray(bodyStart, bodyStart + length).toString("utf8");
+          this.buffer = this.buffer.subarray(bodyStart + length);
+          try {
+            messages.push(JSON.parse(body));
+          } catch {
+            throw new CopilotApiError("Copilot RPC returned invalid JSON", "protocol");
+          }
+        }
+        return messages;
+      }
+    };
+  }
+});
+
 // src/usage/format.ts
 function formatUsage(snapshot) {
   const rows = [
@@ -7598,6 +8524,51 @@ var usage_exports = {};
 __export(usage_exports, {
   usage: () => usage
 });
+async function saveAuxiliarySnapshots() {
+  let saved = 0;
+  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
+      });
+      saved += 1;
+    } catch {
+    }
+  }
+  try {
+    appendSnapshot(USAGE_LOG2, await fetchCodexUsage());
+    saved += 1;
+  } catch (err) {
+    if (!(err instanceof CodexApiError) || err.code !== "no_auth" && err.code !== "api_key_only") {
+      console.warn(`codex usage: ${err.message}`);
+    }
+  }
+  try {
+    appendSnapshot(USAGE_LOG2, await fetchCopilotUsage());
+    saved += 1;
+  } catch (err) {
+    if (!(err instanceof CopilotApiError) || err.code !== "no_cli" && err.code !== "no_auth") {
+      console.warn(`copilot usage: ${err.message}`);
+    }
+  }
+  try {
+    appendSnapshot(USAGE_LOG2, await fetchGrokUsage());
+    saved += 1;
+  } catch (err) {
+    if (!(err instanceof GrokApiError) || err.code !== "no_auth" && err.code !== "not_weekly") {
+      console.warn(`grok usage: ${err.message}`);
+    }
+  }
+  return saved;
+}
 async function usage(args2) {
   if (args2.includes("--help") || args2.includes("-h")) {
     console.log(`fleetlens usage \u2014 plan utilization snapshot
@@ -7614,42 +8585,27 @@ Usage:
     return;
   }
   const save = args2.includes("--save");
+  let snapshot;
   try {
-    const snapshot = await fetchUsage();
+    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) {
+    if (!save || !(err instanceof UsageApiError)) {
+      if (!(err instanceof UsageApiError)) throw err;
       console.error(`Error: ${err.message}`);
-      process.exit(1);
+      process.exitCode = 1;
+      return;
     }
-    throw err;
+    const saved = await saveAuxiliarySnapshots();
+    if (saved === 0) {
+      console.error(`Error: ${err.message}`);
+      process.exitCode = 1;
+    }
+    return;
   }
+  if (save) await saveAuxiliarySnapshots();
+  process.stdout.write("\n  (tip: run with --history for the daily token/cost table)\n");
 }
 var USAGE_LOG2;
 var init_usage = __esm({
@@ -7657,6 +8613,8 @@ var init_usage = __esm({
     "use strict";
     init_api();
     init_grok2();
+    init_codex2();
+    init_copilot2();
     init_format();
     init_storage();
     init_fs();
@@ -8151,6 +9109,7 @@ __export(dist_exports, {
   ANTIGRAVITY_METADATA: () => ANTIGRAVITY_METADATA,
   CLAUDE_CODE_METADATA: () => CLAUDE_CODE_METADATA,
   CODEX_METADATA: () => CODEX_METADATA,
+  COPILOT_METADATA: () => COPILOT_METADATA,
   COWORK_METADATA: () => COWORK_METADATA,
   GEMINI_METADATA: () => GEMINI_METADATA,
   GROK_METADATA: () => GROK_METADATA,
@@ -8567,7 +9526,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_MS5)
+    if (dt < IDLE_GAP_MS6)
       active += dt;
   }
   closed.push({
@@ -8764,7 +9723,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_MS5)
+    if (dt < IDLE_GAP_MS6)
       activeMs2 += dt;
   }
   const tsSortedStrings = dayEvents.map((e) => e.timestamp).filter((t) => !!t).sort();
@@ -8951,7 +9910,7 @@ function buildEntries(sessionDetail) {
   entries2.sort((a, b) => a.local_day.localeCompare(b.local_day));
   return entries2;
 }
-var IDLE_GAP_MS5, INTERRUPT_RE2, PR_TITLE_RE, BASH_CHAIN_SPLIT_RE, SHELL_NOISE, IMAGE_BLOCK_RE;
+var IDLE_GAP_MS6, INTERRUPT_RE2, PR_TITLE_RE, BASH_CHAIN_SPLIT_RE, SHELL_NOISE, IMAGE_BLOCK_RE;
 var init_build = __esm({
   "../entries/dist/build.js"() {
     "use strict";
@@ -8959,7 +9918,7 @@ var init_build = __esm({
     init_types();
     init_signals();
     init_trivial();
-    IDLE_GAP_MS5 = 3 * 60 * 1e3;
+    IDLE_GAP_MS6 = 3 * 60 * 1e3;
     INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
     PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
     BASH_CHAIN_SPLIT_RE = /\|\||&&|;|\|/;
@@ -8988,11 +9947,11 @@ var init_dist2 = __esm({
 });
 
 // ../entries/dist/digest-fs.js
-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(path9, expectedVersion) {
+import { readFileSync as readFileSync13, readdirSync, writeFileSync as writeFileSync7, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync6, existsSync as existsSync11 } from "node:fs";
+import { dirname as dirname9, join as join9 } from "node:path";
+function parseDigestFile(path11, expectedVersion) {
   try {
-    const parsed = JSON.parse(readFileSync12(path9, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path11, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -9011,26 +9970,26 @@ function digestsDir() {
   digestsDirCached = envOverride ?? cclensPath("digests");
   return digestsDirCached;
 }
-function __setDigestsDirForTest(path9) {
-  digestsDirCached = path9;
-  mkdirSync6(join8(path9, "day"), { recursive: true });
-  mkdirSync6(join8(path9, "week"), { recursive: true });
-  mkdirSync6(join8(path9, "month"), { recursive: true });
+function __setDigestsDirForTest(path11) {
+  digestsDirCached = path11;
+  mkdirSync6(join9(path11, "day"), { recursive: true });
+  mkdirSync6(join9(path11, "week"), { recursive: true });
+  mkdirSync6(join9(path11, "month"), { recursive: true });
 }
 function dayDigestPath(date) {
-  return join8(digestsDir(), "day", `${date}.json`);
+  return join9(digestsDir(), "day", `${date}.json`);
 }
 function weekDigestPath(monday) {
-  return join8(digestsDir(), "week", `${monday}.json`);
+  return join9(digestsDir(), "week", `${monday}.json`);
 }
 function monthDigestPath(yearMonth) {
-  return join8(digestsDir(), "month", `${yearMonth}.json`);
+  return join9(digestsDir(), "month", `${yearMonth}.json`);
 }
 function writeDayDigest(digest2) {
   const final = dayDigestPath(digest2.key);
-  mkdirSync6(dirname8(final), { recursive: true });
+  mkdirSync6(dirname9(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync6(tmp, JSON.stringify(digest2, null, 2), "utf8");
+  writeFileSync7(tmp, JSON.stringify(digest2, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -9041,7 +10000,7 @@ function writeDayDigest(digest2) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync9(p))
+  if (!existsSync11(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -9064,9 +10023,9 @@ function __clearTodayCacheForTest() {
 }
 function writeWeekDigest(digest2) {
   const final = weekDigestPath(digest2.key);
-  mkdirSync6(dirname8(final), { recursive: true });
+  mkdirSync6(dirname9(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync6(tmp, JSON.stringify(digest2, null, 2), "utf8");
+  writeFileSync7(tmp, JSON.stringify(digest2, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -9077,13 +10036,13 @@ function writeWeekDigest(digest2) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync9(p))
+  if (!existsSync11(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
 function listWeekDigestKeys() {
-  const dir = join8(digestsDir(), "week");
-  if (!existsSync9(dir))
+  const dir = join9(digestsDir(), "week");
+  if (!existsSync11(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));
 }
@@ -9101,9 +10060,9 @@ function setCurrentWeekDigestInCache(monday, digest2, nowMs) {
 }
 function writeMonthDigest(digest2) {
   const final = monthDigestPath(digest2.key);
-  mkdirSync6(dirname8(final), { recursive: true });
+  mkdirSync6(dirname9(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync6(tmp, JSON.stringify(digest2, null, 2), "utf8");
+  writeFileSync7(tmp, JSON.stringify(digest2, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -9114,13 +10073,13 @@ function writeMonthDigest(digest2) {
 }
 function readMonthDigest(yearMonth) {
   const p = monthDigestPath(yearMonth);
-  if (!existsSync9(p))
+  if (!existsSync11(p))
     return null;
   return parseDigestFile(p, CURRENT_MONTH_DIGEST_SCHEMA_VERSION);
 }
 function listMonthDigestKeys() {
-  const dir = join8(digestsDir(), "month");
-  if (!existsSync9(dir))
+  const dir = join9(digestsDir(), "month");
+  if (!existsSync11(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));
 }
@@ -9182,9 +10141,9 @@ __export(fs_exports2, {
   writeMonthDigest: () => writeMonthDigest,
   writeWeekDigest: () => writeWeekDigest
 });
-import { readFileSync as readFileSync13, readdirSync as readdirSync2, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, renameSync as renameSync3, existsSync as existsSync10 } from "node:fs";
+import { readFileSync as readFileSync14, readdirSync as readdirSync2, writeFileSync as writeFileSync8, mkdirSync as mkdirSync7, renameSync as renameSync3, existsSync as existsSync12 } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function entriesDir() {
   if (entriesDirCached)
     return entriesDirCached;
@@ -9192,12 +10151,12 @@ function entriesDir() {
   entriesDirCached = envOverride ?? cclensPath("entries");
   return entriesDirCached;
 }
-function __setEntriesDirForTest(path9) {
-  entriesDirCached = path9;
-  mkdirSync7(path9, { recursive: true });
+function __setEntriesDirForTest(path11) {
+  entriesDirCached = path11;
+  mkdirSync7(path11, { recursive: true });
 }
 function pathFor(sessionId, localDay2) {
-  return join9(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
+  return join10(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
 }
 function tmpPathFor(final) {
   return `${final}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
@@ -9208,7 +10167,7 @@ function writeEntry(entry) {
   const final = pathFor(entry.session_id, entry.local_day);
   const tmp = tmpPathFor(final);
   const json = JSON.stringify(entry, null, 2);
-  writeFileSync7(tmp, json, { encoding: "utf8" });
+  writeFileSync8(tmp, json, { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 function enrichmentInputHash(e) {
@@ -9236,22 +10195,22 @@ function writeEntryPreservingEnrichment(fresh) {
     toWrite = { ...fresh, enrichment: existing.enrichment };
   }
   const tmp = tmpPathFor(final);
-  writeFileSync7(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
+  writeFileSync8(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 function readEntry(sessionId, localDay2) {
   const p = pathFor(sessionId, localDay2);
-  if (!existsSync10(p))
+  if (!existsSync12(p))
     return null;
-  const raw = readFileSync13(p, "utf8");
+  const raw = readFileSync14(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync10(pathFor(sessionId, localDay2));
+  return existsSync12(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync10(dir))
+  if (!existsSync12(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -9733,8 +10692,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path9, errorMaps, issueData } = params;
-      const fullPath = [...path9, ...issueData.path || []];
+      const { data, path: path11, errorMaps, issueData } = params;
+      const fullPath = [...path11, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -10042,11 +11001,11 @@ var init_types3 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path9, key) {
+      constructor(parent, value, path11, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path9;
+        this._path = path11;
         this._key = key;
       }
       get path() {
@@ -13530,8 +14489,8 @@ RESPOND WITH ONLY VALID JSON (no prose, no code fence):
 });
 
 // ../entries/dist/tmux-runner.js
-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 { mkdirSync as mkdirSync8, writeFileSync as writeFileSync9, existsSync as existsSync13, readdirSync as readdirSync3, realpathSync as realpathSync5, readFileSync as readFileSync15, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
+import { join as join11 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { spawnSync as spawnSync2 } from "node:child_process";
 function which(bin) {
@@ -13548,16 +14507,16 @@ function tmuxRunnerAvailable() {
   return { ok: true };
 }
 function runtimeCwd() {
-  const dir = join10(homedir5(), ".cclens", "runtime");
-  if (!existsSync11(dir))
+  const dir = join11(homedir5(), ".cclens", "runtime");
+  if (!existsSync13(dir))
     mkdirSync8(dir, { recursive: true });
   return realpathSync5(dir);
 }
 function ensureRuntimeCwdTrusted(cwd) {
-  const cfgPath = join10(homedir5(), ".claude.json");
+  const cfgPath = join11(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync14(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync15(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -13572,7 +14531,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   cfg.projects = projects;
   const tmp = `${cfgPath}.cclens-tmp-${process.pid}`;
   try {
-    writeFileSync8(tmp, JSON.stringify(cfg, null, 2));
+    writeFileSync9(tmp, JSON.stringify(cfg, null, 2));
     renameSync4(tmp, cfgPath);
   } catch {
     try {
@@ -13599,16 +14558,16 @@ async function runClaudeUnderTmuxImpl(args2) {
   ensureRuntimeCwdTrusted(cwd);
   const runId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const sessionName = `cclens-${runId}`;
-  const systemFile = join10(cwd, `system-${runId}.txt`);
-  const userFile = join10(cwd, `user-${runId}.txt`);
-  const wrapper = join10(cwd, `run-${runId}.sh`);
-  writeFileSync8(systemFile, args2.systemPrompt);
-  writeFileSync8(userFile, args2.reminder ? `${args2.userPrompt}
+  const systemFile = join11(cwd, `system-${runId}.txt`);
+  const userFile = join11(cwd, `user-${runId}.txt`);
+  const wrapper = join11(cwd, `run-${runId}.sh`);
+  writeFileSync9(systemFile, args2.systemPrompt);
+  writeFileSync9(userFile, args2.reminder ? `${args2.userPrompt}
 
 ---
 
 ${args2.reminder}` : args2.userPrompt);
-  writeFileSync8(wrapper, `#!/bin/bash
+  writeFileSync9(wrapper, `#!/bin/bash
 SYS="$(cat ${shellEscape(systemFile)})"
 USR="$(cat ${shellEscape(userFile)})"
 exec ${shellEscape(claudeBin)} \\
@@ -13620,10 +14579,10 @@ exec ${shellEscape(claudeBin)} \\
   "$USR"
 `, { mode: 493 });
   const existingBefore = snapshotAllTranscripts();
-  const spawn4 = spawnSync2(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
-  if (spawn4.status !== 0) {
+  const spawn5 = spawnSync2(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
+  if (spawn5.status !== 0) {
     cleanup(cwd, runId, tmuxBin, sessionName);
-    throw new TmuxRunError(`tmux new-session failed: ${spawn4.stderr.trim()}`);
+    throw new TmuxRunError(`tmux new-session failed: ${spawn5.stderr.trim()}`);
   }
   const onAbort = () => {
     try {
@@ -13690,7 +14649,7 @@ function snapshotAllTranscripts() {
     return out;
   }
   for (const sub of subs) {
-    const dir = join10(root, sub);
+    const dir = join11(root, sub);
     let files;
     try {
       files = readdirSync3(dir);
@@ -13699,15 +14658,15 @@ function snapshotAllTranscripts() {
     }
     for (const f of files) {
       if (f.endsWith(".jsonl"))
-        out.add(join10(dir, f));
+        out.add(join11(dir, f));
     }
   }
   return out;
 }
-function readJsonlCwd(path9, maxLines = 8) {
+function readJsonlCwd(path11, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync14(path9, "utf8");
+    raw = readFileSync15(path11, "utf8");
   } catch {
     return void 0;
   }
@@ -13740,7 +14699,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
       subs = [];
     }
     for (const sub of subs) {
-      const dir = join10(root, sub);
+      const dir = join11(root, sub);
       let files;
       try {
         files = readdirSync3(dir);
@@ -13750,7 +14709,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const full = join10(dir, f);
+        const full = join11(dir, f);
         if (existingBefore.has(full))
           continue;
         if (readJsonlCwd(full) === targetCwd)
@@ -13761,10 +14720,10 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
   }
   throw new TmuxRunError(`timeout waiting for claude to create the session transcript (cwd: ${targetCwd})`);
 }
-function parseTranscript2(path9, defaultModel) {
+function parseTranscript2(path11, defaultModel) {
   let raw;
   try {
-    raw = readFileSync14(path9, "utf8");
+    raw = readFileSync15(path11, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -13824,7 +14783,7 @@ function cleanup(cwd, runId, tmuxBin, sessionName, transcriptPath) {
     }
     for (const f of [`system-${runId}.txt`, `user-${runId}.txt`, `run-${runId}.sh`]) {
       try {
-        unlinkSync3(join10(cwd, f));
+        unlinkSync3(join11(cwd, f));
       } catch {
       }
     }
@@ -13852,17 +14811,17 @@ var init_tmux_runner = __esm({
       }
     };
     mutex = Promise.resolve();
-    PROJECTS_ROOT = () => join10(homedir5(), ".claude", "projects");
+    PROJECTS_ROOT = () => join11(homedir5(), ".claude", "projects");
   }
 });
 
 // ../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 existsSync12 } from "node:fs";
-import { join as join11 } from "node:path";
+import { spawn as spawn4 } from "node:child_process";
+import { mkdirSync as mkdirSync9, appendFileSync as appendFileSync3, writeFileSync as writeFileSync10, existsSync as existsSync14 } from "node:fs";
+import { join as join12 } from "node:path";
 import { randomUUID } from "node:crypto";
 function ensureRunsDir() {
-  if (!existsSync12(RUNS_DIR)) {
+  if (!existsSync14(RUNS_DIR)) {
     try {
       mkdirSync9(RUNS_DIR, { recursive: true });
     } catch {
@@ -13891,17 +14850,17 @@ function newRunId(kind) {
   return `${ts}_${kind}_${short}`;
 }
 function tracePath(runId) {
-  return join11(RUNS_DIR, `${runId}.jsonl`);
+  return join12(RUNS_DIR, `${runId}.jsonl`);
 }
-function safeAppend(path9, line) {
+function safeAppend(path11, line) {
   try {
-    appendFileSync3(path9, line);
+    appendFileSync3(path11, line);
   } catch {
   }
 }
-function safeWrite(path9, line) {
+function safeWrite(path11, line) {
   try {
-    writeFileSync9(path9, line);
+    writeFileSync10(path11, line);
   } catch {
   }
 }
@@ -14034,7 +14993,7 @@ function runClaudePrintMode(args2) {
       "--append-system-prompt",
       args2.systemPrompt
     ];
-    const proc = spawn3("claude", claudeArgs, { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env } });
+    const proc = spawn4("claude", claudeArgs, { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env } });
     safeAppend(trace, JSON.stringify({ _meta: { type: "spawned", run_id: runId, pid: proc.pid } }) + "\n");
     const stdinPayload = args2.reminder ? `${args2.userPrompt}
 
@@ -14307,30 +15266,30 @@ var init_enrich2 = __esm({
 });
 
 // ../entries/dist/budget.js
-import { appendFileSync as appendFileSync4, readFileSync as readFileSync15, existsSync as existsSync13, mkdirSync as mkdirSync10 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { appendFileSync as appendFileSync4, readFileSync as readFileSync16, existsSync as existsSync15, mkdirSync as mkdirSync10 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 function spendPath() {
   if (spendPathCached)
     return spendPathCached;
   spendPathCached = cclensPath("llm-spend.jsonl");
   return spendPathCached;
 }
-function __setSpendPathForTest(path9) {
-  spendPathCached = path9;
+function __setSpendPathForTest(path11) {
+  spendPathCached = path11;
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync10(dirname9(p), { recursive: true });
+  mkdirSync10(dirname10(p), { recursive: true });
   appendFileSync4(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync13(p))
+  if (!existsSync15(p))
     return 0;
   const year = now.getUTCFullYear();
   const month2 = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync15(p, "utf8");
+  const raw = readFileSync16(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -14359,18 +15318,18 @@ var init_budget = __esm({
 });
 
 // ../entries/dist/pipeline-lock.js
-import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync14, readFileSync as readFileSync16, statSync as statSync3 } from "node:fs";
+import { writeFileSync as writeFileSync11, unlinkSync as unlinkSync4, existsSync as existsSync16, readFileSync as readFileSync17, statSync as statSync3 } from "node:fs";
 function lockPath() {
   if (lockPathCached)
     return lockPathCached;
   lockPathCached = cclensPath("llm-interactive.lock");
   return lockPathCached;
 }
-function __setInteractiveLockPathForTest(path9) {
-  lockPathCached = path9;
+function __setInteractiveLockPathForTest(path11) {
+  lockPathCached = path11;
 }
 function touchLock() {
-  writeFileSync10(lockPath(), String(process.pid), "utf8");
+  writeFileSync11(lockPath(), String(process.pid), "utf8");
 }
 function writeInteractiveLock() {
   touchLock();
@@ -14404,13 +15363,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync14(p))
+  if (!existsSync16(p))
     return false;
   try {
     const mtime = statSync3(p).mtimeMs;
     if (nowMs - mtime > STALE_MS)
       return false;
-    const pid = Number(readFileSync16(p, "utf8").trim());
+    const pid = Number(readFileSync17(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -14516,16 +15475,16 @@ var init_queue = __esm({
 });
 
 // ../entries/dist/settings.js
-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";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync11, existsSync as existsSync17 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
 function settingsPath() {
   if (settingsPathCached)
     return settingsPathCached;
   settingsPathCached = cclensPath("settings.json");
   return settingsPathCached;
 }
-function __setSettingsPathForTest(path9) {
-  settingsPathCached = path9;
+function __setSettingsPathForTest(path11) {
+  settingsPathCached = path11;
 }
 function toDisk(s) {
   return {
@@ -14552,10 +15511,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync15(p))
+  if (!existsSync17(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync17(p, "utf8");
+    const raw = readFileSync18(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -14563,9 +15522,9 @@ function readSettings() {
 }
 function writeSettings(s) {
   const p = settingsPath();
-  mkdirSync11(dirname10(p), { recursive: true });
+  mkdirSync11(dirname11(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  writeFileSync11(tmp, JSON.stringify(toDisk(s), null, 2), { encoding: "utf8" });
+  writeFileSync12(tmp, JSON.stringify(toDisk(s), null, 2), { encoding: "utf8" });
   if (process.platform !== "win32") {
     chmodSync2(tmp, 384);
   }
@@ -16628,7 +17587,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_MS6)
+    if (dt < IDLE_GAP_MS7)
       active += dt;
   }
   return active;
@@ -16799,7 +17758,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_MS6) {
+      if (dt >= IDLE_GAP_MS7) {
         intervals.push({
           start_min: fmtMin(intStart - sliceStartMs),
           end_min: fmtMin(intEnd - sliceStartMs)
@@ -17196,14 +18155,14 @@ async function generateTopSession(slice, opts = {}) {
     void lastModel;
   }
 }
-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 IDLE_GAP_MS7, 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_MS6 = 3 * 60 * 1e3;
+    IDLE_GAP_MS7 = 3 * 60 * 1e3;
     LONG_AUTONOMOUS_MIN = 20;
     N_USER = 150;
     N_FIRST_AGENT = 150;
@@ -17745,8 +18704,8 @@ var init_digest_month_pipeline = __esm({
 });
 
 // ../entries/dist/credentials.js
-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";
+import { writeFileSync as writeFileSync13, readFileSync as readFileSync19, renameSync as renameSync6, chmodSync as chmodSync3, mkdirSync as mkdirSync12, existsSync as existsSync18, unlinkSync as unlinkSync5 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 async function fetchZaiUsage(candidate) {
   const key = candidate.trim();
   if (!key)
@@ -17816,10 +18775,10 @@ function credentialsPath() {
 }
 function readCredentials() {
   const p = credentialsPath();
-  if (!existsSync16(p))
+  if (!existsSync18(p))
     return {};
   try {
-    const raw = readFileSync18(p, "utf8");
+    const raw = readFileSync19(p, "utf8");
     return JSON.parse(raw);
   } catch {
     return {};
@@ -17842,9 +18801,9 @@ function writeZaiKey(apiKey) {
   const store = readCredentials();
   store.zai = { ...store.zai ?? {}, apiKey };
   const p = credentialsPath();
-  mkdirSync12(dirname11(p), { recursive: true });
+  mkdirSync12(dirname12(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  writeFileSync12(tmp, JSON.stringify(store, null, 2), { encoding: "utf8" });
+  writeFileSync13(tmp, JSON.stringify(store, null, 2), { encoding: "utf8" });
   if (process.platform !== "win32") {
     chmodSync3(tmp, 384);
   }
@@ -17862,7 +18821,7 @@ function deleteZaiKey() {
     return;
   }
   const tmp = `${p}.tmp`;
-  writeFileSync12(tmp, JSON.stringify(store, null, 2), { encoding: "utf8" });
+  writeFileSync13(tmp, JSON.stringify(store, null, 2), { encoding: "utf8" });
   if (process.platform !== "win32") {
     chmodSync3(tmp, 384);
   }
@@ -18449,9 +19408,9 @@ var menubar_exports = {};
 __export(menubar_exports, {
   menubar: () => menubar
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync13, cpSync, rmSync as rmSync2, readdirSync as readdirSync4, writeFileSync as writeFileSync13, realpathSync as realpathSync6 } from "node:fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync13, cpSync, rmSync as rmSync2, readdirSync as readdirSync4, writeFileSync as writeFileSync14, realpathSync as realpathSync6 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join12, dirname as dirname12 } from "node:path";
+import { join as join13, dirname as dirname13 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { execFile as execFile2 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
@@ -18459,8 +19418,8 @@ function isMac2() {
   return process.platform === "darwin";
 }
 function bundledAppPath() {
-  const here = dirname12(fileURLToPath3(import.meta.url));
-  return join12(here, "..", "menubar", APP_BUNDLE);
+  const here = dirname13(fileURLToPath3(import.meta.url));
+  return join13(here, "..", "menubar", APP_BUNDLE);
 }
 function resolveScriptPath2() {
   const argv1 = process.argv[1] ?? "";
@@ -18472,7 +19431,7 @@ function resolveScriptPath2() {
 }
 function writeCliLaunchFile() {
   try {
-    writeFileSync13(
+    writeFileSync14(
       cclensPath("cli-launch.json"),
       JSON.stringify({ node: process.execPath, script: resolveScriptPath2() }),
       "utf8"
@@ -18481,7 +19440,7 @@ function writeCliLaunchFile() {
   }
 }
 function installedAppPath() {
-  return join12(homedir6(), "Applications", APP_BUNDLE);
+  return join13(homedir6(), "Applications", APP_BUNDLE);
 }
 async function isRunning() {
   try {
@@ -18491,8 +19450,8 @@ async function isRunning() {
     return false;
   }
 }
-async function launchApp(path9) {
-  await execFileAsync2("open", ["-a", path9]);
+async function launchApp(path11) {
+  await execFileAsync2("open", ["-a", path11]);
 }
 async function quitApp() {
   await execFileAsync2("osascript", ["-e", `tell application "${BUNDLE_EXEC}" to quit`]).catch(
@@ -18513,14 +19472,14 @@ async function installMenubar(opts) {
     return;
   }
   const src = bundledAppPath();
-  if (!existsSync17(src)) {
+  if (!existsSync19(src)) {
     console.error(
       `Bundled widget not found at ${src}.
 This install was probably built without the menubar artifact. Run \`node apps/menubar/build-app.sh && cp -R apps/menubar/dist/FleetlensMenubar.app packages/cli/menubar/\` and rebuild.`
     );
     process.exit(1);
   }
-  const destDir = join12(homedir6(), "Applications");
+  const destDir = join13(homedir6(), "Applications");
   mkdirSync13(destDir, { recursive: true });
   const dest = installedAppPath();
   if (await isRunning()) {
@@ -18555,7 +19514,7 @@ async function uninstallMenubar() {
     await new Promise((r) => setTimeout(r, 300));
   }
   const dest = installedAppPath();
-  if (existsSync17(dest)) {
+  if (existsSync19(dest)) {
     rmSync2(dest, { recursive: true, force: true });
     console.log(`Removed ${dest}`);
   } else {
@@ -18569,7 +19528,7 @@ async function openMenubar() {
     return;
   }
   const dest = installedAppPath();
-  if (!existsSync17(dest)) {
+  if (!existsSync19(dest)) {
     console.log("Widget not installed yet. Run `fleetlens menubar install` first.");
     return;
   }
@@ -18586,15 +19545,15 @@ async function statusMenubar() {
     return;
   }
   const dest = installedAppPath();
-  const installed = existsSync17(dest);
+  const installed = existsSync19(dest);
   const running = await isRunning();
-  const bundled = existsSync17(bundledAppPath());
+  const bundled = existsSync19(bundledAppPath());
   console.log(`Menu bar widget: ${installed ? "installed" : "not installed"}${installed ? ` (${dest})` : ""}`);
   console.log(`Running:         ${running ? "yes" : "no"}`);
   console.log(`Bundled in CLI:  ${bundled ? "yes" : "no \u2014 this build ships without the widget"}`);
   if (installed) {
     try {
-      const apps = readdirSync4(join12(homedir6(), "Applications"));
+      const apps = readdirSync4(join13(homedir6(), "Applications"));
       const ours = apps.find((a) => a === APP_BUNDLE);
       console.log(`App bundle:      ${ours ? "present in ~/Applications" : "missing"}`);
     } catch {
@@ -18677,8 +19636,8 @@ var init_config = __esm({
 });
 
 // src/perception/build-entries.ts
-import { statSync as statSync4, readFileSync as readFileSync19 } from "node:fs";
-import { basename as basename2, dirname as dirname13 } from "node:path";
+import { statSync as statSync4, readFileSync as readFileSync20 } from "node:fs";
+import { basename as basename2, dirname as dirname14 } from "node:path";
 function decodeProjectDirName(projectDir) {
   if (projectDir.startsWith("-")) {
     return "/" + projectDir.slice(1).replace(/-/g, "/");
@@ -18687,7 +19646,7 @@ function decodeProjectDirName(projectDir) {
 }
 function buildEntriesForFile(filePath) {
   const stat = statSync4(filePath);
-  const raw = readFileSync19(filePath, "utf8");
+  const raw = readFileSync20(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -18698,7 +19657,7 @@ function buildEntriesForFile(filePath) {
   if (rawLines.length === 0) return null;
   const { meta, events } = parseTranscript(rawLines);
   const fileName = basename2(filePath);
-  const projectDir = basename2(dirname13(filePath));
+  const projectDir = basename2(dirname14(filePath));
   const sessionId = fileName.replace(/\.jsonl$/, "");
   const sd = {
     ...meta,
@@ -18952,7 +19911,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID2(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "0.16.4",
+    cliVersion: "0.16.7",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -18993,8 +19952,8 @@ var init_push = __esm({
 });
 
 // src/team/git-remote.ts
-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";
+import { existsSync as existsSync20, readFileSync as readFileSync21, statSync as statSync5 } from "node:fs";
+import { dirname as dirname15, isAbsolute as isAbsolute2, join as join14, resolve as resolve2 } from "node:path";
 function parseGithubRemote(url) {
   const m = url.trim().match(GITHUB_URL_RE);
   return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
@@ -19014,19 +19973,19 @@ function originUrl2(configText) {
   return null;
 }
 function gitConfigPathFor(dir) {
-  const dotGit = join13(dir, ".git");
+  const dotGit = join14(dir, ".git");
   const st = statSync5(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
-  if (st.isDirectory()) return join13(dotGit, "config");
-  const m = readFileSync20(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  if (st.isDirectory()) return join14(dotGit, "config");
+  const m = readFileSync21(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 (existsSync18(commondirFile)) {
-    const common = readFileSync20(commondirFile, "utf8").trim();
-    return join13(isAbsolute2(common) ? common : resolve2(gd, common), "config");
+  const commondirFile = join14(gd, "commondir");
+  if (existsSync20(commondirFile)) {
+    const common = readFileSync21(commondirFile, "utf8").trim();
+    return join14(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
-  return join13(gd, "config");
+  return join14(gd, "config");
 }
 function createRepoResolver() {
   const cache = /* @__PURE__ */ new Map();
@@ -19036,14 +19995,14 @@ function createRepoResolver() {
     if (hit !== void 0) return hit;
     let repo = null;
     try {
-      for (let d = dir; ; d = dirname14(d)) {
+      for (let d = dir; ; d = dirname15(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync18(config)) {
-          const url = originUrl2(readFileSync20(config, "utf8"));
+        if (config && existsSync20(config)) {
+          const url = originUrl2(readFileSync21(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
-        if (d === dirname14(d)) break;
+        if (d === dirname15(d)) break;
       }
     } catch {
       repo = null;
@@ -19061,10 +20020,10 @@ var init_git_remote = __esm({
 });
 
 // src/team/queue.ts
-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";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync15, appendFileSync as appendFileSync5, statSync as statSync6, mkdirSync as mkdirSync14 } from "node:fs";
+import { dirname as dirname16 } from "node:path";
 function enqueuePayload(payload, queuePath = QUEUE_PATH) {
-  mkdirSync14(dirname15(queuePath), { recursive: true });
+  mkdirSync14(dirname16(queuePath), { recursive: true });
   const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
   appendFileSync5(queuePath, JSON.stringify(entry) + "\n", "utf8");
   try {
@@ -19078,7 +20037,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync21(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync22(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -19093,18 +20052,18 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
     } catch {
     }
   }
-  writeFileSync14(queuePath, "", "utf8");
+  writeFileSync15(queuePath, "", "utf8");
   return valid.map((e) => e.payload);
 }
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync21(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync22(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
   const keep = lines.slice(Math.floor(lines.length / 2));
-  writeFileSync14(queuePath, keep.join("\n") + "\n", "utf8");
+  writeFileSync15(queuePath, keep.join("\n") + "\n", "utf8");
 }
 var QUEUE_PATH, MAX_SIZE_BYTES, MAX_AGE_MS;
 var init_queue2 = __esm({
@@ -19118,8 +20077,8 @@ var init_queue2 = __esm({
 });
 
 // src/usage/profile.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync15, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
+import { existsSync as existsSync21, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync16 } from "node:fs";
+import { dirname as dirname17 } from "node:path";
 function mapRateLimitTier(rateLimitTier) {
   switch (rateLimitTier) {
     case "default_claude_pro":
@@ -19159,9 +20118,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync19(cachePath)) return null;
+  if (!existsSync21(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync22(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync23(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -19169,8 +20128,8 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync15(dirname16(cachePath), { recursive: true });
-  writeFileSync15(
+  mkdirSync15(dirname17(cachePath), { recursive: true });
+  writeFileSync16(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
     { mode: 384 }
@@ -19350,11 +20309,11 @@ var init_backfill = __esm({
 });
 
 // src/team/sync-log.ts
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 function readPendingSyncLog(watermark) {
   let raw;
   try {
-    raw = readFileSync23(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync24(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -19382,12 +20341,12 @@ var init_sync_log = __esm({
 });
 
 // src/team/last-push.ts
-import { writeFileSync as writeFileSync16, unlinkSync as unlinkSync6, mkdirSync as mkdirSync16 } from "node:fs";
-import { join as join14 } from "node:path";
+import { writeFileSync as writeFileSync17, unlinkSync as unlinkSync6, mkdirSync as mkdirSync16 } from "node:fs";
+import { join as join15 } from "node:path";
 function write(record, dir) {
   const d = dir ?? cclensHome();
   mkdirSync16(d, { recursive: true });
-  writeFileSync16(join14(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
+  writeFileSync17(join15(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
 }
 function writeLastPushSuccess(payload, dir) {
   write({ pushedAt: (/* @__PURE__ */ new Date()).toISOString(), ok: true, payload }, dir);
@@ -19398,7 +20357,7 @@ function writeLastPushFailure(payload, error, dir) {
 function clearLastPush(dir) {
   const d = dir ?? cclensHome();
   try {
-    unlinkSync6(join14(d, LAST_PUSH_FILE));
+    unlinkSync6(join15(d, LAST_PUSH_FILE));
   } catch {
   }
 }
@@ -19418,25 +20377,25 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync20, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync22, 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 { join as join16, relative, resolve as resolve3, sep } from "node:path";
 import { execFileSync as execFileSync3 } from "node:child_process";
 function pathHash(relPath) {
   return createHash("sha256").update(relPath.split(sep).join("/")).digest("hex").slice(0, 32);
 }
 function defaultScanRoots(extraRoots = []) {
   const roots = [];
-  const home = join15(homedir7(), ".claude");
-  if (existsSync20(home)) roots.push({ root: home, label: "user" });
+  const home = join16(homedir7(), ".claude");
+  if (existsSync22(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
     const r = resolve3(e, ".claude");
-    if (existsSync20(r) && r !== home) roots.push({ root: r, label: "project" });
+    if (existsSync22(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync20(dir)) return [];
+  if (!existsSync22(dir)) return [];
   const out = [];
   let entries2;
   try {
@@ -19446,7 +20405,7 @@ function listMarkdownFiles(dir) {
   }
   for (const name of entries2) {
     if (name.startsWith(".")) continue;
-    const full = join15(dir, name);
+    const full = join16(dir, name);
     let stat;
     try {
       stat = statSync7(full);
@@ -19466,7 +20425,7 @@ function firstSeenDateOf(file) {
     const out = execFileSync3(
       "git",
       ["log", "--diff-filter=A", "--follow", "--format=%cs", "--", file],
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname17(file) }
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname18(file) }
     ).trim().split("\n").filter(Boolean);
     if (out.length > 0) return out[out.length - 1];
   } catch {
@@ -19478,7 +20437,7 @@ function firstSeenDateOf(file) {
     return todayLocal();
   }
 }
-function dirname17(p) {
+function dirname18(p) {
   const i = p.lastIndexOf(sep);
   return i < 0 ? "." : p.slice(0, i);
 }
@@ -19505,8 +20464,8 @@ function todayLocal() {
 function scanAuthored(roots, subdir, day2) {
   const out = [];
   for (const r of roots) {
-    const dir = join15(r.root, subdir);
-    if (!existsSync20(dir)) continue;
+    const dir = join16(r.root, subdir);
+    if (!existsSync22(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day2) continue;
@@ -19519,8 +20478,8 @@ function scanAuthored(roots, subdir, day2) {
 function scanEdited(roots, day2) {
   const out = [];
   for (const r of roots) {
-    const dir = join15(r.root, "skills");
-    if (!existsSync20(dir)) continue;
+    const dir = join16(r.root, "skills");
+    if (!existsSync22(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day2) continue;
@@ -19543,16 +20502,16 @@ function claudemdLineDelta(extraRoots, authorEmail, day2) {
   const candidates = [];
   for (const e of extraRoots) {
     const f = resolve3(e, "CLAUDE.md");
-    if (existsSync20(f)) candidates.push(f);
+    if (existsSync22(f)) candidates.push(f);
   }
-  const homeClaudeMd = join15(homedir7(), "CLAUDE.md");
-  if (existsSync20(homeClaudeMd)) candidates.push(homeClaudeMd);
+  const homeClaudeMd = join16(homedir7(), "CLAUDE.md");
+  if (existsSync22(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync3(
         "git",
         ["log", "--numstat", "--format=COMMIT %cs %ae", "--", file],
-        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname17(file) }
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname18(file) }
       );
       let currentDate = "";
       let currentEmail = "";
@@ -20436,11 +21395,11 @@ var logs_exports = {};
 __export(logs_exports, {
   teamLogs: () => teamLogs
 });
-import { readFileSync as readFileSync24 } from "node:fs";
+import { readFileSync as readFileSync25 } from "node:fs";
 async function teamLogs() {
   const logPath = cclensPath("daemon.log");
   try {
-    const lines = readFileSync24(logPath, "utf8").trim().split("\n");
+    const lines = readFileSync25(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.");
@@ -20568,8 +21527,8 @@ __export(runs_exports, {
   runs: () => runs
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync21, readFileSync as readFileSync25, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync26, readdirSync as readdirSync6, statSync as statSync8 } from "node:fs";
+import { join as join17 } from "node:path";
 async function runs(args2) {
   const json = args2.includes("--json");
   const watch = args2.includes("--watch");
@@ -20653,8 +21612,8 @@ function listActiveRuns() {
   return runs2.sort((a, b) => a.elapsed_s - b.elapsed_s);
 }
 function readSpend(sinceMs) {
-  if (!existsSync21(SPEND_PATH)) return [];
-  const lines = readFileSync25(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
+  if (!existsSync23(SPEND_PATH)) return [];
+  const lines = readFileSync26(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
   const out = [];
   for (const line of lines) {
     try {
@@ -20775,23 +21734,23 @@ function ageLabel(ms) {
   return `${Math.floor(ms / 864e5)}d`;
 }
 function listTraceFiles() {
-  if (!existsSync21(RUNS_DIR2)) return [];
+  if (!existsSync23(RUNS_DIR2)) return [];
   const entries2 = readdirSync6(RUNS_DIR2).filter((f) => f.endsWith(".jsonl"));
   return entries2.map((f) => {
-    const path9 = join16(RUNS_DIR2, f);
-    const st = statSync8(path9);
-    return { runId: f.replace(/\.jsonl$/, ""), path: path9, mtimeMs: st.mtimeMs };
+    const path11 = join17(RUNS_DIR2, f);
+    const st = statSync8(path11);
+    return { runId: f.replace(/\.jsonl$/, ""), path: path11, mtimeMs: st.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 function resolveRunId(arg) {
-  if (!existsSync21(RUNS_DIR2)) return null;
+  if (!existsSync23(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 (existsSync21(exact)) return { runId: arg, path: exact };
+  const exact = join17(RUNS_DIR2, `${arg}.jsonl`);
+  if (existsSync23(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 };
@@ -20802,8 +21761,8 @@ function resolveRunId(arg) {
   }
   return null;
 }
-function readTrace(path9) {
-  return readFileSync25(path9, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
+function readTrace(path11) {
+  return readFileSync26(path11, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
     } catch {
@@ -20815,7 +21774,7 @@ async function inspect(arg, follow, json) {
   const r = resolveRunId(arg);
   if (!r) {
     console.error(`run not found: ${arg}`);
-    if (existsSync21(RUNS_DIR2)) {
+    if (existsSync23(RUNS_DIR2)) {
       const all = listTraceFiles().slice(0, 5);
       if (all.length > 0) {
         console.error(`
@@ -20995,7 +21954,7 @@ async function main() {
     case "version":
     case "--version":
     case "-v":
-      console.log(`fleetlens ${"0.16.4"}`);
+      console.log(`fleetlens ${"0.16.7"}`);
       break;
     case "help":
     case "--help":