fleetlens 0.16.4 → 0.16.7

package/dist/daemon-worker.js

@@ -607,7 +607,7 @@ function getAgentMetadata(kind) {
 function isAgentKind(s) {
   return typeof s === "string" && KNOWN_AGENT_KINDS.has(s);
 }
-var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, ANTIGRAVITY_METADATA, COWORK_METADATA, ZAI_METADATA, 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";
@@ -625,6 +625,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",
@@ -664,6 +671,7 @@ var init_agent_metadata = __esm({
     agentMetadata = [
       CLAUDE_CODE_METADATA,
       CODEX_METADATA,
+      COPILOT_METADATA,
       GEMINI_METADATA,
       ANTIGRAVITY_METADATA,
       COWORK_METADATA,
@@ -1525,11 +1533,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);
@@ -3311,24 +3319,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 entries = await fs3.readdir(root, { withFileTypes: true }).catch(() => []);
+  const out = [];
+  for (const entry of entries) {
+    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 start = sorted[0];
+  let end = start;
+  for (let i = 1; i < sorted.length; i++) {
+    const next = sorted[i];
+    if (next - end > IDLE_GAP_MS2) {
+      segments.push({ startMs: start, endMs: end });
+      start = next;
+    }
+    end = next;
+  }
+  segments.push({ startMs: start, 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 entries = await safeReaddir2(chatsDir);
     for (const entry of entries) {
       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;
@@ -3345,13 +3771,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);
@@ -3376,7 +3802,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 {
@@ -3451,10 +3877,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) {
@@ -3493,12 +3919,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;
@@ -3524,7 +3950,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)
@@ -3548,7 +3974,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 usage;
@@ -3574,7 +4000,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
@@ -3631,7 +4057,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",
@@ -3655,7 +4081,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
       });
@@ -3677,7 +4103,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;
@@ -3711,7 +4137,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);
@@ -3719,7 +4145,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];
     }
@@ -3729,23 +4155,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
@@ -3761,7 +4187,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)) {
@@ -3771,7 +4197,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;
@@ -3780,13 +4206,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
@@ -3799,39 +4225,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();
@@ -3848,14 +4274,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 entries = await safeReaddir3(brainDir);
   for (const entry of entries) {
-    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,
@@ -3868,19 +4294,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;
@@ -3952,7 +4378,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)
@@ -3981,14 +4407,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++,
@@ -4034,7 +4460,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,
@@ -4053,7 +4479,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
     });
@@ -4073,7 +4499,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;
@@ -4108,7 +4534,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);
@@ -4116,7 +4542,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];
     }
@@ -4126,23 +4552,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,
@@ -4159,7 +4585,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) {
@@ -4169,13 +4595,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,
@@ -4189,61 +4615,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 entries = await safeReaddir4(workspaceDir);
       for (const entry of entries) {
         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,
@@ -4261,14 +4687,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);
@@ -4286,7 +4712,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 {
@@ -4322,8 +4748,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();
@@ -4459,7 +4885,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)
   ]);
@@ -4494,24 +4920,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 {
     }
@@ -4523,12 +4949,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);
@@ -4537,10 +4963,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";
@@ -4550,24 +4976,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 {
@@ -4577,8 +5003,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 {
@@ -4593,8 +5019,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);
@@ -4602,14 +5028,14 @@ async function listSessionDirs(root) {
     for (const entry of entries) {
       if (entry === "prompt_history.jsonl" || entry.startsWith("."))
         continue;
-      const dirPath = path6.join(groupDir, entry);
-      const summaryPath = path6.join(dirPath, "summary.json");
-      const updatesPath = path6.join(dirPath, "updates.jsonl");
-      const signalsCandidate = path6.join(dirPath, "signals.json");
+      const 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;
@@ -4630,10 +5056,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) {
@@ -4747,7 +5173,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);
@@ -4756,7 +5182,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;
     }
@@ -4765,17 +5191,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;
   }
