fleetlens 0.11.2 → 0.12.0

package/dist/daemon-worker.js

@@ -75,6 +75,16 @@ function findConductorWorkspace(projectName) {
   const canonicalEndIdx = m.index + m[0].length - workspaceName.length - 1 - trailingSlash;
   return { canonicalEndIdx, workspaceName };
 }
+function findSupersetWorkspace(projectName) {
+  const idx = projectName.indexOf(SUPERSET_MARKER);
+  if (idx < 0)
+    return null;
+  const segs = projectName.slice(idx + SUPERSET_MARKER.length).split("/").filter(Boolean);
+  if (segs.length === 0)
+    return null;
+  const workspaceName = UUID_SEG_RE.test(segs[0]) ? segs[1] ?? segs[0] : segs[0];
+  return { canonical: projectName.slice(0, idx) + SUPERSET_MARKER + workspaceName, workspaceName };
+}
 function canonicalProjectName(projectName) {
   const normalized = projectName.replace(/\/{2,}/g, "/");
   const wt = findWorktreeMarker(normalized);
@@ -83,6 +93,9 @@ function canonicalProjectName(projectName) {
   const cd = findConductorWorkspace(normalized);
   if (cd)
     return normalized.slice(0, cd.canonicalEndIdx);
+  const ss = findSupersetWorkspace(normalized);
+  if (ss)
+    return ss.canonical;
   return normalized;
 }
 function worktreeName(projectName) {
@@ -96,8 +109,16 @@ function worktreeName(projectName) {
   const cd = findConductorWorkspace(normalized);
   if (cd)
     return cd.workspaceName;
+  const ss = findSupersetWorkspace(normalized);
+  if (ss)
+    return ss.workspaceName;
   return null;
 }
+function projectRepoName(projectName) {
+  const canonical = canonicalProjectName(projectName);
+  const segs = canonical.replace(/\/+$/, "").split("/").filter(Boolean);
+  return segs[segs.length - 1] || canonical;
+}
 function makeDay(date) {
   return {
     date,
@@ -517,13 +538,13 @@ function summarizeBursts(bursts) {
 function groupByProject(sessions) {
   const map = /* @__PURE__ */ new Map();
   for (const s of sessions) {
-    const canonical = canonicalProjectName(s.projectName);
-    const key = canonical;
+    const repo = projectRepoName(s.projectName);
+    const key = repo;
     let cur = map.get(key);
     if (!cur) {
       cur = {
-        projectDir: canonical,
-        projectName: canonical,
+        projectDir: repo,
+        projectName: repo,
         sessions: [],
         rawProjectDirs: [],
         worktreeCount: 0,
@@ -565,7 +586,7 @@ function groupByProject(sessions) {
   }
   return Array.from(map.values()).sort((a, b) => (b.lastActiveMs ?? 0) - (a.lastActiveMs ?? 0));
 }
-var BLANK_USAGE, WORKTREE_MARKERS, CONDUCTOR_RE, PR_CREATE_RE, PR_NUMBER_RE, TITLE_FLAG_RE;
+var BLANK_USAGE, WORKTREE_MARKERS, CONDUCTOR_RE, SUPERSET_MARKER, UUID_SEG_RE, PR_CREATE_RE, PR_NUMBER_RE, TITLE_FLAG_RE;
 var init_analytics = __esm({
   "../parser/dist/analytics.js"() {
     "use strict";
@@ -576,6 +597,8 @@ var init_analytics = __esm({
       "/claude/worktrees/"
     ];
     CONDUCTOR_RE = /\/conductor\/workspaces\/[^/]+\/([^/]+)(?:\/|$)/;
+    SUPERSET_MARKER = "/.superset/worktrees/";
+    UUID_SEG_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
     PR_CREATE_RE = /gh\s+pr\s+create\b/i;
     PR_NUMBER_RE = /#(\d+)/;
     TITLE_FLAG_RE = /--title\s+["']([^"']+)["']/;
@@ -589,7 +612,7 @@ function getAgentMetadata(kind) {
 function isAgentKind(s) {
   return typeof s === "string" && KNOWN_AGENT_KINDS.has(s);
 }
-var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
+var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, ANTIGRAVITY_METADATA, COWORK_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
 var init_agent_metadata = __esm({
   "../parser/dist/agent-metadata.js"() {
     "use strict";
@@ -614,10 +637,26 @@ var init_agent_metadata = __esm({
       accentColor: "rgb(124, 92, 246)",
       iconChar: "\u273A"
     };
+    ANTIGRAVITY_METADATA = {
+      kind: "antigravity",
+      displayName: "Antigravity",
+      shortLabel: "Agy",
+      accentColor: "rgb(236, 72, 153)",
+      iconChar: "\u23C3"
+    };
+    COWORK_METADATA = {
+      kind: "cowork",
+      displayName: "Cowork",
+      shortLabel: "Cowork",
+      accentColor: "rgb(217, 119, 87)",
+      iconChar: "\u2318"
+    };
     agentMetadata = [
       CLAUDE_CODE_METADATA,
       CODEX_METADATA,
-      GEMINI_METADATA
+      GEMINI_METADATA,
+      ANTIGRAVITY_METADATA,
+      COWORK_METADATA
     ];
     KNOWN_AGENT_KINDS = new Set(agentMetadata.map((m) => m.kind));
   }
@@ -1643,6 +1682,52 @@ async function computeSessionUsageWithSubagents(parentLines, projectDirPath, ses
   }));
   return usage;
 }
+async function scanWorkflowAggregate(projectDirPath, sessionId) {
+  const dir = path.join(projectDirPath, sessionId, "workflows");
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return { workflowCount: 0, spawnedAgentCount: 0, spans: [] };
+  }
+  const jsonFiles = entries.filter((f) => f.startsWith("wf_") && f.endsWith(".json"));
+  if (jsonFiles.length === 0)
+    return { workflowCount: 0, spawnedAgentCount: 0, spans: [] };
+  let spawnedAgentCount = 0;
+  const spans = [];
+  const parsed = await Promise.all(jsonFiles.map(async (f) => {
+    try {
+      const j = JSON.parse(await fs.readFile(path.join(dir, f), "utf8"));
+      if (typeof j.agentCount === "number")
+        spawnedAgentCount += j.agentCount;
+      if (typeof j.startTime === "number" && typeof j.durationMs === "number" && j.durationMs > 0) {
+        spans.push({ startMs: j.startTime, endMs: j.startTime + j.durationMs });
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }));
+  return { workflowCount: parsed.filter(Boolean).length, spawnedAgentCount, spans };
+}
+function foldWorkflowAgentTime(activeSegments, spans) {
+  if (spans.length === 0)
+    return {};
+  const all = [...activeSegments ?? [], ...spans].filter((s) => s.endMs > s.startMs).sort((a, b) => a.startMs - b.startMs);
+  if (all.length === 0)
+    return {};
+  const merged = [{ ...all[0] }];
+  for (let i = 1; i < all.length; i++) {
+    const cur = all[i];
+    const last = merged[merged.length - 1];
+    if (cur.startMs <= last.endMs)
+      last.endMs = Math.max(last.endMs, cur.endMs);
+    else
+      merged.push({ ...cur });
+  }
+  const airTimeMs = merged.reduce((n, s) => n + (s.endMs - s.startMs), 0);
+  return { activeSegments: merged, airTimeMs };
+}
 async function getCachedMeta(f) {
   const cached = metaCache.get(f.fullPath);
   if (cached && cached.mtimeMs === f.mtimeMs && cached.sizeBytes === f.sizeBytes) {
@@ -1654,12 +1739,15 @@ async function getCachedMeta(f) {
     const sessionId = sessionIdFromFileName(f.fileName);
     const projectDirPath = path.dirname(f.fullPath);
     meta.totalUsage = await computeSessionUsageWithSubagents(rawLines, projectDirPath, sessionId);
+    const wf = await scanWorkflowAggregate(projectDirPath, sessionId);
     const full = {
       ...meta,
       id: sessionId,
       filePath: f.fullPath,
       projectDir: f.projectDir,
-      projectName: meta.cwd ?? decodeProjectName(f.projectDir)
+      projectName: meta.cwd ?? decodeProjectName(f.projectDir),
+      ...wf.workflowCount > 0 ? { workflowCount: wf.workflowCount, spawnedAgentCount: wf.spawnedAgentCount } : {},
+      ...foldWorkflowAgentTime(meta.activeSegments, wf.spans)
     };
     metaCache.set(f.fullPath, { meta: full, mtimeMs: f.mtimeMs, sizeBytes: f.sizeBytes });
     return full;
@@ -1675,13 +1763,17 @@ async function getCachedDetail(f) {
   try {
     const rawLines = await readJsonlFile(f.fullPath);
     const { meta, events } = parseTranscript(rawLines);
+    const sessionId = sessionIdFromFileName(f.fileName);
+    const wf = await scanWorkflowAggregate(path.dirname(f.fullPath), sessionId);
     const detail = {
       ...meta,
-      id: sessionIdFromFileName(f.fileName),
+      id: sessionId,
       filePath: f.fullPath,
       projectDir: f.projectDir,
       projectName: meta.cwd ?? decodeProjectName(f.projectDir),
-      events
+      events,
+      ...wf.workflowCount > 0 ? { workflowCount: wf.workflowCount, spawnedAgentCount: wf.spawnedAgentCount } : {},
+      ...foldWorkflowAgentTime(meta.activeSegments, wf.spans)
     };
     detailCache.set(f.fullPath, { detail, mtimeMs: f.mtimeMs, sizeBytes: f.sizeBytes });
     const metaOnly = { ...detail };
@@ -1713,8 +1805,18 @@ async function getSession(id, opts = {}) {
     return detail;
   const sessionStartMs = detail.firstTimestamp ? Date.parse(detail.firstTimestamp) : void 0;
   const subagentsDir = path.join(path.dirname(hit.fullPath), sessionIdFromFileName(hit.fileName), "subagents");
-  const subagents = await loadSubagents(subagentsDir, sessionStartMs, detail.events);
-  return { ...detail, subagents };
+  const workflowsDir = path.join(path.dirname(hit.fullPath), sessionIdFromFileName(hit.fileName), "workflows");
+  const [subagents, workflows] = await Promise.all([
+    loadSubagents(subagentsDir, sessionStartMs, detail.events),
+    loadWorkflows(workflowsDir, sessionStartMs, detail.events)
+  ]);
+  const spawnedAgentCount = workflows.reduce((n, w) => n + w.agentCount, 0);
+  return {
+    ...detail,
+    subagents,
+    workflows,
+    ...workflows.length > 0 ? { workflowCount: workflows.length, spawnedAgentCount } : {}
+  };
 }
 function summarizeSubagentLines(lines) {
   let startMs;
@@ -1904,6 +2006,248 @@ async function loadSubagents(dir, sessionStartMs, parentEvents) {
   }));
   return runs.filter((r) => r !== null).sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
 }
+async function loadWorkflows(dir, sessionStartMs, parentEvents) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+  const jsonFiles = entries.filter((f) => f.startsWith("wf_") && f.endsWith(".json"));
+  if (jsonFiles.length === 0)
+    return [];
+  const dispatches = [];
+  for (const e of parentEvents) {
+    if (e.role !== "tool-call" || e.toolName !== "Workflow")
+      continue;
+    const tsMs = e.timestamp ? Date.parse(e.timestamp) : NaN;
+    if (Number.isNaN(tsMs))
+      continue;
+    for (const b of e.blocks) {
+      if (b?.type !== "tool_use" || b.name !== "Workflow")
+        continue;
+      dispatches.push({ toolUseId: b.id, parentUuid: e.uuid ?? "", tsMs });
+    }
+  }
+  dispatches.sort((a, b) => a.tsMs - b.tsMs);
+  const matchDispatch = (startMs) => {
+    if (startMs === void 0 || dispatches.length === 0)
+      return void 0;
+    const TOLERANCE_MS = 6e4;
+    let before;
+    let beforeDelta = Infinity;
+    let nearest;
+    let nearestDelta = Infinity;
+    for (const d of dispatches) {
+      const delta = Math.abs(startMs - d.tsMs);
+      if (delta > TOLERANCE_MS)
+        continue;
+      if (delta < nearestDelta) {
+        nearest = d;
+        nearestDelta = delta;
+      }
+      if (d.tsMs <= startMs && delta < beforeDelta) {
+        before = d;
+        beforeDelta = delta;
+      }
+    }
+    return before ?? nearest;
+  };
+  const num2 = (v) => typeof v === "number" ? v : void 0;
+  const str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
+  const runs = await Promise.all(jsonFiles.map(async (f) => {
+    let j;
+    try {
+      j = JSON.parse(await fs.readFile(path.join(dir, f), "utf8"));
+    } catch {
+      return null;
+    }
+    const runId = str(j.runId) ?? f.replace(/\.json$/, "");
+    const startMs = num2(j.startTime);
+    const durationMs = num2(j.durationMs);
+    const endMs = startMs !== void 0 && durationMs !== void 0 ? startMs + durationMs : void 0;
+    const startTOffsetMs = sessionStartMs !== void 0 && startMs !== void 0 ? Math.max(0, startMs - sessionStartMs) : void 0;
+    const endTOffsetMs = sessionStartMs !== void 0 && endMs !== void 0 ? Math.max(0, endMs - sessionStartMs) : void 0;
+    const phases = Array.isArray(j.phases) ? j.phases.filter((p) => !!p && typeof p === "object" && typeof p.title === "string").map((p) => ({ title: p.title, detail: str(p.detail) })) : [];
+    const logs = Array.isArray(j.logs) ? j.logs.filter((l) => typeof l === "string") : [];
+    const cap = (v, n) => {
+      const s = str(v);
+      return s === void 0 ? void 0 : s.length > n ? s.slice(0, n) + "\u2026" : s;
+    };
+    const progress = Array.isArray(j.workflowProgress) ? j.workflowProgress : [];
+    const agents = progress.filter((e) => !!e && typeof e === "object" && e.type === "workflow_agent").map((e) => ({
+      index: num2(e.index) ?? 0,
+      label: str(e.label) ?? "(agent)",
+      phaseIndex: num2(e.phaseIndex),
+      phaseTitle: str(e.phaseTitle),
+      agentId: str(e.agentId),
+      model: str(e.model),
+      state: str(e.state),
+      startedAt: num2(e.startedAt),
+      durationMs: num2(e.durationMs),
+      tokens: num2(e.tokens),
+      toolCalls: num2(e.toolCalls),
+      lastToolSummary: cap(e.lastToolSummary, 200),
+      promptPreview: cap(e.promptPreview, 600),
+      resultPreview: cap(e.resultPreview, 600)
+    })).sort((a, b) => a.index - b.index);
+    const parent = matchDispatch(startMs);
+    return {
+      runId,
+      name: str(j.workflowName) ?? runId,
+      description: str(j.summary),
+      status: str(j.status) ?? "unknown",
+      agentCount: num2(j.agentCount) ?? 0,
+      toolCallCount: num2(j.totalToolCalls) ?? 0,
+      totalTokens: num2(j.totalTokens) ?? 0,
+      durationMs,
+      startMs,
+      endMs,
+      startTOffsetMs,
+      endTOffsetMs,
+      model: str(j.defaultModel),
+      phases,
+      logs,
+      agents,
+      parentToolUseId: parent?.toolUseId,
+      parentUuid: parent?.parentUuid
+    };
+  }));
+  return runs.filter((r) => r !== null).sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
+}
+function salientToolInput(input) {
+  if (!input || typeof input !== "object")
+    return "";
+  const o = input;
+  const pick = (k) => typeof o[k] === "string" ? o[k] : void 0;
+  return pick("command") ?? pick("file_path") ?? pick("path") ?? pick("pattern") ?? pick("url") ?? pick("description") ?? pick("query") ?? pick("prompt") ?? pick("old_string") ?? JSON.stringify(o);
+}
+async function loadWorkflowAgentDetail(sessionId, runId, agentId, opts = {}) {
+  const { root = DEFAULT_ROOT } = opts;
+  if (!/^[\w.-]+$/.test(runId) || !/^[\w.-]+$/.test(agentId))
+    return null;
+  const files = await walkJsonlFiles(root);
+  const hit = files.find((f) => sessionIdFromFileName(f.fileName) === sessionId);
+  if (!hit)
+    return null;
+  const file = path.join(path.dirname(hit.fullPath), sessionId, "subagents", "workflows", runId, `agent-${agentId}.jsonl`);
+  let lines;
+  try {
+    lines = await readJsonlFile(file);
+  } catch {
+    return null;
+  }
+  const errored = /* @__PURE__ */ new Set();
+  for (const raw of lines) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const content = raw.message?.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const b of content) {
+      if (b && typeof b === "object" && b.type === "tool_result" && b.is_error === true && typeof b.tool_use_id === "string") {
+        errored.add(b.tool_use_id);
+      }
+    }
+  }
+  const steps = [];
+  const toolCounts = /* @__PURE__ */ new Map();
+  const totalUsage = { ...BLANK_USAGE3 };
+  const seen = /* @__PURE__ */ new Set();
+  let prompt;
+  let finalText;
+  let model;
+  let assistantMessageCount = 0;
+  let eventCount = 0;
+  let startMs;
+  let endMs;
+  for (const raw of lines) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const r = raw;
+    eventCount++;
+    const ts = typeof r.timestamp === "string" ? Date.parse(r.timestamp) : NaN;
+    if (!Number.isNaN(ts)) {
+      if (startMs === void 0 || ts < startMs)
+        startMs = ts;
+      if (endMs === void 0 || ts > endMs)
+        endMs = ts;
+    }
+    if (prompt === void 0 && r.type === "user" && (r.parentUuid === null || r.parentUuid === void 0)) {
+      const c = r.message?.content;
+      if (typeof c === "string")
+        prompt = c;
+      else if (Array.isArray(c)) {
+        const t = c.find((b) => b && typeof b === "object" && b.type === "text");
+        if (t?.text)
+          prompt = t.text;
+      }
+    }
+    if (r.type !== "assistant")
+      continue;
+    const m = r.message;
+    if (!m)
+      continue;
+    if (!model && typeof m.model === "string")
+      model = m.model;
+    const mid = typeof m.id === "string" ? m.id : void 0;
+    const rid = typeof r.requestId === "string" ? r.requestId : void 0;
+    const key = mid != null && rid != null ? `${mid}:${rid}` : void 0;
+    const fresh = key ? !seen.has(key) : true;
+    if (key && fresh)
+      seen.add(key);
+    if (fresh) {
+      assistantMessageCount++;
+      const u = m.usage;
+      if (u) {
+        const n = (v) => typeof v === "number" ? v : 0;
+        totalUsage.input += n(u.input_tokens);
+        totalUsage.output += n(u.output_tokens);
+        totalUsage.cacheRead += n(u.cache_read_input_tokens);
+        totalUsage.cacheWrite += n(u.cache_creation_input_tokens);
+      }
+    }
+    const content = m.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const b of content) {
+      if (!b || typeof b !== "object")
+        continue;
+      if (b.type === "text" && typeof b.text === "string") {
+        finalText = b.text;
+      } else if (b.type === "tool_use" && typeof b.name === "string") {
+        toolCounts.set(b.name, (toolCounts.get(b.name) ?? 0) + 1);
+        if (steps.length < 2e3) {
+          const salient = salientToolInput(b.input);
+          const preview = salient.replace(/\s+/g, " ").trim().slice(0, 160);
+          const full = salient.length > 4e3 ? salient.slice(0, 4e3) + "\u2026" : salient;
+          steps.push({
+            index: steps.length + 1,
+            tool: b.name,
+            preview,
+            // Only carry `full` when it adds something over the one-line preview.
+            full: full.length > preview.length || full.includes("\n") ? full : void 0,
+            isError: typeof b.id === "string" && errored.has(b.id)
+          });
+        }
+      }
+    }
+  }
+  const toolCalls = Array.from(toolCounts.entries()).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count);
+  return {
+    agentId,
+    prompt,
+    finalText,
+    steps,
+    toolCalls,
+    toolCallCount: steps.length,
+    assistantMessageCount,
+    eventCount,
+    totalUsage,
+    model,
+    durationMs: startMs !== void 0 && endMs !== void 0 ? endMs - startMs : void 0
+  };
+}
 async function listProjects(root = DEFAULT_ROOT) {
   const files = await walkJsonlFiles(root);
   const byRawDir = /* @__PURE__ */ new Map();
@@ -1925,10 +2269,10 @@ async function listProjects(root = DEFAULT_ROOT) {
   const canonicalMap = /* @__PURE__ */ new Map();
   for (const [rawDir, { count, lastActiveMs }] of byRawDir) {
     const cwdOrDecoded = cwdForProject(rawDir) ?? decodeProjectName(rawDir);
-    const canonical = canonicalProjectName(cwdOrDecoded);
+    const repo = projectRepoName(cwdOrDecoded);
     const wt = worktreeName(cwdOrDecoded);
-    const agg = canonicalMap.get(canonical) ?? {
-      canonicalName: canonical,
+    const agg = canonicalMap.get(repo) ?? {
+      canonicalName: repo,
       count: 0,
       lastActiveMs: 0,
       worktreeBranches: /* @__PURE__ */ new Set()
@@ -1938,7 +2282,7 @@ async function listProjects(root = DEFAULT_ROOT) {
       agg.lastActiveMs = lastActiveMs;
     if (wt)
       agg.worktreeBranches.add(wt);
-    canonicalMap.set(canonical, agg);
+    canonicalMap.set(repo, agg);
   }
   return Array.from(canonicalMap.values()).map((a) => ({
     projectDir: a.canonicalName,
@@ -2838,76 +3182,705 @@ async function parseSession(file) {
       prevMs = ms;
     }
   }
-  const activeSegments = computeActiveSegments3(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;
-  const projectName = cwd ? canonicalProjectName(cwd) : file.slug;
-  const projectDir = cwd ? cwd.replace(/^\//, "-").replace(/\//g, "-") : file.slug;
+  const activeSegments = computeActiveSegments3(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;
+  const projectName = cwd ? canonicalProjectName(cwd) : file.slug;
+  const projectDir = cwd ? cwd.replace(/^\//, "-").replace(/\//g, "-") : file.slug;
+  const meta = {
+    agent: "gemini",
+    id: sessionId,
+    filePath: file.filePath,
+    projectName,
+    projectDir,
+    sessionId,
+    firstTimestamp,
+    lastTimestamp,
+    durationMs: durationMs && Number.isFinite(durationMs) ? durationMs : void 0,
+    eventCount: events.length,
+    model,
+    cwd,
+    totalUsage,
+    status: "idle",
+    firstUserPreview,
+    lastUserPreview,
+    lastAgentPreview,
+    toolCallCount,
+    turnCount,
+    airTimeMs,
+    activeSegments
+  };
+  return { meta, events };
+}
+function computeActiveSegments3(tsMs) {
+  if (tsMs.length === 0)
+    return [];
+  const sorted = [...tsMs].sort((a, b) => a - b);
+  const out = [];
+  let segStart = sorted[0];
+  let segEnd = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i] - segEnd > IDLE_GAP_MS2) {
+      out.push({ startMs: segStart, endMs: segEnd });
+      segStart = sorted[i];
+    }
+    segEnd = sorted[i];
+  }
+  out.push({ startMs: segStart, endMs: segEnd });
+  return out;
+}
+function clearGeminiCaches() {
+  metaCache3.clear();
+  detailCache3.clear();
+  projectsCache = null;
+}
+async function listGeminiSessions(opts = {}) {
+  const root = opts.root ?? DEFAULT_GEMINI_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(cached.meta);
+      continue;
+    }
+    try {
+      const { meta } = await parseSession(file);
+      metaCache3.set(file.filePath, {
+        meta,
+        mtimeMs: file.mtimeMs,
+        sizeBytes: file.sizeBytes
+      });
+      out.push(meta);
+    } catch {
+    }
+  }
+  out.sort((a, b) => (b.firstTimestamp ?? "").localeCompare(a.firstTimestamp ?? ""));
+  if (opts.limit !== void 0)
+    return out.slice(0, opts.limit);
+  return out;
+}
+async function getGeminiSession(id, opts = {}) {
+  const root = opts.root ?? DEFAULT_GEMINI_ROOT;
+  const files = await listSessionFiles(root);
+  let chosen;
+  for (const file of files) {
+    if (file.filenameId === id || id.startsWith(file.filenameId)) {
+      chosen = file;
+      break;
+    }
+  }
+  if (!chosen) {
+    for (const file of files) {
+      const { meta: meta2 } = await parseSession(file).catch(() => ({ meta: { id: "" } }));
+      if (meta2.id === id) {
+        chosen = file;
+        break;
+      }
+    }
+  }
+  if (!chosen)
+    return null;
+  const cached = detailCache3.get(chosen.filePath);
+  if (cached && cached.mtimeMs === chosen.mtimeMs && cached.sizeBytes === chosen.sizeBytes) {
+    return cached.detail;
+  }
+  const { meta, events } = await parseSession(chosen);
+  const detail = { ...meta, events };
+  detailCache3.set(chosen.filePath, {
+    detail,
+    mtimeMs: chosen.mtimeMs,
+    sizeBytes: chosen.sizeBytes
+  });
+  return detail;
+}
+function geminiSessionLocalDay(meta) {
+  if (!meta.firstTimestamp)
+    return void 0;
+  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 init_gemini = __esm({
+  "../parser/dist/gemini.js"() {
+    "use strict";
+    init_analytics();
+    init_user_input();
+    DEFAULT_GEMINI_ROOT = path3.join(os3.homedir(), ".gemini", "tmp");
+    GEMINI_PROJECTS_FILE = path3.join(os3.homedir(), ".gemini", "projects.json");
+    SESSION_FILE_RE = /^session-.+\.(jsonl|json)$/;
+    IDLE_GAP_MS2 = 3 * 60 * 1e3;
+    projectsCache = null;
+    metaCache3 = /* @__PURE__ */ new Map();
+    detailCache3 = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../parser/dist/antigravity.js
+import { promises as fs4 } from "node:fs";
+import os4 from "node:os";
+import path4 from "node:path";
+async function safeReaddir3(p) {
+  return fs4.readdir(p).catch(() => []);
+}
+async function loadSlugToCwd2(root) {
+  const historyFile = path4.join(root, "history.jsonl");
+  const stat = await fs4.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 slugToCwd = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.conversationId && parsed.workspace) {
+        slugToCwd.set(parsed.conversationId, parsed.workspace);
+      }
+    } catch {
+    }
+  }
+  historyCache = { mtimeMs: stat.mtimeMs, slugToCwd };
+  return slugToCwd;
+}
+async function listSessionFiles2(root) {
+  const slugToCwd = await loadSlugToCwd2(root);
+  const out = [];
+  const brainDir = path4.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);
+    if (stat && stat.isFile()) {
+      out.push({
+        filePath: transcriptPath,
+        conversationId: entry,
+        cwd: slugToCwd.get(entry),
+        mtimeMs: stat.mtimeMs,
+        sizeBytes: stat.size
+      });
+    }
+  }
+  return out;
+}
+function emptyUsage3() {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+}
+function previewOf3(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");
+  const events = [];
+  const totalUsage = emptyUsage3();
+  let firstTimestamp;
+  let lastTimestamp;
+  let model;
+  let toolCallCount = 0;
+  let turnCount = 0;
+  let firstUserPreview;
+  let lastUserPreview;
+  let lastAgentPreview;
+  const tsMs = [];
+  let idx = 0;
+  function pushEvent(e) {
+    events.push(e);
+    if (e.timestamp && e.role !== "meta") {
+      if (!firstTimestamp)
+        firstTimestamp = e.timestamp;
+      lastTimestamp = e.timestamp;
+      const ms = Date.parse(e.timestamp);
+      if (Number.isFinite(ms))
+        tsMs.push(ms);
+    }
+  }
+  const pendingToolCalls = [];
+  const parsedObjects = [];
+  const indexMap = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      const stepIdx = obj.step_index;
+      if (typeof stepIdx === "number") {
+        if (indexMap.has(stepIdx)) {
+          parsedObjects[indexMap.get(stepIdx)] = obj;
+        } else {
+          indexMap.set(stepIdx, parsedObjects.length);
+          parsedObjects.push(obj);
+        }
+      } else {
+        parsedObjects.push(obj);
+      }
+    } catch {
+    }
+  }
+  for (const eventObj of parsedObjects) {
+    const ts = eventObj.created_at || eventObj.timestamp;
+    if (eventObj.type === "USER_INPUT") {
+      if (typeof eventObj.content === "string") {
+        const matchNoNeed = eventObj.content.match(/Model Selection` from .*? to (.*?)\.\s*No need to/);
+        if (matchNoNeed) {
+          let rawModel = matchNoNeed[1].trim();
+          rawModel = rawModel.replace(/\s*\(.*?\)\s*$/, "").trim();
+          model = rawModel;
+        } else {
+          const matchDot = eventObj.content.match(/Model Selection` from .*? to ([^\n]+)/);
+          if (matchDot) {
+            let rawModel = matchDot[1].trim();
+            if (rawModel.endsWith(".")) {
+              rawModel = rawModel.slice(0, -1).trim();
+            }
+            rawModel = rawModel.replace(/\s*\(.*?\)\s*$/, "").trim();
+            model = rawModel;
+          }
+        }
+      }
+      let text2 = eventObj.content || "";
+      const requestMatch = text2.match(/<USER_REQUEST>([\s\S]*?)<\/USER_REQUEST>/);
+      if (requestMatch) {
+        text2 = requestMatch[1].trim();
+      }
+      const preview = previewOf3(text2);
+      const isHidden = isFrameworkInjectedUserInput(text2);
+      if (text2 && !isHidden) {
+        if (!firstUserPreview)
+          firstUserPreview = preview;
+        lastUserPreview = preview;
+        turnCount += 1;
+      }
+      pushEvent({
+        index: idx++,
+        timestamp: ts,
+        role: "user",
+        rawType: "antigravity/user",
+        preview,
+        blocks: text2 ? [{ type: "text", text: text2 }] : [],
+        messageId: eventObj.step_index?.toString(),
+        raw: eventObj
+      });
+      continue;
+    }
+    if (eventObj.type === "PLANNER_RESPONSE") {
+      const thinking = eventObj.thinking;
+      const content = eventObj.content;
+      if (thinking) {
+        pushEvent({
+          index: idx++,
+          timestamp: ts,
+          role: "agent-thinking",
+          rawType: "antigravity/thought",
+          preview: previewOf3(thinking),
+          blocks: [{ type: "thinking", thinking }],
+          model,
+          raw: eventObj
+        });
+      }
+      if (content) {
+        const preview = previewOf3(content);
+        lastAgentPreview = preview;
+        pushEvent({
+          index: idx++,
+          timestamp: ts,
+          role: "agent",
+          rawType: "antigravity/agent",
+          preview,
+          blocks: [{ type: "text", text: content }],
+          messageId: eventObj.step_index?.toString(),
+          model,
+          raw: eventObj
+        });
+      }
+      const toolCalls = eventObj.tool_calls || [];
+      for (let cIdx = 0; cIdx < toolCalls.length; cIdx++) {
+        const tc = toolCalls[cIdx];
+        toolCallCount += 1;
+        const toolUseId = `tool-${eventObj.step_index}-${cIdx}`;
+        const argsStr = tc.args ? JSON.stringify(tc.args) : "";
+        pendingToolCalls.push({ id: toolUseId, name: tc.name });
+        pushEvent({
+          index: idx++,
+          timestamp: ts,
+          role: "tool-call",
+          rawType: "antigravity/tool_call",
+          preview: `${tc.name}(${truncate4(argsStr, 80)})`,
+          blocks: [{ type: "tool_use", id: toolUseId, name: tc.name, input: tc.args || {} }],
+          toolName: tc.name,
+          toolUseId,
+          model,
+          raw: tc
+        });
+      }
+      continue;
+    }
+    if (eventObj.source === "MODEL" && eventObj.type !== "PLANNER_RESPONSE" && eventObj.type !== "ERROR_MESSAGE" && pendingToolCalls.length > 0) {
+      const matchedCall = pendingToolCalls.shift();
+      const toolUseId = matchedCall ? matchedCall.id : `tool-${eventObj.step_index}-unknown`;
+      const contentStr = typeof eventObj.content === "string" ? eventObj.content : JSON.stringify(eventObj.content || "");
+      const isError = eventObj.status === "ERROR" || eventObj.status === "FAILED" || eventObj.status === "CANCELED" || !!eventObj.error;
+      pushEvent({
+        index: idx++,
+        timestamp: ts,
+        role: "tool-result",
+        rawType: "antigravity/tool_result",
+        preview: previewOf3(contentStr),
+        blocks: [{
+          type: "tool_result",
+          tool_use_id: toolUseId,
+          content: contentStr,
+          is_error: isError
+        }],
+        toolUseId,
+        toolResult: contentStr,
+        raw: eventObj
+      });
+      continue;
+    }
+    const text = eventObj.content || eventObj.error || "";
+    pushEvent({
+      index: idx++,
+      timestamp: ts,
+      role: "meta",
+      rawType: `antigravity/${eventObj.type?.toLowerCase() || "unknown"}`,
+      preview: previewOf3(text),
+      blocks: text ? [{ type: "text", text }] : [],
+      raw: eventObj
+    });
+  }
+  const startMs = firstTimestamp ? Date.parse(firstTimestamp) : void 0;
+  if (startMs !== void 0 && Number.isFinite(startMs)) {
+    let prevMs;
+    for (const ev of events) {
+      if (!ev.timestamp)
+        continue;
+      const ms = Date.parse(ev.timestamp);
+      if (!Number.isFinite(ms))
+        continue;
+      ev.tOffsetMs = Math.max(0, ms - startMs);
+      if (prevMs !== void 0)
+        ev.gapMs = Math.max(0, ms - prevMs);
+      prevMs = ms;
+    }
+  }
+  const activeSegments = 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 = file.conversationId;
+  const cwd = file.cwd;
+  const projectName = cwd ? canonicalProjectName(cwd) : file.conversationId;
+  const projectDir = cwd ? cwd.replace(/^\//, "-").replace(/\//g, "-") : file.conversationId;
+  const meta = {
+    agent: "antigravity",
+    id: sessionId,
+    filePath: file.filePath,
+    projectName,
+    projectDir,
+    sessionId,
+    firstTimestamp,
+    lastTimestamp,
+    durationMs: durationMs && Number.isFinite(durationMs) ? durationMs : void 0,
+    eventCount: events.length,
+    model,
+    cwd,
+    totalUsage,
+    status: "idle",
+    firstUserPreview,
+    lastUserPreview,
+    lastAgentPreview,
+    toolCallCount,
+    turnCount,
+    airTimeMs,
+    activeSegments
+  };
+  return { meta, events };
+}
+function computeActiveSegments4(tsMs) {
+  if (tsMs.length === 0)
+    return [];
+  const sorted = [...tsMs].sort((a, b) => a - b);
+  const out = [];
+  let segStart = sorted[0];
+  let segEnd = sorted[0];
+  for (let i = 1; i < sorted.length; i++) {
+    if (sorted[i] - segEnd > IDLE_GAP_MS3) {
+      out.push({ startMs: segStart, endMs: segEnd });
+      segStart = sorted[i];
+    }
+    segEnd = sorted[i];
+  }
+  out.push({ startMs: segStart, endMs: segEnd });
+  return out;
+}
+function clearAntigravityCaches() {
+  metaCache4.clear();
+  detailCache4.clear();
+  historyCache = null;
+}
+async function listAntigravitySessions(opts = {}) {
+  const root = opts.root ?? DEFAULT_ANTIGRAVITY_ROOT;
+  const files = await listSessionFiles2(root);
+  const out = [];
+  for (const file of files) {
+    const cached = metaCache4.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, {
+        meta,
+        mtimeMs: file.mtimeMs,
+        sizeBytes: file.sizeBytes,
+        cwd: file.cwd
+      });
+      out.push(meta);
+    } catch {
+    }
+  }
+  out.sort((a, b) => (b.firstTimestamp ?? "").localeCompare(a.firstTimestamp ?? ""));
+  if (opts.limit !== void 0)
+    return out.slice(0, opts.limit);
+  return out;
+}
+async function getAntigravitySession(id, opts = {}) {
+  const root = opts.root ?? DEFAULT_ANTIGRAVITY_ROOT;
+  const files = await listSessionFiles2(root);
+  let chosen;
+  for (const file of files) {
+    if (file.conversationId === id) {
+      chosen = file;
+      break;
+    }
+  }
+  if (!chosen)
+    return null;
+  const cached = detailCache4.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 detail = { ...meta, events };
+  detailCache4.set(chosen.filePath, {
+    detail,
+    mtimeMs: chosen.mtimeMs,
+    sizeBytes: chosen.sizeBytes,
+    cwd: chosen.cwd
+  });
+  return detail;
+}
+function antigravitySessionLocalDay(meta) {
+  if (!meta.firstTimestamp)
+    return void 0;
+  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 init_antigravity = __esm({
+  "../parser/dist/antigravity.js"() {
+    "use strict";
+    init_analytics();
+    init_user_input();
+    DEFAULT_ANTIGRAVITY_ROOT = path4.join(os4.homedir(), ".gemini", "antigravity-cli");
+    IDLE_GAP_MS3 = 3 * 60 * 1e3;
+    historyCache = null;
+    metaCache4 = /* @__PURE__ */ new Map();
+    detailCache4 = /* @__PURE__ */ new Map();
+  }
+});
+
+// ../parser/dist/cowork.js
+import { promises as fs5 } from "node:fs";
+import os5 from "node:os";
+import path5 from "node:path";
+function defaultCoworkRoot() {
+  const home = os5.homedir();
+  if (process.platform === "darwin") {
+    return path5.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");
+  }
+  return path5.join(home, ".config", "Claude", "local-agent-mode-sessions");
+}
+async function safeReaddir4(p) {
+  return fs5.readdir(p).catch(() => []);
+}
+async function statMs(p) {
+  const s = await fs5.stat(p).catch(() => null);
+  return s ? s.mtimeMs : 0;
+}
+async function listSessionFiles3(root) {
+  const out = [];
+  const accounts = await safeReaddir4(root);
+  for (const accountId of accounts) {
+    const accountDir = path5.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 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);
+        if (!auditStat || !auditStat.isFile() || auditStat.size === 0)
+          continue;
+        const metaPath = path5.join(workspaceDir, `${entry}.json`);
+        const metaMtimeMs = await statMs(metaPath);
+        out.push({
+          sessionId: entry,
+          auditPath,
+          metaPath,
+          workspaceDir,
+          auditMtimeMs: auditStat.mtimeMs,
+          auditSize: auditStat.size,
+          metaMtimeMs,
+          spacesMtimeMs
+        });
+      }
+    }
+  }
+  return out;
+}
+async function loadSpacesForWorkspace(workspaceDir) {
+  const spacesPath = path5.join(workspaceDir, "spaces.json");
+  const stat = await fs5.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 out = /* @__PURE__ */ new Map();
+  try {
+    const parsed = JSON.parse(raw);
+    for (const space of parsed.spaces ?? []) {
+      const id = typeof space.id === "string" ? space.id : void 0;
+      const folders = Array.isArray(space.folders) ? space.folders : [];
+      const first = folders[0];
+      const folderPath = typeof first?.path === "string" ? first.path : void 0;
+      if (id && folderPath)
+        out.set(id, folderPath);
+    }
+  } catch {
+  }
+  spacesCache.set(workspaceDir, { mtimeMs: stat.mtimeMs, spaceIdToPath: out });
+  return out;
+}
+async function readCoworkMeta(metaPath) {
+  const raw = await fs5.readFile(metaPath, "utf8").catch(() => "");
+  if (!raw)
+    return {};
+  try {
+    const j = JSON.parse(raw);
+    return {
+      spaceId: typeof j.spaceId === "string" ? j.spaceId : void 0,
+      userSelectedFolders: Array.isArray(j.userSelectedFolders) ? j.userSelectedFolders.filter((s) => typeof s === "string") : void 0,
+      cwd: typeof j.cwd === "string" ? j.cwd : void 0,
+      model: typeof j.model === "string" ? j.model : void 0,
+      title: typeof j.title === "string" ? j.title : void 0,
+      createdAt: typeof j.createdAt === "number" ? j.createdAt : void 0,
+      lastActivityAt: typeof j.lastActivityAt === "number" ? j.lastActivityAt : void 0
+    };
+  } catch {
+    return {};
+  }
+}
+function resolveProject(meta, spaceIdToPath) {
+  let projectPath;
+  if (meta.spaceId)
+    projectPath = spaceIdToPath.get(meta.spaceId);
+  if (!projectPath && meta.userSelectedFolders && meta.userSelectedFolders.length > 0) {
+    projectPath = meta.userSelectedFolders[0];
+  }
+  if (!projectPath) {
+    return { projectName: "cowork:unspaced", projectDir: "cowork-unspaced" };
+  }
+  return {
+    projectName: canonicalProjectName(projectPath),
+    projectDir: projectPath.replace(/^\//, "-").replace(/\//g, "-"),
+    cwd: projectPath
+  };
+}
+async function readJsonl2(filePath) {
+  const raw = await fs5.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;
+}
+async function parseCoworkSession(file) {
+  const [lines, coworkMeta, spaceIdToPath] = await Promise.all([
+    readJsonl2(file.auditPath),
+    readCoworkMeta(file.metaPath),
+    loadSpacesForWorkspace(file.workspaceDir)
+  ]);
+  const { meta: baseMeta, events } = parseTranscript(lines);
+  const { projectName, projectDir, cwd } = resolveProject(coworkMeta, spaceIdToPath);
   const meta = {
-    agent: "gemini",
-    id: sessionId,
-    filePath: file.filePath,
+    ...baseMeta,
+    agent: "cowork",
+    id: file.sessionId,
+    sessionId: file.sessionId,
+    filePath: file.auditPath,
     projectName,
     projectDir,
-    sessionId,
-    firstTimestamp,
-    lastTimestamp,
-    durationMs: durationMs && Number.isFinite(durationMs) ? durationMs : void 0,
-    eventCount: events.length,
-    model,
-    cwd,
-    totalUsage,
-    status: "idle",
-    firstUserPreview,
-    lastUserPreview,
-    lastAgentPreview,
-    toolCallCount,
-    turnCount,
-    airTimeMs,
-    activeSegments
+    cwd: cwd ?? baseMeta.cwd,
+    model: baseMeta.model ?? coworkMeta.model
   };
   return { meta, events };
 }
-function computeActiveSegments3(tsMs) {
-  if (tsMs.length === 0)
-    return [];
-  const sorted = [...tsMs].sort((a, b) => a - b);
-  const out = [];
-  let segStart = sorted[0];
-  let segEnd = sorted[0];
-  for (let i = 1; i < sorted.length; i++) {
-    if (sorted[i] - segEnd > IDLE_GAP_MS2) {
-      out.push({ startMs: segStart, endMs: segEnd });
-      segStart = sorted[i];
-    }
-    segEnd = sorted[i];
-  }
-  out.push({ startMs: segStart, endMs: segEnd });
-  return out;
+function cacheKeyFor(file) {
+  return {
+    auditMtimeMs: file.auditMtimeMs,
+    auditSize: file.auditSize,
+    metaMtimeMs: file.metaMtimeMs,
+    spacesMtimeMs: file.spacesMtimeMs
+  };
 }
-function clearGeminiCaches() {
-  metaCache3.clear();
-  detailCache3.clear();
-  projectsCache = null;
+function cacheKeyMatches(a, b) {
+  return a.auditMtimeMs === b.auditMtimeMs && a.auditSize === b.auditSize && a.metaMtimeMs === b.metaMtimeMs && a.spacesMtimeMs === b.spacesMtimeMs;
 }
-async function listGeminiSessions(opts = {}) {
-  const root = opts.root ?? DEFAULT_GEMINI_ROOT;
-  const files = await listSessionFiles(root);
+function clearCoworkCaches() {
+  metaCache5.clear();
+  detailCache5.clear();
+  spacesCache.clear();
+}
+async function listCoworkSessions(opts = {}) {
+  const root = opts.root ?? DEFAULT_COWORK_ROOT;
+  const files = await listSessionFiles3(root);
   const out = [];
   for (const file of files) {
-    const cached = metaCache3.get(file.filePath);
-    if (cached && cached.mtimeMs === file.mtimeMs && cached.sizeBytes === file.sizeBytes) {
+    const key = cacheKeyFor(file);
+    const cached = metaCache5.get(file.auditPath);
+    if (cached && cacheKeyMatches(cached.key, key)) {
       out.push(cached.meta);
       continue;
     }
     try {
-      const { meta } = await parseSession(file);
-      metaCache3.set(file.filePath, {
-        meta,
-        mtimeMs: file.mtimeMs,
-        sizeBytes: file.sizeBytes
-      });
+      const { meta } = await parseCoworkSession(file);
+      metaCache5.set(file.auditPath, { meta, key });
       out.push(meta);
     } catch {
     }
@@ -2917,59 +3890,38 @@ async function listGeminiSessions(opts = {}) {
     return out.slice(0, opts.limit);
   return out;
 }
-async function getGeminiSession(id, opts = {}) {
-  const root = opts.root ?? DEFAULT_GEMINI_ROOT;
-  const files = await listSessionFiles(root);
-  let chosen;
-  for (const file of files) {
-    if (file.filenameId === id || id.startsWith(file.filenameId)) {
-      chosen = file;
-      break;
-    }
-  }
-  if (!chosen) {
-    for (const file of files) {
-      const { meta: meta2 } = await parseSession(file).catch(() => ({ meta: { id: "" } }));
-      if (meta2.id === id) {
-        chosen = file;
-        break;
-      }
-    }
-  }
-  if (!chosen)
+async function getCoworkSession(id, opts = {}) {
+  const root = opts.root ?? DEFAULT_COWORK_ROOT;
+  const files = await listSessionFiles3(root);
+  const file = files.find((f) => f.sessionId === id);
+  if (!file)
     return null;
-  const cached = detailCache3.get(chosen.filePath);
-  if (cached && cached.mtimeMs === chosen.mtimeMs && cached.sizeBytes === chosen.sizeBytes) {
+  const key = cacheKeyFor(file);
+  const cached = detailCache5.get(file.auditPath);
+  if (cached && cacheKeyMatches(cached.key, key))
     return cached.detail;
-  }
-  const { meta, events } = await parseSession(chosen);
+  const { meta, events } = await parseCoworkSession(file);
   const detail = { ...meta, events };
-  detailCache3.set(chosen.filePath, {
-    detail,
-    mtimeMs: chosen.mtimeMs,
-    sizeBytes: chosen.sizeBytes
-  });
+  detailCache5.set(file.auditPath, { detail, key });
   return detail;
 }
-function geminiSessionLocalDay(meta) {
+function coworkSessionLocalDay(meta) {
   if (!meta.firstTimestamp)
     return void 0;
   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 init_gemini = __esm({
-  "../parser/dist/gemini.js"() {
+var DEFAULT_COWORK_ROOT, SESSION_ID_RE, spacesCache, metaCache5, detailCache5;
+var init_cowork = __esm({
+  "../parser/dist/cowork.js"() {
     "use strict";
     init_analytics();
-    init_user_input();
-    DEFAULT_GEMINI_ROOT = path3.join(os3.homedir(), ".gemini", "tmp");
-    GEMINI_PROJECTS_FILE = path3.join(os3.homedir(), ".gemini", "projects.json");
-    SESSION_FILE_RE = /^session-.+\.(jsonl|json)$/;
-    IDLE_GAP_MS2 = 3 * 60 * 1e3;
-    projectsCache = null;
-    metaCache3 = /* @__PURE__ */ new Map();
-    detailCache3 = /* @__PURE__ */ new Map();
+    init_parser();
+    DEFAULT_COWORK_ROOT = defaultCoworkRoot();
+    SESSION_ID_RE = /^local_[0-9a-f-]+$/;
+    spacesCache = /* @__PURE__ */ new Map();
+    metaCache5 = /* @__PURE__ */ new Map();
+    detailCache5 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -3017,11 +3969,14 @@ var init_team_wire = __esm({
 // ../parser/dist/fs.js
 var fs_exports = {};
 __export(fs_exports, {
+  DEFAULT_ANTIGRAVITY_ROOT: () => DEFAULT_ANTIGRAVITY_ROOT,
   DEFAULT_CODEX_ROOT: () => DEFAULT_CODEX_ROOT,
+  DEFAULT_COWORK_ROOT: () => DEFAULT_COWORK_ROOT,
   DEFAULT_GEMINI_ROOT: () => DEFAULT_GEMINI_ROOT,
   DEFAULT_ROOT: () => DEFAULT_ROOT,
   RICH_ROLLUP_SCHEMA_VERSION: () => RICH_ROLLUP_SCHEMA_VERSION,
   agentSources: () => agentSources,
+  antigravitySessionLocalDay: () => antigravitySessionLocalDay,
   buildCalibrationCurve: () => buildCalibrationCurve,
   cacheStats: () => cacheStats,
   cclensHome: () => cclensHome,
@@ -3029,19 +3984,24 @@ __export(fs_exports, {
   clearCaches: () => clearCaches,
   clearTeamConfig: () => clearTeamConfig,
   codexSessionLocalDay: () => codexSessionLocalDay,
+  coworkSessionLocalDay: () => coworkSessionLocalDay,
   decodeProjectName: () => decodeProjectName,
   findTeamLead: () => findTeamLead,
   geminiSessionLocalDay: () => geminiSessionLocalDay,
   getAgentSource: () => getAgentSource,
+  getAntigravitySession: () => getAntigravitySession,
   getAnySession: () => getAnySession,
   getCodexSession: () => getCodexSession,
+  getCoworkSession: () => getCoworkSession,
   getGeminiSession: () => getGeminiSession,
   getLatestCodexUsage: () => getLatestCodexUsage,
   getSession: () => getSession,
   invalidateFile: () => invalidateFile,
   isFleetlensRuntimeDir: () => isFleetlensRuntimeDir,
   listAllSessions: () => listAllSessions,
+  listAntigravitySessions: () => listAntigravitySessions,
   listCodexSessions: () => listCodexSessions,
+  listCoworkSessions: () => listCoworkSessions,
   listGeminiSessions: () => listGeminiSessions,
   listProjects: () => listProjects,
   listSessions: () => listSessions,
@@ -3050,20 +4010,21 @@ __export(fs_exports, {
   loadCalibrationSnapshots: () => loadCalibrationSnapshots,
   loadTeamForSession: () => loadTeamForSession,
   loadUsageByDay: () => loadUsageByDay,
+  loadWorkflowAgentDetail: () => loadWorkflowAgentDetail,
   readJsonlFile: () => readJsonlFile,
   readTeamConfig: () => readTeamConfig,
   sessionIdFromFileName: () => sessionIdFromFileName,
   walkJsonlFiles: () => walkJsonlFiles,
   writeTeamConfig: () => writeTeamConfig
 });
-import { promises as fs4 } from "node:fs";
-import os4 from "node:os";
-import path4 from "node:path";
+import { promises as fs6 } from "node:fs";
+import os6 from "node:os";
+import path6 from "node:path";
 function cclensHome() {
-  return process.env.CCLENS_HOME || path4.join(os4.homedir(), ".cclens");
+  return process.env.CCLENS_HOME || path6.join(os6.homedir(), ".cclens");
 }
 function cclensPath(...parts) {
-  return path4.join(cclensHome(), ...parts);
+  return path6.join(cclensHome(), ...parts);
 }
 function cacheStats() {
   return claudeCodeCacheStats();
@@ -3072,6 +4033,8 @@ function clearCaches() {
   clearClaudeCodeCaches();
   clearCodexCaches();
   clearGeminiCaches();
+  clearAntigravityCaches();
+  clearCoworkCaches();
 }
 function invalidateFile(fullPath) {
   invalidateClaudeCodeFile(fullPath);
@@ -3103,7 +4066,7 @@ function usageLogPath() {
 async function loadUsageByDay(start, end) {
   let raw;
   try {
-    raw = await fs4.readFile(usageLogPath(), "utf8");
+    raw = await fs6.readFile(usageLogPath(), "utf8");
   } catch {
     return { by_day: [] };
   }
@@ -3148,7 +4111,7 @@ async function loadUsageByDay(start, end) {
 async function loadCalibrationSnapshots() {
   let raw;
   try {
-    raw = await fs4.readFile(usageLogPath(), "utf8");
+    raw = await fs6.readFile(usageLogPath(), "utf8");
   } catch {
     return [];
   }
@@ -3306,7 +4269,7 @@ async function loadCalibrationCurve(tier = "pro-max-20x", root = DEFAULT_ROOT, g
   ]);
   return buildCalibrationCurve(events, snapshots, tier, granularityMin);
 }
-var codexSource, geminiSource, agentSources;
+var codexSource, geminiSource, antigravitySource, coworkSource, agentSources;
 var init_fs = __esm({
   "../parser/dist/fs.js"() {
     "use strict";
@@ -3316,9 +4279,13 @@ var init_fs = __esm({
     init_claude_code();
     init_codex();
     init_gemini();
+    init_antigravity();
+    init_cowork();
     init_claude_code();
     init_codex();
     init_gemini();
+    init_antigravity();
+    init_cowork();
     init_team_config();
     init_team_wire();
     codexSource = {
@@ -3352,7 +4319,33 @@ var init_fs = __esm({
         return getGeminiSession(id);
       }
     };
-    agentSources = [claudeCodeSource, codexSource, geminiSource];
+    antigravitySource = {
+      ...ANTIGRAVITY_METADATA,
+      defaultRoot: DEFAULT_ANTIGRAVITY_ROOT,
+      async listSessions(opts) {
+        return listAntigravitySessions(opts);
+      },
+      async getSession(id) {
+        return getAntigravitySession(id);
+      }
+    };
+    coworkSource = {
+      ...COWORK_METADATA,
+      defaultRoot: DEFAULT_COWORK_ROOT,
+      async listSessions(opts) {
+        return listCoworkSessions(opts);
+      },
+      async getSession(id) {
+        return getCoworkSession(id);
+      }
+    };
+    agentSources = [
+      claudeCodeSource,
+      codexSource,
+      geminiSource,
+      antigravitySource,
+      coworkSource
+    ];
   }
 });
 
@@ -3764,8 +4757,10 @@ var init_aggregate = __esm({
 // ../parser/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
+  ANTIGRAVITY_METADATA: () => ANTIGRAVITY_METADATA,
   CLAUDE_CODE_METADATA: () => CLAUDE_CODE_METADATA,
   CODEX_METADATA: () => CODEX_METADATA,
+  COWORK_METADATA: () => COWORK_METADATA,
   GEMINI_METADATA: () => GEMINI_METADATA,
   PRICES: () => PRICES,
   RATE_PER_PCT: () => RATE_PER_PCT,
@@ -3806,6 +4801,7 @@ __export(dist_exports, {
   predictUtilization: () => predictUtilization,
   priorCalendarMonth: () => priorCalendarMonth,
   priorCalendarWeek: () => priorCalendarWeek,
+  projectRepoName: () => projectRepoName,
   rowPrimaryIndex: () => rowPrimaryIndex,
   sessionAirTimeMs: () => sessionAirTimeMs,
   sessionDay: () => sessionDay,
@@ -3830,10 +4826,198 @@ var init_dist = __esm({
   }
 });
 
+// src/perception/file-probe.ts
+var file_probe_exports = {};
+__export(file_probe_exports, {
+  pathHash: () => pathHash,
+  probeArtifactSignals: () => probeArtifactSignals
+});
+import { createHash } from "node:crypto";
+import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join7, relative, resolve as resolve2, 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 = join7(homedir2(), ".claude");
+  if (existsSync6(home)) roots.push({ root: home, label: "user" });
+  for (const e of extraRoots) {
+    const r = resolve2(e, ".claude");
+    if (existsSync6(r) && r !== home) roots.push({ root: r, label: "project" });
+  }
+  return roots;
+}
+function listMarkdownFiles(dir) {
+  if (!existsSync6(dir)) return [];
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch {
+    return [];
+  }
+  for (const name of entries) {
+    if (name.startsWith(".")) continue;
+    const full = join7(dir, name);
+    let stat;
+    try {
+      stat = statSync3(full);
+    } catch {
+      continue;
+    }
+    if (stat.isDirectory()) {
+      out.push(...listMarkdownFiles(full));
+    } else if (stat.isFile() && name.endsWith(".md")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+function firstSeenDateOf(file) {
+  try {
+    const out = execFileSync2(
+      "git",
+      ["log", "--diff-filter=A", "--follow", "--format=%cs", "--", file],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname6(file) }
+    ).trim().split("\n").filter(Boolean);
+    if (out.length > 0) return out[out.length - 1];
+  } catch {
+  }
+  try {
+    const s = statSync3(file);
+    return new Date((s.birthtime || s.mtime).getTime()).toISOString().slice(0, 10);
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  }
+}
+function dirname6(p) {
+  const i = p.lastIndexOf(sep);
+  return i < 0 ? "." : p.slice(0, i);
+}
+function detectGitEmail(cwd) {
+  try {
+    return execFileSync2("git", ["config", "user.email"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      cwd
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+function todayLocal() {
+  const d = /* @__PURE__ */ new Date();
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function scanAuthored(roots, subdir, day) {
+  const out = [];
+  for (const r of roots) {
+    const dir = join7(r.root, subdir);
+    if (!existsSync6(dir)) continue;
+    for (const f of listMarkdownFiles(dir)) {
+      const firstSeen = firstSeenDateOf(f);
+      if (firstSeen !== day) continue;
+      const rel = relative(dir, f);
+      out.push({ pathHash: pathHash(`${r.label}:${subdir}:${rel}`), firstSeenDate: firstSeen });
+    }
+  }
+  return out;
+}
+function scanEdited(roots, day) {
+  const out = [];
+  for (const r of roots) {
+    const dir = join7(r.root, "skills");
+    if (!existsSync6(dir)) continue;
+    for (const f of listMarkdownFiles(dir)) {
+      const firstSeen = firstSeenDateOf(f);
+      if (firstSeen === day) continue;
+      let stat;
+      try {
+        stat = statSync3(f);
+      } catch {
+        continue;
+      }
+      const mtimeDay = new Date(stat.mtime.getTime()).toISOString().slice(0, 10);
+      if (mtimeDay !== day) continue;
+      const rel = relative(dir, f);
+      out.push({ pathHash: pathHash(`${r.label}:skills:${rel}`), lineDelta: 0 });
+    }
+  }
+  return out;
+}
+function claudemdLineDelta(extraRoots, authorEmail, day) {
+  let delta = 0;
+  const candidates = [];
+  for (const e of extraRoots) {
+    const f = resolve2(e, "CLAUDE.md");
+    if (existsSync6(f)) candidates.push(f);
+  }
+  const homeClaudeMd = join7(homedir2(), "CLAUDE.md");
+  if (existsSync6(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: dirname6(file) }
+      );
+      let currentDate = "";
+      let currentEmail = "";
+      for (const line of out.split("\n")) {
+        if (line.startsWith("COMMIT ")) {
+          const parts = line.slice("COMMIT ".length).trim().split(/\s+/);
+          currentDate = parts[0] ?? "";
+          currentEmail = parts.slice(1).join(" ");
+        } else if (currentDate === day && line.trim().length > 0) {
+          if (authorEmail && currentEmail !== authorEmail) continue;
+          const parts = line.split(/\s+/);
+          const added = Number(parts[0]);
+          const removed = Number(parts[1]);
+          if (Number.isFinite(added) && Number.isFinite(removed)) {
+            delta += added - removed;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return delta;
+}
+function probeArtifactSignals(opts = {}) {
+  const day = opts.day ?? todayLocal();
+  const roots = defaultScanRoots(opts.extraRoots);
+  const skillsAuthored = scanAuthored(roots, "skills", day);
+  const subagentsAuthored = scanAuthored(roots, "agents", day);
+  const slashCommandsAuthored = scanAuthored(roots, "commands", day);
+  const skillsEdited = scanEdited(roots, day);
+  const authorEmail = opts.authorEmail ?? detectGitEmail(opts.extraRoots?.[0] ?? process.cwd()) ?? void 0;
+  const claudemd = claudemdLineDelta(opts.extraRoots ?? [], authorEmail, day);
+  const empty = skillsAuthored.length === 0 && subagentsAuthored.length === 0 && slashCommandsAuthored.length === 0 && skillsEdited.length === 0 && claudemd === 0;
+  if (empty) return null;
+  return {
+    skillsAuthored,
+    skillsEdited,
+    subagentsAuthored,
+    slashCommandsAuthored,
+    claudemdLineDelta: claudemd
+  };
+}
+var init_file_probe = __esm({
+  "src/perception/file-probe.ts"() {
+    "use strict";
+  }
+});
+
 // src/daemon-worker.ts
 import { spawn as spawn2 } from "node:child_process";
-import { appendFileSync as appendFileSync5, closeSync, existsSync as existsSync11, mkdirSync as mkdirSync13, openSync, readFileSync as readFileSync14, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname8, join as join9 } from "node:path";
+import { appendFileSync as appendFileSync5, closeSync, existsSync as existsSync13, mkdirSync as mkdirSync13, openSync, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname10, join as join11 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/usage/token.ts
@@ -3864,9 +5048,9 @@ function readFromCredentialsFile() {
     join(homedir(), ".claude", ".credentials.json"),
     join(homedir(), ".config", "claude", "credentials.json")
   ];
-  for (const path5 of candidates) {
+  for (const path7 of candidates) {
     try {
-      const blob = readFileSync(path5, "utf8");
+      const blob = readFileSync(path7, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -4322,7 +5506,7 @@ function sessionTouchesDay(s, day) {
   }
   return sessionDay(s) === day;
 }
-function buildRichRollupBlocks(day, daySessions, entries, privateProjects) {
+function buildRichRollupBlocks(day, daySessions, entries, privateProjects, resolveRepo) {
   const bounds = dayBoundsMs(day);
   const clippedSessions = [];
   for (const s of daySessions) {
@@ -4332,16 +5516,40 @@ function buildRichRollupBlocks(day, daySessions, entries, privateProjects) {
   }
   const bursts = computeBurstsFromSessions(clippedSessions);
   const stats = summarizeBursts(bursts);
+  const repoForEntry = (e) => {
+    if (resolveRepo) {
+      const own = resolveRepo(e.project);
+      if (own) return own;
+      const counts = /* @__PURE__ */ new Map();
+      for (const d of e.edited_dirs ?? []) {
+        const r = resolveRepo(d);
+        if (r) counts.set(r, (counts.get(r) ?? 0) + 1);
+      }
+      const dominant = [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+      if (dominant) return dominant;
+    }
+    return e.github_repos?.length === 1 ? e.github_repos[0] : null;
+  };
+  const sessionRepo = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    if (privateProjects.has(projectRepoName(e.project)) || privateProjects.has(e.project)) continue;
+    const r = repoForEntry(e);
+    if (r) sessionRepo.set(e.session_id, r);
+  }
   const projects = /* @__PURE__ */ new Map();
   for (const s of clippedSessions) {
-    const name = canonicalProjectName(s.projectName);
-    if (privateProjects.has(name)) continue;
+    const canonical = canonicalProjectName(s.projectName);
+    const name = projectRepoName(s.projectName);
+    if (privateProjects.has(name) || privateProjects.has(canonical)) continue;
+    const repo = resolveRepo?.(canonical) ?? sessionRepo.get(s.id);
+    const key = repo ?? name;
     const ms = s.activeSegments.reduce((sum, seg) => sum + (seg.endMs - seg.startMs), 0);
-    const cur = projects.get(name) ?? { agentTimeMs: 0, sessions: 0 };
+    const cur = projects.get(key) ?? { project: name, agentTimeMs: 0, sessions: 0, ...repo ? { resolved: repo } : {} };
     cur.agentTimeMs += ms;
     cur.sessions += 1;
-    projects.set(name, cur);
+    projects.set(key, cur);
   }
+  const projectRepos = /* @__PURE__ */ new Map();
   const workingShapes = /* @__PURE__ */ new Map();
   const skills = /* @__PURE__ */ new Map();
   const subagents = /* @__PURE__ */ new Map();
@@ -4355,12 +5563,12 @@ function buildRichRollupBlocks(day, daySessions, entries, privateProjects) {
   let longTotalMin = 0;
   let longMaxSingleMin = 0;
   for (const e of entries) {
-    if (privateProjects.has(e.project)) continue;
+    if (privateProjects.has(projectRepoName(e.project)) || privateProjects.has(e.project)) continue;
     const shape = e.signals?.working_shape ?? null;
     if (shape) {
       const cur = workingShapes.get(shape) ?? { sessions: 0, agentTimeMs: 0 };
       cur.sessions += 1;
-      cur.agentTimeMs += e.numbers.active_min * 6e4;
+      cur.agentTimeMs += Math.round(e.numbers.active_min * 6e4);
       workingShapes.set(shape, cur);
     }
     for (const [name, count] of Object.entries(e.skills)) {
@@ -4375,6 +5583,12 @@ function buildRichRollupBlocks(day, daySessions, entries, privateProjects) {
     prs += e.numbers.prs;
     commits += e.numbers.commits;
     pushes += e.numbers.pushes;
+    if (e.github_repos?.length) {
+      const key = sessionRepo.get(e.session_id) ?? projectRepoName(e.project);
+      const set = projectRepos.get(key) ?? /* @__PURE__ */ new Set();
+      for (const r of e.github_repos) set.add(r);
+      projectRepos.set(key, set);
+    }
     if (e.flags.includes("long_autonomous")) {
       longCount += 1;
       longTotalMin += e.numbers.active_min;
@@ -4382,11 +5596,21 @@ function buildRichRollupBlocks(day, daySessions, entries, privateProjects) {
     }
   }
   return {
-    projects: Array.from(projects.entries()).map(([project, v]) => ({ project, ...v })).sort((a, b) => b.agentTimeMs - a.agentTimeMs),
+    projects: Array.from(projects.entries()).map(([key, v]) => {
+      const extras = [...projectRepos.get(key) ?? []].filter((r) => r !== v.resolved);
+      const repos = v.resolved ? [v.resolved, ...extras] : extras;
+      return {
+        project: v.project,
+        agentTimeMs: v.agentTimeMs,
+        sessions: v.sessions,
+        ...repos.length ? { githubRepos: repos.slice(0, 5) } : {}
+      };
+    }).sort((a, b) => b.agentTimeMs - a.agentTimeMs),
     workingShapes: Array.from(workingShapes.entries()).map(([shape, v]) => ({ shape, ...v })).sort((a, b) => b.sessions - a.sessions),
     concurrencyPeak: stats.peakConcurrent,
     parallelMinutes: Math.round(stats.totalParallelMs / 6e4),
-    longAutonomous: { count: longCount, totalMin: longTotalMin, maxSingleMin: longMaxSingleMin },
+    // Wire schema requires integer minutes (active_min is a float).
+    longAutonomous: { count: longCount, totalMin: Math.round(longTotalMin), maxSingleMin: Math.round(longMaxSingleMin) },
     toolErrors,
     skillsLoaded: Array.from(skills.entries()).map(([name, sessions]) => ({ name, sessions })).sort((a, b) => b.sessions - a.sessions),
     subagentsDispatched: Array.from(subagents.entries()).map(([type, count]) => ({ type, count })).sort((a, b) => b.count - a.count),
@@ -4415,10 +5639,10 @@ function buildEnrichedExtras(entries) {
   }
   return { outcomeMix, helpfulnessMix, goalMix };
 }
-function buildRichBlocksForDay(day, daySessions, privateProjects, enrichmentOptIn) {
+function buildRichBlocksForDay(day, daySessions, privateProjects, enrichmentOptIn, resolveRepo) {
   const entries = listEntriesForDay(day);
   if (entries.length === 0) return void 0;
-  const rich = buildRichRollupBlocks(day, daySessions, entries, privateProjects);
+  const rich = buildRichRollupBlocks(day, daySessions, entries, privateProjects, resolveRepo);
   const enriched = enrichmentOptIn ? buildEnrichedExtras(entries) : void 0;
   return enriched ? { rich, enriched } : { rich };
 }
@@ -4427,10 +5651,11 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    ...richRollup || inputs.enrichedExtras ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
+    ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
     ...inputs.enrichedExtras ? { enrichedExtras: inputs.enrichedExtras } : {},
+    ...inputs.artifactSignals ? { artifactSignals: inputs.artifactSignals } : {},
     ...inputs.usageSnapshot ? { usageSnapshot: inputs.usageSnapshot } : {},
     ...inputs.planTier ? { planTier: inputs.planTier } : {},
     ...inputs.cyclePeaks ? { cyclePeaks: inputs.cyclePeaks } : {}
@@ -4450,19 +5675,81 @@ async function pushToTeamServer(config, payload) {
   return { ok: res.ok, status: res.status, body };
 }
 
+// src/team/git-remote.ts
+import { existsSync as existsSync4, readFileSync as readFileSync6, statSync } from "node:fs";
+import { dirname as dirname3, isAbsolute, join as join5, resolve } 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);
+  return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
+}
+function originUrl(configText) {
+  let inOrigin = false;
+  for (const line of configText.split("\n")) {
+    const t = line.trim();
+    if (t.startsWith("[")) {
+      inOrigin = /^\[remote\s+"origin"\]/.test(t);
+      continue;
+    }
+    if (!inOrigin) continue;
+    const m = t.match(/^url\s*=\s*(.+)$/);
+    if (m) return m[1].trim();
+  }
+  return null;
+}
+function gitConfigPathFor(dir) {
+  const dotGit = join5(dir, ".git");
+  const st = statSync(dotGit, { throwIfNoEntry: false });
+  if (!st) return null;
+  if (st.isDirectory()) return join5(dotGit, "config");
+  const m = readFileSync6(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  if (!m) return null;
+  const gd = isAbsolute(m[1]) ? m[1] : resolve(dir, m[1]);
+  const commondirFile = join5(gd, "commondir");
+  if (existsSync4(commondirFile)) {
+    const common = readFileSync6(commondirFile, "utf8").trim();
+    return join5(isAbsolute(common) ? common : resolve(gd, common), "config");
+  }
+  return join5(gd, "config");
+}
+function createRepoResolver() {
+  const cache = /* @__PURE__ */ new Map();
+  return (dir) => {
+    if (!dir || !isAbsolute(dir)) return null;
+    const hit = cache.get(dir);
+    if (hit !== void 0) return hit;
+    let repo = null;
+    try {
+      for (let d = dir; ; d = dirname3(d)) {
+        const config = gitConfigPathFor(d);
+        if (config && existsSync4(config)) {
+          const url = originUrl(readFileSync6(config, "utf8"));
+          repo = url ? parseGithubRemote(url) : null;
+          break;
+        }
+        if (d === dirname3(d)) break;
+      }
+    } catch {
+      repo = null;
+    }
+    cache.set(dir, repo);
+    return repo;
+  };
+}
+
 // src/team/queue.ts
 init_fs();
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, appendFileSync as appendFileSync2, statSync, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname3 } from "node:path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, appendFileSync as appendFileSync2, statSync as statSync2, mkdirSync as mkdirSync5 } from "node:fs";
+import { dirname as dirname4 } 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) {
-  mkdirSync5(dirname3(queuePath), { recursive: true });
+  mkdirSync5(dirname4(queuePath), { recursive: true });
   const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
   appendFileSync2(queuePath, JSON.stringify(entry) + "\n", "utf8");
   try {
-    const { size } = statSync(queuePath);
+    const { size } = statSync2(queuePath);
     if (size > MAX_SIZE_BYTES) {
       pruneOldest(queuePath);
     }
@@ -4472,7 +5759,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync6(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync7(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -4493,7 +5780,7 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync6(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync7(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
@@ -4506,8 +5793,8 @@ init_storage();
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/usage/profile.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname4 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname5 } 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;
@@ -4550,9 +5837,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync4(cachePath)) return null;
+  if (!existsSync5(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync7(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync8(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -4560,7 +5847,7 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync6(dirname4(cachePath), { recursive: true });
+  mkdirSync6(dirname5(cachePath), { recursive: true });
   writeFileSync5(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
@@ -4722,12 +6009,12 @@ async function runTeamBackfill(log3 = noopLog, filePath = USAGE_LOG, configOverr
 // src/team/last-push.ts
 init_fs();
 import { writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, mkdirSync as mkdirSync7 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 var LAST_PUSH_FILE = "team-last-push.json";
 function write(record, dir) {
   const d = dir ?? cclensHome();
   mkdirSync7(d, { recursive: true });
-  writeFileSync6(join5(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
+  writeFileSync6(join6(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);
@@ -4753,6 +6040,7 @@ async function dispatchCommand(command, config, log3) {
 async function runActivityBackfill(command, config, log3) {
   const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   const { toLocalDay: toLocalDay3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { probeArtifactSignals: probeArtifactSignals2 } = await Promise.resolve().then(() => (init_file_probe(), file_probe_exports));
   const days = command.params.days;
   const todayMs = Date.now();
   const targetDayMs = todayMs - (days - 1) * 24 * 60 * 60 * 1e3;
@@ -4778,9 +6066,24 @@ async function runActivityBackfill(command, config, log3) {
       summary: { pushed: 0, fromDay: targetDay }
     };
   }
+  const privateProjects = new Set(config.privateProjects ?? []);
+  const enrichmentOptIn = !!config.enrichmentOptIn;
+  const resolveRepo = createRepoResolver();
   let pushed = 0;
   for (const rollup of rollups) {
-    const payload = buildIngestPayload({ rollup });
+    const daySessions = sessions.filter((s) => sessionTouchesDay(s, rollup.day));
+    const richBlocks = buildRichBlocksForDay(rollup.day, daySessions, privateProjects, enrichmentOptIn, resolveRepo);
+    let artifactSignals = null;
+    try {
+      artifactSignals = probeArtifactSignals2({ day: rollup.day, extraRoots: [process.cwd()] });
+    } catch {
+    }
+    const payload = buildIngestPayload({
+      rollup,
+      richExtras: richBlocks?.rich,
+      enrichedExtras: richBlocks?.enriched,
+      artifactSignals: artifactSignals ?? void 0
+    });
     const result = await pushToTeamServer(config, payload);
     if (!result.ok) {
       return {
@@ -4906,6 +6209,8 @@ async function runTeamSync(log3 = noopLog2, configOverride, options = {}) {
     let lastPushedDay;
     const privateProjects = new Set(config.privateProjects ?? []);
     const enrichmentOptIn = !!config.enrichmentOptIn;
+    const resolveRepo = createRepoResolver();
+    const { probeArtifactSignals: probeArtifactSignals2 } = await Promise.resolve().then(() => (init_file_probe(), file_probe_exports));
     for (let i = 0; i < rollups.length; i++) {
       const rollup = rollups[i];
       const isLatest = i === rollups.length - 1;
@@ -4914,12 +6219,22 @@ async function runTeamSync(log3 = noopLog2, configOverride, options = {}) {
         rollup.day,
         daySessions,
         privateProjects,
-        enrichmentOptIn
+        enrichmentOptIn,
+        resolveRepo
       );
+      let artifactSignals = null;
+      try {
+        artifactSignals = probeArtifactSignals2({
+          day: rollup.day,
+          extraRoots: [process.cwd()]
+        });
+      } catch {
+      }
       const payload = buildIngestPayload({
         rollup,
         richExtras: richBlocks?.rich,
         enrichedExtras: richBlocks?.enriched,
+        artifactSignals: artifactSignals ?? void 0,
         usageSnapshot: isLatest ? usageSnapshot : void 0,
         planTier,
         // Same rationale as usageSnapshot — current cycle data only on the
@@ -5038,8 +6353,8 @@ async function buildCyclePeaksForPush(planTier, loadCurve) {
 // src/perception/worker.ts
 init_dist();
 init_fs();
-import { statSync as statSync2, readFileSync as readFileSync9 } from "node:fs";
-import { basename, dirname as dirname6 } from "node:path";
+import { statSync as statSync4, readFileSync as readFileSync10 } from "node:fs";
+import { basename, dirname as dirname8 } from "node:path";
 
 // ../entries/dist/signals.js
 init_dist();
@@ -5271,7 +6586,7 @@ function viewEvent(ev) {
     cwd: rawCwd
   };
 }
-var IDLE_GAP_MS3 = 3 * 60 * 1e3;
+var IDLE_GAP_MS4 = 3 * 60 * 1e3;
 var INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
 var PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
 var BASH_CHAIN_SPLIT_RE = /\|\||&&|;|\|/;
@@ -5383,7 +6698,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_MS3)
+    if (dt < IDLE_GAP_MS4)
       active += dt;
   }
   closed.push({
@@ -5410,6 +6725,9 @@ function aggregateDay(dayEvents, _sessionFallbackProject) {
   const prTitles = [];
   let commits = 0;
   let pushes = 0;
+  const gitToolUseIds = /* @__PURE__ */ new Set();
+  const githubRepos = /* @__PURE__ */ new Set();
+  const editedDirCounts = /* @__PURE__ */ new Map();
   const modelTurns = /* @__PURE__ */ new Map();
   let totalToolErrors = 0;
   let totalInterrupts = 0;
@@ -5451,11 +6769,23 @@ function aggregateDay(dayEvents, _sessionFallbackProject) {
       } else {
         if (Array.isArray(content)) {
           for (const c of content) {
-            if (c && typeof c === "object" && c.type === "tool_result" && c.is_error) {
+            if (!c || typeof c !== "object" || c.type !== "tool_result")
+              continue;
+            if (c.is_error) {
               totalToolErrors++;
               if (cur)
                 cur.toolErrors++;
             }
+            const tuId = c.tool_use_id;
+            if (tuId && gitToolUseIds.has(tuId)) {
+              const rc = c.content;
+              const text = typeof rc === "string" ? rc : Array.isArray(rc) ? rc.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").join("\n") : "";
+              for (const m of text.matchAll(/(?<![.\w])github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git\b|[/\s"'),]|$)/g)) {
+                if (m[1].toLowerCase() === "user-attachments")
+                  continue;
+                githubRepos.add(`${m[1]}/${m[2]}`.toLowerCase());
+              }
+            }
           }
         }
         if (cur && tsMs !== void 0) {
@@ -5511,10 +6841,6 @@ function aggregateDay(dayEvents, _sessionFallbackProject) {
               if (name === "Skill") {
                 const sk = String(ct.input?.skill ?? "unknown");
                 cur.skills.set(sk, (cur.skills.get(sk) ?? 0) + 1);
-              } else if (name === "ToolSearch") {
-                const q = String(ct.input?.query ?? "");
-                const key = `(ToolSearch: ${trunc(q, 60)})`;
-                cur.skills.set(key, (cur.skills.get(key) ?? 0) + 1);
               }
               if (name === "Agent") {
                 const inp = ct.input ?? {};
@@ -5544,10 +6870,20 @@ function aggregateDay(dayEvents, _sessionFallbackProject) {
                 commits++;
               if (/\bgit\s+push\b/.test(cmd))
                 pushes++;
+              if (ct.id && /\bgit\s+push\b|\bgh\s+pr\s+/.test(cmd))
+                gitToolUseIds.add(ct.id);
             }
             if (eventCwd && (name === "Bash" || name === "Edit" || name === "Write" || name === "Read")) {
               cwdCounts.set(eventCwd, (cwdCounts.get(eventCwd) ?? 0) + 1);
             }
+            if (name === "Edit" || name === "Write" || name === "MultiEdit" || name === "NotebookEdit") {
+              const fp = String(ct.input?.file_path ?? ct.input?.notebook_path ?? "");
+              const slash = fp.lastIndexOf("/");
+              if (slash > 0) {
+                const dir = fp.slice(0, slash);
+                editedDirCounts.set(dir, (editedDirCounts.get(dir) ?? 0) + 1);
+              }
+            }
           }
         }
       }
@@ -5559,7 +6895,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_MS3)
+    if (dt < IDLE_GAP_MS4)
       activeMs2 += dt;
   }
   const tsSortedStrings = dayEvents.map((e) => e.timestamp).filter((t) => !!t).sort();
@@ -5572,6 +6908,8 @@ function aggregateDay(dayEvents, _sessionFallbackProject) {
     prTitles,
     commits,
     pushes,
+    githubRepos: [...githubRepos].slice(0, 5),
+    editedDirs: [...editedDirCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([dir]) => dir),
     modelTurns,
     totalToolErrors,
     totalInterrupts,
@@ -5725,6 +7063,8 @@ function buildEntries(sessionDetail) {
       first_user,
       final_agent,
       pr_titles: agg.prTitles,
+      ...agg.githubRepos.length ? { github_repos: agg.githubRepos } : {},
+      ...agg.editedDirs.length ? { edited_dirs: agg.editedDirs } : {},
       top_tools,
       skills,
       subagents,
@@ -5744,8 +7084,8 @@ function buildEntries(sessionDetail) {
 
 // src/perception/state.ts
 init_fs();
-import { existsSync as existsSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, renameSync as renameSync3 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, renameSync as renameSync3 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
 var STALE_MS = 15 * 60 * 1e3;
 var pathCached = null;
 function statePath() {
@@ -5755,7 +7095,7 @@ function statePath() {
 }
 function readState() {
   const p = statePath();
-  if (!existsSync5(p)) {
+  if (!existsSync7(p)) {
     return {
       sweep_in_progress: false,
       last_sweep_started_at: null,
@@ -5763,12 +7103,12 @@ function readState() {
       file_checkpoints: {}
     };
   }
-  const raw = readFileSync8(p, "utf8");
+  const raw = readFileSync9(p, "utf8");
   return JSON.parse(raw);
 }
 function writeState(s) {
   const p = statePath();
-  mkdirSync8(dirname5(p), { recursive: true });
+  mkdirSync8(dirname7(p), { recursive: true });
   const tmp = `${p}.tmp`;
   writeFileSync7(tmp, JSON.stringify(s, null, 2), "utf8");
   renameSync3(tmp, p);
@@ -5799,18 +7139,18 @@ function updateCheckpoint(jsonlPath, cp) {
 }
 
 // src/perception/scan.ts
-import { readdirSync as readdirSync3 } from "node:fs";
-import { join as join6 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { readdirSync as readdirSync4 } from "node:fs";
+import { join as join8 } from "node:path";
+import { homedir as homedir3 } from "node:os";
 async function listAllSessionJsonls(root) {
-  const projectsRoot = root ?? join6(homedir2(), ".claude", "projects");
+  const projectsRoot = root ?? join8(homedir3(), ".claude", "projects");
   const out = [];
   try {
-    for (const project of readdirSync3(projectsRoot)) {
-      const dir = join6(projectsRoot, project);
+    for (const project of readdirSync4(projectsRoot)) {
+      const dir = join8(projectsRoot, project);
       try {
-        for (const f of readdirSync3(dir)) {
-          if (f.endsWith(".jsonl")) out.push(join6(dir, f));
+        for (const f of readdirSync4(dir)) {
+          if (f.endsWith(".jsonl")) out.push(join8(dir, f));
         }
       } catch {
       }
@@ -5843,10 +7183,10 @@ async function runPerceptionSweep(opts = {}) {
     const files = await listAllSessionJsonls(opts.projectsRoot);
     for (const f of files) {
       try {
-        const stat = statSync2(f);
+        const stat = statSync4(f);
         const prev = state.file_checkpoints[f];
         if (prev && prev.byte_offset >= stat.size) continue;
-        const raw = readFileSync9(f, "utf8");
+        const raw = readFileSync10(f, "utf8");
         const rawLines = raw.split("\n").filter(Boolean).map((l) => {
           try {
             return JSON.parse(l);
@@ -5857,7 +7197,7 @@ async function runPerceptionSweep(opts = {}) {
         if (rawLines.length === 0) continue;
         const { meta, events } = parseTranscript(rawLines);
         const fileName = basename(f);
-        const projectDir = basename(dirname6(f));
+        const projectDir = basename(dirname8(f));
         const sessionId = fileName.replace(/\.jsonl$/, "");
         const sd = {
           ...meta,
@@ -5896,7 +7236,7 @@ async function runPerceptionSweep(opts = {}) {
               const built = buildEntries(detail);
               for (const e of built) {
                 try {
-                  const stat = statSync2(meta.filePath);
+                  const stat = statSync4(meta.filePath);
                   e.source_checkpoint.byte_offset = stat.size;
                 } catch {
                 }
@@ -6398,8 +7738,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path5, errorMaps, issueData } = params;
-  const fullPath = [...path5, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -6515,11 +7855,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path5, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path5;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -10053,14 +11393,14 @@ var ENRICHMENT_SYSTEM_PROMPT = SYSTEM_PROMPT;
 // ../entries/dist/llm-runner.js
 init_fs();
 import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync10, appendFileSync as appendFileSync3, writeFileSync as writeFileSync9, existsSync as existsSync7 } from "node:fs";
-import { join as join8 } from "node:path";
+import { mkdirSync as mkdirSync10, appendFileSync as appendFileSync3, writeFileSync as writeFileSync9, existsSync as existsSync9 } from "node:fs";
+import { join as join10 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, existsSync as existsSync6, readdirSync as readdirSync4, realpathSync, readFileSync as readFileSync10, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
-import { join as join7 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, existsSync as existsSync8, readdirSync as readdirSync5, realpathSync, readFileSync as readFileSync11, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
+import { join as join9 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 import { spawnSync } from "node:child_process";
 var TmuxUnavailableError = class extends Error {
   constructor(message) {
@@ -10088,16 +11428,16 @@ function tmuxRunnerAvailable() {
   return { ok: true };
 }
 function runtimeCwd() {
-  const dir = join7(homedir3(), ".cclens", "runtime");
-  if (!existsSync6(dir))
+  const dir = join9(homedir4(), ".cclens", "runtime");
+  if (!existsSync8(dir))
     mkdirSync9(dir, { recursive: true });
   return realpathSync(dir);
 }
 function ensureRuntimeCwdTrusted(cwd) {
-  const cfgPath = join7(homedir3(), ".claude.json");
+  const cfgPath = join9(homedir4(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync10(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync11(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -10140,9 +11480,9 @@ async function runClaudeUnderTmuxImpl(args) {
   ensureRuntimeCwdTrusted(cwd);
   const runId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const sessionName = `cclens-${runId}`;
-  const systemFile = join7(cwd, `system-${runId}.txt`);
-  const userFile = join7(cwd, `user-${runId}.txt`);
-  const wrapper = join7(cwd, `run-${runId}.sh`);
+  const systemFile = join9(cwd, `system-${runId}.txt`);
+  const userFile = join9(cwd, `user-${runId}.txt`);
+  const wrapper = join9(cwd, `run-${runId}.sh`);
   writeFileSync8(systemFile, args.systemPrompt);
   writeFileSync8(userFile, args.reminder ? `${args.userPrompt}
 
@@ -10221,35 +11561,35 @@ function num(v) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var PROJECTS_ROOT = () => join7(homedir3(), ".claude", "projects");
+var PROJECTS_ROOT = () => join9(homedir4(), ".claude", "projects");
 function snapshotAllTranscripts() {
   const out = /* @__PURE__ */ new Set();
   const root = PROJECTS_ROOT();
   let subs;
   try {
-    subs = readdirSync4(root);
+    subs = readdirSync5(root);
   } catch {
     return out;
   }
   for (const sub of subs) {
-    const dir = join7(root, sub);
+    const dir = join9(root, sub);
     let files;
     try {
-      files = readdirSync4(dir);
+      files = readdirSync5(dir);
     } catch {
       continue;
     }
     for (const f of files) {
       if (f.endsWith(".jsonl"))
-        out.add(join7(dir, f));
+        out.add(join9(dir, f));
     }
   }
   return out;
 }
-function readJsonlCwd(path5, maxLines = 8) {
+function readJsonlCwd(path7, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync10(path5, "utf8");
+    raw = readFileSync11(path7, "utf8");
   } catch {
     return void 0;
   }
@@ -10277,22 +11617,22 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
     const root = PROJECTS_ROOT();
     let subs;
     try {
-      subs = readdirSync4(root);
+      subs = readdirSync5(root);
     } catch {
       subs = [];
     }
     for (const sub of subs) {
-      const dir = join7(root, sub);
+      const dir = join9(root, sub);
       let files;
       try {
-        files = readdirSync4(dir);
+        files = readdirSync5(dir);
       } catch {
         continue;
       }
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const full = join7(dir, f);
+        const full = join9(dir, f);
         if (existingBefore.has(full))
           continue;
         if (readJsonlCwd(full) === targetCwd)
@@ -10303,10 +11643,10 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
   }
   throw new TmuxRunError(`timeout waiting for claude to create the session transcript (cwd: ${targetCwd})`);
 }
-function parseTranscript2(path5, defaultModel) {
+function parseTranscript2(path7, defaultModel) {
   let raw;
   try {
-    raw = readFileSync10(path5, "utf8");
+    raw = readFileSync11(path7, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -10366,7 +11706,7 @@ function cleanup(cwd, runId, tmuxBin, sessionName, transcriptPath) {
     }
     for (const f of [`system-${runId}.txt`, `user-${runId}.txt`, `run-${runId}.sh`]) {
       try {
-        unlinkSync3(join7(cwd, f));
+        unlinkSync3(join9(cwd, f));
       } catch {
       }
     }
@@ -10381,7 +11721,7 @@ function shellEscape(s) {
 // ../entries/dist/llm-runner.js
 var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync7(RUNS_DIR)) {
+  if (!existsSync9(RUNS_DIR)) {
     try {
       mkdirSync10(RUNS_DIR, { recursive: true });
     } catch {
@@ -10410,17 +11750,17 @@ function newRunId(kind) {
   return `${ts}_${kind}_${short}`;
 }
 function tracePath(runId) {
-  return join8(RUNS_DIR, `${runId}.jsonl`);
+  return join10(RUNS_DIR, `${runId}.jsonl`);
 }
-function safeAppend(path5, line) {
+function safeAppend(path7, line) {
   try {
-    appendFileSync3(path5, line);
+    appendFileSync3(path7, line);
   } catch {
   }
 }
-function safeWrite(path5, line) {
+function safeWrite(path7, line) {
   try {
-    writeFileSync9(path5, line);
+    writeFileSync9(path7, line);
   } catch {
   }
 }
@@ -10498,7 +11838,7 @@ async function runClaudeSubprocess(args) {
   return runClaudePrintMode(args);
 }
 function runClaudePrintMode(args) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     ensureRunsDir();
     const kind = detectKindFromSystemPrompt(args.systemPrompt);
     const runId = newRunId(kind);
@@ -10629,7 +11969,7 @@ ${args.reminder}` : args.userPrompt;
         reject(new Error(`claude exited ${code}: ${stderr.trim().slice(0, 300)}`));
         return;
       }
-      resolve({ content: buffer, input_tokens: inputTokens, output_tokens: outputTokens, model: modelUsed });
+      resolve3({ content: buffer, input_tokens: inputTokens, output_tokens: outputTokens, model: modelUsed });
     });
     proc.on("error", (err) => {
       safeAppend(trace, JSON.stringify({ _meta: { type: "spawn_error", run_id: runId, ts: (/* @__PURE__ */ new Date()).toISOString(), error: err.message } }) + "\n");
@@ -10809,8 +12149,8 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 
 // ../entries/dist/budget.js
 init_fs();
-import { appendFileSync as appendFileSync4, readFileSync as readFileSync11, existsSync as existsSync8, mkdirSync as mkdirSync11 } from "node:fs";
-import { dirname as dirname7 } from "node:path";
+import { appendFileSync as appendFileSync4, readFileSync as readFileSync12, existsSync as existsSync10, mkdirSync as mkdirSync11 } from "node:fs";
+import { dirname as dirname9 } from "node:path";
 var spendPathCached = null;
 function spendPath() {
   if (spendPathCached)
@@ -10820,17 +12160,17 @@ function spendPath() {
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync11(dirname7(p), { recursive: true });
+  mkdirSync11(dirname9(p), { recursive: true });
   appendFileSync4(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync8(p))
+  if (!existsSync10(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync11(p, "utf8");
+  const raw = readFileSync12(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -10852,7 +12192,7 @@ function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
 
 // ../entries/dist/pipeline-lock.js
 init_fs();
-import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync9, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
+import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync11, readFileSync as readFileSync13, statSync as statSync5 } from "node:fs";
 var STALE_MS2 = 60 * 1e3;
 var HEARTBEAT_MS = 30 * 1e3;
 var lockPathCached = null;
@@ -10898,13 +12238,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync9(p))
+  if (!existsSync11(p))
     return false;
   try {
-    const mtime = statSync3(p).mtimeMs;
+    const mtime = statSync5(p).mtimeMs;
     if (nowMs - mtime > STALE_MS2)
       return false;
-    const pid = Number(readFileSync12(p, "utf8").trim());
+    const pid = Number(readFileSync13(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -10919,7 +12259,7 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync11, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync12, existsSync as existsSync10 } from "node:fs";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync11, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync12, existsSync as existsSync12 } from "node:fs";
 init_fs();
 var DEFAULT_SETTINGS = {
   ai_features: {
@@ -10951,10 +12291,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync10(p))
+  if (!existsSync12(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync13(p, "utf8");
+    const raw = readFileSync14(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -11127,7 +12467,7 @@ function rollupOutcomeDay(entries) {
     return "exploratory";
   return "trivial";
 }
-function truncate4(s, max) {
+function truncate5(s, max) {
   if (s.length <= max)
     return s;
   return s.slice(0, max - 1).trimEnd() + "\u2026";
@@ -11183,7 +12523,7 @@ function computeDaySignals(entries) {
     type,
     count: v.count,
     sample_description: v.sample_description,
-    sample_prompt_preview: truncate4(v.sample_prompt_preview, 200)
+    sample_prompt_preview: truncate5(v.sample_prompt_preview, 200)
   }));
   const frameCounts = /* @__PURE__ */ new Map();
   for (const s of signalsList) {
@@ -11202,7 +12542,7 @@ function computeDaySignals(entries) {
     if ((e.first_user ?? "").length > 0)
       verbosity_distribution[s.verbosity] += 1;
     for (const ref of s.external_refs) {
-      external_refs.push({ session_id: e.session_id, kind: ref.kind, preview: truncate4(ref.preview, 200) });
+      external_refs.push({ session_id: e.session_id, kind: ref.kind, preview: truncate5(ref.preview, 200) });
     }
     const ints = e.numbers.interrupts ?? 0;
     interrupts += ints;
@@ -12045,7 +13385,7 @@ function computeInteractionModes(entries) {
       date: entry.local_day,
       project_display: prettyProject3(entry.project),
       type: sa.type,
-      prompt_preview: truncate5(sa.prompt_preview, 200)
+      prompt_preview: truncate6(sa.prompt_preview, 200)
     });
   }
   const skillExamples = [];
@@ -12062,7 +13402,7 @@ function computeInteractionModes(entries) {
       skillExamples.push({
         date: e.local_day,
         skill,
-        first_user_preview: truncate5(e.first_user, 200)
+        first_user_preview: truncate6(e.first_user, 200)
       });
     }
   }
@@ -12079,7 +13419,7 @@ function computeInteractionModes(entries) {
     project_display: prettyProject3(longestTurnEntry.project),
     active_min: longestTurnEntry.numbers.active_min,
     top_tools: longestTurnEntry.top_tools.slice(0, 5),
-    first_user_preview: truncate5(longestTurnEntry.first_user, 200)
+    first_user_preview: truncate6(longestTurnEntry.first_user, 200)
   } : null;
   const tools_per_turn = turn_count > 0 ? tools_total / turn_count : 0;
   const label = tools_per_turn < 5 ? "rapid" : tools_per_turn < 15 ? "mixed" : "batch";
@@ -12110,7 +13450,7 @@ function computeInteractionModes(entries) {
     }
   };
 }
-function truncate5(s, max) {
+function truncate6(s, max) {
   if (s.length <= max)
     return s;
   return s.slice(0, max - 1).trimEnd() + "\u2026";
@@ -12167,7 +13507,7 @@ function computeWorkingShapes(dayDigests, entriesByDay = /* @__PURE__ */ new Map
         evidence_subagent = {
           type: sa.type,
           description: sa.description,
-          prompt_preview: truncate5(sa.prompt_preview, 200)
+          prompt_preview: truncate6(sa.prompt_preview, 200)
         };
       }
       const project_display = repEntry ? prettyProject3(repEntry.project) : dd.projects[0]?.display_name ?? "";
@@ -12178,7 +13518,7 @@ function computeWorkingShapes(dayDigests, entriesByDay = /* @__PURE__ */ new Map
         outcome: dayOutcome.get(dd.key) ?? null,
         helpfulness: dayHelp.get(dd.key) ?? null,
         evidence_subagent,
-        evidence_first_user: repEntry?.first_user ? truncate5(repEntry.first_user, 200) : null,
+        evidence_first_user: repEntry?.first_user ? truncate6(repEntry.first_user, 200) : null,
         day_signature: dd.day_signature ?? null
       };
     });
@@ -12253,7 +13593,7 @@ function computeInteractionGrammar(dayDigests, entriesByDay = /* @__PURE__ */ ne
         date: day,
         session_id: ref.session_id,
         ref_kind: ref.kind,
-        preview: truncate5(ref.preview, 200)
+        preview: truncate6(ref.preview, 200)
       });
     }
     total_interrupts += signals.comm_style.steering.interrupts;
@@ -12325,7 +13665,7 @@ function computeInteractionGrammar(dayDigests, entriesByDay = /* @__PURE__ */ ne
       count: v.count,
       days: [...v.days].sort(),
       sample_description: v.sample_description,
-      sample_prompt_preview: truncate5(v.sample_prompt_preview, 200)
+      sample_prompt_preview: truncate6(v.sample_prompt_preview, 200)
     })),
     threads,
     communication_style: {
@@ -12625,7 +13965,7 @@ var MonthDigestResponseSchema = external_exports.object({
 }).passthrough();
 
 // ../entries/dist/top-sessions.js
-var IDLE_GAP_MS4 = 3 * 60 * 1e3;
+var IDLE_GAP_MS5 = 3 * 60 * 1e3;
 var LONG_AUTONOMOUS_MIN = 20;
 var N_USER = 150;
 var N_FIRST_AGENT = 150;
@@ -12656,7 +13996,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_MS4)
+    if (dt < IDLE_GAP_MS5)
       active += dt;
   }
   return active;
@@ -12830,7 +14170,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_MS4) {
+      if (dt >= IDLE_GAP_MS5) {
         intervals.push({
           start_min: fmtMin(intStart - sliceStartMs),
           end_min: fmtMin(intEnd - sliceStartMs)
@@ -13711,14 +15051,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.11.2",
+    current: "0.12.0",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.11.2",
+    current: "0.12.0",
     latest,
-    updateAvailable: shouldUpdate("0.11.2", latest)
+    updateAvailable: shouldUpdate("0.12.0", latest)
   };
 }
 
@@ -13728,7 +15068,7 @@ 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;
-mkdirSync13(dirname8(USAGE_LOG3), { recursive: true });
+mkdirSync13(dirname10(USAGE_LOG3), { recursive: true });
 function log2(level, message) {
   const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${level.toUpperCase()} ${message}
 `;
@@ -13770,7 +15110,7 @@ var perceptionHandle = setInterval(async () => {
 }, PERCEPTION_INTERVAL_MS);
 function readUpdateState() {
   try {
-    return JSON.parse(readFileSync14(UPDATE_STATE, "utf8"));
+    return JSON.parse(readFileSync15(UPDATE_STATE, "utf8"));
   } catch {
     return null;
   }
@@ -13790,7 +15130,7 @@ function nextUpdateCheckFromState(nowMs) {
 }
 var nextUpdateCheckAtMs = nextUpdateCheckFromState(Date.now());
 function cliEntryPath() {
-  return join9(dirname8(fileURLToPath(import.meta.url)), "index.js");
+  return join11(dirname10(fileURLToPath(import.meta.url)), "index.js");
 }
 async function runDaemonUpdateCheck() {
   if (process.env.FLEETLENS_DAEMON_AUTO_UPDATE === "0") {
@@ -13819,7 +15159,7 @@ async function runDaemonUpdateCheck() {
       return;
     }
     const entry = cliEntryPath();
-    if (!existsSync11(entry)) {
+    if (!existsSync13(entry)) {
       log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
       return;
     }
@@ -13911,7 +15251,7 @@ function scheduleAfter(now, outcome) {
   nextPollAtMs = now + currentIntervalMs;
 }
 function sleep2(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function runLoop() {
   while (true) {