fleetlens 0.11.2 → 0.12.1

package/dist/index.js

@@ -92,6 +92,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);
@@ -100,6 +110,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) {
@@ -113,8 +126,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,
@@ -155,7 +176,19 @@ function dailyActivity(sessions) {
   };
   for (const s of sessions) {
     const startDay = sessionDay(s);
-    if (startDay) {
+    if (s.dailyBreakdown && s.dailyBreakdown.length > 0) {
+      for (const d of s.dailyBreakdown) {
+        const bucket = touchBucket(d.day);
+        bucket.toolCalls += d.toolCalls;
+        bucket.turns += d.turns;
+        bucket.tokens.input += d.tokens.input;
+        bucket.tokens.output += d.tokens.output;
+        bucket.tokens.cacheRead += d.tokens.cacheRead;
+        bucket.tokens.cacheWrite += d.tokens.cacheWrite;
+      }
+      if (startDay)
+        touchBucket(startDay).durationMs += s.durationMs ?? 0;
+    } else if (startDay) {
       const bucket = touchBucket(startDay);
       bucket.toolCalls += s.toolCallCount ?? 0;
       bucket.turns += s.turnCount ?? 0;
@@ -165,31 +198,30 @@ function dailyActivity(sessions) {
       bucket.tokens.cacheWrite += s.totalUsage.cacheWrite;
       bucket.durationMs += s.durationMs ?? 0;
     }
+    const presenceDays = /* @__PURE__ */ new Set();
     const segments = s.activeSegments;
     if (segments && segments.length > 0) {
-      const touchedDays = /* @__PURE__ */ new Set();
       for (const seg of segments) {
         let cur = seg.startMs;
         while (cur < seg.endMs) {
           const day2 = toLocalDay(cur);
-          touchedDays.add(day2);
+          presenceDays.add(day2);
           const d = new Date(cur);
           d.setHours(24, 0, 0, 0);
           const dayEndMs = Math.min(d.getTime(), seg.endMs);
-          const bucket = touchBucket(day2);
-          bucket.airTimeMs += dayEndMs - cur;
+          touchBucket(day2).airTimeMs += dayEndMs - cur;
           cur = dayEndMs;
         }
       }
-      for (const day2 of touchedDays) {
-        const bucket = touchBucket(day2);
-        bucket.sessions++;
-      }
     } else if (startDay) {
-      const bucket = touchBucket(startDay);
-      bucket.sessions++;
-      bucket.airTimeMs += s.airTimeMs ?? 0;
+      presenceDays.add(startDay);
+      touchBucket(startDay).airTimeMs += s.airTimeMs ?? 0;
     }
+    if (s.dailyBreakdown)
+      for (const d of s.dailyBreakdown)
+        presenceDays.add(d.day);
+    for (const day2 of presenceDays)
+      touchBucket(day2).sessions++;
   }
   const range = minDay && maxDay ? daysBetween(minDay, maxDay) : [];
   const out = [];
@@ -534,13 +566,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,
@@ -582,7 +614,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";
@@ -593,6 +625,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+["']([^"']+)["']/;
@@ -606,7 +640,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";
@@ -631,10 +665,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));
   }
@@ -1216,9 +1266,31 @@ function parseTranscript(rawLines) {
   let linesAdded = 0;
   let linesRemoved = 0;
   const filesEdited = /* @__PURE__ */ new Set();
+  const perDay = /* @__PURE__ */ new Map();
+  const fallbackDay = startMs !== void 0 ? toLocalDay(startMs) : void 0;
+  const dayBucket = (ts) => {
+    let day2;
+    if (ts) {
+      const ms = Date.parse(ts);
+      if (!Number.isNaN(ms))
+        day2 = toLocalDay(ms);
+    }
+    day2 = day2 ?? fallbackDay;
+    if (!day2)
+      return void 0;
+    let b = perDay.get(day2);
+    if (!b) {
+      b = { toolCalls: 0, turns: 0, tokens: { ...BLANK_USAGE2 } };
+      perDay.set(day2, b);
+    }
+    return b;
+  };
   for (const e of events) {
     if (e.role === "tool-call") {
       toolCallCount++;
+      const tcDay = dayBucket(e.timestamp);
+      if (tcDay)
+        tcDay.toolCalls++;
       const toolBlock = e.blocks.find((b) => b && b.type === "tool_use");
       if (toolBlock) {
         const input = toolBlock.input ?? {};
@@ -1255,6 +1327,9 @@ function parseTranscript(rawLines) {
           firstUserPreview = e.teammateMessage ? e.teammateMessage.body : e.preview;
         }
         turnCount++;
+        const turnDay = dayBucket(e.timestamp);
+        if (turnDay)
+          turnDay.turns++;
         lastUserPreview = e.preview;
       }
     }
@@ -1296,6 +1371,14 @@ function parseTranscript(rawLines) {
           totalUsage.output += u.output;
           totalUsage.cacheRead += u.cacheRead;
           totalUsage.cacheWrite += u.cacheWrite;
+          const ts = typeof o.timestamp === "string" ? o.timestamp : void 0;
+          const b = dayBucket(ts);
+          if (b) {
+            b.tokens.input += u.input;
+            b.tokens.output += u.output;
+            b.tokens.cacheRead += u.cacheRead;
+            b.tokens.cacheWrite += u.cacheWrite;
+          }
         }
       }
     }