@@ -4809,7 +5235,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) {
@@ -4969,7 +5395,7 @@ async function parseSession3(dir) {
         timestamp: ts,
         role: "tool-result",
         rawType: "grok/tool_result",
-        preview: previewOf4(resultText),
+        preview: previewOf5(resultText),
         blocks: [
           {
             type: "tool_result",
@@ -5018,7 +5444,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;
@@ -5027,7 +5453,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 = {
@@ -5064,38 +5490,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 entries = await safeReaddir5(subRoot);
   let n = 0;
   for (const e of entries) {
-    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 entries = await safeReaddir5(subRoot);
-  const groupDir = path6.dirname(parentDir.dirPath);
+  const groupDir = path7.dirname(parentDir.dirPath);
   const runs = [];
   for (const entry of entries) {
-    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 usage = emptyUsage4();
+    const usage = emptyUsage5();
     if (childSignals?.contextTokensUsed)
       usage.input = childSignals.contextTokensUsed;
     runs.push({
@@ -5118,8 +5544,8 @@ async function loadGrokSubagents(parentDir, parentStartMs) {
   return runs;
 }
 function clearGrokCaches() {
-  metaCache6.clear();
-  detailCache6.clear();
+  metaCache7.clear();
+  detailCache7.clear();
 }
 async function listGrokSessions(opts = {}) {
   const root = opts.root ?? resolveDefaultGrokRoot();
@@ -5129,16 +5555,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
@@ -5159,10 +5585,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
@@ -5174,11 +5600,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 = {
@@ -5186,12 +5612,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 } : {}
@@ -5207,17 +5633,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();
   }
 });
 
@@ -5278,6 +5704,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,
@@ -5294,6 +5721,7 @@ __export(fs_exports, {
   clearGrokCaches: () => clearGrokCaches,
   clearTeamConfig: () => clearTeamConfig,
   codexSessionLocalDay: () => codexSessionLocalDay,
+  copilotSessionLocalDay: () => copilotSessionLocalDay,
   decodeProjectName: () => decodeProjectName,
   findTeamLead: () => findTeamLead,
   geminiSessionLocalDay: () => geminiSessionLocalDay,
@@ -5301,6 +5729,7 @@ __export(fs_exports, {
   getAntigravitySession: () => getAntigravitySession,
   getAnySession: () => getAnySession,
   getCodexSession: () => getCodexSession,
+  getCopilotSession: () => getCopilotSession,
   getCoworkSession: () => getCoworkSession,
   getGeminiSession: () => getGeminiSession,
   getGrokSession: () => getGrokSession,
@@ -5312,6 +5741,7 @@ __export(fs_exports, {
   listAllSessions: () => listAllSessions,
   listAntigravitySessions: () => listAntigravitySessions,
   listCodexSessions: () => listCodexSessions,
+  listCopilotSessions: () => listCopilotSessions,
   listCoworkSessions: () => listCoworkSessions,
   listGeminiSessions: () => listGeminiSessions,
   listGrokSessions: () => listGrokSessions,
@@ -5334,14 +5764,14 @@ __export(fs_exports, {
   walkJsonlFiles: () => walkJsonlFiles,
   writeTeamConfig: () => writeTeamConfig
 });
-import { promises as fs7, existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, appendFileSync, mkdirSync as mkdirSync2 } from "node:fs";
-import os7 from "node:os";
-import path7 from "node:path";
+import { promises as fs8, existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, appendFileSync, mkdirSync as mkdirSync2 } 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();
@@ -5349,6 +5779,7 @@ function cacheStats() {
 function clearCaches() {
   clearClaudeCodeCaches();
   clearCodexCaches();
+  clearCopilotCaches();
   clearGeminiCaches();
   clearAntigravityCaches();
   clearCoworkCaches();
@@ -5383,7 +5814,7 @@ function usageLogPath() {
 }
 function appendUsageSnapshot(snapshot) {
   const p = usageLogPath();
-  mkdirSync2(path7.dirname(p), { recursive: true });
+  mkdirSync2(path8.dirname(p), { recursive: true });
   appendFileSync(p, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function pruneUsageAgent(agent) {
@@ -5399,13 +5830,13 @@ function pruneUsageAgent(agent) {
       return true;
     }
   });
-  mkdirSync2(path7.dirname(p), { recursive: true });
+  mkdirSync2(path8.dirname(p), { recursive: true });
   writeFileSync2(p, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
 }
 async function loadUsageByDay(start, end) {
   let raw;
   try {
-    raw = await fs7.readFile(usageLogPath(), "utf8");
+    raw = await fs8.readFile(usageLogPath(), "utf8");
   } catch {
     return { by_day: [] };
   }
@@ -5450,7 +5881,7 @@ async function loadUsageByDay(start, end) {
 async function loadCalibrationSnapshots() {
   let raw;
   try {
-    raw = await fs7.readFile(usageLogPath(), "utf8");
+    raw = await fs8.readFile(usageLogPath(), "utf8");
   } catch {
     return [];
   }
@@ -5614,7 +6045,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";
@@ -5623,6 +6054,7 @@ var init_fs = __esm({
     init_calibration();
     init_claude_code();
     init_codex();
+    init_copilot();
     init_gemini();
     init_antigravity();
     init_cowork();
@@ -5630,6 +6062,7 @@ var init_fs = __esm({
     init_claude_code();
     init_git_project();
     init_codex();
+    init_copilot();
     init_gemini();
     init_antigravity();
     init_cowork();
@@ -5644,18 +6077,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 = {
@@ -5702,6 +6133,7 @@ var init_fs = __esm({
     agentSources = [
       claudeCodeSource,
       codexSource,
+      copilotSource,
       geminiSource,
       antigravitySource,
       coworkSource,
@@ -5711,15 +6143,15 @@ var init_fs = __esm({
 });
 
 // src/usage/storage.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync7 } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 function appendSnapshot(filePath, snapshot) {
-  mkdirSync3(dirname2(filePath), { recursive: true });
+  mkdirSync3(dirname3(filePath), { recursive: true });
   appendFileSync2(filePath, JSON.stringify(snapshot) + "\n", "utf8");
 }
 function readSnapshots(filePath) {
-  if (!existsSync5(filePath)) return [];
-  const content = readFileSync7(filePath, "utf8");
+  if (!existsSync7(filePath)) return [];
+  const content = readFileSync8(filePath, "utf8");
   const snapshots = [];
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -5731,8 +6163,8 @@ function readSnapshots(filePath) {
   return snapshots;
 }
 function pruneAgent(filePath, agent) {
-  if (!existsSync5(filePath)) return;
-  const kept = readFileSync7(filePath, "utf8").split("\n").filter((line) => {
+  if (!existsSync7(filePath)) return;
+  const kept = readFileSync8(filePath, "utf8").split("\n").filter((line) => {
     if (!line.trim()) return false;
     try {
       return JSON.parse(line).agent !== agent;
@@ -5740,8 +6172,8 @@ function pruneAgent(filePath, agent) {
       return true;
     }
   });
-  mkdirSync3(dirname2(filePath), { recursive: true });
-  writeFileSync3(filePath, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
+  mkdirSync3(dirname3(filePath), { recursive: true });
+  writeFileSync4(filePath, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
 }
 function latestClaudeCodeSnapshot(filePath) {
   const all = readSnapshots(filePath);
@@ -6168,6 +6600,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,
@@ -6244,25 +6677,25 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync12, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
-import { join as join8, relative, resolve as resolve3, sep } from "node:path";
+import { join as join9, relative, resolve as resolve3, sep } from "node:path";
 import { execFileSync as execFileSync2 } 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 = join8(homedir3(), ".claude");
-  if (existsSync10(home)) roots.push({ root: home, label: "user" });
+  const home = join9(homedir3(), ".claude");
+  if (existsSync12(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
     const r = resolve3(e, ".claude");
-    if (existsSync10(r) && r !== home) roots.push({ root: r, label: "project" });
+    if (existsSync12(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync10(dir)) return [];
+  if (!existsSync12(dir)) return [];
   const out = [];
   let entries;
   try {
@@ -6272,7 +6705,7 @@ function listMarkdownFiles(dir) {
   }
   for (const name of entries) {
     if (name.startsWith(".")) continue;
-    const full = join8(dir, name);
+    const full = join9(dir, name);
     let stat;
     try {
       stat = statSync5(full);
@@ -6292,7 +6725,7 @@ function firstSeenDateOf(file) {
     const out = execFileSync2(
       "git",
       ["log", "--diff-filter=A", "--follow", "--format=%cs", "--", file],
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname8(file) }
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname9(file) }
     ).trim().split("\n").filter(Boolean);
     if (out.length > 0) return out[out.length - 1];
   } catch {
@@ -6304,7 +6737,7 @@ function firstSeenDateOf(file) {
     return todayLocal();
   }
 }
-function dirname8(p) {
+function dirname9(p) {
   const i = p.lastIndexOf(sep);
   return i < 0 ? "." : p.slice(0, i);
 }
@@ -6331,8 +6764,8 @@ function todayLocal() {
 function scanAuthored(roots, subdir, day) {
   const out = [];
   for (const r of roots) {
-    const dir = join8(r.root, subdir);
-    if (!existsSync10(dir)) continue;
+    const dir = join9(r.root, subdir);
+    if (!existsSync12(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day) continue;
@@ -6345,8 +6778,8 @@ function scanAuthored(roots, subdir, day) {
 function scanEdited(roots, day) {
   const out = [];
   for (const r of roots) {
-    const dir = join8(r.root, "skills");
-    if (!existsSync10(dir)) continue;
+    const dir = join9(r.root, "skills");
+    if (!existsSync12(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day) continue;
@@ -6369,16 +6802,16 @@ function claudemdLineDelta(extraRoots, authorEmail, day) {
   const candidates = [];
   for (const e of extraRoots) {
     const f = resolve3(e, "CLAUDE.md");
-    if (existsSync10(f)) candidates.push(f);
+    if (existsSync12(f)) candidates.push(f);
   }
-  const homeClaudeMd = join8(homedir3(), "CLAUDE.md");
-  if (existsSync10(homeClaudeMd)) candidates.push(homeClaudeMd);
+  const homeClaudeMd = join9(homedir3(), "CLAUDE.md");
+  if (existsSync12(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync2(
         "git",
         ["log", "--numstat", "--format=COMMIT %cs %ae", "--", file],
-        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname8(file) }
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname9(file) }
       );
       let currentDate = "";
       let currentEmail = "";
@@ -6428,9 +6861,9 @@ var init_file_probe = __esm({
 });
 
 // src/daemon-worker.ts
-import { spawn as spawn2 } from "node:child_process";
-import { closeSync, existsSync as existsSync17, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname11, join as join12 } from "node:path";
+import { spawn as spawn3 } from "node:child_process";
+import { closeSync, existsSync as existsSync19, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname12, join as join13 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/usage/token.ts
@@ -6461,9 +6894,9 @@ function readFromCredentialsFile() {
     join(homedir(), ".claude", ".credentials.json"),
     join(homedir(), ".config", "claude", "credentials.json")
   ];
-  for (const path9 of candidates) {
+  for (const path11 of candidates) {
     try {
-      const blob = readFileSync(path9, "utf8");
+      const blob = readFileSync(path11, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -6677,8 +7110,8 @@ async function fetchZaiUsage() {
 
 // src/usage/grok.ts
 import { existsSync as existsSync4, readFileSync as readFileSync6 } from "node:fs";
-import os8 from "node:os";
-import path8 from "node:path";
+import os9 from "node:os";
+import path9 from "node:path";
 var CREDITS_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
 var SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
 var REFRESH_URL = "https://auth.x.ai/oauth2/token";
@@ -6693,10 +7126,10 @@ var GrokApiError = class extends Error {
   }
 };
 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();
@@ -6759,8 +7192,8 @@ async function refreshAccessToken(entry) {
           break;
         }
       }
-      const { writeFileSync: writeFileSync15 } = await import("node:fs");
-      writeFileSync15(p, JSON.stringify(raw, null, 2), "utf8");
+      const { writeFileSync: writeFileSync16 } = await import("node:fs");
+      writeFileSync16(p, JSON.stringify(raw, null, 2), "utf8");
     } catch {
     }
     return j.access_token;
@@ -6887,6 +7320,488 @@ async function fetchGrokUsage() {
   };
 }
 
+// src/usage/codex.ts
+import {
+  existsSync as existsSync5,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import os10 from "node:os";
+import path10 from "node:path";
+var USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+var REFRESH_URL2 = "https://auth.openai.com/oauth/token";
+var CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var FIVE_HOUR_SECONDS = 5 * 60 * 60;
+var SEVEN_DAY_SECONDS = 7 * 24 * 60 * 60;
+var REFRESH_BUFFER_MS2 = 5 * 60 * 1e3;
+var CodexApiError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+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 (!existsSync5(p)) {
+    throw new CodexApiError(
+      "Codex not logged in. Run `codex` to authenticate.",
+      "no_auth"
+    );
+  }
+  let auth;
+  try {
+    auth = JSON.parse(readFileSync7(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 pad = "=".repeat((4 - parts[1].length % 4) % 4);
+    const json = Buffer.from(parts[1] + pad, "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 {
+      writeFileSync3(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, body, headers } = await fetchUsageResponse(access, accountId);
+  if (status === 401 || status === 403) {
+    const refreshed = await refreshAccessToken2(auth, loaded.path);
+    if (refreshed) {
+      access = refreshed.accessToken;
+      ({ status, body, headers } = await fetchUsageResponse(access, accountId));
+    }
+  }
+  if (status < 200 || status >= 300) {
+    throw new CodexApiError(
+      `Codex usage returned HTTP ${status}`,
+      status === 401 || status === 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
+  };
+}
+
+// src/usage/copilot.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+var RPC_TIMEOUT_MS = 1e4;
+var CopilotApiError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+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"
+  };
+}
+var 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;
+  }
+};
+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 = join4(dirname2(process.execPath), process.platform === "win32" ? "copilot.cmd" : "copilot");
+  return existsSync6(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 = spawn(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();
+  }
+}
+
 // src/daemon-worker.ts
 init_storage();
 init_fs();
@@ -6928,9 +7843,9 @@ import { randomUUID } from "node:crypto";
 
 // ../entries/dist/fs.js
 init_fs();
-import { readFileSync as readFileSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, renameSync as renameSync3, existsSync as existsSync7 } from "node:fs";
+import { readFileSync as readFileSync10, readdirSync as readdirSync2, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, renameSync as renameSync3, existsSync as existsSync9 } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // ../entries/dist/types.js
 var CURRENT_ENTRY_SCHEMA_VERSION = 2;
@@ -7003,12 +7918,12 @@ var PROMPT_FRAME_ORIGIN = {
 
 // ../entries/dist/digest-fs.js
 init_fs();
-import { readFileSync as readFileSync8, readdirSync, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "node:fs";
-import { dirname as dirname3, join as join4 } from "node:path";
+import { readFileSync as readFileSync9, readdirSync, writeFileSync as writeFileSync5, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync4, existsSync as existsSync8 } from "node:fs";
+import { dirname as dirname4, join as join5 } from "node:path";
 var digestsDirCached = null;
-function parseDigestFile(path9, expectedVersion) {
+function parseDigestFile(path11, expectedVersion) {
   try {
-    const parsed = JSON.parse(readFileSync8(path9, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path11, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -7028,16 +7943,16 @@ function digestsDir() {
   return digestsDirCached;
 }
 function dayDigestPath(date) {
-  return join4(digestsDir(), "day", `${date}.json`);
+  return join5(digestsDir(), "day", `${date}.json`);
 }
 function weekDigestPath(monday) {
-  return join4(digestsDir(), "week", `${monday}.json`);
+  return join5(digestsDir(), "week", `${monday}.json`);
 }
 function writeDayDigest(digest) {
   const final = dayDigestPath(digest.key);
-  mkdirSync4(dirname3(final), { recursive: true });
+  mkdirSync4(dirname4(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(digest, null, 2), "utf8");
+  writeFileSync5(tmp, JSON.stringify(digest, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -7048,7 +7963,7 @@ function writeDayDigest(digest) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync6(p))
+  if (!existsSync8(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -7068,9 +7983,9 @@ function setTodayDigestInCache(date, digest, nowMs) {
 }
 function writeWeekDigest(digest) {
   const final = weekDigestPath(digest.key);
-  mkdirSync4(dirname3(final), { recursive: true });
+  mkdirSync4(dirname4(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync4(tmp, JSON.stringify(digest, null, 2), "utf8");
+  writeFileSync5(tmp, JSON.stringify(digest, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -7081,7 +7996,7 @@ function writeWeekDigest(digest) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync6(p))
+  if (!existsSync8(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
@@ -7111,7 +8026,7 @@ function entriesDir() {
   return entriesDirCached;
 }
 function pathFor(sessionId, localDay2) {
-  return join5(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
+  return join6(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
 }
 function tmpPathFor(final) {
   return `${final}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
@@ -7122,7 +8037,7 @@ function writeEntry(entry) {
   const final = pathFor(entry.session_id, entry.local_day);
   const tmp = tmpPathFor(final);
   const json = JSON.stringify(entry, null, 2);
-  writeFileSync5(tmp, json, { encoding: "utf8" });
+  writeFileSync6(tmp, json, { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 var PRESERVABLE_STATUSES = /* @__PURE__ */ new Set([
@@ -7154,22 +8069,22 @@ function writeEntryPreservingEnrichment(fresh) {
     toWrite = { ...fresh, enrichment: existing.enrichment };
   }
   const tmp = tmpPathFor(final);
-  writeFileSync5(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
+  writeFileSync6(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 function readEntry(sessionId, localDay2) {
   const p = pathFor(sessionId, localDay2);
-  if (!existsSync7(p))
+  if (!existsSync9(p))
     return null;
-  const raw = readFileSync9(p, "utf8");
+  const raw = readFileSync10(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync7(pathFor(sessionId, localDay2));
+  return existsSync9(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync7(dir))
+  if (!existsSync9(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -7188,8 +8103,8 @@ function listEntriesForDay(localDay2) {
 
 // src/perception/build-entries.ts
 init_dist();
-import { statSync as statSync2, readFileSync as readFileSync10 } from "node:fs";
-import { basename as basename2, dirname as dirname4 } from "node:path";
+import { statSync as statSync2, readFileSync as readFileSync11 } from "node:fs";
+import { basename as basename2, dirname as dirname5 } from "node:path";
 
 // ../entries/dist/signals.js
 init_dist();
@@ -7422,7 +8337,7 @@ function viewEvent(ev) {
     cwd: rawCwd
   };
 }
-var IDLE_GAP_MS5 = 3 * 60 * 1e3;
+var IDLE_GAP_MS6 = 3 * 60 * 1e3;
 var INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
 var PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
 var BASH_CHAIN_SPLIT_RE = /\|\||&&|;|\|/;
@@ -7534,7 +8449,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({
@@ -7731,7 +8646,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();
@@ -7928,7 +8843,7 @@ function decodeProjectDirName(projectDir) {
 }
 function buildEntriesForFile(filePath) {
   const stat = statSync2(filePath);
-  const raw = readFileSync10(filePath, "utf8");
+  const raw = readFileSync11(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -7939,7 +8854,7 @@ function buildEntriesForFile(filePath) {
   if (rawLines.length === 0) return null;
   const { meta, events } = parseTranscript(rawLines);
   const fileName = basename2(filePath);
-  const projectDir = basename2(dirname4(filePath));
+  const projectDir = basename2(dirname5(filePath));
   const sessionId = fileName.replace(/\.jsonl$/, "");
   const sd = {
     ...meta,
@@ -8189,7 +9104,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID(),
     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 } : {},
@@ -8216,8 +9131,8 @@ async function pushToTeamServer(config, payload) {
 }
 
 // src/team/git-remote.ts
-import { existsSync as existsSync8, readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
-import { dirname as dirname5, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync10, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
+import { dirname as dirname6, isAbsolute as isAbsolute2, join as join7, resolve as resolve2 } from "node:path";
 var GITHUB_URL_RE = /github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
 function parseGithubRemote(url) {
   const m = url.trim().match(GITHUB_URL_RE);
@@ -8238,19 +9153,19 @@ function originUrl2(configText) {
   return null;
 }
 function gitConfigPathFor(dir) {
-  const dotGit = join6(dir, ".git");
+  const dotGit = join7(dir, ".git");
   const st = statSync3(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
-  if (st.isDirectory()) return join6(dotGit, "config");
-  const m = readFileSync11(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  if (st.isDirectory()) return join7(dotGit, "config");
+  const m = readFileSync12(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
   const gd = isAbsolute2(m[1]) ? m[1] : resolve2(dir, m[1]);
-  const commondirFile = join6(gd, "commondir");
-  if (existsSync8(commondirFile)) {
-    const common = readFileSync11(commondirFile, "utf8").trim();
-    return join6(isAbsolute2(common) ? common : resolve2(gd, common), "config");
+  const commondirFile = join7(gd, "commondir");
+  if (existsSync10(commondirFile)) {
+    const common = readFileSync12(commondirFile, "utf8").trim();
+    return join7(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
-  return join6(gd, "config");
+  return join7(gd, "config");
 }
 function createRepoResolver() {
   const cache = /* @__PURE__ */ new Map();
@@ -8260,14 +9175,14 @@ function createRepoResolver() {
     if (hit !== void 0) return hit;
     let repo = null;
     try {
-      for (let d = dir; ; d = dirname5(d)) {
+      for (let d = dir; ; d = dirname6(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync8(config)) {
-          const url = originUrl2(readFileSync11(config, "utf8"));
+        if (config && existsSync10(config)) {
+          const url = originUrl2(readFileSync12(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
-        if (d === dirname5(d)) break;
+        if (d === dirname6(d)) break;
       }
     } catch {
       repo = null;
@@ -8279,13 +9194,13 @@ function createRepoResolver() {
 
 // src/team/queue.ts
 init_fs();
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync6, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync6 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync7, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync6 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
 var QUEUE_PATH = cclensPath("ingest-queue.jsonl");
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
 var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 function enqueuePayload(payload, queuePath = QUEUE_PATH) {
-  mkdirSync6(dirname6(queuePath), { recursive: true });
+  mkdirSync6(dirname7(queuePath), { recursive: true });
   const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
   appendFileSync4(queuePath, JSON.stringify(entry) + "\n", "utf8");
   try {
@@ -8299,7 +9214,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync12(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync13(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -8314,18 +9229,18 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
     } catch {
     }
   }
-  writeFileSync6(queuePath, "", "utf8");
+  writeFileSync7(queuePath, "", "utf8");
   return valid.map((e) => e.payload);
 }
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync12(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync13(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
   const keep = lines.slice(Math.floor(lines.length / 2));
-  writeFileSync6(queuePath, keep.join("\n") + "\n", "utf8");
+  writeFileSync7(queuePath, keep.join("\n") + "\n", "utf8");
 }
 
 // src/team/backfill.ts
@@ -8333,8 +9248,8 @@ init_storage();
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/usage/profile.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
 var PROFILE_ENDPOINT = "https://api.anthropic.com/api/oauth/profile";
 var BETA_HEADER2 = "oauth-2025-04-20";
 var PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -8377,9 +9292,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync9(cachePath)) return null;
+  if (!existsSync11(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync13(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync14(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -8387,8 +9302,8 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync7(dirname7(cachePath), { recursive: true });
-  writeFileSync7(
+  mkdirSync7(dirname8(cachePath), { recursive: true });
+  writeFileSync8(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
     { mode: 384 }
@@ -8548,13 +9463,13 @@ async function runTeamBackfill(log3 = noopLog, filePath = USAGE_LOG, configOverr
 
 // src/team/sync-log.ts
 init_fs();
-import { readFileSync as readFileSync14 } from "node:fs";
+import { readFileSync as readFileSync15 } from "node:fs";
 var MAX_LINES = 300;
 var MAX_MSG_CHARS = 1900;
 function readPendingSyncLog(watermark) {
   let raw;
   try {
-    raw = readFileSync14(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync15(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -8574,13 +9489,13 @@ function readPendingSyncLog(watermark) {
 
 // src/team/last-push.ts
 init_fs();
-import { writeFileSync as writeFileSync8, unlinkSync as unlinkSync2, mkdirSync as mkdirSync8 } from "node:fs";
-import { join as join7 } from "node:path";
+import { writeFileSync as writeFileSync9, unlinkSync as unlinkSync2, mkdirSync as mkdirSync8 } from "node:fs";
+import { join as join8 } from "node:path";
 var LAST_PUSH_FILE = "team-last-push.json";
 function write(record, dir) {
   const d = dir ?? cclensHome();
   mkdirSync8(d, { recursive: true });
-  writeFileSync8(join7(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
+  writeFileSync9(join8(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);
@@ -9180,8 +10095,8 @@ init_fs();
 
 // src/perception/state.ts
 init_fs();
-import { existsSync as existsSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, renameSync as renameSync4 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync16, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, renameSync as renameSync4 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 var STALE_MS = 15 * 60 * 1e3;
 var pathCached = null;
 function statePath() {
@@ -9191,7 +10106,7 @@ function statePath() {
 }
 function readState() {
   const p = statePath();
-  if (!existsSync11(p)) {
+  if (!existsSync13(p)) {
     return {
       sweep_in_progress: false,
       last_sweep_started_at: null,
@@ -9199,14 +10114,14 @@ function readState() {
       file_checkpoints: {}
     };
   }
-  const raw = readFileSync15(p, "utf8");
+  const raw = readFileSync16(p, "utf8");
   return JSON.parse(raw);
 }
 function writeState(s) {
   const p = statePath();
-  mkdirSync9(dirname9(p), { recursive: true });
+  mkdirSync9(dirname10(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  writeFileSync9(tmp, JSON.stringify(s, null, 2), "utf8");
+  writeFileSync10(tmp, JSON.stringify(s, null, 2), "utf8");
   renameSync4(tmp, p);
 }
 function markSweepStart() {
@@ -9236,17 +10151,17 @@ function updateCheckpoint(jsonlPath, cp) {
 
 // src/perception/scan.ts
 import { readdirSync as readdirSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 async function listAllSessionJsonls(root) {
-  const projectsRoot = root ?? join9(homedir4(), ".claude", "projects");
+  const projectsRoot = root ?? join10(homedir4(), ".claude", "projects");
   const out = [];
   try {
     for (const project of readdirSync4(projectsRoot)) {
-      const dir = join9(projectsRoot, project);
+      const dir = join10(projectsRoot, project);
       try {
         for (const f of readdirSync4(dir)) {
-          if (f.endsWith(".jsonl")) out.push(join9(dir, f));
+          if (f.endsWith(".jsonl")) out.push(join10(dir, f));
         }
       } catch {
       }
@@ -9807,8 +10722,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var 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
@@ -9924,11 +10839,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var 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() {
@@ -13461,14 +14376,14 @@ var ENRICHMENT_SYSTEM_PROMPT = SYSTEM_PROMPT;
 
 // ../entries/dist/llm-runner.js
 init_fs();
-import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "node:fs";
-import { join as join11 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync12, existsSync as existsSync15 } from "node:fs";
+import { join as join12 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, existsSync as existsSync12, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync16, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
-import { join as join10 } from "node:path";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, existsSync as existsSync14, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync17, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
+import { join as join11 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { spawnSync } from "node:child_process";
 var TmuxUnavailableError = class extends Error {
@@ -13497,16 +14412,16 @@ function tmuxRunnerAvailable() {
   return { ok: true };
 }
 function runtimeCwd() {
-  const dir = join10(homedir5(), ".cclens", "runtime");
-  if (!existsSync12(dir))
+  const dir = join11(homedir5(), ".cclens", "runtime");
+  if (!existsSync14(dir))
     mkdirSync10(dir, { recursive: true });
   return realpathSync2(dir);
 }
 function ensureRuntimeCwdTrusted(cwd) {
-  const cfgPath = join10(homedir5(), ".claude.json");
+  const cfgPath = join11(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync16(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync17(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -13521,7 +14436,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   cfg.projects = projects;
   const tmp = `${cfgPath}.cclens-tmp-${process.pid}`;
   try {
-    writeFileSync10(tmp, JSON.stringify(cfg, null, 2));
+    writeFileSync11(tmp, JSON.stringify(cfg, null, 2));
     renameSync5(tmp, cfgPath);
   } catch {
     try {
@@ -13549,16 +14464,16 @@ async function runClaudeUnderTmuxImpl(args) {
   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`);
-  writeFileSync10(systemFile, args.systemPrompt);
-  writeFileSync10(userFile, args.reminder ? `${args.userPrompt}
+  const systemFile = join11(cwd, `system-${runId}.txt`);
+  const userFile = join11(cwd, `user-${runId}.txt`);
+  const wrapper = join11(cwd, `run-${runId}.sh`);
+  writeFileSync11(systemFile, args.systemPrompt);
+  writeFileSync11(userFile, args.reminder ? `${args.userPrompt}
 
 ---
 
 ${args.reminder}` : args.userPrompt);
-  writeFileSync10(wrapper, `#!/bin/bash
+  writeFileSync11(wrapper, `#!/bin/bash
 SYS="$(cat ${shellEscape(systemFile)})"
 USR="$(cat ${shellEscape(userFile)})"
 exec ${shellEscape(claudeBin)} \\
@@ -13570,10 +14485,10 @@ exec ${shellEscape(claudeBin)} \\
   "$USR"
 `, { mode: 493 });
   const existingBefore = snapshotAllTranscripts();
-  const spawn3 = spawnSync(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
-  if (spawn3.status !== 0) {
+  const spawn4 = spawnSync(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
+  if (spawn4.status !== 0) {
     cleanup(cwd, runId, tmuxBin, sessionName);
-    throw new TmuxRunError(`tmux new-session failed: ${spawn3.stderr.trim()}`);
+    throw new TmuxRunError(`tmux new-session failed: ${spawn4.stderr.trim()}`);
   }
   const onAbort = () => {
     try {
@@ -13630,7 +14545,7 @@ function num(v) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var PROJECTS_ROOT = () => join10(homedir5(), ".claude", "projects");
+var PROJECTS_ROOT = () => join11(homedir5(), ".claude", "projects");
 function snapshotAllTranscripts() {
   const out = /* @__PURE__ */ new Set();
   const root = PROJECTS_ROOT();
@@ -13641,7 +14556,7 @@ function snapshotAllTranscripts() {
     return out;
   }
   for (const sub of subs) {
-    const dir = join10(root, sub);
+    const dir = join11(root, sub);
     let files;
     try {
       files = readdirSync5(dir);
@@ -13650,15 +14565,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 = readFileSync16(path9, "utf8");
+    raw = readFileSync17(path11, "utf8");
   } catch {
     return void 0;
   }
@@ -13691,7 +14606,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 = readdirSync5(dir);
@@ -13701,7 +14616,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)
@@ -13712,10 +14627,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 = readFileSync16(path9, "utf8");
+    raw = readFileSync17(path11, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -13775,7 +14690,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 {
       }
     }
@@ -13790,7 +14705,7 @@ function shellEscape(s) {
 // ../entries/dist/llm-runner.js
 var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync13(RUNS_DIR)) {
+  if (!existsSync15(RUNS_DIR)) {
     try {
       mkdirSync11(RUNS_DIR, { recursive: true });
     } catch {
@@ -13819,17 +14734,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 {
-    appendFileSync5(path9, line);
+    appendFileSync5(path11, line);
   } catch {
   }
 }
-function safeWrite(path9, line) {
+function safeWrite(path11, line) {
   try {
-    writeFileSync11(path9, line);
+    writeFileSync12(path11, line);
   } catch {
   }
 }
@@ -13962,7 +14877,7 @@ function runClaudePrintMode(args) {
       "--append-system-prompt",
       args.systemPrompt
     ];
-    const proc = spawn("claude", claudeArgs, { stdio: ["pipe", "pipe", "pipe"], env: { ...process.env } });
+    const proc = spawn2("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 = args.reminder ? `${args.userPrompt}
 
@@ -14218,8 +15133,8 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 
 // ../entries/dist/budget.js
 init_fs();
-import { appendFileSync as appendFileSync6, readFileSync as readFileSync17, existsSync as existsSync14, mkdirSync as mkdirSync12 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { appendFileSync as appendFileSync6, readFileSync as readFileSync18, existsSync as existsSync16, mkdirSync as mkdirSync12 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
 var spendPathCached = null;
 function spendPath() {
   if (spendPathCached)
@@ -14229,17 +15144,17 @@ function spendPath() {
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync12(dirname10(p), { recursive: true });
+  mkdirSync12(dirname11(p), { recursive: true });
   appendFileSync6(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync14(p))
+  if (!existsSync16(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync17(p, "utf8");
+  const raw = readFileSync18(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -14261,7 +15176,7 @@ function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
 
 // ../entries/dist/pipeline-lock.js
 init_fs();
-import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync15, readFileSync as readFileSync18, statSync as statSync7 } from "node:fs";
+import { writeFileSync as writeFileSync13, unlinkSync as unlinkSync4, existsSync as existsSync17, readFileSync as readFileSync19, statSync as statSync7 } from "node:fs";
 var STALE_MS2 = 60 * 1e3;
 var HEARTBEAT_MS = 30 * 1e3;
 var lockPathCached = null;
@@ -14273,7 +15188,7 @@ function lockPath() {
   return lockPathCached;
 }
 function touchLock() {
-  writeFileSync12(lockPath(), String(process.pid), "utf8");
+  writeFileSync13(lockPath(), String(process.pid), "utf8");
 }
 function writeInteractiveLock() {
   touchLock();
@@ -14307,13 +15222,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync15(p))
+  if (!existsSync17(p))
     return false;
   try {
     const mtime = statSync7(p).mtimeMs;
     if (nowMs - mtime > STALE_MS2)
       return false;
-    const pid = Number(readFileSync18(p, "utf8").trim());
+    const pid = Number(readFileSync19(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -14328,7 +15243,7 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync16 } from "node:fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync18 } from "node:fs";
 init_fs();
 var DEFAULT_SETTINGS = {
   ai_features: {
@@ -14360,10 +15275,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync16(p))
+  if (!existsSync18(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync19(p, "utf8");
+    const raw = readFileSync20(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -16034,7 +16949,7 @@ var MonthDigestResponseSchema = external_exports.object({
 }).passthrough();
 
 // ../entries/dist/top-sessions.js
-var IDLE_GAP_MS6 = 3 * 60 * 1e3;
+var IDLE_GAP_MS7 = 3 * 60 * 1e3;
 var LONG_AUTONOMOUS_MIN = 20;
 var N_USER = 150;
 var N_FIRST_AGENT = 150;
@@ -16065,7 +16980,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;
@@ -16239,7 +17154,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)
@@ -17123,14 +18038,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)
   };
 }
 
@@ -17140,11 +18055,12 @@ var DAEMON_LOG = cclensPath("daemon.log");
 var UPDATE_STATE = cclensPath("daemon-update.json");
 var WATCHDOG_INTERVAL_MS = 5 * 1e3;
 var AUTO_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
-mkdirSync14(dirname11(USAGE_LOG3), { recursive: true });
+mkdirSync14(dirname12(USAGE_LOG3), { recursive: true });
 function log2(level, message) {
   appendDaemonLogLine(level, message);
 }
 var nextPollAtMs = 0;
+var nextAuxPollAtMs = 0;
 var nextTeamSyncAtMs = 0;
 var firstTeamSync = true;
 var currentIntervalMs = BASE_INTERVAL_MS;
@@ -17178,14 +18094,14 @@ var perceptionHandle = setInterval(async () => {
 }, PERCEPTION_INTERVAL_MS);
 function readUpdateState() {
   try {
-    return JSON.parse(readFileSync20(UPDATE_STATE, "utf8"));
+    return JSON.parse(readFileSync21(UPDATE_STATE, "utf8"));
   } catch {
     return null;
   }
 }
 function writeUpdateState(state) {
   try {
-    writeFileSync14(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
+    writeFileSync15(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
   } catch {
   }
 }
@@ -17198,7 +18114,7 @@ function nextUpdateCheckFromState(nowMs) {
 }
 var nextUpdateCheckAtMs = nextUpdateCheckFromState(Date.now());
 function cliEntryPath() {
-  return join12(dirname11(fileURLToPath(import.meta.url)), "index.js");
+  return join13(dirname12(fileURLToPath(import.meta.url)), "index.js");
 }
 async function runDaemonUpdateCheck() {
   if (process.env.FLEETLENS_DAEMON_AUTO_UPDATE === "0") {
@@ -17230,7 +18146,7 @@ async function runDaemonUpdateCheck() {
       return;
     }
     const entry = cliEntryPath();
-    if (!existsSync17(entry)) {
+    if (!existsSync19(entry)) {
       log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
       return;
     }
@@ -17239,7 +18155,7 @@ async function runDaemonUpdateCheck() {
       logFd = openSync(DAEMON_LOG, "a");
     } catch {
     }
-    const child = spawn2(process.execPath, [entry, "update"], {
+    const child = spawn3(process.execPath, [entry, "update"], {
       detached: true,
       stdio: ["ignore", logFd, logFd],
       env: { ...process.env, FLEETLENS_UPDATE_SOURCE: "daemon" }
@@ -17269,7 +18185,7 @@ async function runDaemonUpdateCheck() {
     nextUpdateCheckAtMs = Date.now() + AUTO_UPDATE_INTERVAL_MS;
   }
 }
-async function tick() {
+async function pollAuxiliaryUsage() {
   for (const source of agentSources) {
     if (source.kind === "claude-code") continue;
     if (!source.usagePoller) continue;
@@ -17309,6 +18225,31 @@ async function tick() {
       log2("warn", `zai poll failed: ${err.message}`);
     }
   }
+  try {
+    const copilotSnapshot = await fetchCopilotUsage();
+    appendSnapshot(USAGE_LOG3, copilotSnapshot);
+    const monthly = copilotSnapshot.monthly?.utilization;
+    log2("info", `copilot snapshot monthly=${monthly === null || monthly === void 0 ? "\u2014" : `${monthly}%`}`);
+  } catch (err) {
+    if (err instanceof CopilotApiError && err.code === "no_cli") {
+      pruneAgent(USAGE_LOG3, "copilot");
+    } else if (!(err instanceof CopilotApiError && err.code === "no_auth")) {
+      log2("warn", `copilot poll failed: ${err.message}`);
+    }
+  }
+  try {
+    const codexSnapshot = await fetchCodexUsage();
+    appendSnapshot(USAGE_LOG3, codexSnapshot);
+    const fiveHour = codexSnapshot.five_hour.utilization === null ? "\u2014" : `${codexSnapshot.five_hour.utilization}%`;
+    const sevenDay = codexSnapshot.seven_day.utilization === null ? "\u2014" : `${codexSnapshot.seven_day.utilization}%`;
+    log2("info", `codex snapshot 5h=${fiveHour} 7d=${sevenDay}`);
+  } catch (err) {
+    if (err instanceof CodexApiError && (err.code === "no_auth" || err.code === "api_key_only")) {
+      pruneAgent(USAGE_LOG3, "codex");
+    } else {
+      log2("warn", `codex poll failed: ${err.message}`);
+    }
+  }
   try {
     const grokSnapshot = await fetchGrokUsage();
     appendSnapshot(USAGE_LOG3, grokSnapshot);
@@ -17327,6 +18268,8 @@ async function tick() {
       log2("warn", `grok poll failed: ${err.message}`);
     }
   }
+}
+async function pollClaudeUsage() {
   try {
     const snapshot = await fetchUsage();
     appendSnapshot(USAGE_LOG3, snapshot);
@@ -17361,6 +18304,10 @@ function sleep2(ms) {
 async function runLoop() {
   while (true) {
     const now = Date.now();
+    if (now >= nextAuxPollAtMs) {
+      await pollAuxiliaryUsage();
+      nextAuxPollAtMs = Date.now() + BASE_INTERVAL_MS;
+    }
     if (now >= nextPollAtMs) {
       if (nextPollAtMs > 0 && now - nextPollAtMs > currentIntervalMs) {
         log2(
@@ -17383,7 +18330,7 @@ async function runLoop() {
           log2("info", "token refreshed; resuming polls");
           waitingForRefresh = false;
         }
-        const outcome = await tick();
+        const outcome = await pollClaudeUsage();
         scheduleAfter(Date.now(), outcome);
       }
     }