@@ -1319,6 +1402,7 @@ function parseTranscript(rawLines) {
       lastAgentPreview,
       toolCallCount,
       turnCount,
+      dailyBreakdown: Array.from(perDay.entries()).map(([day2, v]) => ({ day: day2, toolCalls: v.toolCalls, turns: v.turns, tokens: v.tokens })).sort((a, b) => a.day.localeCompare(b.day)),
       airTimeMs,
       activeSegments,
       linesAdded,
@@ -1337,6 +1421,7 @@ var init_parser = __esm({
   "../parser/dist/parser.js"() {
     "use strict";
     init_user_input();
+    init_analytics();
     BLANK_USAGE2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
     TEAMMATE_MSG_RE = /^\s*<teammate-message\s+teammate_id="([^"]+)"[^>]*>([\s\S]*?)<\/teammate-message>/;
   }
@@ -1610,7 +1695,7 @@ async function loadCalibrationEvents(root = DEFAULT_ROOT) {
   out.sort((a, b) => a.ts.localeCompare(b.ts));
   return out;
 }
-function aggregateUsageFromLines(lines, seenKeys, usage2) {
+function aggregateUsageFromLines(lines, seenKeys, usage2, perDay, fallbackDay) {
   for (const raw of lines) {
     if (!raw || typeof raw !== "object")
       continue;
@@ -1630,35 +1715,131 @@ function aggregateUsageFromLines(lines, seenKeys, usage2) {
     const u = m.usage;
     if (u) {
       const toNum = (v) => typeof v === "number" ? v : 0;
-      usage2.input += toNum(u.input_tokens);
-      usage2.output += toNum(u.output_tokens);
-      usage2.cacheRead += toNum(u.cache_read_input_tokens);
-      usage2.cacheWrite += toNum(u.cache_creation_input_tokens);
+      const inp = toNum(u.input_tokens);
+      const out = toNum(u.output_tokens);
+      const cr = toNum(u.cache_read_input_tokens);
+      const cw = toNum(u.cache_creation_input_tokens);
+      usage2.input += inp;
+      usage2.output += out;
+      usage2.cacheRead += cr;
+      usage2.cacheWrite += cw;
+      if (perDay) {
+        let day2;
+        const ts = typeof r.timestamp === "string" ? r.timestamp : void 0;
+        if (ts) {
+          const ms = Date.parse(ts);
+          if (!Number.isNaN(ms))
+            day2 = toLocalDay(ms);
+        }
+        day2 = day2 ?? fallbackDay;
+        if (day2) {
+          let d = perDay.get(day2);
+          if (!d) {
+            d = { ...BLANK_USAGE3 };
+            perDay.set(day2, d);
+          }
+          d.input += inp;
+          d.output += out;
+          d.cacheRead += cr;
+          d.cacheWrite += cw;
+        }
+      }
     }
   }
 }
-async function computeSessionUsageWithSubagents(parentLines, projectDirPath, sessionId) {
+async function computeSessionUsageWithSubagents(parentLines, projectDirPath, sessionId, fallbackDay) {
   const usage2 = { ...BLANK_USAGE3 };
   const seenKeys = /* @__PURE__ */ new Set();
-  aggregateUsageFromLines(parentLines, seenKeys, usage2);
+  const perDay = /* @__PURE__ */ new Map();
+  aggregateUsageFromLines(parentLines, seenKeys, usage2, perDay, fallbackDay);
   const subagentsDir = path.join(projectDirPath, sessionId, "subagents");
   let entries2;
   try {
     entries2 = await fs.readdir(subagentsDir);
   } catch {
-    return usage2;
+    return { usage: usage2, perDay };
   }
   const jsonlFiles = entries2.filter((f) => f.endsWith(".jsonl"));
   if (jsonlFiles.length === 0)
-    return usage2;
+    return { usage: usage2, perDay };
   await Promise.all(jsonlFiles.map(async (f) => {
     try {
       const lines = await readJsonlFile(path.join(subagentsDir, f));
-      aggregateUsageFromLines(lines, seenKeys, usage2);
+      aggregateUsageFromLines(lines, seenKeys, usage2, perDay, fallbackDay);
     } catch {
     }
   }));
-  return usage2;
+  return { usage: usage2, perDay };
+}
+function mergeDailyTokens(base, perDayTokens, totalUsage) {
+  const counts = new Map((base ?? []).map((d) => [d.day, d]));
+  const days = /* @__PURE__ */ new Set([...counts.keys(), ...perDayTokens.keys()]);
+  const out = [...days].sort((a, b) => a.localeCompare(b)).map((day2) => ({
+    day: day2,
+    toolCalls: counts.get(day2)?.toolCalls ?? 0,
+    turns: counts.get(day2)?.turns ?? 0,
+    tokens: { ...perDayTokens.get(day2) ?? BLANK_USAGE3 }
+  }));
+  if (out.length > 0) {
+    const summed = out.reduce((a, r) => ({
+      input: a.input + r.tokens.input,
+      output: a.output + r.tokens.output,
+      cacheRead: a.cacheRead + r.tokens.cacheRead,
+      cacheWrite: a.cacheWrite + r.tokens.cacheWrite
+    }), { ...BLANK_USAGE3 });
+    const first = out[0].tokens;
+    first.input += totalUsage.input - summed.input;
+    first.output += totalUsage.output - summed.output;
+    first.cacheRead += totalUsage.cacheRead - summed.cacheRead;
+    first.cacheWrite += totalUsage.cacheWrite - summed.cacheWrite;
+  }
+  return out;
+}
+async function scanWorkflowAggregate(projectDirPath, sessionId) {
+  const dir = path.join(projectDirPath, sessionId, "workflows");
+  let entries2;
+  try {
+    entries2 = await fs.readdir(dir);
+  } catch {
+    return { workflowCount: 0, spawnedAgentCount: 0, spans: [] };
+  }
+  const jsonFiles = entries2.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);
@@ -1670,13 +1851,19 @@ async function getCachedMeta(f) {
     const { meta } = parseTranscript(rawLines);
     const sessionId = sessionIdFromFileName(f.fileName);
     const projectDirPath = path.dirname(f.fullPath);
-    meta.totalUsage = await computeSessionUsageWithSubagents(rawLines, projectDirPath, sessionId);
+    const fallbackDay = meta.firstTimestamp ? toLocalDay(Date.parse(meta.firstTimestamp)) : void 0;
+    const { usage: usage2, perDay: perDayTokens } = await computeSessionUsageWithSubagents(rawLines, projectDirPath, sessionId, fallbackDay);
+    meta.totalUsage = usage2;
+    meta.dailyBreakdown = mergeDailyTokens(meta.dailyBreakdown, perDayTokens, usage2);
+    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;
@@ -1692,13 +1879,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 };
@@ -1730,8 +1921,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;
@@ -1921,6 +2122,248 @@ async function loadSubagents(dir, sessionStartMs, parentEvents) {
   }));
   return runs2.filter((r) => r !== null).sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
 }
+async function loadWorkflows(dir, sessionStartMs, parentEvents) {
+  let entries2;
+  try {
+    entries2 = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+  const jsonFiles = entries2.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 runs2 = 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 runs2.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();
@@ -1942,10 +2385,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()
@@ -1955,7 +2398,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,
@@ -2919,11 +3362,404 @@ async function listGeminiSessions(opts = {}) {
       continue;
     }
     try {
-      const { meta } = await parseSession(file);
-      metaCache3.set(file.filePath, {
+      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 entries2 = await safeReaddir3(brainDir);
+  for (const entry of entries2) {
+    const transcriptPath = path4.join(brainDir, entry, ".system_generated", "logs", "transcript.jsonl");
+    const stat = await fs4.stat(transcriptPath).catch(() => null);
+    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
+        sizeBytes: file.sizeBytes,
+        cwd: file.cwd
       });
       out.push(meta);
     } catch {
@@ -2934,59 +3770,274 @@ 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);
+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.filenameId === id || id.startsWith(file.filenameId)) {
+    if (file.conversationId === id) {
       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) {
+  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 parseSession(chosen);
+  const { meta, events } = await parseSession2(chosen);
   const detail = { ...meta, events };
-  detailCache3.set(chosen.filePath, {
+  detailCache4.set(chosen.filePath, {
     detail,
     mtimeMs: chosen.mtimeMs,
-    sizeBytes: chosen.sizeBytes
+    sizeBytes: chosen.sizeBytes,
+    cwd: chosen.cwd
   });
   return detail;
 }
-function geminiSessionLocalDay(meta) {
+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_GEMINI_ROOT, GEMINI_PROJECTS_FILE, SESSION_FILE_RE, IDLE_GAP_MS2, projectsCache, metaCache3, detailCache3;
-var init_gemini = __esm({
-  "../parser/dist/gemini.js"() {
+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_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();
+    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 entries2 = await safeReaddir4(workspaceDir);
+      for (const entry of entries2) {
+        if (!SESSION_ID_RE.test(entry))
+          continue;
+        const auditPath = path5.join(workspaceDir, entry, "audit.jsonl");
+        const auditStat = await fs5.stat(auditPath).catch(() => null);
+        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 = {
+    ...baseMeta,
+    agent: "cowork",
+    id: file.sessionId,
+    sessionId: file.sessionId,
+    filePath: file.auditPath,
+    projectName,
+    projectDir,
+    cwd: cwd ?? baseMeta.cwd,
+    model: baseMeta.model ?? coworkMeta.model
+  };
+  return { meta, events };
+}
+function cacheKeyFor(file) {
+  return {
+    auditMtimeMs: file.auditMtimeMs,
+    auditSize: file.auditSize,
+    metaMtimeMs: file.metaMtimeMs,
+    spacesMtimeMs: file.spacesMtimeMs
+  };
+}
+function cacheKeyMatches(a, b) {
+  return a.auditMtimeMs === b.auditMtimeMs && a.auditSize === b.auditSize && a.metaMtimeMs === b.metaMtimeMs && a.spacesMtimeMs === b.spacesMtimeMs;
+}
+function clearCoworkCaches() {
+  metaCache5.clear();
+  detailCache5.clear();
+  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 key = cacheKeyFor(file);
+    const cached = metaCache5.get(file.auditPath);
+    if (cached && cacheKeyMatches(cached.key, key)) {
+      out.push(cached.meta);
+      continue;
+    }
+    try {
+      const { meta } = await parseCoworkSession(file);
+      metaCache5.set(file.auditPath, { meta, key });
+      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 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 key = cacheKeyFor(file);
+  const cached = detailCache5.get(file.auditPath);
+  if (cached && cacheKeyMatches(cached.key, key))
+    return cached.detail;
+  const { meta, events } = await parseCoworkSession(file);
+  const detail = { ...meta, events };
+  detailCache5.set(file.auditPath, { detail, key });
+  return detail;
+}
+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_COWORK_ROOT, SESSION_ID_RE, spacesCache, metaCache5, detailCache5;
+var init_cowork = __esm({
+  "../parser/dist/cowork.js"() {
+    "use strict";
+    init_analytics();
+    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();
   }
 });
 
@@ -3034,11 +4085,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,
@@ -3046,19 +4100,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,
@@ -3067,20 +4126,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();
@@ -3089,6 +4149,8 @@ function clearCaches() {
   clearClaudeCodeCaches();
   clearCodexCaches();
   clearGeminiCaches();
+  clearAntigravityCaches();
+  clearCoworkCaches();
 }
 function invalidateFile(fullPath) {
   invalidateClaudeCodeFile(fullPath);
@@ -3120,7 +4182,7 @@ function usageLogPath() {
 async function loadUsageByDay(start2, end) {
   let raw;
   try {
-    raw = await fs4.readFile(usageLogPath(), "utf8");
+    raw = await fs6.readFile(usageLogPath(), "utf8");
   } catch {
     return { by_day: [] };
   }
@@ -3165,7 +4227,7 @@ async function loadUsageByDay(start2, end) {
 async function loadCalibrationSnapshots() {
   let raw;
   try {
-    raw = await fs4.readFile(usageLogPath(), "utf8");
+    raw = await fs6.readFile(usageLogPath(), "utf8");
   } catch {
     return [];
   }
@@ -3323,7 +4385,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";
@@ -3333,9 +4395,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 = {
@@ -3369,7 +4435,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
+    ];
   }
 });
 
@@ -3442,11 +4534,11 @@ function stopServer() {
 }
 async function checkPort(port) {
   const { createServer } = await import("node:net");
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     const server = createServer();
-    server.once("error", () => resolve(true));
+    server.once("error", () => resolve3(true));
     server.once("listening", () => {
-      server.close(() => resolve(false));
+      server.close(() => resolve3(false));
     });
     server.listen(port, "localhost");
   });
@@ -3776,9 +4868,9 @@ Installed: ${PACKAGE_NAME}@${verify.installedVersion}  at ${verify.installedPath
     console.warn(
       `    \u2022 reinstall in the correct Node env: 'npm install -g ${PACKAGE_NAME}@latest'`
     );
-  } else if (verify.installedVersion !== "0.11.2") {
+  } else if (verify.installedVersion !== "0.12.1") {
     console.log(
-      `  \u2192 This process is still running ${"0.11.2"}. Next invocation will use ${verify.installedVersion}.`
+      `  \u2192 This process is still running ${"0.12.1"}. Next invocation will use ${verify.installedVersion}.`
     );
   }
 }
@@ -3813,14 +4905,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.11.2",
+    current: "0.12.1",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.11.2",
+    current: "0.12.1",
     latest,
-    updateAvailable: shouldUpdate("0.11.2", latest)
+    updateAvailable: shouldUpdate("0.12.1", latest)
   };
 }
 async function checkForUpdate() {
@@ -3910,7 +5002,7 @@ async function restartServices(state) {
 }
 async function forceUpdate() {
   const latest = await fetchLatestVersion();
-  const current = "0.11.2";
+  const current = "0.12.1";
   if (latest === null) {
     console.error("Could not reach npm registry. Check your network.");
     process.exit(1);
@@ -4088,10 +5180,10 @@ async function web(args2) {
   const open = args2.includes("--open");
   const positional = args2.filter((a) => !a.startsWith("--"));
   const rawPath = positional[0] ?? "";
-  const path5 = rawPath.startsWith("/") ? rawPath : rawPath ? `/${rawPath}` : "";
+  const path7 = rawPath.startsWith("/") ? rawPath : rawPath ? `/${rawPath}` : "";
   const status2 = getServerStatus();
   if (status2.running) {
-    const url = `http://localhost:${status2.port}${path5}`;
+    const url = `http://localhost:${status2.port}${path7}`;
     if (open) {
       console.log(`Opening ${url}`);
       openBrowser(url);
@@ -4103,7 +5195,7 @@ async function web(args2) {
   console.log("fleetlens is not running. Starting server...");
   try {
     const result = await startServer({});
-    const url = `http://localhost:${result.port}${path5}`;
+    const url = `http://localhost:${result.port}${path7}`;
     console.log(`fleetlens running on ${url} (PID ${result.pid})`);
     if (open) {
       openBrowser(url);
@@ -4165,9 +5257,9 @@ function readFromCredentialsFile() {
     join5(homedir2(), ".claude", ".credentials.json"),
     join5(homedir2(), ".config", "claude", "credentials.json")
   ];
-  for (const path5 of candidates) {
+  for (const path7 of candidates) {
     try {
-      const blob = readFileSync6(path5, "utf8");
+      const blob = readFileSync6(path7, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -5100,8 +6192,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,
@@ -5142,6 +6236,7 @@ __export(dist_exports, {
   predictUtilization: () => predictUtilization,
   priorCalendarMonth: () => priorCalendarMonth,
   priorCalendarWeek: () => priorCalendarWeek,
+  projectRepoName: () => projectRepoName,
   rowPrimaryIndex: () => rowPrimaryIndex,
   sessionAirTimeMs: () => sessionAirTimeMs,
   sessionDay: () => sessionDay,
@@ -5345,7 +6440,7 @@ var init_trivial = __esm({
 });
 
 // ../entries/dist/build.js
-var IDLE_GAP_MS3;
+var IDLE_GAP_MS4;
 var init_build = __esm({
   "../entries/dist/build.js"() {
     "use strict";
@@ -5353,7 +6448,7 @@ var init_build = __esm({
     init_types();
     init_signals();
     init_trivial();
-    IDLE_GAP_MS3 = 3 * 60 * 1e3;
+    IDLE_GAP_MS4 = 3 * 60 * 1e3;
   }
 });
 
@@ -5386,11 +6481,11 @@ function digestsDir() {
   digestsDirCached = envOverride ?? cclensPath("digests");
   return digestsDirCached;
 }
-function __setDigestsDirForTest(path5) {
-  digestsDirCached = path5;
-  mkdirSync4(join6(path5, "day"), { recursive: true });
-  mkdirSync4(join6(path5, "week"), { recursive: true });
-  mkdirSync4(join6(path5, "month"), { recursive: true });
+function __setDigestsDirForTest(path7) {
+  digestsDirCached = path7;
+  mkdirSync4(join6(path7, "day"), { recursive: true });
+  mkdirSync4(join6(path7, "week"), { recursive: true });
+  mkdirSync4(join6(path7, "month"), { recursive: true });
 }
 function dayDigestPath(date) {
   return join6(digestsDir(), "day", `${date}.json`);
@@ -5577,9 +6672,9 @@ function entriesDir() {
   entriesDirCached = envOverride ?? cclensPath("entries");
   return entriesDirCached;
 }
-function __setEntriesDirForTest(path5) {
-  entriesDirCached = path5;
-  mkdirSync5(path5, { recursive: true });
+function __setEntriesDirForTest(path7) {
+  entriesDirCached = path7;
+  mkdirSync5(path7, { recursive: true });
 }
 function pathFor(sessionId, localDay) {
   return join7(entriesDir(), `${entryKey(sessionId, localDay)}.json`);
@@ -6115,8 +7210,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     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
@@ -6424,11 +7519,11 @@ var init_types3 = __esm({
     init_parseUtil();
     init_util();
     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() {
@@ -10086,10 +11181,10 @@ function snapshotAllTranscripts() {
   }
   return out;
 }
-function readJsonlCwd(path5, maxLines = 8) {
+function readJsonlCwd(path7, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync9(path5, "utf8");
+    raw = readFileSync9(path7, "utf8");
   } catch {
     return void 0;
   }
@@ -10143,10 +11238,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 = readFileSync9(path5, "utf8");
+    raw = readFileSync9(path7, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -10275,15 +11370,15 @@ function newRunId(kind) {
 function tracePath(runId) {
   return join9(RUNS_DIR, `${runId}.jsonl`);
 }
-function safeAppend(path5, line) {
+function safeAppend(path7, line) {
   try {
-    appendFileSync2(path5, line);
+    appendFileSync2(path7, line);
   } catch {
   }
 }
-function safeWrite(path5, line) {
+function safeWrite(path7, line) {
   try {
-    writeFileSync6(path5, line);
+    writeFileSync6(path7, line);
   } catch {
   }
 }
@@ -10361,7 +11456,7 @@ async function runClaudeSubprocess(args2) {
   return runClaudePrintMode(args2);
 }
 function runClaudePrintMode(args2) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve3, reject) => {
     ensureRunsDir();
     const kind = detectKindFromSystemPrompt(args2.systemPrompt);
     const runId = newRunId(kind);
@@ -10492,7 +11587,7 @@ ${args2.reminder}` : args2.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");
@@ -10697,8 +11792,8 @@ function spendPath() {
   spendPathCached = cclensPath("llm-spend.jsonl");
   return spendPathCached;
 }
-function __setSpendPathForTest(path5) {
-  spendPathCached = path5;
+function __setSpendPathForTest(path7) {
+  spendPathCached = path7;
 }
 function appendSpend(record) {
   const p = spendPath();
@@ -10748,8 +11843,8 @@ function lockPath() {
   lockPathCached = cclensPath("llm-interactive.lock");
   return lockPathCached;
 }
-function __setInteractiveLockPathForTest(path5) {
-  lockPathCached = path5;
+function __setInteractiveLockPathForTest(path7) {
+  lockPathCached = path7;
 }
 function touchLock() {
   writeFileSync7(lockPath(), String(process.pid), "utf8");
@@ -10832,10 +11927,10 @@ async function runEnrichmentQueue(settings, opts = {}) {
   if (monthToDateSpend() >= budget)
     return { skipped: "budget_cap_reached" };
   const queue = listEntriesWithStatus(["pending", "error"]).filter((e) => (e.enrichment.retry_count ?? 0) < MAX_RETRY_COUNT);
-  const todayLocal = toLocalDay2(now());
+  const todayLocal2 = toLocalDay2(now());
   let enriched = 0, errors = 0, skipped = 0;
   for (const entry of queue) {
-    if (entry.local_day === todayLocal) {
+    if (entry.local_day === todayLocal2) {
       skipped++;
       continue;
     }
@@ -10906,8 +12001,8 @@ function settingsPath() {
   settingsPathCached = cclensPath("settings.json");
   return settingsPathCached;
 }
-function __setSettingsPathForTest(path5) {
-  settingsPathCached = path5;
+function __setSettingsPathForTest(path7) {
+  settingsPathCached = path7;
 }
 function toDisk(s) {
   return {
@@ -11144,7 +12239,7 @@ function rollupOutcomeDay(entries2) {
     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";
@@ -11200,7 +12295,7 @@ function computeDaySignals(entries2) {
     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) {
@@ -11219,7 +12314,7 @@ function computeDaySignals(entries2) {
     if ((e.first_user ?? "").length > 0)
       verbosity_distribution[s.verbosity] += 1;
     for (const ref of s.external_refs) {
-      external_refs.push({ session_id: e.session_id, kind: ref.kind, preview: 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;
@@ -12092,7 +13187,7 @@ function computeInteractionModes(entries2) {
       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 = [];
@@ -12109,7 +13204,7 @@ function computeInteractionModes(entries2) {
       skillExamples.push({
         date: e.local_day,
         skill,
-        first_user_preview: truncate5(e.first_user, 200)
+        first_user_preview: truncate6(e.first_user, 200)
       });
     }
   }
@@ -12126,7 +13221,7 @@ function computeInteractionModes(entries2) {
     project_display: prettyProject3(longestTurnEntry.project),
     active_min: longestTurnEntry.numbers.active_min,
     top_tools: longestTurnEntry.top_tools.slice(0, 5),
-    first_user_preview: 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";
@@ -12157,7 +13252,7 @@ function computeInteractionModes(entries2) {
     }
   };
 }
-function truncate5(s, max) {
+function truncate6(s, max) {
   if (s.length <= max)
     return s;
   return s.slice(0, max - 1).trimEnd() + "\u2026";
@@ -12204,7 +13299,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 ?? "";
@@ -12215,7 +13310,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
       };
     });
@@ -12290,7 +13385,7 @@ function computeInteractionGrammar(dayDigests, entriesByDay = /* @__PURE__ */ ne
         date: day2,
         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;
@@ -12362,7 +13457,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: {
@@ -13010,7 +14105,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;
@@ -13181,7 +14276,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)
@@ -13578,14 +14673,14 @@ async function generateTopSession(slice, opts = {}) {
     void lastModel;
   }
 }
-var IDLE_GAP_MS4, LONG_AUTONOMOUS_MIN, N_USER, N_FIRST_AGENT, N_LAST_AGENT, N_USER_TURN1, N_SUBAGENT, SHELL_NOISE, INTERRUPT_RE2, PR_TITLE_RE, PinResponseSchema, TopSessionResponseSchema, SYSTEM_PROMPT5, TOP_SESSION_SYSTEM_PROMPT, DEFAULT_MODEL5, defaultCallLLMTopSession, validateTopSession;
+var IDLE_GAP_MS5, LONG_AUTONOMOUS_MIN, N_USER, N_FIRST_AGENT, N_LAST_AGENT, N_USER_TURN1, N_SUBAGENT, SHELL_NOISE, INTERRUPT_RE2, PR_TITLE_RE, PinResponseSchema, TopSessionResponseSchema, SYSTEM_PROMPT5, TOP_SESSION_SYSTEM_PROMPT, DEFAULT_MODEL5, defaultCallLLMTopSession, validateTopSession;
 var init_top_sessions = __esm({
   "../entries/dist/top-sessions.js"() {
     "use strict";
     init_zod();
     init_signals();
     init_llm_runner();
-    IDLE_GAP_MS4 = 3 * 60 * 1e3;
+    IDLE_GAP_MS5 = 3 * 60 * 1e3;
     LONG_AUTONOMOUS_MIN = 20;
     N_USER = 150;
     N_FIRST_AGENT = 150;
@@ -14104,6 +15199,10 @@ async function* runMonthDigestPipeline(yearMonth, opts) {
     } else {
       digest2.is_live = true;
       setCurrentMonthDigestInCache(yearMonth, digest2, now());
+      if (opts.force === true) {
+        writeMonthDigest(digest2);
+        yield { type: "saved", path: `~/.cclens/digests/month/${yearMonth}.json` };
+      }
     }
     yield { type: "digest", digest: digest2 };
   } finally {
@@ -14719,16 +15818,12 @@ function bucketToRollup(b) {
   };
 }
 function buildRollupsForRange(sessions, sinceDay) {
-  const buckets = dailyActivity(sessions);
   const startCounts = /* @__PURE__ */ new Map();
   for (const s of sessions) {
     const d = sessionDay(s);
     if (d) startCounts.set(d, (startCounts.get(d) ?? 0) + 1);
   }
-  return buckets.filter((b) => !sinceDay || b.date >= sinceDay).map((b) => ({
-    ...bucketToRollup(b),
-    sessions: startCounts.get(b.date) ?? 0
-  }));
+  return dailyActivity(sessions).filter((b) => !sinceDay || b.date >= sinceDay).map((b) => ({ ...bucketToRollup(b), uniqueSessions: startCounts.get(b.date) ?? 0 }));
 }
 function dayBoundsMs(day2) {
   const [y, m, d] = day2.split("-").map(Number);
@@ -14754,7 +15849,7 @@ function sessionTouchesDay(s, day2) {
   }
   return sessionDay(s) === day2;
 }
-function buildRichRollupBlocks(day2, daySessions, entries2, privateProjects) {
+function buildRichRollupBlocks(day2, daySessions, entries2, privateProjects, resolveRepo) {
   const bounds = dayBoundsMs(day2);
   const clippedSessions = [];
   for (const s of daySessions) {
@@ -14764,16 +15859,40 @@ function buildRichRollupBlocks(day2, daySessions, entries2, 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 entries2) {
+    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();
@@ -14787,12 +15906,12 @@ function buildRichRollupBlocks(day2, daySessions, entries2, privateProjects) {
   let longTotalMin = 0;
   let longMaxSingleMin = 0;
   for (const e of entries2) {
-    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)) {
@@ -14807,6 +15926,12 @@ function buildRichRollupBlocks(day2, daySessions, entries2, 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;
@@ -14814,11 +15939,21 @@ function buildRichRollupBlocks(day2, daySessions, entries2, 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),
@@ -14847,10 +15982,10 @@ function buildEnrichedExtras(entries2) {
   }
   return { outcomeMix, helpfulnessMix, goalMix };
 }
-function buildRichBlocksForDay(day2, daySessions, privateProjects, enrichmentOptIn) {
+function buildRichBlocksForDay(day2, daySessions, privateProjects, enrichmentOptIn, resolveRepo) {
   const entries2 = listEntriesForDay(day2);
   if (entries2.length === 0) return void 0;
-  const rich = buildRichRollupBlocks(day2, daySessions, entries2, privateProjects);
+  const rich = buildRichRollupBlocks(day2, daySessions, entries2, privateProjects, resolveRepo);
   const enriched = enrichmentOptIn ? buildEnrichedExtras(entries2) : void 0;
   return enriched ? { rich, enriched } : { rich };
 }
@@ -14859,10 +15994,11 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID2(),
     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 } : {}
@@ -14894,15 +16030,83 @@ var init_push = __esm({
   }
 });
 
+// src/team/git-remote.ts
+import { existsSync as existsSync12, readFileSync as readFileSync13, statSync as statSync3 } from "node:fs";
+import { dirname as dirname9, isAbsolute, join as join10, resolve } from "node:path";
+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 = join10(dir, ".git");
+  const st = statSync3(dotGit, { throwIfNoEntry: false });
+  if (!st) return null;
+  if (st.isDirectory()) return join10(dotGit, "config");
+  const m = readFileSync13(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  if (!m) return null;
+  const gd = isAbsolute(m[1]) ? m[1] : resolve(dir, m[1]);
+  const commondirFile = join10(gd, "commondir");
+  if (existsSync12(commondirFile)) {
+    const common = readFileSync13(commondirFile, "utf8").trim();
+    return join10(isAbsolute(common) ? common : resolve(gd, common), "config");
+  }
+  return join10(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 = dirname9(d)) {
+        const config = gitConfigPathFor(d);
+        if (config && existsSync12(config)) {
+          const url = originUrl(readFileSync13(config, "utf8"));
+          repo = url ? parseGithubRemote(url) : null;
+          break;
+        }
+        if (d === dirname9(d)) break;
+      }
+    } catch {
+      repo = null;
+    }
+    cache.set(dir, repo);
+    return repo;
+  };
+}
+var GITHUB_URL_RE;
+var init_git_remote = __esm({
+  "src/team/git-remote.ts"() {
+    "use strict";
+    GITHUB_URL_RE = /github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
+  }
+});
+
 // src/team/queue.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, appendFileSync as appendFileSync4, statSync as statSync3, mkdirSync as mkdirSync10 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync10 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
 function enqueuePayload(payload, queuePath = QUEUE_PATH) {
-  mkdirSync10(dirname9(queuePath), { recursive: true });
+  mkdirSync10(dirname10(queuePath), { recursive: true });
   const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
   appendFileSync4(queuePath, JSON.stringify(entry) + "\n", "utf8");
   try {
-    const { size } = statSync3(queuePath);
+    const { size } = statSync4(queuePath);
     if (size > MAX_SIZE_BYTES) {
       pruneOldest(queuePath);
     }
@@ -14912,7 +16116,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync13(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync14(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -14933,7 +16137,7 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync13(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync14(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
@@ -14952,8 +16156,8 @@ var init_queue2 = __esm({
 });
 
 // src/usage/profile.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
 function mapRateLimitTier(rateLimitTier) {
   switch (rateLimitTier) {
     case "default_claude_pro":
@@ -14993,9 +16197,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync12(cachePath)) return null;
+  if (!existsSync13(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync14(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync15(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -15003,7 +16207,7 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync11(dirname10(cachePath), { recursive: true });
+  mkdirSync11(dirname11(cachePath), { recursive: true });
   writeFileSync10(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
@@ -15185,11 +16389,11 @@ var init_backfill = __esm({
 
 // src/team/last-push.ts
 import { writeFileSync as writeFileSync11, unlinkSync as unlinkSync5, mkdirSync as mkdirSync12 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 function write(record, dir) {
   const d = dir ?? cclensHome();
   mkdirSync12(d, { recursive: true });
-  writeFileSync11(join10(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
+  writeFileSync11(join11(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);
@@ -15200,7 +16404,7 @@ function writeLastPushFailure(payload, error, dir) {
 function clearLastPush(dir) {
   const d = dir ?? cclensHome();
   try {
-    unlinkSync5(join10(d, LAST_PUSH_FILE));
+    unlinkSync5(join11(d, LAST_PUSH_FILE));
   } catch {
   }
 }
@@ -15213,6 +16417,194 @@ var init_last_push = __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 existsSync14, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join12, 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 = join12(homedir4(), ".claude");
+  if (existsSync14(home)) roots.push({ root: home, label: "user" });
+  for (const e of extraRoots) {
+    const r = resolve2(e, ".claude");
+    if (existsSync14(r) && r !== home) roots.push({ root: r, label: "project" });
+  }
+  return roots;
+}
+function listMarkdownFiles(dir) {
+  if (!existsSync14(dir)) return [];
+  const out = [];
+  let entries2;
+  try {
+    entries2 = readdirSync4(dir);
+  } catch {
+    return [];
+  }
+  for (const name of entries2) {
+    if (name.startsWith(".")) continue;
+    const full = join12(dir, name);
+    let stat;
+    try {
+      stat = statSync5(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: dirname12(file) }
+    ).trim().split("\n").filter(Boolean);
+    if (out.length > 0) return out[out.length - 1];
+  } catch {
+  }
+  try {
+    const s = statSync5(file);
+    return new Date((s.birthtime || s.mtime).getTime()).toISOString().slice(0, 10);
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  }
+}
+function dirname12(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 day2 = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day2}`;
+}
+function scanAuthored(roots, subdir, day2) {
+  const out = [];
+  for (const r of roots) {
+    const dir = join12(r.root, subdir);
+    if (!existsSync14(dir)) continue;
+    for (const f of listMarkdownFiles(dir)) {
+      const firstSeen = firstSeenDateOf(f);
+      if (firstSeen !== day2) continue;
+      const rel = relative(dir, f);
+      out.push({ pathHash: pathHash(`${r.label}:${subdir}:${rel}`), firstSeenDate: firstSeen });
+    }
+  }
+  return out;
+}
+function scanEdited(roots, day2) {
+  const out = [];
+  for (const r of roots) {
+    const dir = join12(r.root, "skills");
+    if (!existsSync14(dir)) continue;
+    for (const f of listMarkdownFiles(dir)) {
+      const firstSeen = firstSeenDateOf(f);
+      if (firstSeen === day2) continue;
+      let stat;
+      try {
+        stat = statSync5(f);
+      } catch {
+        continue;
+      }
+      const mtimeDay = new Date(stat.mtime.getTime()).toISOString().slice(0, 10);
+      if (mtimeDay !== day2) continue;
+      const rel = relative(dir, f);
+      out.push({ pathHash: pathHash(`${r.label}:skills:${rel}`), lineDelta: 0 });
+    }
+  }
+  return out;
+}
+function claudemdLineDelta(extraRoots, authorEmail, day2) {
+  let delta = 0;
+  const candidates = [];
+  for (const e of extraRoots) {
+    const f = resolve2(e, "CLAUDE.md");
+    if (existsSync14(f)) candidates.push(f);
+  }
+  const homeClaudeMd = join12(homedir4(), "CLAUDE.md");
+  if (existsSync14(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: dirname12(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 === day2 && 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 day2 = opts.day ?? todayLocal();
+  const roots = defaultScanRoots(opts.extraRoots);
+  const skillsAuthored = scanAuthored(roots, "skills", day2);
+  const subagentsAuthored = scanAuthored(roots, "agents", day2);
+  const slashCommandsAuthored = scanAuthored(roots, "commands", day2);
+  const skillsEdited = scanEdited(roots, day2);
+  const authorEmail = opts.authorEmail ?? detectGitEmail(opts.extraRoots?.[0] ?? process.cwd()) ?? void 0;
+  const claudemd = claudemdLineDelta(opts.extraRoots ?? [], authorEmail, day2);
+  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/team/commands.ts
 async function dispatchCommand(command2, config, log) {
   switch (command2.type) {
@@ -15230,6 +16622,7 @@ async function dispatchCommand(command2, config, log) {
 async function runActivityBackfill(command2, config, log) {
   const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
   const { toLocalDay: toLocalDay4 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { probeArtifactSignals: probeArtifactSignals2 } = await Promise.resolve().then(() => (init_file_probe(), file_probe_exports));
   const days = command2.params.days;
   const todayMs = Date.now();
   const targetDayMs = todayMs - (days - 1) * 24 * 60 * 60 * 1e3;
@@ -15255,9 +16648,24 @@ async function runActivityBackfill(command2, config, log) {
       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 {
@@ -15281,6 +16689,7 @@ var init_commands = __esm({
   "src/team/commands.ts"() {
     "use strict";
     init_push();
+    init_git_remote();
   }
 });
 
@@ -15388,6 +16797,8 @@ async function runTeamSync(log = 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;
@@ -15396,12 +16807,22 @@ async function runTeamSync(log = 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
@@ -15522,6 +16943,7 @@ var init_sync = __esm({
     "use strict";
     init_config();
     init_push();
+    init_git_remote();
     init_queue2();
     init_backfill();
     init_last_push();
@@ -15677,11 +17099,11 @@ var logs_exports = {};
 __export(logs_exports, {
   teamLogs: () => teamLogs
 });
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 async function teamLogs() {
   const logPath = cclensPath("daemon.log");
   try {
-    const lines = readFileSync15(logPath, "utf8").trim().split("\n");
+    const lines = readFileSync16(logPath, "utf8").trim().split("\n");
     const teamLines = lines.filter((l) => l.includes("team "));
     if (teamLines.length === 0) {
       console.log("No team-related log entries found.");
@@ -15787,8 +17209,8 @@ __export(runs_exports, {
   runs: () => runs
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync13, readFileSync as readFileSync16, readdirSync as readdirSync4, statSync as statSync4 } from "node:fs";
-import { join as join11 } from "node:path";
+import { existsSync as existsSync15, readFileSync as readFileSync17, readdirSync as readdirSync5, statSync as statSync6 } from "node:fs";
+import { join as join13 } from "node:path";
 async function runs(args2) {
   const json = args2.includes("--json");
   const watch = args2.includes("--watch");
@@ -15872,8 +17294,8 @@ function listActiveRuns() {
   return runs2.sort((a, b) => a.elapsed_s - b.elapsed_s);
 }
 function readSpend(sinceMs) {
-  if (!existsSync13(SPEND_PATH)) return [];
-  const lines = readFileSync16(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
+  if (!existsSync15(SPEND_PATH)) return [];
+  const lines = readFileSync17(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
   const out = [];
   for (const line of lines) {
     try {
@@ -15994,23 +17416,23 @@ function ageLabel(ms) {
   return `${Math.floor(ms / 864e5)}d`;
 }
 function listTraceFiles() {
-  if (!existsSync13(RUNS_DIR2)) return [];
-  const entries2 = readdirSync4(RUNS_DIR2).filter((f) => f.endsWith(".jsonl"));
+  if (!existsSync15(RUNS_DIR2)) return [];
+  const entries2 = readdirSync5(RUNS_DIR2).filter((f) => f.endsWith(".jsonl"));
   return entries2.map((f) => {
-    const path5 = join11(RUNS_DIR2, f);
-    const st = statSync4(path5);
-    return { runId: f.replace(/\.jsonl$/, ""), path: path5, mtimeMs: st.mtimeMs };
+    const path7 = join13(RUNS_DIR2, f);
+    const st = statSync6(path7);
+    return { runId: f.replace(/\.jsonl$/, ""), path: path7, mtimeMs: st.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
 function resolveRunId(arg) {
-  if (!existsSync13(RUNS_DIR2)) return null;
+  if (!existsSync15(RUNS_DIR2)) return null;
   if (arg === "latest") {
     const all2 = listTraceFiles();
     if (all2.length === 0) return null;
     return { runId: all2[0].runId, path: all2[0].path };
   }
-  const exact = join11(RUNS_DIR2, `${arg}.jsonl`);
-  if (existsSync13(exact)) return { runId: arg, path: exact };
+  const exact = join13(RUNS_DIR2, `${arg}.jsonl`);
+  if (existsSync15(exact)) return { runId: arg, path: exact };
   const all = listTraceFiles();
   const matches = all.filter((r) => r.runId.includes(arg));
   if (matches.length === 1) return { runId: matches[0].runId, path: matches[0].path };
@@ -16021,8 +17443,8 @@ function resolveRunId(arg) {
   }
   return null;
 }
-function readTrace(path5) {
-  return readFileSync16(path5, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
+function readTrace(path7) {
+  return readFileSync17(path7, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
     } catch {
@@ -16034,7 +17456,7 @@ async function inspect(arg, follow, json) {
   const r = resolveRunId(arg);
   if (!r) {
     console.error(`run not found: ${arg}`);
-    if (existsSync13(RUNS_DIR2)) {
+    if (existsSync15(RUNS_DIR2)) {
       const all = listTraceFiles().slice(0, 5);
       if (all.length > 0) {
         console.error(`
@@ -16054,13 +17476,13 @@ recent runs:`);
   const events = readTrace(r.path);
   printTrace(r.runId, events);
   if (!follow) return;
-  let lastSize = statSync4(r.path).size;
+  let lastSize = statSync6(r.path).size;
   let lastIdx = events.length;
   console.log("\n  \u27F6 following \xB7 ^C to quit\n");
   process.on("SIGINT", () => process.exit(0));
   while (true) {
     await new Promise((res) => setTimeout(res, 500));
-    const st = statSync4(r.path);
+    const st = statSync6(r.path);
     if (st.size === lastSize) continue;
     lastSize = st.size;
     const all = readTrace(r.path);
@@ -16204,7 +17626,7 @@ async function main() {
     case "version":
     case "--version":
     case "-v":
-      console.log(`fleetlens ${"0.11.2"}`);
+      console.log(`fleetlens ${"0.12.1"}`);
       break;
     case "help":
     case "--help":