fleetlens 0.3.0 → 0.4.0

package/dist/index.js

@@ -454,9 +454,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.3.0") {
+  } else if (verify.installedVersion !== "0.4.0") {
     console.log(
-      `  \u2192 This process is still running ${"0.3.0"}. Next invocation will use ${verify.installedVersion}.`
+      `  \u2192 This process is still running ${"0.4.0"}. Next invocation will use ${verify.installedVersion}.`
     );
   }
 }
@@ -492,7 +492,7 @@ async function checkForUpdate() {
   if (process.env.__FLEETLENS_UPDATED === "1" || process.env.__CCLENS_UPDATED === "1") return;
   const latest = await fetchLatestVersion();
   if (latest === null) return;
-  const current = "0.3.0";
+  const current = "0.4.0";
   if (!shouldUpdate(current, latest)) return;
   console.log(`Updating ${PACKAGE_NAME} ${current} \u2192 ${latest}...`);
   await stopRunningServices();
@@ -574,7 +574,7 @@ async function restartServices(state) {
 }
 async function forceUpdate() {
   const latest = await fetchLatestVersion();
-  const current = "0.3.0";
+  const current = "0.4.0";
   if (latest === null) {
     console.error("Could not reach npm registry. Check your network.");
     process.exit(1);
@@ -851,7 +851,7 @@ function toEvent(raw, index) {
     const stopReason = msg.stop_reason;
     const first = content[0];
     let role = "agent";
-    let preview = "";
+    let preview;
     let toolName;
     let toolUseId;
     if (first?.type === "thinking") {
@@ -1157,13 +1157,622 @@ var init_parser = __esm({
 });
 
 // ../parser/dist/analytics.js
+function toLocalDay(ms) {
+  const d = new Date(ms);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+function sessionDay(meta) {
+  if (!meta.firstTimestamp)
+    return void 0;
+  const ms = Date.parse(meta.firstTimestamp);
+  if (Number.isNaN(ms))
+    return void 0;
+  return toLocalDay(ms);
+}
+function findWorktreeMarker(projectName) {
+  for (const marker of WORKTREE_MARKERS) {
+    const idx = projectName.lastIndexOf(marker);
+    if (idx >= 0)
+      return { idx, marker };
+  }
+  return null;
+}
+function canonicalProjectName(projectName) {
+  const hit = findWorktreeMarker(projectName);
+  if (hit)
+    return projectName.slice(0, hit.idx);
+  return projectName;
+}
+function worktreeName(projectName) {
+  const hit = findWorktreeMarker(projectName);
+  if (!hit)
+    return null;
+  const tail = projectName.slice(hit.idx + hit.marker.length);
+  const slash = tail.indexOf("/");
+  return slash >= 0 ? tail.slice(0, slash) : tail;
+}
+function makeDay(date) {
+  return {
+    date,
+    sessions: 0,
+    toolCalls: 0,
+    turns: 0,
+    tokens: { ...BLANK_USAGE2 },
+    durationMs: 0,
+    airTimeMs: 0,
+    peakParallelism: 0
+  };
+}
+function daysBetween(startDay, endDay) {
+  const [ys, ms, ds] = startDay.split("-").map(Number);
+  const [ye, me, de] = endDay.split("-").map(Number);
+  const start2 = new Date(ys, ms - 1, ds);
+  const end = new Date(ye, me - 1, de);
+  const out = [];
+  for (let d = new Date(start2); d <= end; d.setDate(d.getDate() + 1)) {
+    out.push(toLocalDay(d.getTime()));
+  }
+  return out;
+}
+function dailyActivity(sessions) {
+  if (sessions.length === 0)
+    return [];
+  const byDay = /* @__PURE__ */ new Map();
+  let minDay;
+  let maxDay;
+  const touchBucket = (day) => {
+    if (!minDay || day < minDay)
+      minDay = day;
+    if (!maxDay || day > maxDay)
+      maxDay = day;
+    const b = byDay.get(day) ?? makeDay(day);
+    byDay.set(day, b);
+    return b;
+  };
+  for (const s of sessions) {
+    const startDay = sessionDay(s);
+    if (startDay) {
+      const bucket = touchBucket(startDay);
+      bucket.toolCalls += s.toolCallCount ?? 0;
+      bucket.turns += s.turnCount ?? 0;
+      bucket.tokens.input += s.totalUsage.input;
+      bucket.tokens.output += s.totalUsage.output;
+      bucket.tokens.cacheRead += s.totalUsage.cacheRead;
+      bucket.tokens.cacheWrite += s.totalUsage.cacheWrite;
+      bucket.durationMs += s.durationMs ?? 0;
+    }
+    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 day = toLocalDay(cur);
+          touchedDays.add(day);
+          const d = new Date(cur);
+          d.setHours(24, 0, 0, 0);
+          const dayEndMs = Math.min(d.getTime(), seg.endMs);
+          const bucket = touchBucket(day);
+          bucket.airTimeMs += dayEndMs - cur;
+          cur = dayEndMs;
+        }
+      }
+      for (const day of touchedDays) {
+        const bucket = touchBucket(day);
+        bucket.sessions++;
+      }
+    } else if (startDay) {
+      const bucket = touchBucket(startDay);
+      bucket.sessions++;
+      bucket.airTimeMs += s.airTimeMs ?? 0;
+    }
+  }
+  const range = minDay && maxDay ? daysBetween(minDay, maxDay) : [];
+  const out = [];
+  for (const day of range) {
+    out.push(byDay.get(day) ?? makeDay(day));
+  }
+  const parallelism = computeParallelism(sessions);
+  const byDayPar = /* @__PURE__ */ new Map();
+  for (const p of parallelism) {
+    const day = toLocalDay(p.atMs);
+    const cur = byDayPar.get(day) ?? 0;
+    if (p.active > cur)
+      byDayPar.set(day, p.active);
+  }
+  for (const b of out) {
+    b.peakParallelism = byDayPar.get(b.date) ?? 0;
+  }
+  return out;
+}
+function computeParallelism(sessions) {
+  const events = [];
+  for (const s of sessions) {
+    const segs = s.activeSegments && s.activeSegments.length > 0 ? s.activeSegments : s.firstTimestamp && s.lastTimestamp ? (() => {
+      const start2 = Date.parse(s.firstTimestamp);
+      const end = Date.parse(s.lastTimestamp);
+      if (Number.isNaN(start2) || Number.isNaN(end) || end < start2)
+        return [];
+      return [{ startMs: start2, endMs: end }];
+    })() : [];
+    for (const seg of segs) {
+      events.push({ ms: seg.startMs, delta: 1, sessionId: s.id });
+      events.push({ ms: seg.endMs, delta: -1, sessionId: s.id });
+    }
+  }
+  events.sort((a, b) => a.ms - b.ms || b.delta - a.delta);
+  const segCount = /* @__PURE__ */ new Map();
+  const points = [];
+  for (const e of events) {
+    if (e.delta === 1) {
+      segCount.set(e.sessionId, (segCount.get(e.sessionId) ?? 0) + 1);
+    } else {
+      const n = (segCount.get(e.sessionId) ?? 0) - 1;
+      if (n <= 0)
+        segCount.delete(e.sessionId);
+      else
+        segCount.set(e.sessionId, n);
+    }
+    points.push({
+      atMs: e.ms,
+      active: segCount.size,
+      sessions: Array.from(segCount.keys()).slice(0, 10)
+    });
+  }
+  return points;
+}
+function detectParallelRuns(sessions, minActive = 2) {
+  const points = computeParallelism(sessions);
+  const runs = [];
+  let cur = null;
+  for (const p of points) {
+    if (p.active >= minActive) {
+      if (!cur) {
+        cur = { startMs: p.atMs, endMs: p.atMs, peak: p.active, sessions: [...p.sessions] };
+      } else {
+        cur.endMs = p.atMs;
+        if (p.active > cur.peak)
+          cur.peak = p.active;
+        for (const sid of p.sessions) {
+          if (!cur.sessions.includes(sid))
+            cur.sessions.push(sid);
+        }
+      }
+    } else if (cur) {
+      cur.endMs = p.atMs;
+      runs.push(cur);
+      cur = null;
+    }
+  }
+  if (cur)
+    runs.push(cur);
+  return runs;
+}
+function detectPrMarkers(session) {
+  const out = [];
+  const total = session.durationMs ?? 0;
+  for (const e of session.events) {
+    if (e.role !== "tool-call" || e.toolName !== "Bash")
+      continue;
+    const toolUseBlock = e.blocks.find((b) => b && "type" in b && b.type === "tool_use");
+    if (!toolUseBlock || toolUseBlock.type !== "tool_use")
+      continue;
+    const input = toolUseBlock.input;
+    const command2 = typeof input?.command === "string" ? input.command : "";
+    if (!PR_CREATE_RE.test(command2))
+      continue;
+    const titleMatch = command2.match(TITLE_FLAG_RE);
+    const numberMatch = command2.match(PR_NUMBER_RE);
+    out.push({
+      sessionId: session.id,
+      timestamp: e.timestamp ?? session.firstTimestamp ?? "",
+      tOffsetMs: e.tOffsetMs,
+      positionInSession: total > 0 && e.tOffsetMs !== void 0 ? Math.min(1, Math.max(0, e.tOffsetMs / total)) : void 0,
+      command: command2.slice(0, 300),
+      prNumber: numberMatch ? Number(numberMatch[1]) : void 0,
+      title: titleMatch?.[1]
+    });
+  }
+  return out;
+}
+function sessionAirTimeMs(events, idleThresholdMs = 3 * 60 * 1e3) {
+  let air = 0;
+  for (const e of events) {
+    if (e.gapMs === void 0)
+      continue;
+    if (e.gapMs <= idleThresholdMs)
+      air += e.gapMs;
+  }
+  return air;
+}
+function highLevelMetrics(sessions) {
+  const totals = {
+    sessionCount: sessions.length,
+    totalDurationMs: 0,
+    totalAirTimeMs: 0,
+    totalTokens: { ...BLANK_USAGE2 },
+    totalToolCalls: 0,
+    totalTurns: 0,
+    avgTurnsPerSession: 0,
+    avgDurationMs: 0,
+    totalLinesAdded: 0,
+    totalLinesRemoved: 0,
+    totalFilesEdited: 0
+  };
+  for (const s of sessions) {
+    totals.totalDurationMs += s.durationMs ?? 0;
+    totals.totalAirTimeMs += s.airTimeMs ?? s.durationMs ?? 0;
+    totals.totalTokens.input += s.totalUsage.input;
+    totals.totalTokens.output += s.totalUsage.output;
+    totals.totalTokens.cacheRead += s.totalUsage.cacheRead;
+    totals.totalTokens.cacheWrite += s.totalUsage.cacheWrite;
+    totals.totalToolCalls += s.toolCallCount ?? 0;
+    totals.totalTurns += s.turnCount ?? 0;
+    totals.totalLinesAdded += s.linesAdded ?? 0;
+    totals.totalLinesRemoved += s.linesRemoved ?? 0;
+    totals.totalFilesEdited += s.filesEdited ?? 0;
+  }
+  if (sessions.length > 0) {
+    totals.avgTurnsPerSession = totals.totalTurns / sessions.length;
+    totals.avgDurationMs = totals.totalDurationMs / sessions.length;
+  }
+  return totals;
+}
+function computeActiveSegments(events, idleThresholdMs = 3 * 60 * 1e3) {
+  const timed = events.filter((e) => e.timestamp).map((e) => Date.parse(e.timestamp)).filter((ms) => !Number.isNaN(ms)).sort((a, b) => a - b);
+  if (timed.length === 0)
+    return [];
+  const segments = [];
+  let segStart = timed[0];
+  let segEnd = timed[0];
+  for (let i = 1; i < timed.length; i++) {
+    const t = timed[i];
+    if (t - segEnd > idleThresholdMs) {
+      segments.push({ startMs: segStart, endMs: segEnd });
+      segStart = t;
+    }
+    segEnd = t;
+  }
+  segments.push({ startMs: segStart, endMs: segEnd });
+  return segments;
+}
+function buildGanttDay(sessions, date) {
+  const [y, m, d] = date.split("-").map(Number);
+  const dayStartMs = new Date(y, m - 1, d).getTime();
+  const dayEndMs = new Date(y, m - 1, d + 1).getTime();
+  const ganttSessions = [];
+  for (const s of sessions) {
+    const allSegments = computeActiveSegments(s.events);
+    const daySegments = allSegments.filter((seg) => seg.endMs > dayStartMs && seg.startMs < dayEndMs).map((seg) => ({
+      startMs: Math.max(seg.startMs, dayStartMs),
+      endMs: Math.min(seg.endMs, dayEndMs)
+    }));
+    if (daySegments.length === 0)
+      continue;
+    const startMs = Math.min(...daySegments.map((seg) => seg.startMs));
+    const endMs = Math.max(...daySegments.map((seg) => seg.endMs));
+    const activeMs = daySegments.reduce((sum, seg) => sum + (seg.endMs - seg.startMs), 0);
+    ganttSessions.push({
+      id: s.id,
+      projectName: s.projectName,
+      projectDir: s.projectDir,
+      firstUserPreview: s.firstUserPreview,
+      lastAgentPreview: s.lastAgentPreview,
+      model: s.model,
+      segments: daySegments,
+      startMs,
+      endMs,
+      activeMs,
+      totalUsage: s.totalUsage
+    });
+  }
+  ganttSessions.sort((a, b) => a.startMs - b.startMs);
+  const evts = [];
+  for (const s of ganttSessions) {
+    for (const seg of s.segments) {
+      evts.push({ ms: seg.startMs, delta: 1 });
+      evts.push({ ms: seg.endMs, delta: -1 });
+    }
+  }
+  evts.sort((a, b) => a.ms - b.ms || b.delta - a.delta);
+  let active = 0;
+  let peak = 0;
+  for (const e of evts) {
+    active += e.delta;
+    if (active > peak)
+      peak = active;
+  }
+  return { date, sessions: ganttSessions, dayStartMs, dayEndMs, peakActiveParallelism: peak };
+}
+function detectBurstsCore(sessions, opts) {
+  const minDurationMs = opts.minDurationMs ?? 6e4;
+  const mergeGapMs = opts.mergeGapMs ?? 10 * 6e4;
+  const minActive = opts.minActive ?? 2;
+  const events = [];
+  for (const s of sessions) {
+    for (const seg of s.segments) {
+      if (seg.endMs <= seg.startMs)
+        continue;
+      events.push({ ms: seg.startMs, delta: 1, sessionId: s.id });
+      events.push({ ms: seg.endMs, delta: -1, sessionId: s.id });
+    }
+  }
+  events.sort((a, b) => a.ms - b.ms || b.delta - a.delta);
+  const segCount = /* @__PURE__ */ new Map();
+  const rawRuns = [];
+  let cur = null;
+  for (const e of events) {
+    if (e.delta === 1) {
+      segCount.set(e.sessionId, (segCount.get(e.sessionId) ?? 0) + 1);
+    } else {
+      const n = (segCount.get(e.sessionId) ?? 0) - 1;
+      if (n <= 0)
+        segCount.delete(e.sessionId);
+      else
+        segCount.set(e.sessionId, n);
+    }
+    const active = segCount.size;
+    if (active >= minActive) {
+      if (!cur) {
+        cur = {
+          startMs: e.ms,
+          endMs: e.ms,
+          peak: active,
+          sessionIds: new Set(segCount.keys())
+        };
+      } else {
+        cur.endMs = e.ms;
+        if (active > cur.peak)
+          cur.peak = active;
+        for (const sid of segCount.keys())
+          cur.sessionIds.add(sid);
+      }
+    } else if (cur) {
+      cur.endMs = e.ms;
+      rawRuns.push(cur);
+      cur = null;
+    }
+  }
+  if (cur)
+    rawRuns.push(cur);
+  const significant = rawRuns.filter((r) => r.endMs - r.startMs >= minDurationMs);
+  const merged = [];
+  for (const r of significant) {
+    const last = merged[merged.length - 1];
+    if (last && r.startMs - last.endMs <= mergeGapMs) {
+      last.endMs = r.endMs;
+      if (r.peak > last.peak)
+        last.peak = r.peak;
+      for (const sid of r.sessionIds)
+        last.sessionIds.add(sid);
+    } else {
+      merged.push({
+        startMs: r.startMs,
+        endMs: r.endMs,
+        peak: r.peak,
+        sessionIds: new Set(r.sessionIds)
+      });
+    }
+  }
+  const projectBySession = /* @__PURE__ */ new Map();
+  for (const s of sessions)
+    projectBySession.set(s.id, s.projectDir);
+  return merged.map((r) => {
+    const projectDirs = Array.from(new Set(Array.from(r.sessionIds).map((sid) => projectBySession.get(sid)).filter((p) => !!p)));
+    return {
+      startMs: r.startMs,
+      endMs: r.endMs,
+      peak: r.peak,
+      sessionIds: Array.from(r.sessionIds),
+      projectDirs,
+      crossProject: projectDirs.length > 1
+    };
+  });
+}
+function computeParallelismBursts(gantt, opts = {}) {
+  return detectBurstsCore(gantt.sessions, opts);
+}
+function computeBurstsFromSessions(sessions, opts = {}) {
+  const input = [];
+  for (const s of sessions) {
+    if (!s.activeSegments || s.activeSegments.length === 0)
+      continue;
+    input.push({
+      id: s.id,
+      projectDir: s.projectDir,
+      segments: s.activeSegments
+    });
+  }
+  return detectBurstsCore(input, opts);
+}
+function summarizeBursts(bursts) {
+  let peakConcurrent = 0;
+  let totalParallelMs = 0;
+  let crossProjectBurstCount = 0;
+  const days = /* @__PURE__ */ new Set();
+  for (const b of bursts) {
+    if (b.peak > peakConcurrent)
+      peakConcurrent = b.peak;
+    totalParallelMs += b.endMs - b.startMs;
+    if (b.crossProject)
+      crossProjectBurstCount++;
+    days.add(toLocalDay(b.startMs));
+  }
+  return {
+    peakConcurrent,
+    totalParallelMs,
+    burstCount: bursts.length,
+    crossProjectBurstCount,
+    activeDayCount: days.size
+  };
+}
+function groupByProject(sessions) {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const canonical = canonicalProjectName(s.projectName);
+    const key = canonical;
+    let cur = map.get(key);
+    if (!cur) {
+      cur = {
+        projectDir: canonical,
+        projectName: canonical,
+        sessions: [],
+        rawProjectDirs: [],
+        worktreeCount: 0,
+        metrics: highLevelMetrics([]),
+        lastActiveMs: void 0
+      };
+      map.set(key, cur);
+    }
+    cur.sessions.push(s);
+    if (!cur.rawProjectDirs.includes(s.projectDir)) {
+      cur.rawProjectDirs.push(s.projectDir);
+    }
+    const last = s.lastTimestamp ? Date.parse(s.lastTimestamp) : void 0;
+    if (last && (!cur.lastActiveMs || last > cur.lastActiveMs)) {
+      cur.lastActiveMs = last;
+    }
+  }
+  for (const p of map.values()) {
+    p.metrics = highLevelMetrics(p.sessions);
+    const wtNames = /* @__PURE__ */ new Set();
+    for (const s of p.sessions) {
+      const wt = worktreeName(s.projectName);
+      if (wt)
+        wtNames.add(wt);
+    }
+    p.worktreeCount = wtNames.size;
+  }
+  return Array.from(map.values()).sort((a, b) => (b.lastActiveMs ?? 0) - (a.lastActiveMs ?? 0));
+}
+var BLANK_USAGE2, WORKTREE_MARKERS, PR_CREATE_RE, PR_NUMBER_RE, TITLE_FLAG_RE;
 var init_analytics = __esm({
   "../parser/dist/analytics.js"() {
     "use strict";
+    BLANK_USAGE2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    WORKTREE_MARKERS = ["/.claude/worktrees/", "/.worktrees/"];
+    PR_CREATE_RE = /gh\s+pr\s+create\b/i;
+    PR_NUMBER_RE = /#(\d+)/;
+    TITLE_FLAG_RE = /--title\s+["']([^"']+)["']/;
   }
 });
 
 // ../parser/dist/team.js
+function groupByTeam(sessions, details) {
+  const byTeam = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    if (!s.teamName)
+      continue;
+    const arr = byTeam.get(s.teamName) ?? [];
+    arr.push(s);
+    byTeam.set(s.teamName, arr);
+  }
+  const views = [];
+  for (const [teamName, group] of byTeam) {
+    const view = buildTeamView(teamName, group, details);
+    if (view)
+      views.push(view);
+  }
+  return views;
+}
+function buildTeamView(teamName, group, details) {
+  const candidates = group.filter((s) => s.isTeamLead);
+  if (candidates.length === 0)
+    return null;
+  let lead;
+  for (const c of candidates) {
+    const d = details.get(c.sessionId);
+    if (d && containsTeamCreate(d.events)) {
+      lead = c;
+      break;
+    }
+  }
+  if (!lead) {
+    const sorted = [...candidates].sort((a, b) => Date.parse(a.firstTimestamp ?? "") - Date.parse(b.firstTimestamp ?? ""));
+    lead = sorted[0];
+  }
+  const agentNameBySessionId = /* @__PURE__ */ new Map();
+  for (const s of group)
+    agentNameBySessionId.set(s.sessionId, s.agentName);
+  const members = group.filter((s) => s.sessionId !== lead.sessionId).sort((a, b) => Date.parse(a.firstTimestamp ?? "") - Date.parse(b.firstTimestamp ?? ""));
+  const sessionIdByAgentName = /* @__PURE__ */ new Map();
+  for (const m of members) {
+    if (m.agentName)
+      sessionIdByAgentName.set(m.agentName, m.sessionId);
+  }
+  const messages = [];
+  for (const s of group) {
+    const d = details.get(s.sessionId);
+    if (!d)
+      continue;
+    const senderId = s.sessionId;
+    const senderTeammateId = s.agentName ?? "team-lead";
+    for (const ev of d.events) {
+      const msg = extractSendMessage(ev);
+      if (!msg)
+        continue;
+      const toTeammateId = msg.to;
+      const toSessionId = toTeammateId === "team-lead" ? lead.sessionId : sessionIdByAgentName.get(toTeammateId) ?? "";
+      messages.push({
+        tsMs: ev.timestamp ? Date.parse(ev.timestamp) : 0,
+        fromSessionId: senderId,
+        fromTeammateId: senderTeammateId,
+        toSessionId,
+        toTeammateId,
+        body: msg.body,
+        kind: "message"
+      });
+    }
+  }
+  messages.sort((a, b) => a.tsMs - b.tsMs);
+  const allTs = [];
+  for (const s of group) {
+    if (s.firstTimestamp)
+      allTs.push(Date.parse(s.firstTimestamp));
+    if (s.lastTimestamp)
+      allTs.push(Date.parse(s.lastTimestamp));
+  }
+  const firstEventMs = allTs.length ? Math.min(...allTs) : 0;
+  const lastEventMs = allTs.length ? Math.max(...allTs) : 0;
+  return {
+    teamName,
+    leadSessionId: lead.sessionId,
+    memberSessionIds: members.map((m) => m.sessionId),
+    agentNameBySessionId,
+    messages,
+    firstEventMs,
+    lastEventMs
+  };
+}
+function containsTeamCreate(events) {
+  for (const ev of events) {
+    if (ev.role !== "tool-call")
+      continue;
+    if (ev.toolName === "TeamCreate")
+      return true;
+  }
+  return false;
+}
+function extractSendMessage(ev) {
+  if (ev.role !== "tool-call" || ev.toolName !== "SendMessage")
+    return null;
+  for (const b of ev.blocks) {
+    if (!b || typeof b !== "object")
+      continue;
+    if (b.type !== "tool_use")
+      continue;
+    const input = b.input ?? {};
+    const to = typeof input.to === "string" ? input.to : "";
+    const body = typeof input.message === "string" ? input.message : "";
+    if (!to)
+      return null;
+    return { to, body };
+  }
+  return null;
+}
 var init_team = __esm({
   "../parser/dist/team.js"() {
     "use strict";
@@ -1171,6 +1780,23 @@ var init_team = __esm({
 });
 
 // ../parser/dist/fs.js
+var fs_exports = {};
+__export(fs_exports, {
+  DEFAULT_ROOT: () => DEFAULT_ROOT,
+  cacheStats: () => cacheStats,
+  clearCaches: () => clearCaches,
+  decodeProjectName: () => decodeProjectName,
+  findTeamLead: () => findTeamLead,
+  getSession: () => getSession,
+  invalidateFile: () => invalidateFile,
+  listProjects: () => listProjects,
+  listSessions: () => listSessions,
+  loadTeamForSession: () => loadTeamForSession,
+  loadUsageByDay: () => loadUsageByDay,
+  readJsonlFile: () => readJsonlFile,
+  sessionIdFromFileName: () => sessionIdFromFileName,
+  walkJsonlFiles: () => walkJsonlFiles
+});
 import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -1193,11 +1819,24 @@ async function readJsonlFile(filePath) {
   }
   return out;
 }
+function cacheStats() {
+  return { metaEntries: metaCache.size, detailEntries: detailCache.size };
+}
+function clearCaches() {
+  metaCache.clear();
+  detailCache.clear();
+  fileListCache = null;
+}
+function invalidateFile(fullPath) {
+  metaCache.delete(fullPath);
+  detailCache.delete(fullPath);
+  fileListCache = null;
+}
 async function walkJsonlFiles(root = DEFAULT_ROOT) {
   if (fileListCache && fileListCache.root === root && Date.now() - fileListCache.capturedAtMs < FILE_LIST_TTL_MS) {
     return fileListCache.files;
   }
-  let topEntries = [];
+  let topEntries;
   try {
     topEntries = await fs.readdir(root, { withFileTypes: true });
   } catch {
@@ -1265,7 +1904,7 @@ function aggregateUsageFromLines(lines, seenKeys, usage2) {
   }
 }
 async function computeSessionUsageWithSubagents(parentLines, projectDirPath, sessionId) {
-  const usage2 = { ...BLANK_USAGE2 };
+  const usage2 = { ...BLANK_USAGE3 };
   const seenKeys = /* @__PURE__ */ new Set();
   aggregateUsageFromLines(parentLines, seenKeys, usage2);
   const subagentsDir = path.join(projectDirPath, sessionId, "subagents");
@@ -1311,6 +1950,31 @@ async function getCachedMeta(f) {
     return null;
   }
 }
+async function getCachedDetail(f) {
+  const cached = detailCache.get(f.fullPath);
+  if (cached && cached.mtimeMs === f.mtimeMs && cached.sizeBytes === f.sizeBytes) {
+    return cached.detail;
+  }
+  try {
+    const rawLines = await readJsonlFile(f.fullPath);
+    const { meta, events } = parseTranscript(rawLines);
+    const detail = {
+      ...meta,
+      id: sessionIdFromFileName(f.fileName),
+      filePath: f.fullPath,
+      projectDir: f.projectDir,
+      projectName: meta.cwd ?? decodeProjectName(f.projectDir),
+      events
+    };
+    detailCache.set(f.fullPath, { detail, mtimeMs: f.mtimeMs, sizeBytes: f.sizeBytes });
+    const metaOnly = { ...detail };
+    delete metaOnly.events;
+    metaCache.set(f.fullPath, { meta: metaOnly, mtimeMs: f.mtimeMs, sizeBytes: f.sizeBytes });
+    return detail;
+  } catch {
+    return null;
+  }
+}
 async function listSessions(opts = {}) {
   const { root = DEFAULT_ROOT, limit = 500, projectDir } = opts;
   let files = await walkJsonlFiles(root);
@@ -1321,7 +1985,334 @@ async function listSessions(opts = {}) {
   const metas = await Promise.all(sliced.map((f) => getCachedMeta(f)));
   return metas.filter((m) => m !== null);
 }
-var DEFAULT_ROOT, metaCache, fileListCache, FILE_LIST_TTL_MS, BLANK_USAGE2;
+async function getSession(id, opts = {}) {
+  const { root = DEFAULT_ROOT } = opts;
+  const files = await walkJsonlFiles(root);
+  const hit = files.find((f) => sessionIdFromFileName(f.fileName) === id);
+  if (!hit)
+    return null;
+  const detail = await getCachedDetail(hit);
+  if (!detail)
+    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 };
+}
+function summarizeSubagentLines(lines) {
+  let startMs;
+  let endMs;
+  const totalUsage = { ...BLANK_USAGE3 };
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  let finalText;
+  let model;
+  let eventCount = 0;
+  let assistantMessageCount = 0;
+  let toolCallCount = 0;
+  const toolCounts = /* @__PURE__ */ new Map();
+  let initialPrompt;
+  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 (initialPrompt === void 0 && r.type === "user" && (r.parentUuid === null || r.parentUuid === void 0)) {
+      const msg = r.message;
+      const content = msg?.content;
+      if (typeof content === "string") {
+        initialPrompt = content;
+      } else if (Array.isArray(content)) {
+        const txt = content.find((b) => b && typeof b === "object" && b.type === "text");
+        if (txt?.text)
+          initialPrompt = txt.text;
+      }
+    }
+    if (r.type === "assistant") {
+      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 dedupKey = mid != null && rid != null ? `${mid}:${rid}` : void 0;
+      const fresh = dedupKey ? !seenMessageIds.has(dedupKey) : true;
+      if (dedupKey && fresh)
+        seenMessageIds.add(dedupKey);
+      if (fresh) {
+        assistantMessageCount++;
+        const u = m.usage;
+        if (u) {
+          const toNum = (v) => typeof v === "number" ? v : 0;
+          totalUsage.input += toNum(u.input_tokens);
+          totalUsage.output += toNum(u.output_tokens);
+          totalUsage.cacheRead += toNum(u.cache_read_input_tokens);
+          totalUsage.cacheWrite += toNum(u.cache_creation_input_tokens);
+        }
+      }
+      const content = m.content;
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (!block || typeof block !== "object")
+            continue;
+          if (block.type === "text" && typeof block.text === "string") {
+            finalText = block.text;
+          } else if (block.type === "tool_use" && typeof block.name === "string") {
+            toolCallCount++;
+            toolCounts.set(block.name, (toolCounts.get(block.name) ?? 0) + 1);
+          }
+        }
+      }
+    }
+  }
+  const toolCalls = Array.from(toolCounts.entries()).map(([name, count]) => ({ name, count })).sort((a, b) => b.count - a.count);
+  const finalPreview = finalText !== void 0 ? finalText.replace(/\s+/g, " ").trim().slice(0, 240) : void 0;
+  return {
+    startMs,
+    endMs,
+    totalUsage,
+    eventCount,
+    finalPreview,
+    finalText,
+    model,
+    toolCalls,
+    toolCallCount,
+    assistantMessageCount,
+    initialPrompt
+  };
+}
+async function loadSubagents(dir, sessionStartMs, parentEvents) {
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return [];
+  }
+  const byDesc = /* @__PURE__ */ new Map();
+  const dispatchesByTs = [];
+  for (const e of parentEvents) {
+    if (e.role !== "tool-call" || e.toolName !== "Agent")
+      continue;
+    for (const b of e.blocks) {
+      if (b?.type !== "tool_use" || b.name !== "Agent")
+        continue;
+      const input = b.input ?? {};
+      const desc = typeof input.description === "string" ? input.description : void 0;
+      const tsMs = e.timestamp ? Date.parse(e.timestamp) : void 0;
+      const ref = {
+        toolUseId: b.id,
+        parentUuid: e.uuid ?? "",
+        runInBackground: input.run_in_background === true,
+        prompt: typeof input.prompt === "string" ? input.prompt : void 0,
+        tsMs
+      };
+      if (desc)
+        byDesc.set(desc, ref);
+      if (tsMs !== void 0)
+        dispatchesByTs.push(ref);
+    }
+  }
+  dispatchesByTs.sort((a, b) => (a.tsMs ?? 0) - (b.tsMs ?? 0));
+  function matchByTime(startMs) {
+    if (startMs === void 0)
+      return void 0;
+    const TOLERANCE_MS = 2e3;
+    let best;
+    let bestDelta = Infinity;
+    for (const ref of dispatchesByTs) {
+      if (ref.tsMs === void 0)
+        continue;
+      const delta = Math.abs(startMs - ref.tsMs);
+      if (delta < bestDelta && delta <= TOLERANCE_MS) {
+        best = ref;
+        bestDelta = delta;
+      }
+    }
+    return best;
+  }
+  const jsonlFiles = entries.filter((f) => f.startsWith("agent-") && f.endsWith(".jsonl"));
+  const runs = await Promise.all(jsonlFiles.map(async (f) => {
+    const agentId = f.replace(/^agent-/, "").replace(/\.jsonl$/, "");
+    const jsonlPath = path.join(dir, f);
+    const metaPath = path.join(dir, `agent-${agentId}.meta.json`);
+    let meta = {};
+    try {
+      const raw = await fs.readFile(metaPath, "utf8");
+      meta = JSON.parse(raw);
+    } catch {
+    }
+    let lines;
+    try {
+      lines = await readJsonlFile(jsonlPath);
+    } catch {
+      return null;
+    }
+    const summary = summarizeSubagentLines(lines);
+    const metaDesc = meta.description && meta.description.trim().length > 0 ? meta.description : void 0;
+    const parentRef = metaDesc ? byDesc.get(metaDesc) : matchByTime(summary.startMs);
+    const description = metaDesc ?? (summary.initialPrompt ? summary.initialPrompt.replace(/\s+/g, " ").trim().slice(0, 80) : "(no description)");
+    const prompt = parentRef?.prompt ?? summary.initialPrompt;
+    const startTOffsetMs = sessionStartMs !== void 0 && summary.startMs !== void 0 ? Math.max(0, summary.startMs - sessionStartMs) : void 0;
+    const endTOffsetMs = sessionStartMs !== void 0 && summary.endMs !== void 0 ? Math.max(0, summary.endMs - sessionStartMs) : void 0;
+    const durationMs = summary.startMs !== void 0 && summary.endMs !== void 0 ? summary.endMs - summary.startMs : void 0;
+    return {
+      agentId,
+      agentType: meta.agentType ?? "unknown",
+      description,
+      startMs: summary.startMs,
+      endMs: summary.endMs,
+      durationMs,
+      startTOffsetMs,
+      endTOffsetMs,
+      eventCount: summary.eventCount,
+      totalUsage: summary.totalUsage,
+      parentUuid: parentRef?.parentUuid,
+      parentToolUseId: parentRef?.toolUseId,
+      runInBackground: parentRef?.runInBackground,
+      prompt,
+      finalPreview: summary.finalPreview,
+      finalText: summary.finalText,
+      model: summary.model,
+      toolCalls: summary.toolCalls,
+      toolCallCount: summary.toolCallCount,
+      assistantMessageCount: summary.assistantMessageCount
+    };
+  }));
+  return runs.filter((r) => r !== null).sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
+}
+async function listProjects(root = DEFAULT_ROOT) {
+  const files = await walkJsonlFiles(root);
+  const byRawDir = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const cur = byRawDir.get(f.projectDir) ?? { count: 0, lastActiveMs: 0 };
+    cur.count++;
+    if (f.mtimeMs > cur.lastActiveMs)
+      cur.lastActiveMs = f.mtimeMs;
+    byRawDir.set(f.projectDir, cur);
+  }
+  const cwdForProject = (dir) => {
+    for (const [, entry] of metaCache.entries()) {
+      if (entry.meta.projectDir === dir && entry.meta.cwd) {
+        return entry.meta.cwd;
+      }
+    }
+    return void 0;
+  };
+  const canonicalMap = /* @__PURE__ */ new Map();
+  for (const [rawDir, { count, lastActiveMs }] of byRawDir) {
+    const cwdOrDecoded = cwdForProject(rawDir) ?? decodeProjectName(rawDir);
+    const canonical = canonicalProjectName(cwdOrDecoded);
+    const wt = worktreeName(cwdOrDecoded);
+    const agg = canonicalMap.get(canonical) ?? {
+      canonicalName: canonical,
+      count: 0,
+      lastActiveMs: 0,
+      worktreeBranches: /* @__PURE__ */ new Set()
+    };
+    agg.count += count;
+    if (lastActiveMs > agg.lastActiveMs)
+      agg.lastActiveMs = lastActiveMs;
+    if (wt)
+      agg.worktreeBranches.add(wt);
+    canonicalMap.set(canonical, agg);
+  }
+  return Array.from(canonicalMap.values()).map((a) => ({
+    projectDir: a.canonicalName,
+    projectName: a.canonicalName,
+    sessionCount: a.count,
+    lastActiveMs: a.lastActiveMs,
+    worktreeCount: a.worktreeBranches.size
+  })).sort((a, b) => b.lastActiveMs - a.lastActiveMs);
+}
+async function loadTeamForSession(sessionId, opts = {}) {
+  const { root = DEFAULT_ROOT } = opts;
+  const all = await listSessions({ root });
+  const self = all.find((s) => s.sessionId === sessionId);
+  if (!self || !self.teamName)
+    return null;
+  const teamName = self.teamName;
+  const candidates = all.filter((s) => s.teamName === teamName && !s.filePath.includes("/subagents/"));
+  const loaded = await Promise.all(candidates.map((c) => getSession(c.sessionId, { root })));
+  const details = /* @__PURE__ */ new Map();
+  candidates.forEach((c, i) => {
+    const d = loaded[i];
+    if (d)
+      details.set(c.sessionId, d);
+  });
+  const views = groupByTeam(candidates, details);
+  const view = views.find((v) => v.teamName === teamName);
+  if (!view)
+    return null;
+  return { view, details };
+}
+async function findTeamLead(sessionId, opts = {}) {
+  const { root = DEFAULT_ROOT } = opts;
+  const all = await listSessions({ root });
+  const self = all.find((s) => s.sessionId === sessionId);
+  if (!self || !self.teamName || !self.agentName)
+    return null;
+  if (self.isTeamLead)
+    return null;
+  const candidates = all.filter((s) => s.teamName === self.teamName && s.isTeamLead && !s.filePath.includes("/subagents/"));
+  if (candidates.length === 0)
+    return null;
+  return {
+    leadSessionId: candidates[0].sessionId,
+    teamName: self.teamName,
+    agentName: self.agentName
+  };
+}
+async function loadUsageByDay(start2, end) {
+  let raw;
+  try {
+    raw = await fs.readFile(USAGE_LOG2, "utf8");
+  } catch {
+    return { by_day: [] };
+  }
+  const startMs = new Date(start2.getFullYear(), start2.getMonth(), start2.getDate()).getTime();
+  const endMs = new Date(end.getFullYear(), end.getMonth(), end.getDate(), 23, 59, 59, 999).getTime();
+  const byDay = /* @__PURE__ */ new Map();
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      const snap = JSON.parse(trimmed);
+      if (!snap.captured_at)
+        continue;
+      const ms = Date.parse(snap.captured_at);
+      if (Number.isNaN(ms))
+        continue;
+      if (ms < startMs)
+        continue;
+      if (ms > endMs)
+        break;
+      const key = toLocalDay(ms);
+      const util = snap.five_hour?.utilization ?? 0;
+      const cur2 = byDay.get(key) ?? 0;
+      if (util > cur2)
+        byDay.set(key, util);
+    } catch {
+    }
+  }
+  const out = [];
+  const cur = new Date(start2.getFullYear(), start2.getMonth(), start2.getDate());
+  const stop2 = new Date(end.getFullYear(), end.getMonth(), end.getDate());
+  while (cur.getTime() <= stop2.getTime()) {
+    const k = toLocalDay(cur.getTime());
+    out.push({ date: k, peak_util_pct: byDay.get(k) ?? 0 });
+    cur.setDate(cur.getDate() + 1);
+  }
+  return { by_day: out };
+}
+var DEFAULT_ROOT, metaCache, detailCache, fileListCache, FILE_LIST_TTL_MS, BLANK_USAGE3, USAGE_LOG2;
 var init_fs = __esm({
   "../parser/dist/fs.js"() {
     "use strict";
@@ -1330,26 +2321,1467 @@ var init_fs = __esm({
     init_team();
     DEFAULT_ROOT = path.join(os.homedir(), ".claude", "projects");
     metaCache = /* @__PURE__ */ new Map();
+    detailCache = /* @__PURE__ */ new Map();
     fileListCache = null;
     FILE_LIST_TTL_MS = 1e3;
-    BLANK_USAGE2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    BLANK_USAGE3 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    USAGE_LOG2 = path.join(os.homedir(), ".cclens", "usage.jsonl");
   }
 });
 
-// src/pricing.ts
-function findPricing(model) {
-  for (const [prefix, pricing] of PRICING) {
-    if (model.startsWith(prefix)) return pricing;
+// ../parser/dist/types.js
+var init_types = __esm({
+  "../parser/dist/types.js"() {
+    "use strict";
   }
-  return null;
-}
-function estimateCost(model, usage2) {
-  const p = findPricing(model);
-  if (!p) return null;
-  return (usage2.input * p.input + usage2.output * p.output + usage2.cacheRead * p.cacheRead + usage2.cacheWrite * p.cacheWrite) / 1e6;
+});
+
+// ../parser/dist/presentation.js
+function rowPrimaryIndex(r) {
+  if (r.kind === "tool-group")
+    return r.events[0].index;
+  return r.event.index;
 }
-var PRICING;
-var init_pricing = __esm({
+function buildMegaRows(rows) {
+  const out = [];
+  let buffer = [];
+  const flush = () => {
+    if (buffer.length === 0)
+      return;
+    let agentMessages = 0;
+    let toolCalls = 0;
+    let errors = 0;
+    let firstAgentIndex;
+    const toolMap = /* @__PURE__ */ new Map();
+    const seenMsgIds = /* @__PURE__ */ new Set();
+    const tokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    for (let i = 0; i < buffer.length; i++) {
+      const r = buffer[i];
+      if (r.kind === "agent") {
+        agentMessages++;
+        if (firstAgentIndex === void 0)
+          firstAgentIndex = i;
+        const msgId = r.event.messageId;
+        const usage2 = r.event.usage;
+        if (msgId && !seenMsgIds.has(msgId) && usage2) {
+          seenMsgIds.add(msgId);
+          tokens.input += usage2.input;
+          tokens.output += usage2.output;
+          tokens.cacheRead += usage2.cacheRead;
+          tokens.cacheWrite += usage2.cacheWrite;
+        }
+      } else if (r.kind === "tool-group") {
+        toolCalls += r.count;
+        for (const t of r.toolNames) {
+          toolMap.set(t.name, (toolMap.get(t.name) ?? 0) + t.count);
+        }
+      } else if (r.kind === "error") {
+        errors++;
+      }
+    }
+    let finalAgentIndex;
+    for (let i = buffer.length - 1; i >= 0; i--) {
+      const r = buffer[i];
+      if (r.kind !== "agent")
+        continue;
+      const prev = buffer[i - 1];
+      if (prev?.kind === "task-notification")
+        continue;
+      finalAgentIndex = i;
+      break;
+    }
+    if (finalAgentIndex === void 0) {
+      for (let i = buffer.length - 1; i >= 0; i--) {
+        if (buffer[i].kind === "agent") {
+          finalAgentIndex = i;
+          break;
+        }
+      }
+    }
+    const firstAgentPreview = firstAgentIndex !== void 0 && buffer[firstAgentIndex].kind === "agent" ? buffer[firstAgentIndex].event.preview : void 0;
+    const finalAgentPreview = finalAgentIndex !== void 0 && buffer[finalAgentIndex].kind === "agent" ? buffer[finalAgentIndex].event.preview : void 0;
+    const toolNames = Array.from(toolMap.entries()).sort((a, b) => b[1] - a[1]).map(([name, count]) => ({ name, count }));
+    const first = buffer[0];
+    const last = buffer[buffer.length - 1];
+    const start2 = first.tOffsetMs;
+    const end = last.tOffsetMs;
+    const durationMs = start2 !== void 0 && end !== void 0 ? end - start2 : void 0;
+    out.push({
+      kind: "turn",
+      rows: buffer,
+      firstPrimaryIndex: rowPrimaryIndex(first),
+      tOffsetMs: start2,
+      durationMs,
+      summary: {
+        agentMessages,
+        toolCalls,
+        errors,
+        firstAgentPreview,
+        finalAgentPreview,
+        firstAgentIndex,
+        finalAgentIndex,
+        toolNames,
+        totalTokens: tokens
+      }
+    });
+    buffer = [];
+  };
+  for (const r of rows) {
+    if (r.kind === "user" || r.kind === "interrupt") {
+      flush();
+      out.push(r);
+    } else {
+      buffer.push(r);
+    }
+  }
+  flush();
+  return out;
+}
+function parseTaskNotification(text) {
+  if (!TASK_NOTIFICATION_RE.test(text))
+    return null;
+  const pick = (tag) => {
+    const m = text.match(new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`));
+    return m ? m[1].trim() : void 0;
+  };
+  const statusRaw = (pick("status") ?? "").toLowerCase();
+  let status2 = "unknown";
+  if (statusRaw === "success" || statusRaw === "ok" || statusRaw === "done" || statusRaw === "completed")
+    status2 = "success";
+  else if (statusRaw === "failed" || statusRaw === "error" || statusRaw === "fail")
+    status2 = "failed";
+  else if (statusRaw === "running" || statusRaw === "in_progress")
+    status2 = "running";
+  return {
+    status: status2,
+    summary: pick("summary") ?? "Background task notification",
+    taskId: pick("task-id"),
+    toolUseId: pick("tool-use-id"),
+    outputFile: pick("output-file")
+  };
+}
+function isAttachmentOrMeta(e) {
+  return e.role === "system" || e.role === "meta";
+}
+function firstTextOfBlocks(blocks) {
+  for (const b of blocks) {
+    if (b?.type === "text")
+      return b.text;
+  }
+  return void 0;
+}
+function hasZeroUsage(e) {
+  if (!e.usage)
+    return false;
+  const u = e.usage;
+  return u.input === 0 && u.output === 0 && u.cacheRead === 0 && u.cacheWrite === 0;
+}
+function buildPresentation(events) {
+  const byMessageId = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (!e.messageId)
+      continue;
+    const list = byMessageId.get(e.messageId) ?? [];
+    list.push(e);
+    byMessageId.set(e.messageId, list);
+  }
+  const visible = events.filter((e) => {
+    if (isAttachmentOrMeta(e))
+      return false;
+    if (e.role === "tool-result")
+      return false;
+    if (e.role === "agent-thinking")
+      return false;
+    if (e.role === "user") {
+      const txt = firstTextOfBlocks(e.blocks) ?? "";
+      if (SKILL_CONTENT_RE.test(txt))
+        return false;
+    }
+    return true;
+  });
+  const rows = [];
+  for (let i = 0; i < visible.length; i++) {
+    const e = visible[i];
+    if (e.role === "tool-call") {
+      const start2 = i;
+      while (i + 1 < visible.length && visible[i + 1].role === "tool-call") {
+        i++;
+      }
+      const group = visible.slice(start2, i + 1);
+      const order = [];
+      const counts = /* @__PURE__ */ new Map();
+      for (const ev of group) {
+        const name = ev.toolName ?? "tool";
+        if (!counts.has(name))
+          order.push(name);
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+      }
+      const toolNames = order.map((name) => ({
+        name,
+        count: counts.get(name) ?? 1
+      }));
+      rows.push({
+        kind: "tool-group",
+        toolNames,
+        count: group.length,
+        events: group,
+        tOffsetMs: group[0].tOffsetMs,
+        gapMs: group[0].gapMs
+      });
+      continue;
+    }
+    if (e.role === "user") {
+      const txt = firstTextOfBlocks(e.blocks) ?? "";
+      const taskNotif = parseTaskNotification(txt);
+      if (taskNotif) {
+        rows.push({
+          kind: "task-notification",
+          event: e,
+          status: taskNotif.status,
+          summary: taskNotif.summary,
+          taskId: taskNotif.taskId,
+          toolUseId: taskNotif.toolUseId,
+          outputFile: taskNotif.outputFile,
+          tOffsetMs: e.tOffsetMs,
+          gapMs: e.gapMs
+        });
+        continue;
+      }
+      if (INTERRUPT_RE.test(txt)) {
+        rows.push({
+          kind: "interrupt",
+          event: e,
+          tOffsetMs: e.tOffsetMs,
+          gapMs: e.gapMs
+        });
+        continue;
+      }
+      const slashMatch = txt.match(SLASH_COMMAND_RE);
+      if (slashMatch) {
+        const cmd = slashMatch[1];
+        const args2 = (slashMatch[2] ?? "").trim();
+        const pretty = args2 ? `${cmd} ${args2}` : cmd;
+        rows.push({
+          kind: "user",
+          event: e,
+          displayPreview: pretty,
+          displayBlocks: [{ type: "text", text: pretty }],
+          tOffsetMs: e.tOffsetMs,
+          gapMs: e.gapMs
+        });
+        continue;
+      }
+      rows.push({
+        kind: "user",
+        event: e,
+        tOffsetMs: e.tOffsetMs,
+        gapMs: e.gapMs
+      });
+      continue;
+    }
+    if (e.role === "agent") {
+      const txt = firstTextOfBlocks(e.blocks) ?? "";
+      if (hasZeroUsage(e)) {
+        rows.push({
+          kind: "model",
+          event: e,
+          tOffsetMs: e.tOffsetMs,
+          gapMs: e.gapMs
+        });
+        if (RATE_LIMIT_RE.test(txt) && txt.length < 500) {
+          rows.push({
+            kind: "error",
+            event: e,
+            message: txt,
+            tOffsetMs: e.tOffsetMs,
+            gapMs: 0
+          });
+        }
+        continue;
+      }
+      if (RATE_LIMIT_RE.test(txt) && txt.length < 500) {
+        rows.push({
+          kind: "error",
+          event: e,
+          message: txt,
+          tOffsetMs: e.tOffsetMs,
+          gapMs: e.gapMs
+        });
+        continue;
+      }
+      const grouped = e.messageId ? byMessageId.get(e.messageId) ?? [e] : [e];
+      rows.push({
+        kind: "agent",
+        event: e,
+        groupedEvents: grouped,
+        tOffsetMs: e.tOffsetMs,
+        gapMs: e.gapMs
+      });
+      continue;
+    }
+  }
+  return rows;
+}
+var INTERRUPT_RE, RATE_LIMIT_RE, SKILL_CONTENT_RE, SLASH_COMMAND_RE, TASK_NOTIFICATION_RE;
+var init_presentation = __esm({
+  "../parser/dist/presentation.js"() {
+    "use strict";
+    INTERRUPT_RE = /\[request interrupted|interrupted by user/i;
+    RATE_LIMIT_RE = /rate.?limit|overloaded_error|api error|Error sending message/i;
+    SKILL_CONTENT_RE = /^Base directory for this skill:/;
+    SLASH_COMMAND_RE = /<command-name>(\/[^<\s]+)<\/command-name>(?:[\s\S]*?<command-args>([\s\S]*?)<\/command-args>)?/;
+    TASK_NOTIFICATION_RE = /<task-notification>/;
+  }
+});
+
+// ../parser/dist/capsule.js
+function trunc(s, n) {
+  if (!s)
+    return "";
+  const one = s.replace(/\s+/g, " ").trim();
+  return one.length <= n ? one : one.slice(0, n - 1) + "\u2026";
+}
+function minimizeImages(s) {
+  if (!s)
+    return s;
+  let counter = 0;
+  return s.replace(IMAGE_BLOCK_RE, () => `[Image #${++counter}]`);
+}
+function firstNSentences(s, n = 3, hardCap = 500) {
+  if (!s)
+    return "";
+  const flat = s.replace(/\s+/g, " ").trim();
+  const out = flat.split(SENTENCE_SPLIT_RE).slice(0, n).join(" ").trim();
+  return out.length > hardCap ? out.slice(0, hardCap - 1) + "\u2026" : out;
+}
+function median(xs) {
+  if (xs.length === 0)
+    return 0;
+  const s = [...xs].sort((a, b) => a - b);
+  const n = s.length;
+  return n % 2 ? s[n >> 1] : (s[(n >> 1) - 1] + s[n >> 1]) / 2;
+}
+function p90(xs) {
+  if (xs.length === 0)
+    return 0;
+  const s = [...xs].sort((a, b) => a - b);
+  return s[Math.min(Math.floor(0.9 * s.length), s.length - 1)];
+}
+function bashVerb(cmd) {
+  if (!cmd)
+    return "?";
+  let firstSeg = cmd.split(BASH_CHAIN_SPLIT_RE, 1)[0].trim();
+  if (firstSeg.startsWith("cd ") || firstSeg === "cd") {
+    const parts = cmd.split(/&&|;/, 3);
+    if (parts.length >= 2)
+      firstSeg = parts[1].trim();
+  }
+  const tokens = firstSeg.split(/\s+/).filter(Boolean);
+  while (tokens.length && SHELL_NOISE.has(tokens[0]))
+    tokens.shift();
+  if (!tokens.length)
+    return "?";
+  let first = tokens[0];
+  if (first.includes("=") && !first.startsWith("/")) {
+    tokens.shift();
+    if (!tokens.length)
+      return "?";
+    first = tokens[0];
+  }
+  if (first.includes("/") && !first.startsWith("./")) {
+    first = first.replace(/\/+$/, "").split("/").pop();
+  }
+  return first.replace(/^["']|["']$/g, "") || "?";
+}
+function newTurn(startMs, userInput = "") {
+  return {
+    startMs,
+    lastMs: startMs,
+    eventTs: startMs !== void 0 ? [startMs] : [],
+    userInput,
+    firstToolsIfNoText: [],
+    toolsTotal: 0,
+    toolMix: /* @__PURE__ */ new Map(),
+    bashVerbs: /* @__PURE__ */ new Map(),
+    skills: /* @__PURE__ */ new Map(),
+    subagents: [],
+    taskOps: 0,
+    toolErrors: 0,
+    consecSameToolMax: 0,
+    consec: 0,
+    endedInInterrupt: false,
+    models: /* @__PURE__ */ new Map(),
+    tokensIn: 0,
+    tokensOut: 0,
+    tokensCacheR: 0,
+    tokensCacheW: 0,
+    seenMsgIds: /* @__PURE__ */ new Set()
+  };
+}
+function closeTurn(t, closed) {
+  const ts = [...t.eventTs].sort((a, b) => a - b);
+  let active = 0;
+  for (let i = 1; i < ts.length; i++) {
+    const dt = ts[i] - ts[i - 1];
+    if (dt < IDLE_GAP_MS)
+      active += dt;
+  }
+  const wall = t.startMs !== void 0 && t.lastMs !== void 0 ? t.lastMs - t.startMs : 0;
+  closed.push({
+    startMs: t.startMs ?? 0,
+    activeMs: active,
+    wallMs: wall,
+    userInput: t.userInput,
+    firstAgentText: t.firstAgentText,
+    lastAgentText: t.lastAgentText,
+    firstToolsIfNoText: t.firstToolsIfNoText,
+    toolsTotal: t.toolsTotal,
+    toolMix: t.toolMix,
+    bashVerbs: t.bashVerbs,
+    skills: t.skills,
+    subagents: t.subagents,
+    taskOps: t.taskOps,
+    toolErrors: t.toolErrors,
+    consecSameToolMax: t.consecSameToolMax,
+    endedInInterrupt: t.endedInInterrupt,
+    models: t.models,
+    totalTokens: t.tokensIn + t.tokensOut + t.tokensCacheR + t.tokensCacheW
+  });
+}
+function firstTextBlock(blocks) {
+  if (!Array.isArray(blocks))
+    return "";
+  for (const b of blocks) {
+    if (b && typeof b === "object" && b.type === "text") {
+      return String(b.text ?? "");
+    }
+  }
+  return "";
+}
+function parseMs(iso) {
+  if (!iso)
+    return void 0;
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? void 0 : ms;
+}
+function buildCapsule(session, opts = {}) {
+  const { compact = false } = opts;
+  let firstUserSession;
+  let finalAgentSession;
+  const prTitles = [];
+  let commits = 0;
+  let pushes = 0;
+  const modelTurnsGlobal = /* @__PURE__ */ new Map();
+  let totalToolErrors = 0;
+  let totalInterrupts = 0;
+  let exitPlanCalls = 0;
+  let taskOpsGlobal = 0;
+  const closed = [];
+  let cur;
+  let sessionFirstTs;
+  let sessionLastTs;
+  const allEventTs = [];
+  for (const ev of session.events) {
+    const tsMs = parseMs(ev.timestamp);
+    if (tsMs !== void 0) {
+      if (sessionFirstTs === void 0 || tsMs < sessionFirstTs)
+        sessionFirstTs = tsMs;
+      if (sessionLastTs === void 0 || tsMs > sessionLastTs)
+        sessionLastTs = tsMs;
+      allEventTs.push(tsMs);
+    }
+    const rawType = ev.rawType;
+    const raw = ev.raw;
+    const msg = raw?.message ?? {};
+    const content = msg.content;
+    if (rawType === "user") {
+      const isToolResultOnly = Array.isArray(content) && content.length > 0 && content.every((c) => c && typeof c === "object" && c.type === "tool_result");
+      if (!isToolResultOnly) {
+        const text = firstTextBlock(content) || (typeof content === "string" ? content : "");
+        if (cur) {
+          if (text && INTERRUPT_RE2.test(text)) {
+            cur.endedInInterrupt = true;
+            totalInterrupts++;
+          }
+          closeTurn(cur, closed);
+        }
+        cur = newTurn(tsMs, text);
+        if (!firstUserSession && text && !text.startsWith("<command-name>")) {
+          firstUserSession = text;
+        }
+      } else {
+        if (Array.isArray(content)) {
+          for (const c of content) {
+            if (c && typeof c === "object" && c.type === "tool_result" && c.is_error) {
+              totalToolErrors++;
+              if (cur)
+                cur.toolErrors++;
+            }
+          }
+        }
+        if (cur && tsMs !== void 0) {
+          cur.eventTs.push(tsMs);
+          cur.lastMs = tsMs;
+        }
+      }
+    } else if (rawType === "assistant") {
+      if (cur && tsMs !== void 0) {
+        cur.eventTs.push(tsMs);
+        cur.lastMs = tsMs;
+      }
+      const model = msg.model;
+      if (model) {
+        modelTurnsGlobal.set(model, (modelTurnsGlobal.get(model) ?? 0) + 1);
+        if (cur)
+          cur.models.set(model, (cur.models.get(model) ?? 0) + 1);
+      }
+      const msgId = msg.id;
+      const usage2 = msg.usage;
+      if (cur && msgId && !cur.seenMsgIds.has(msgId) && usage2) {
+        cur.seenMsgIds.add(msgId);
+        cur.tokensIn += usage2.input_tokens ?? 0;
+        cur.tokensOut += usage2.output_tokens ?? 0;
+        cur.tokensCacheR += usage2.cache_read_input_tokens ?? 0;
+        cur.tokensCacheW += usage2.cache_creation_input_tokens ?? 0;
+      }
+      if (Array.isArray(content)) {
+        for (const c of content) {
+          if (!c || typeof c !== "object")
+            continue;
+          const ct = c;
+          if (ct.type === "text" && ct.text) {
+            finalAgentSession = ct.text;
+            if (cur) {
+              if (cur.firstAgentText === void 0)
+                cur.firstAgentText = ct.text;
+              cur.lastAgentText = ct.text;
+            }
+          } else if (ct.type === "tool_use") {
+            const name = ct.name ?? "unknown";
+            if (cur) {
+              cur.toolsTotal++;
+              cur.toolMix.set(name, (cur.toolMix.get(name) ?? 0) + 1);
+              if (cur.firstAgentText === void 0 && cur.firstToolsIfNoText.length < 3) {
+                cur.firstToolsIfNoText.push(name);
+              }
+              if (name === cur.lastTool)
+                cur.consec++;
+              else {
+                cur.lastTool = name;
+                cur.consec = 1;
+              }
+              if (cur.consec > cur.consecSameToolMax)
+                cur.consecSameToolMax = cur.consec;
+              if (name === "Skill") {
+                const sk = String(ct.input?.skill ?? "unknown");
+                cur.skills.set(sk, (cur.skills.get(sk) ?? 0) + 1);
+              } else if (name === "ToolSearch") {
+                const q = String(ct.input?.query ?? "");
+                const key = `(ToolSearch: ${trunc(q, 60)})`;
+                cur.skills.set(key, (cur.skills.get(key) ?? 0) + 1);
+              }
+              if (name === "Agent") {
+                const inp = ct.input ?? {};
+                cur.subagents.push({
+                  type: String(inp.subagent_type ?? "general-purpose"),
+                  model: typeof inp.model === "string" ? inp.model : void 0,
+                  description: trunc(String(inp.description ?? ""), 80),
+                  prompt_preview: trunc(String(inp.prompt ?? ""), 240),
+                  background: Boolean(inp.run_in_background)
+                });
+              }
+              if (name === "ExitPlanMode")
+                exitPlanCalls++;
+              if (name === "TodoWrite" || name === "TaskCreate" || name === "TaskUpdate") {
+                cur.taskOps++;
+                taskOpsGlobal++;
+              }
+            }
+            if (name === "Bash") {
+              const cmd = String(ct.input?.command ?? "");
+              if (cur)
+                cur.bashVerbs.set(bashVerb(cmd), (cur.bashVerbs.get(bashVerb(cmd)) ?? 0) + 1);
+              if (/\bgh\s+pr\s+create\b/.test(cmd)) {
+                const m = cmd.match(PR_TITLE_RE);
+                prTitles.push(m?.[1] ?? cmd.slice(0, 120));
+              }
+              if (/\bgit\s+commit\b/.test(cmd))
+                commits++;
+              if (/\bgit\s+push\b/.test(cmd))
+                pushes++;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (cur)
+    closeTurn(cur, closed);
+  const tsSorted = [...allEventTs].sort((a, b) => a - b);
+  let activeMsTotal = 0;
+  for (let i = 1; i < tsSorted.length; i++) {
+    const dt = tsSorted[i] - tsSorted[i - 1];
+    if (dt < IDLE_GAP_MS)
+      activeMsTotal += dt;
+  }
+  const turnActives = closed.map((t) => t.activeMs);
+  const turnTools = closed.map((t) => t.toolsTotal);
+  const turnTokens = closed.map((t) => t.totalTokens);
+  const subagentTurns = closed.filter((t) => t.subagents.length > 0).length;
+  const primaryModel = [...modelTurnsGlobal.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+  const consecMax = Math.max(0, ...closed.map((t) => t.consecSameToolMax));
+  const longestTurnActive = Math.max(0, ...turnActives);
+  const sessionSkills = /* @__PURE__ */ new Map();
+  const sessionSubagents = [];
+  for (const t of closed) {
+    for (const [k, v] of t.skills)
+      sessionSkills.set(k, (sessionSkills.get(k) ?? 0) + v);
+    sessionSubagents.push(...t.subagents);
+  }
+  const skillCalls = [...sessionSkills.values()].reduce((a, b) => a + b, 0);
+  const prs = prTitles.length;
+  let outcome;
+  if (prs > 0)
+    outcome = "shipped";
+  else if (commits > 0 && pushes > 0)
+    outcome = "shipped-no-pr";
+  else if (commits > 0)
+    outcome = "partial";
+  else if (activeMsTotal < 2 * 6e4 && closed.length < 3)
+    outcome = "trivial";
+  else
+    outcome = "exploratory";
+  const flags = [];
+  if (totalInterrupts >= 3)
+    flags.push("interrupt_heavy");
+  if (totalToolErrors >= 20)
+    flags.push("high_errors");
+  if (consecMax >= 8)
+    flags.push("loop_suspected");
+  if (activeMsTotal < 5 * 6e4 && prs >= 1)
+    flags.push("fast_ship");
+  if (exitPlanCalls > 0)
+    flags.push("plan_used");
+  if (subagentTurns >= 3)
+    flags.push("orchestrated");
+  if (longestTurnActive >= 20 * 6e4 && totalInterrupts === 0)
+    flags.push("long_autonomous");
+  const maxTokens = Math.max(1, ...turnTokens);
+  const maxTools = Math.max(1, ...turnTools);
+  function significance(t) {
+    return 0.5 * (t.totalTokens / maxTokens) + 0.5 * (t.toolsTotal / maxTools);
+  }
+  let substantive = closed.filter((t) => t.activeMs >= TURN_FLOOR_MS || t.toolsTotal >= 1);
+  const droppedTrivial = closed.length - substantive.length;
+  if (substantive.length > MAX_TURNS_IN_CAPSULE) {
+    substantive = [...substantive].sort((a, b) => significance(b) - significance(a)).slice(0, MAX_TURNS_IN_CAPSULE);
+  }
+  substantive.sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
+  function renderTurn(t) {
+    const tOffsetS = t.startMs && sessionFirstTs ? (t.startMs - sessionFirstTs) / 1e3 : 0;
+    const topToolsArr = [];
+    const topTools = [...t.toolMix.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+    for (const [name, count] of topTools) {
+      if (name === "Bash" && t.bashVerbs.size > 0) {
+        const sub = [...t.bashVerbs.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([v, c]) => c > 1 ? `${v}\xD7${c}` : v).join(", ");
+        topToolsArr.push(`Bash\xD7${count} (${sub})`);
+      } else {
+        topToolsArr.push(count > 1 ? `${name}\xD7${count}` : name);
+      }
+    }
+    const firstAgentRaw = t.firstAgentText ?? (t.firstToolsIfNoText.length > 0 ? `(tools only: ${t.firstToolsIfNoText.join(", ")})` : "");
+    const firstTrunc = trunc(minimizeImages(firstAgentRaw), 260);
+    const finalTrunc = firstNSentences(minimizeImages(t.lastAgentText ?? ""), 3, 500);
+    const ended = t.endedInInterrupt ? "interrupt" : t.lastAgentText ? "text" : "tool-in-flight";
+    const model = [...t.models.entries()].sort((a, b) => b[1] - a[1])[0]?.[0];
+    const turn = {
+      t_offset_min: Math.round(tOffsetS / 6) / 10,
+      active_min: Math.round(t.activeMs / 6e3) / 10,
+      wall_min: Math.round(t.wallMs / 6e3) / 10,
+      user_input: trunc(minimizeImages(t.userInput), 300),
+      tools_total: t.toolsTotal,
+      top_tools: topToolsArr,
+      tokens: t.totalTokens,
+      errors: t.toolErrors,
+      consec_same_tool_max: t.consecSameToolMax,
+      ended,
+      model
+    };
+    if (firstTrunc && finalTrunc && firstTrunc === finalTrunc) {
+      turn.agent = firstTrunc;
+    } else if (firstAgentRaw && t.lastAgentText && t.firstAgentText === t.lastAgentText) {
+      turn.agent = finalTrunc;
+    } else {
+      turn.first_agent = firstTrunc;
+      turn.final_agent = finalTrunc;
+    }
+    if (t.skills.size > 0)
+      turn.skills = Object.fromEntries(t.skills);
+    if (t.subagents.length > 0)
+      turn.subagents = t.subagents;
+    return turn;
+  }
+  const capsule = {
+    session_id: session.id,
+    project: session.projectName,
+    start_iso: session.firstTimestamp,
+    end_iso: session.lastTimestamp,
+    outcome,
+    flags,
+    primary_model: primaryModel,
+    model_mix: Object.fromEntries(modelTurnsGlobal),
+    numbers: {
+      active_min: Math.round(activeMsTotal / 6e3) / 10,
+      turn_count: closed.length,
+      longest_turn_min: Math.round(longestTurnActive / 6e3) / 10,
+      median_turn_min: Math.round(median(turnActives) / 6e3) / 10,
+      p90_turn_min: Math.round(p90(turnActives) / 6e3) / 10,
+      tools_total: turnTools.reduce((a, b) => a + b, 0),
+      tokens_total: turnTokens.reduce((a, b) => a + b, 0),
+      subagent_turns: subagentTurns,
+      subagent_calls: sessionSubagents.length,
+      skill_calls: skillCalls,
+      task_ops: taskOpsGlobal,
+      interrupts: totalInterrupts,
+      tool_errors: totalToolErrors,
+      consec_same_tool_max: consecMax,
+      exit_plan_calls: exitPlanCalls,
+      prs,
+      commits,
+      pushes
+    },
+    pr_titles: prTitles,
+    first_user: trunc(minimizeImages(firstUserSession ?? ""), 400),
+    final_agent: trunc(minimizeImages(finalAgentSession ?? ""), 400)
+  };
+  if (sessionSkills.size > 0)
+    capsule.skills = Object.fromEntries(sessionSkills);
+  if (sessionSubagents.length > 0)
+    capsule.subagents = sessionSubagents;
+  if (!compact) {
+    capsule.numbers.turns_in_capsule = substantive.length;
+    capsule.numbers.trivial_turns_dropped = droppedTrivial;
+    capsule.turns = substantive.map(renderTurn);
+  }
+  return capsule;
+}
+var IDLE_GAP_MS, MAX_TURNS_IN_CAPSULE, TURN_FLOOR_MS, INTERRUPT_RE2, SENTENCE_SPLIT_RE, IMAGE_BLOCK_RE, PR_TITLE_RE, BASH_CHAIN_SPLIT_RE, SHELL_NOISE;
+var init_capsule = __esm({
+  "../parser/dist/capsule.js"() {
+    "use strict";
+    IDLE_GAP_MS = 3 * 60 * 1e3;
+    MAX_TURNS_IN_CAPSULE = 25;
+    TURN_FLOOR_MS = 15 * 1e3;
+    INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
+    SENTENCE_SPLIT_RE = /(?<=[.!?])\s+(?=[A-Z[`])/;
+    IMAGE_BLOCK_RE = /\[Image:\s*source:\s*[^\]]+\]/g;
+    PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
+    BASH_CHAIN_SPLIT_RE = /\|\||&&|;|\|/;
+    SHELL_NOISE = /* @__PURE__ */ new Set(["sudo", "time", "nohup", "nice", "env", "exec"]);
+  }
+});
+
+// ../parser/dist/aggregate.js
+function isoDay(d) {
+  return toLocalDay(d.getTime());
+}
+function rangeDays(start2, end) {
+  const out = [];
+  const cur = new Date(start2.getFullYear(), start2.getMonth(), start2.getDate());
+  const stop2 = new Date(end.getFullYear(), end.getMonth(), end.getDate());
+  while (cur.getTime() <= stop2.getTime()) {
+    out.push(new Date(cur));
+    cur.setDate(cur.getDate() + 1);
+  }
+  return out;
+}
+function prettyProjectName(p) {
+  const cleaned = p.replace(/^\/Users\/[^/]+\//, "");
+  return cleaned || p;
+}
+function buildPeriodBundle(caps, opts) {
+  const { period, trivial_dropped, sessions_total } = opts;
+  const days = rangeDays(period.start, period.end);
+  const dayKeys = new Map(days.map((d) => [isoDay(d), d]));
+  const dayAgent = /* @__PURE__ */ new Map();
+  const daySessions = /* @__PURE__ */ new Map();
+  for (const k of dayKeys.keys()) {
+    dayAgent.set(k, 0);
+    daySessions.set(k, 0);
+  }
+  for (const c of caps) {
+    if (!c.start_iso)
+      continue;
+    const d = isoDay(new Date(c.start_iso));
+    if (!dayAgent.has(d))
+      continue;
+    dayAgent.set(d, (dayAgent.get(d) ?? 0) + c.numbers.active_min);
+    daySessions.set(d, (daySessions.get(d) ?? 0) + 1);
+  }
+  const by_day = days.map((d) => {
+    const key = isoDay(d);
+    return {
+      date: key,
+      day_name: DAY_NAMES[d.getDay()],
+      agent_min: Math.round((dayAgent.get(key) ?? 0) * 10) / 10,
+      sessions: daySessions.get(key) ?? 0
+    };
+  });
+  const projectAccum = /* @__PURE__ */ new Map();
+  for (const c of caps) {
+    const canon = canonicalProjectName(c.project ?? "unknown");
+    const b = projectAccum.get(canon) ?? { agent_min: 0, prs: 0, commits: 0 };
+    b.agent_min += c.numbers.active_min;
+    b.prs += c.numbers.prs;
+    b.commits += c.numbers.commits;
+    projectAccum.set(canon, b);
+  }
+  const totalProjectMin = [...projectAccum.values()].reduce((a, b) => a + b.agent_min, 0);
+  const project_shares = [...projectAccum.entries()].map(([name, b]) => ({
+    name,
+    display_name: prettyProjectName(name),
+    agent_min: Math.round(b.agent_min * 10) / 10,
+    share_pct: totalProjectMin === 0 ? 0 : Math.round(b.agent_min / totalProjectMin * 100),
+    prs: b.prs,
+    commits: b.commits
+  })).sort((a, b) => b.agent_min - a.agent_min);
+  const shipped_prs = [];
+  for (const c of caps) {
+    for (const title of c.pr_titles) {
+      shipped_prs.push({
+        title,
+        project: prettyProjectName(canonicalProjectName(c.project ?? "")),
+        session_id: c.session_id,
+        start_iso: c.start_iso ?? "",
+        active_min: c.numbers.active_min,
+        commits: c.numbers.commits,
+        subagents: c.numbers.subagent_calls,
+        flags: c.flags
+      });
+    }
+  }
+  const flags_count = {};
+  const skills_total = {};
+  const totals = { agent_min: 0, commits: 0, pushes: 0, prs: 0, subagent_calls: 0, tool_errors: 0 };
+  for (const c of caps) {
+    for (const f of c.flags)
+      flags_count[f] = (flags_count[f] ?? 0) + 1;
+    if (c.skills) {
+      for (const [k, v] of Object.entries(c.skills)) {
+        skills_total[k] = (skills_total[k] ?? 0) + v;
+      }
+    }
+    totals.agent_min += c.numbers.active_min;
+    totals.commits += c.numbers.commits;
+    totals.pushes += c.numbers.pushes;
+    totals.prs += c.numbers.prs;
+    totals.subagent_calls += c.numbers.subagent_calls;
+    totals.tool_errors += c.numbers.tool_errors;
+  }
+  totals.agent_min = Math.round(totals.agent_min * 10) / 10;
+  const longest = [...caps].sort((a, b) => b.numbers.active_min - a.numbers.active_min)[0];
+  const shipped = caps.filter((c) => c.numbers.prs >= 1);
+  const fastest = shipped.sort((a, b) => a.numbers.active_min - b.numbers.active_min)[0];
+  const mostErr = [...caps].sort((a, b) => b.numbers.tool_errors - a.numbers.tool_errors)[0];
+  const wandered = [...caps].filter((c) => c.outcome === "exploratory" && c.numbers.prs === 0 && c.numbers.commits === 0 && c.numbers.pushes === 0 && c.numbers.active_min >= 10).sort((a, b) => b.numbers.active_min - a.numbers.active_min)[0];
+  const outliers = {};
+  if (longest && longest.numbers.active_min > 0) {
+    outliers.longest_run = {
+      session_id: longest.session_id,
+      project: prettyProjectName(canonicalProjectName(longest.project ?? "")),
+      active_min: longest.numbers.active_min,
+      flags: longest.flags
+    };
+  }
+  if (fastest) {
+    outliers.fastest_ship = {
+      session_id: fastest.session_id,
+      project: prettyProjectName(canonicalProjectName(fastest.project ?? "")),
+      active_min: fastest.numbers.active_min,
+      pr_title: fastest.pr_titles[0] ?? ""
+    };
+  }
+  if (mostErr && mostErr.numbers.tool_errors > 0) {
+    outliers.most_errors = {
+      session_id: mostErr.session_id,
+      project: prettyProjectName(canonicalProjectName(mostErr.project ?? "")),
+      active_min: mostErr.numbers.active_min,
+      tool_errors: mostErr.numbers.tool_errors
+    };
+  }
+  if (wandered) {
+    outliers.wandered = {
+      session_id: wandered.session_id,
+      project: prettyProjectName(canonicalProjectName(wandered.project ?? "")),
+      active_min: wandered.numbers.active_min
+    };
+  }
+  const label = period.range_type === "month" ? period.start.toLocaleDateString("en-US", { month: "long", year: "numeric" }) : `${period.start.toLocaleDateString("en-US", { month: "short", day: "numeric" })} \u2014 ${period.end.toLocaleDateString("en-US", { month: "short", day: "numeric" })}`;
+  return {
+    period: {
+      start: isoDay(period.start),
+      end: isoDay(period.end),
+      label,
+      day_count: days.length,
+      range_type: period.range_type ?? "custom"
+    },
+    counts: { sessions_total, substantive: caps.length, trivial_dropped },
+    totals,
+    by_day,
+    project_shares,
+    shipped_prs,
+    flags_count,
+    skills_total,
+    outliers
+  };
+}
+function calendarWeek(ref = /* @__PURE__ */ new Date()) {
+  const d = new Date(ref.getFullYear(), ref.getMonth(), ref.getDate());
+  const dow = d.getDay();
+  const daysSinceMon = (dow + 6) % 7;
+  const monday = new Date(d);
+  monday.setDate(d.getDate() - daysSinceMon);
+  const sunday = new Date(monday);
+  sunday.setDate(monday.getDate() + 6);
+  return { start: monday, end: sunday };
+}
+function priorCalendarWeek(ref = /* @__PURE__ */ new Date()) {
+  const cur = calendarWeek(ref);
+  const prevEnd = new Date(cur.start);
+  prevEnd.setDate(cur.start.getDate() - 1);
+  const prevStart = new Date(prevEnd);
+  prevStart.setDate(prevEnd.getDate() - 6);
+  return { start: prevStart, end: prevEnd };
+}
+function last4CompletedWeeks(ref = /* @__PURE__ */ new Date()) {
+  const { end } = priorCalendarWeek(ref);
+  const start2 = new Date(end);
+  start2.setDate(end.getDate() - 27);
+  return { start: start2, end };
+}
+function calendarMonth(ref = /* @__PURE__ */ new Date()) {
+  const start2 = new Date(ref.getFullYear(), ref.getMonth(), 1);
+  const end = new Date(ref.getFullYear(), ref.getMonth() + 1, 0);
+  return { start: start2, end };
+}
+function priorCalendarMonth(ref = /* @__PURE__ */ new Date()) {
+  const start2 = new Date(ref.getFullYear(), ref.getMonth() - 1, 1);
+  const end = new Date(ref.getFullYear(), ref.getMonth(), 0);
+  return { start: start2, end };
+}
+function aggregateConcurrency(bursts, period) {
+  const days = rangeDays(period.start, period.end);
+  const byDayKey = /* @__PURE__ */ new Map();
+  for (const d of days)
+    byDayKey.set(isoDay(d), { peak: 0, has_cross_project: false });
+  for (const b of bursts) {
+    const dayKey = isoDay(new Date(b.startMs));
+    const cur = byDayKey.get(dayKey);
+    if (!cur)
+      continue;
+    if (b.peak > cur.peak)
+      cur.peak = b.peak;
+    if (b.crossProject)
+      cur.has_cross_project = true;
+  }
+  const by_day = days.map((d) => {
+    const k = isoDay(d);
+    const v = byDayKey.get(k);
+    return { date: k, peak: v.peak, has_cross_project: v.has_cross_project };
+  });
+  let peak = 0;
+  let peak_day;
+  let multi_agent_days = 0;
+  let cross_project_days = 0;
+  for (const d of by_day) {
+    if (d.peak > peak) {
+      peak = d.peak;
+      peak_day = d.date;
+    }
+    if (d.peak >= 3)
+      multi_agent_days++;
+    if (d.has_cross_project)
+      cross_project_days++;
+  }
+  return { by_day, peak, peak_day, multi_agent_days, cross_project_days };
+}
+var DAY_NAMES;
+var init_aggregate = __esm({
+  "../parser/dist/aggregate.js"() {
+    "use strict";
+    init_analytics();
+    DAY_NAMES = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  }
+});
+
+// ../parser/dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
+  aggregateConcurrency: () => aggregateConcurrency,
+  buildCapsule: () => buildCapsule,
+  buildGanttDay: () => buildGanttDay,
+  buildMegaRows: () => buildMegaRows,
+  buildPeriodBundle: () => buildPeriodBundle,
+  buildPresentation: () => buildPresentation,
+  calendarMonth: () => calendarMonth,
+  calendarWeek: () => calendarWeek,
+  canonicalProjectName: () => canonicalProjectName,
+  computeActiveSegments: () => computeActiveSegments,
+  computeBurstsFromSessions: () => computeBurstsFromSessions,
+  computeParallelism: () => computeParallelism,
+  computeParallelismBursts: () => computeParallelismBursts,
+  dailyActivity: () => dailyActivity,
+  daysBetween: () => daysBetween,
+  detectParallelRuns: () => detectParallelRuns,
+  detectPrMarkers: () => detectPrMarkers,
+  groupByProject: () => groupByProject,
+  groupByTeam: () => groupByTeam,
+  highLevelMetrics: () => highLevelMetrics,
+  last4CompletedWeeks: () => last4CompletedWeeks,
+  parseTranscript: () => parseTranscript,
+  priorCalendarMonth: () => priorCalendarMonth,
+  priorCalendarWeek: () => priorCalendarWeek,
+  rowPrimaryIndex: () => rowPrimaryIndex,
+  sessionAirTimeMs: () => sessionAirTimeMs,
+  sessionDay: () => sessionDay,
+  summarizeBursts: () => summarizeBursts,
+  toLocalDay: () => toLocalDay,
+  worktreeName: () => worktreeName
+});
+var init_dist = __esm({
+  "../parser/dist/index.js"() {
+    "use strict";
+    init_types();
+    init_parser();
+    init_presentation();
+    init_analytics();
+    init_capsule();
+    init_aggregate();
+    init_team();
+  }
+});
+
+// src/args.ts
+function parseDateArg(raw) {
+  if (!raw) return null;
+  const compact = raw.replace(/-/g, "");
+  if (!/^\d{8}$/.test(compact)) return null;
+  const d = /* @__PURE__ */ new Date(`${compact.slice(0, 4)}-${compact.slice(4, 6)}-${compact.slice(6, 8)}`);
+  return Number.isNaN(d.getTime()) ? null : d;
+}
+function flag(args2, name) {
+  const idx = args2.indexOf(name);
+  return idx === -1 ? void 0 : args2[idx + 1];
+}
+var init_args = __esm({
+  "src/args.ts"() {
+    "use strict";
+  }
+});
+
+// src/commands/stats.ts
+var stats_exports = {};
+__export(stats_exports, {
+  stats: () => stats
+});
+async function stats(args2) {
+  if (args2.includes("--help") || args2.includes("-h")) {
+    printHelp();
+    return;
+  }
+  const json = args2.includes("--json") || !args2.includes("--pretty");
+  const pretty = args2.includes("--pretty");
+  let range;
+  if (args2.includes("--week")) {
+    range = { ...calendarWeek(), range_type: "week" };
+  } else if (args2.includes("--4weeks")) {
+    range = { ...last4CompletedWeeks(), range_type: "4weeks" };
+  } else {
+    const sinceArg = parseDateArg(flag(args2, "--since"));
+    const untilArg = parseDateArg(flag(args2, "--until"));
+    const daysArg = flag(args2, "--days");
+    let start2 = sinceArg;
+    const end = untilArg ?? /* @__PURE__ */ new Date();
+    if (!start2 && daysArg) {
+      const d = parseInt(daysArg, 10);
+      if (Number.isFinite(d) && d > 0) {
+        start2 = /* @__PURE__ */ new Date();
+        start2.setDate(start2.getDate() - d);
+        start2.setHours(0, 0, 0, 0);
+      }
+    }
+    if (!start2) {
+      range = { ...calendarWeek(), range_type: "week" };
+    } else {
+      range = { start: start2, end, range_type: "custom" };
+    }
+  }
+  const bundle = await buildBundle(range);
+  if (json) {
+    process.stdout.write(JSON.stringify(bundle, null, pretty ? 2 : 0));
+    if (pretty) process.stdout.write("\n");
+  } else {
+    printSummary(bundle);
+  }
+}
+async function buildBundle(range) {
+  const metas = await listSessions({ limit: 1e4 });
+  const inRange = metas.filter((m) => {
+    if (!m.firstTimestamp) return false;
+    const t = new Date(m.firstTimestamp).getTime();
+    return t >= range.start.getTime() && t <= range.end.getTime();
+  });
+  const caps = [];
+  let trivial = 0;
+  const CONCURRENCY = 8;
+  for (let i = 0; i < inRange.length; i += CONCURRENCY) {
+    const slice = inRange.slice(i, i + CONCURRENCY);
+    const results = await Promise.all(slice.map(async (m) => {
+      try {
+        const d = await getSession(m.id);
+        if (!d) return null;
+        return buildCapsule(d, { compact: true });
+      } catch {
+        return null;
+      }
+    }));
+    for (const cap of results) {
+      if (!cap) continue;
+      if (cap.outcome === "trivial") trivial++;
+      else caps.push(cap);
+    }
+  }
+  const bundle = buildPeriodBundle(caps, {
+    period: range,
+    trivial_dropped: trivial,
+    sessions_total: inRange.length
+  });
+  bundle.concurrency = aggregateConcurrency(computeBurstsFromSessions(inRange), range);
+  try {
+    bundle.usage = await loadUsageByDay(range.start, range.end);
+  } catch {
+  }
+  return bundle;
+}
+function printSummary(b) {
+  console.log(`Insight aggregates \xB7 ${b.period.label} (${b.period.range_type})`);
+  console.log(`  ${b.counts.substantive} substantive \xB7 ${b.counts.trivial_dropped} trivial dropped \xB7 ${b.counts.sessions_total} total`);
+  console.log(`  ${b.totals.agent_min.toFixed(0)}m agent time \xB7 ${b.totals.prs} PRs \xB7 ${b.totals.commits} commits \xB7 ${b.totals.subagent_calls} subagents`);
+  console.log("");
+  console.log("By day:");
+  for (const d of b.by_day) {
+    const bar = "\u2588".repeat(Math.min(40, Math.round(d.agent_min / 15)));
+    console.log(`  ${d.day_name} ${d.date}  ${String(d.agent_min).padStart(5)}m  ${d.sessions} sess  ${bar}`);
+  }
+  console.log("");
+  console.log("Top projects:");
+  for (const p of b.project_shares.slice(0, 6)) {
+    console.log(`  ${String(p.share_pct).padStart(3)}%  ${p.display_name.padEnd(42)}  ${p.prs} PR  ${p.commits} commits`);
+  }
+  if (b.shipped_prs.length > 0) {
+    console.log("");
+    console.log("Shipped:");
+    for (const s of b.shipped_prs) {
+      console.log(`  ${s.title} \xB7 ${s.active_min.toFixed(0)}m \xB7 ${s.flags.join(",") || "\u2014"}`);
+    }
+  }
+  if (b.concurrency) {
+    console.log("");
+    console.log(`Concurrency: peak \xD7${b.concurrency.peak} on ${b.concurrency.peak_day ?? "\u2014"} \xB7 ${b.concurrency.multi_agent_days} multi-agent days \xB7 ${b.concurrency.cross_project_days} cross-project`);
+  }
+  if (b.usage) {
+    const hot = b.usage.by_day.filter((d) => d.peak_util_pct > 0);
+    if (hot.length > 0) {
+      console.log(`Usage: peak ${Math.max(...hot.map((d) => d.peak_util_pct))}% (${hot.length} active days)`);
+    }
+  }
+  console.log("");
+  console.log("Flags:", Object.entries(b.flags_count).map(([k, v]) => `${k}\xD7${v}`).join(", ") || "\u2014");
+}
+function printHelp() {
+  console.log(`fleetlens stats \u2014 period aggregates for the insights pipeline
+
+Usage:
+  fleetlens stats [--week | --4weeks | --since DATE --until DATE | --days N]
+                  [--json | --pretty]
+
+Range selection:
+  --week          Current Monday-Sunday calendar week (default).
+  --4weeks        Last 28 days ending with this week's Sunday.
+  --since DATE    inclusive start (YYYYMMDD or YYYY-MM-DD)
+  --until DATE    inclusive end (default: now)
+  --days N        alternative to --since (last N days)
+
+Output:
+  --json          (default when piped) structured JSON \u2014 the second half
+                  of the insight LLM payload. Matches the PeriodBundle
+                  type in @claude-lens/parser.
+  --pretty        human-readable terminal summary.
+
+Examples:
+  fleetlens stats --week --pretty
+  fleetlens stats --week --json | jq '.concurrency'
+  fleetlens stats --since 2026-04-14 --until 2026-04-20 --json > /tmp/bundle.json`);
+}
+var init_stats = __esm({
+  "src/commands/stats.ts"() {
+    "use strict";
+    init_fs();
+    init_dist();
+    init_args();
+  }
+});
+
+// src/usage/token.ts
+import { execFileSync } from "node:child_process";
+import { readFileSync as readFileSync5 } from "node:fs";
+import { homedir as homedir3, platform } from "node:os";
+import { join as join4 } from "node:path";
+function readOAuthCredentials() {
+  if (platform() === "darwin") {
+    return readFromMacKeychain() ?? readFromCredentialsFile();
+  }
+  return readFromCredentialsFile();
+}
+function readFromMacKeychain() {
+  try {
+    const blob = execFileSync(
+      "security",
+      ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+      { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" }
+    );
+    return extractCredentials(blob);
+  } catch {
+    return null;
+  }
+}
+function readFromCredentialsFile() {
+  const candidates = [
+    join4(homedir3(), ".claude", ".credentials.json"),
+    join4(homedir3(), ".config", "claude", "credentials.json")
+  ];
+  for (const path2 of candidates) {
+    try {
+      const blob = readFileSync5(path2, "utf8");
+      const creds = extractCredentials(blob);
+      if (creds) return creds;
+    } catch {
+    }
+  }
+  return null;
+}
+function extractCredentials(blob) {
+  try {
+    const parsed = JSON.parse(blob);
+    const oauth = parsed.claudeAiOauth;
+    if (!oauth) return null;
+    const accessToken = typeof oauth.accessToken === "string" ? oauth.accessToken : null;
+    const expiresAt = typeof oauth.expiresAt === "number" ? oauth.expiresAt : null;
+    if (!accessToken || expiresAt === null) return null;
+    return { accessToken, expiresAt };
+  } catch {
+    return null;
+  }
+}
+var init_token = __esm({
+  "src/usage/token.ts"() {
+    "use strict";
+  }
+});
+
+// src/usage/api.ts
+async function fetchUsage() {
+  const creds = readOAuthCredentials();
+  if (!creds) {
+    throw new UsageApiError(
+      "No Claude Code OAuth token found. Run `claude` to log in first.",
+      "no_token"
+    );
+  }
+  if (creds.expiresAt - EXPIRY_SKEW_MS <= Date.now()) {
+    throw new UsageApiError(
+      "Claude Code OAuth token expired. Open Claude Code to refresh it.",
+      "expired"
+    );
+  }
+  let res;
+  try {
+    res = await fetch(USAGE_ENDPOINT, {
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        "anthropic-beta": BETA_HEADER
+      }
+    });
+  } catch (err) {
+    throw new UsageApiError(
+      `Network error reaching Anthropic: ${err.message}`,
+      "network"
+    );
+  }
+  if (!res.ok) {
+    throw new UsageApiError(
+      `Usage endpoint returned ${res.status} ${res.statusText}`,
+      "http"
+    );
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    throw new UsageApiError(`Failed to parse usage response: ${err.message}`, "parse");
+  }
+  const b = body;
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    five_hour: normalizeWindow(b.five_hour) ?? { utilization: null, resets_at: null },
+    seven_day: normalizeWindow(b.seven_day) ?? { utilization: null, resets_at: null },
+    seven_day_opus: normalizeWindow(b.seven_day_opus),
+    seven_day_sonnet: normalizeWindow(b.seven_day_sonnet),
+    seven_day_oauth_apps: normalizeWindow(b.seven_day_oauth_apps),
+    seven_day_cowork: normalizeWindow(b.seven_day_cowork),
+    extra_usage: normalizeExtra(b.extra_usage)
+  };
+}
+function normalizeWindow(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  return {
+    utilization: typeof r.utilization === "number" ? r.utilization : null,
+    resets_at: typeof r.resets_at === "string" ? r.resets_at : null
+  };
+}
+function normalizeExtra(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  return {
+    is_enabled: r.is_enabled === true,
+    monthly_limit: typeof r.monthly_limit === "number" ? r.monthly_limit : null,
+    used_credits: typeof r.used_credits === "number" ? r.used_credits : null,
+    utilization: typeof r.utilization === "number" ? r.utilization : null
+  };
+}
+var EXPIRY_SKEW_MS, USAGE_ENDPOINT, BETA_HEADER, UsageApiError;
+var init_api = __esm({
+  "src/usage/api.ts"() {
+    "use strict";
+    init_token();
+    EXPIRY_SKEW_MS = 60 * 1e3;
+    USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
+    BETA_HEADER = "oauth-2025-04-20";
+    UsageApiError = class extends Error {
+      constructor(message, code) {
+        super(message);
+        this.code = code;
+      }
+    };
+  }
+});
+
+// src/usage/format.ts
+function formatUsage(snapshot) {
+  const rows = [
+    ["5 hour", snapshot.five_hour],
+    ["7 day", snapshot.seven_day],
+    ["7 day (Opus)", snapshot.seven_day_opus],
+    ["7 day (Sonnet)", snapshot.seven_day_sonnet],
+    ["7 day (OAuth apps)", snapshot.seven_day_oauth_apps],
+    ["7 day (Cowork)", snapshot.seven_day_cowork]
+  ];
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${BOLD}Claude Code Usage${RESET}`);
+  lines.push("");
+  for (const [label, window] of rows) {
+    if (!window || window.utilization === null) continue;
+    const pct = window.utilization;
+    const bar = renderBar(pct);
+    const pctStr = `${pct.toFixed(1)}%`.padStart(6);
+    const labelStr = label.padEnd(16);
+    lines.push(`  ${labelStr}${bar}  ${BOLD}${pctStr}${RESET}`);
+    if (window.resets_at) {
+      lines.push(`  ${" ".repeat(16)}${DIM}resets ${formatRelative(window.resets_at)}${RESET}`);
+    }
+    lines.push("");
+  }
+  if (snapshot.extra_usage?.is_enabled) {
+    const extra = snapshot.extra_usage;
+    lines.push(`  ${BOLD}Extra usage${RESET}`);
+    if (extra.utilization !== null) {
+      lines.push(`  ${" ".repeat(16)}${extra.utilization.toFixed(1)}%`);
+    }
+    if (extra.used_credits !== null && extra.monthly_limit !== null) {
+      lines.push(`  ${" ".repeat(16)}${extra.used_credits} / ${extra.monthly_limit} credits`);
+    }
+    lines.push("");
+  }
+  lines.push(`  ${DIM}captured ${formatRelative(snapshot.captured_at)}${RESET}`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderBar(utilization) {
+  const clamped = Math.max(0, Math.min(100, utilization));
+  const color = clamped >= 90 ? RED : clamped >= 70 ? YELLOW : GREEN;
+  const totalEighths = Math.round(clamped / 100 * BAR_WIDTH * 8);
+  const fullBlocks = Math.floor(totalEighths / 8);
+  const remainder = totalEighths % 8;
+  const partial = EIGHTHS[remainder];
+  const filledCells = fullBlocks + (partial ? 1 : 0);
+  const emptyCells = BAR_WIDTH - filledCells;
+  const filled = "\u2588".repeat(fullBlocks) + partial;
+  const empty = "\xB7".repeat(emptyCells);
+  return `${color}${filled}${RESET}${DIM}${empty}${RESET}`;
+}
+function formatRelative(iso) {
+  const then = new Date(iso).getTime();
+  const now = Date.now();
+  const diffSec = Math.round((then - now) / 1e3);
+  const abs = Math.abs(diffSec);
+  const past = diffSec < 0;
+  let value;
+  if (abs < 60) {
+    value = `${abs}s`;
+  } else if (abs < 3600) {
+    value = `${Math.floor(abs / 60)}m`;
+  } else if (abs < 86400) {
+    const h = Math.floor(abs / 3600);
+    const m = Math.floor(abs % 3600 / 60);
+    value = m > 0 ? `${h}h${m}m` : `${h}h`;
+  } else {
+    const d = Math.floor(abs / 86400);
+    const h = Math.floor(abs % 86400 / 3600);
+    value = h > 0 ? `${d}d${h}h` : `${d}d`;
+  }
+  return past ? `${value} ago` : `in ${value}`;
+}
+var DIM, BOLD, RESET, GREEN, YELLOW, RED, BAR_WIDTH, EIGHTHS;
+var init_format = __esm({
+  "src/usage/format.ts"() {
+    "use strict";
+    DIM = "\x1B[2m";
+    BOLD = "\x1B[1m";
+    RESET = "\x1B[0m";
+    GREEN = "\x1B[32m";
+    YELLOW = "\x1B[33m";
+    RED = "\x1B[31m";
+    BAR_WIDTH = 40;
+    EIGHTHS = ["", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589"];
+  }
+});
+
+// src/pricing.ts
+function findPricing(model) {
+  for (const [prefix, pricing] of PRICING) {
+    if (model.startsWith(prefix)) return pricing;
+  }
+  return null;
+}
+function estimateCost(model, usage2) {
+  const p = findPricing(model);
+  if (!p) return null;
+  return (usage2.input * p.input + usage2.output * p.output + usage2.cacheRead * p.cacheRead + usage2.cacheWrite * p.cacheWrite) / 1e6;
+}
+var PRICING;
+var init_pricing = __esm({
   "src/pricing.ts"() {
     "use strict";
     PRICING = [
@@ -1378,7 +3810,7 @@ function pad(s, width, align = "right") {
 function renderTable(rows, title) {
   const lines = [];
   lines.push("");
-  lines.push(`${BOLD}${title}${RESET}`);
+  lines.push(`${BOLD2}${title}${RESET2}`);
   lines.push("");
   const header = [
     pad("Date", 12, "left"),
@@ -1390,8 +3822,8 @@ function renderTable(rows, title) {
     pad("Total", 14),
     pad("Cost (USD)", 12)
   ].join("  ");
-  lines.push(`${DIM}${header}${RESET}`);
-  lines.push(`${DIM}${"\u2500".repeat(header.length)}${RESET}`);
+  lines.push(`${DIM2}${header}${RESET2}`);
+  lines.push(`${DIM2}${"\u2500".repeat(header.length)}${RESET2}`);
   let hasUnknownCost = false;
   for (const r of rows) {
     if (r.cost === null) hasUnknownCost = true;
@@ -1417,9 +3849,9 @@ function renderTable(rows, title) {
     }),
     { input: 0, output: 0, cacheCreate: 0, cacheRead: 0, totalTokens: 0, cost: 0 }
   );
-  lines.push(`${DIM}${"\u2500".repeat(header.length)}${RESET}`);
+  lines.push(`${DIM2}${"\u2500".repeat(header.length)}${RESET2}`);
   lines.push(
-    `${BOLD}${[
+    `${BOLD2}${[
       pad("Total", 12, "left"),
       pad("", 20, "left"),
       pad(fmtNum(totals.input), 12),
@@ -1428,31 +3860,31 @@ function renderTable(rows, title) {
       pad(fmtNum(totals.cacheRead), 14),
       pad(fmtNum(totals.totalTokens), 14),
       pad(fmtCost(totals.cost), 12)
-    ].join("  ")}${RESET}`
+    ].join("  ")}${RESET2}`
   );
   if (hasUnknownCost) {
     lines.push("");
-    lines.push(`${DIM}  Note: some models had unknown pricing (shown as \u2014)${RESET}`);
+    lines.push(`${DIM2}  Note: some models had unknown pricing (shown as \u2014)${RESET2}`);
   }
   lines.push("");
   return lines.join("\n");
 }
-var DIM, BOLD, RESET;
+var DIM2, BOLD2, RESET2;
 var init_table = __esm({
   "src/table.ts"() {
     "use strict";
-    DIM = "\x1B[2m";
-    BOLD = "\x1B[1m";
-    RESET = "\x1B[0m";
+    DIM2 = "\x1B[2m";
+    BOLD2 = "\x1B[1m";
+    RESET2 = "\x1B[0m";
   }
 });
 
-// src/commands/stats.ts
-var stats_exports = {};
-__export(stats_exports, {
-  stats: () => stats
+// src/commands/usage-history.ts
+var usage_history_exports = {};
+__export(usage_history_exports, {
+  history: () => history
 });
-async function stats(args2) {
+async function history(args2) {
   const live = args2.includes("--live");
   const sinceIdx = args2.indexOf("-s");
   const daysIdx = args2.indexOf("--days");
@@ -1556,8 +3988,8 @@ async function liveStats(sinceDate) {
   await refresh();
   setInterval(refresh, 2e3);
 }
-var init_stats = __esm({
-  "src/commands/stats.ts"() {
+var init_usage_history = __esm({
+  "src/commands/usage-history.ts"() {
     "use strict";
     init_fs();
     init_pricing();
@@ -1566,271 +3998,557 @@ var init_stats = __esm({
   }
 });
 
-// src/usage/token.ts
-import { execFileSync } from "node:child_process";
-import { readFileSync as readFileSync5 } from "node:fs";
-import { homedir as homedir3, platform } from "node:os";
-import { join as join4 } from "node:path";
-function readOAuthCredentials() {
-  if (platform() === "darwin") {
-    return readFromMacKeychain() ?? readFromCredentialsFile();
+// src/commands/usage.ts
+var usage_exports = {};
+__export(usage_exports, {
+  usage: () => usage
+});
+import { join as join5 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+async function usage(args2) {
+  if (args2.includes("--help") || args2.includes("-h")) {
+    console.log(`fleetlens usage \u2014 plan utilization snapshot
+
+Usage:
+  fleetlens usage [--save]        Current 5h/7d plan utilization
+  fleetlens usage --history [-s YYYYMMDD | --days N]
+                                  Daily token / cost history table`);
+    return;
+  }
+  if (args2.includes("--history")) {
+    const { history: history2 } = await Promise.resolve().then(() => (init_usage_history(), usage_history_exports));
+    await history2(args2.filter((a) => a !== "--history"));
+    return;
+  }
+  const save = args2.includes("--save");
+  try {
+    const snapshot = await fetchUsage();
+    if (save) appendSnapshot(USAGE_LOG3, snapshot);
+    process.stdout.write(formatUsage(snapshot));
+    process.stdout.write("\n  (tip: run with --history for the daily token/cost table)\n");
+  } catch (err) {
+    if (err instanceof UsageApiError) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+    throw err;
   }
-  return readFromCredentialsFile();
 }
-function readFromMacKeychain() {
+var USAGE_LOG3;
+var init_usage = __esm({
+  "src/commands/usage.ts"() {
+    "use strict";
+    init_api();
+    init_format();
+    init_storage();
+    USAGE_LOG3 = join5(homedir4(), ".cclens", "usage.jsonl");
+  }
+});
+
+// src/commands/capsules.ts
+var capsules_exports = {};
+__export(capsules_exports, {
+  capsules: () => capsules
+});
+async function capsules(args2) {
+  if (args2.includes("--help") || args2.includes("-h")) {
+    printHelp2();
+    return;
+  }
+  const compact = !args2.includes("--full");
+  const pretty = args2.includes("--pretty");
+  const json = args2.includes("--json") || !pretty;
+  const daysArg = flag(args2, "--days");
+  let sinceDate = parseDateArg(flag(args2, "--since"));
+  let untilDate = parseDateArg(flag(args2, "--until"));
+  if (!sinceDate && daysArg) {
+    const d = parseInt(daysArg, 10);
+    if (Number.isFinite(d) && d > 0) {
+      sinceDate = /* @__PURE__ */ new Date();
+      sinceDate.setDate(sinceDate.getDate() - d);
+      sinceDate.setHours(0, 0, 0, 0);
+    }
+  }
+  if (!sinceDate) {
+    sinceDate = /* @__PURE__ */ new Date();
+    sinceDate.setDate(sinceDate.getDate() - 7);
+    sinceDate.setHours(0, 0, 0, 0);
+  }
+  if (!untilDate) untilDate = /* @__PURE__ */ new Date();
+  const metas = await listSessions({ limit: 1e4 });
+  const inRange = metas.filter((m) => {
+    if (!m.firstTimestamp) return false;
+    const t = new Date(m.firstTimestamp).getTime();
+    return t >= sinceDate.getTime() && t <= untilDate.getTime();
+  });
+  const out = [];
+  const CONCURRENCY = 8;
+  for (let i = 0; i < inRange.length; i += CONCURRENCY) {
+    const slice = inRange.slice(i, i + CONCURRENCY);
+    const results = await Promise.all(slice.map(async (m) => {
+      try {
+        const d = await getSession(m.id);
+        if (!d) return null;
+        return buildCapsule(d, { compact });
+      } catch {
+        return null;
+      }
+    }));
+    for (const cap of results) {
+      if (!cap || cap.outcome === "trivial") continue;
+      out.push(cap);
+    }
+  }
+  out.sort((a, b) => (a.start_iso ?? "").localeCompare(b.start_iso ?? ""));
+  if (json) {
+    process.stdout.write(JSON.stringify(out, null, pretty ? 2 : 0));
+    if (pretty) process.stdout.write("\n");
+  } else {
+    printSummary2(out, sinceDate, untilDate);
+  }
+}
+function printSummary2(caps, since, until) {
+  const since_s = since.toISOString().slice(0, 10);
+  const until_s = until.toISOString().slice(0, 10);
+  console.log(`Capsules from ${since_s} to ${until_s} \xB7 ${caps.length} substantive sessions`);
+  console.log("");
+  for (const c of caps) {
+    const tag = c.outcome.padEnd(14);
+    const flags = c.flags.length > 0 ? `  [${c.flags.join(",")}]` : "";
+    const ship = c.pr_titles.length > 0 ? `  PR: ${c.pr_titles[0]}` : "";
+    const proj = (c.project ?? "").replace("/Users/", "~/").slice(0, 40);
+    const min = c.numbers.active_min.toFixed(1);
+    console.log(`  ${c.start_iso?.slice(0, 16)}  ${tag}  ${min.padStart(6)}m  ${proj.padEnd(42)}${flags}${ship}`);
+  }
+}
+function printHelp2() {
+  console.log(`fleetlens capsules \u2014 per-session insight capsules
+
+Usage:
+  fleetlens capsules [--since DATE] [--until DATE] [--days N] [--compact] [--json|--pretty]
+
+Options:
+  --since DATE    inclusive start (YYYYMMDD or YYYY-MM-DD). Default: 7 days ago.
+  --until DATE    inclusive end. Default: now.
+  --days N        alternative to --since (last N days).
+  --full          include per-turn detail (heavy: ~15 KB/session). Default: compact.
+  --json          structured JSON (default when piping).
+  --pretty        pretty-printed JSON (with --json) or human-readable table (without).
+
+Examples:
+  fleetlens capsules --days 7 --json | jq '.[] | .outcome' | sort | uniq -c
+  fleetlens capsules --since 2026-04-14 --until 2026-04-20 --pretty
+  fleetlens capsules --days 30 > /tmp/month.json`);
+}
+var init_capsules = __esm({
+  "src/commands/capsules.ts"() {
+    "use strict";
+    init_fs();
+    init_dist();
+    init_args();
+  }
+});
+
+// src/team/config.ts
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join6 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+function readTeamConfig(dir = DEFAULT_DIR) {
   try {
-    const blob = execFileSync(
-      "security",
-      ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
-      { stdio: ["ignore", "pipe", "ignore"], encoding: "utf8" }
-    );
-    return extractCredentials(blob);
+    return JSON.parse(readFileSync6(join6(dir, CONFIG_FILE), "utf8"));
   } catch {
     return null;
   }
 }
-function readFromCredentialsFile() {
-  const candidates = [
-    join4(homedir3(), ".claude", ".credentials.json"),
-    join4(homedir3(), ".config", "claude", "credentials.json")
-  ];
-  for (const path2 of candidates) {
-    try {
-      const blob = readFileSync5(path2, "utf8");
-      const creds = extractCredentials(blob);
-      if (creds) return creds;
-    } catch {
-    }
+function writeTeamConfig(config, dir = DEFAULT_DIR) {
+  mkdirSync3(dir, { recursive: true });
+  writeFileSync2(join6(dir, CONFIG_FILE), JSON.stringify(config, null, 2), { mode: 384 });
+}
+function clearTeamConfig(dir = DEFAULT_DIR) {
+  try {
+    unlinkSync2(join6(dir, CONFIG_FILE));
+  } catch {
   }
-  return null;
 }
-function extractCredentials(blob) {
+var DEFAULT_DIR, CONFIG_FILE;
+var init_config = __esm({
+  "src/team/config.ts"() {
+    "use strict";
+    DEFAULT_DIR = join6(homedir5(), ".cclens");
+    CONFIG_FILE = "team.json";
+  }
+});
+
+// src/team/join.ts
+var join_exports = {};
+__export(join_exports, {
+  joinTeam: () => joinTeam
+});
+async function joinTeam(args2) {
+  const [serverUrl, bearerToken] = args2;
+  if (!serverUrl || !bearerToken) {
+    console.error("Usage: fleetlens team join <server-url> <device-token>");
+    console.error("");
+    console.error("Get the device token from the dashboard after signup,");
+    console.error("or from Settings \u2192 My device token.");
+    process.exit(1);
+  }
+  const res = await fetch(`${serverUrl}/api/team/whoami`, {
+    method: "GET",
+    headers: { Authorization: `Bearer ${bearerToken}` }
+  });
+  if (!res.ok) {
+    console.error(`Pairing failed: ${res.status} ${res.statusText}`);
+    console.error("The device token may be revoked or the server URL wrong.");
+    process.exit(1);
+  }
+  const data = await res.json();
+  writeTeamConfig({
+    serverUrl,
+    memberId: data.membership.id,
+    bearerToken,
+    teamSlug: data.team.slug,
+    pairedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log(`Paired with "${data.team.name}" as ${data.user.displayName || data.user.email}`);
+  console.log(`  role: ${data.membership.role}`);
+  console.log("  Your daemon will push metrics on the next 5-minute cycle.");
+}
+var init_join = __esm({
+  "src/team/join.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/team/status.ts
+var status_exports2 = {};
+__export(status_exports2, {
+  teamStatus: () => teamStatus
+});
+async function teamStatus() {
+  const config = readTeamConfig();
+  if (!config) {
+    console.log("Not paired with any team.");
+    console.log("Use 'fleetlens team join <url> <token>' to pair.");
+    return;
+  }
+  console.log(`Team:    ${config.teamSlug}`);
+  console.log(`Server:  ${config.serverUrl}`);
+  console.log(`Member:  ${config.memberId}`);
+  console.log(`Paired:  ${config.pairedAt}`);
   try {
-    const parsed = JSON.parse(blob);
-    const oauth = parsed.claudeAiOauth;
-    if (!oauth) return null;
-    const accessToken = typeof oauth.accessToken === "string" ? oauth.accessToken : null;
-    const expiresAt = typeof oauth.expiresAt === "number" ? oauth.expiresAt : null;
-    if (!accessToken || expiresAt === null) return null;
-    return { accessToken, expiresAt };
+    const res = await fetch(`${config.serverUrl}/api/ingest/metrics`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${config.bearerToken}`, "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (res.status === 401) {
+      console.log("Status:  ! Token revoked \u2014 run 'fleetlens team leave' then re-join");
+    } else {
+      console.log("Status:  Connected");
+    }
   } catch {
-    return null;
+    console.log("Status:  ! Cannot reach server");
   }
 }
-var init_token = __esm({
-  "src/usage/token.ts"() {
+var init_status2 = __esm({
+  "src/team/status.ts"() {
     "use strict";
+    init_config();
   }
 });
 
-// src/usage/api.ts
-async function fetchUsage() {
-  const creds = readOAuthCredentials();
-  if (!creds) {
-    throw new UsageApiError(
-      "No Claude Code OAuth token found. Run `claude` to log in first.",
-      "no_token"
-    );
-  }
-  if (creds.expiresAt - EXPIRY_SKEW_MS <= Date.now()) {
-    throw new UsageApiError(
-      "Claude Code OAuth token expired. Open Claude Code to refresh it.",
-      "expired"
-    );
+// src/team/leave.ts
+var leave_exports = {};
+__export(leave_exports, {
+  teamLeave: () => teamLeave
+});
+async function teamLeave() {
+  const config = readTeamConfig();
+  if (!config) {
+    console.log("Not paired with any team.");
+    return;
   }
-  let res;
   try {
-    res = await fetch(USAGE_ENDPOINT, {
-      headers: {
-        Authorization: `Bearer ${creds.accessToken}`,
-        "anthropic-beta": BETA_HEADER
-      }
+    await fetch(`${config.serverUrl}/api/team/leave`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${config.bearerToken}` },
+      signal: AbortSignal.timeout(5e3)
     });
-  } catch (err) {
-    throw new UsageApiError(
-      `Network error reaching Anthropic: ${err.message}`,
-      "network"
-    );
+  } catch {
   }
-  if (!res.ok) {
-    throw new UsageApiError(
-      `Usage endpoint returned ${res.status} ${res.statusText}`,
-      "http"
-    );
+  clearTeamConfig();
+  console.log("Left team. Local data is unaffected.");
+}
+var init_leave = __esm({
+  "src/team/leave.ts"() {
+    "use strict";
+    init_config();
   }
-  let body;
+});
+
+// src/team/logs.ts
+var logs_exports = {};
+__export(logs_exports, {
+  teamLogs: () => teamLogs
+});
+import { readFileSync as readFileSync7 } from "node:fs";
+import { join as join7 } from "node:path";
+import { homedir as homedir6 } from "node:os";
+async function teamLogs() {
+  const logPath = join7(homedir6(), ".cclens", "daemon.log");
   try {
-    body = await res.json();
-  } catch (err) {
-    throw new UsageApiError(`Failed to parse usage response: ${err.message}`, "parse");
+    const lines = readFileSync7(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.");
+      return;
+    }
+    for (const line of teamLines.slice(-20)) {
+      console.log(line);
+    }
+  } catch {
+    console.log("No daemon log found. Is the daemon running?");
   }
-  const b = body;
-  return {
-    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
-    five_hour: normalizeWindow(b.five_hour) ?? { utilization: null, resets_at: null },
-    seven_day: normalizeWindow(b.seven_day) ?? { utilization: null, resets_at: null },
-    seven_day_opus: normalizeWindow(b.seven_day_opus),
-    seven_day_sonnet: normalizeWindow(b.seven_day_sonnet),
-    seven_day_oauth_apps: normalizeWindow(b.seven_day_oauth_apps),
-    seven_day_cowork: normalizeWindow(b.seven_day_cowork),
-    extra_usage: normalizeExtra(b.extra_usage)
-  };
 }
-function normalizeWindow(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const r = raw;
+var init_logs = __esm({
+  "src/team/logs.ts"() {
+    "use strict";
+  }
+});
+
+// src/team/push.ts
+import { randomUUID } from "node:crypto";
+function bucketToRollup(b) {
   return {
-    utilization: typeof r.utilization === "number" ? r.utilization : null,
-    resets_at: typeof r.resets_at === "string" ? r.resets_at : null
+    day: b.date,
+    agentTimeMs: b.airTimeMs,
+    sessions: b.sessions,
+    toolCalls: b.toolCalls,
+    turns: b.turns,
+    tokens: { ...b.tokens }
   };
 }
-function normalizeExtra(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const r = raw;
+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
+  }));
+}
+function buildIngestPayload(rollup) {
   return {
-    is_enabled: r.is_enabled === true,
-    monthly_limit: typeof r.monthly_limit === "number" ? r.monthly_limit : null,
-    used_credits: typeof r.used_credits === "number" ? r.used_credits : null,
-    utilization: typeof r.utilization === "number" ? r.utilization : null
+    ingestId: randomUUID(),
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dailyRollup: rollup
   };
 }
-var EXPIRY_SKEW_MS, USAGE_ENDPOINT, BETA_HEADER, UsageApiError;
-var init_api = __esm({
-  "src/usage/api.ts"() {
+async function pushToTeamServer(config, payload) {
+  const res = await fetch(`${config.serverUrl}/api/ingest/metrics`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.bearerToken}`
+    },
+    body: JSON.stringify(payload)
+  });
+  const body = await res.json().catch(() => null);
+  return { ok: res.ok, status: res.status, body };
+}
+var init_push = __esm({
+  "src/team/push.ts"() {
     "use strict";
-    init_token();
-    EXPIRY_SKEW_MS = 60 * 1e3;
-    USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage";
-    BETA_HEADER = "oauth-2025-04-20";
-    UsageApiError = class extends Error {
-      constructor(message, code) {
-        super(message);
-        this.code = code;
-      }
-    };
+    init_dist();
   }
 });
 
-// src/usage/format.ts
-function formatUsage(snapshot) {
-  const rows = [
-    ["5 hour", snapshot.five_hour],
-    ["7 day", snapshot.seven_day],
-    ["7 day (Opus)", snapshot.seven_day_opus],
-    ["7 day (Sonnet)", snapshot.seven_day_sonnet],
-    ["7 day (OAuth apps)", snapshot.seven_day_oauth_apps],
-    ["7 day (Cowork)", snapshot.seven_day_cowork]
-  ];
-  const lines = [];
-  lines.push("");
-  lines.push(`  ${BOLD2}Claude Code Usage${RESET2}`);
-  lines.push("");
-  for (const [label, window] of rows) {
-    if (!window || window.utilization === null) continue;
-    const pct = window.utilization;
-    const bar = renderBar(pct);
-    const pctStr = `${pct.toFixed(1)}%`.padStart(6);
-    const labelStr = label.padEnd(16);
-    lines.push(`  ${labelStr}${bar}  ${BOLD2}${pctStr}${RESET2}`);
-    if (window.resets_at) {
-      lines.push(`  ${" ".repeat(16)}${DIM2}resets ${formatRelative(window.resets_at)}${RESET2}`);
+// src/team/queue.ts
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync3, appendFileSync as appendFileSync2, statSync as statSync2, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join8, dirname as dirname6 } from "node:path";
+import { homedir as homedir7 } from "node:os";
+function enqueuePayload(payload, queuePath = QUEUE_PATH) {
+  mkdirSync4(dirname6(queuePath), { recursive: true });
+  const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  appendFileSync2(queuePath, JSON.stringify(entry) + "\n", "utf8");
+  try {
+    const { size } = statSync2(queuePath);
+    if (size > MAX_SIZE_BYTES) {
+      pruneOldest(queuePath);
     }
-    lines.push("");
+  } catch {
   }
-  if (snapshot.extra_usage?.is_enabled) {
-    const extra = snapshot.extra_usage;
-    lines.push(`  ${BOLD2}Extra usage${RESET2}`);
-    if (extra.utilization !== null) {
-      lines.push(`  ${" ".repeat(16)}${extra.utilization.toFixed(1)}%`);
-    }
-    if (extra.used_credits !== null && extra.monthly_limit !== null) {
-      lines.push(`  ${" ".repeat(16)}${extra.used_credits} / ${extra.monthly_limit} credits`);
+}
+function dequeuePayloads(queuePath = QUEUE_PATH) {
+  let lines;
+  try {
+    lines = readFileSync8(queuePath, "utf8").trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+  const now = Date.now();
+  const valid = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (now - new Date(entry.enqueuedAt).getTime() < MAX_AGE_MS) {
+        valid.push(entry);
+      }
+    } catch {
     }
-    lines.push("");
   }
-  lines.push(`  ${DIM2}captured ${formatRelative(snapshot.captured_at)}${RESET2}`);
-  lines.push("");
-  return lines.join("\n");
-}
-function renderBar(utilization) {
-  const clamped = Math.max(0, Math.min(100, utilization));
-  const color = clamped >= 90 ? RED : clamped >= 70 ? YELLOW : GREEN;
-  const totalEighths = Math.round(clamped / 100 * BAR_WIDTH * 8);
-  const fullBlocks = Math.floor(totalEighths / 8);
-  const remainder = totalEighths % 8;
-  const partial = EIGHTHS[remainder];
-  const filledCells = fullBlocks + (partial ? 1 : 0);
-  const emptyCells = BAR_WIDTH - filledCells;
-  const filled = "\u2588".repeat(fullBlocks) + partial;
-  const empty = "\xB7".repeat(emptyCells);
-  return `${color}${filled}${RESET2}${DIM2}${empty}${RESET2}`;
+  writeFileSync3(queuePath, "", "utf8");
+  return valid.map((e) => e.payload);
 }
-function formatRelative(iso) {
-  const then = new Date(iso).getTime();
-  const now = Date.now();
-  const diffSec = Math.round((then - now) / 1e3);
-  const abs = Math.abs(diffSec);
-  const past = diffSec < 0;
-  let value;
-  if (abs < 60) {
-    value = `${abs}s`;
-  } else if (abs < 3600) {
-    value = `${Math.floor(abs / 60)}m`;
-  } else if (abs < 86400) {
-    const h = Math.floor(abs / 3600);
-    const m = Math.floor(abs % 3600 / 60);
-    value = m > 0 ? `${h}h${m}m` : `${h}h`;
-  } else {
-    const d = Math.floor(abs / 86400);
-    const h = Math.floor(abs % 86400 / 3600);
-    value = h > 0 ? `${d}d${h}h` : `${d}d`;
+function pruneOldest(queuePath) {
+  let lines;
+  try {
+    lines = readFileSync8(queuePath, "utf8").trim().split("\n").filter(Boolean);
+  } catch {
+    return;
   }
-  return past ? `${value} ago` : `in ${value}`;
+  const keep = lines.slice(Math.floor(lines.length / 2));
+  writeFileSync3(queuePath, keep.join("\n") + "\n", "utf8");
 }
-var DIM2, BOLD2, RESET2, GREEN, YELLOW, RED, BAR_WIDTH, EIGHTHS;
-var init_format = __esm({
-  "src/usage/format.ts"() {
+var QUEUE_PATH, MAX_SIZE_BYTES, MAX_AGE_MS;
+var init_queue = __esm({
+  "src/team/queue.ts"() {
     "use strict";
-    DIM2 = "\x1B[2m";
-    BOLD2 = "\x1B[1m";
-    RESET2 = "\x1B[0m";
-    GREEN = "\x1B[32m";
-    YELLOW = "\x1B[33m";
-    RED = "\x1B[31m";
-    BAR_WIDTH = 40;
-    EIGHTHS = ["", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589"];
+    QUEUE_PATH = join8(homedir7(), ".cclens", "ingest-queue.jsonl");
+    MAX_SIZE_BYTES = 10 * 1024 * 1024;
+    MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
   }
 });
 
-// src/commands/usage.ts
-var usage_exports = {};
-__export(usage_exports, {
-  usage: () => usage
+// src/team/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  runTeamSync: () => runTeamSync
 });
-import { join as join5 } from "node:path";
-import { homedir as homedir4 } from "node:os";
-async function usage(args2) {
-  const save = args2.includes("--save");
+async function runTeamSync(log = noopLog) {
+  const config = readTeamConfig();
+  if (!config) return { paired: false, pushed: 0, queued: 0, queuedDrained: 0 };
   try {
-    const snapshot = await fetchUsage();
-    if (save) appendSnapshot(USAGE_LOG2, snapshot);
-    process.stdout.write(formatUsage(snapshot));
+    const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    const { toLocalDay: toLocalDay2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+    const today = toLocalDay2(Date.now());
+    const sessions = await listSessions2({ limit: 1e4 });
+    const rollups = buildRollupsForRange(sessions, config.lastSyncedDay);
+    if (rollups.length === 0) {
+      log("info", "team push: nothing to sync");
+      return { paired: true, pushed: 0, queued: 0, queuedDrained: 0 };
+    }
+    let pushed = 0;
+    let queued = 0;
+    let failedDay;
+    for (const rollup of rollups) {
+      const payload = buildIngestPayload(rollup);
+      const result = await pushToTeamServer(config, payload);
+      if (!result.ok) {
+        log("warn", `team push failed on ${rollup.day} (${result.status}); queueing`);
+        enqueuePayload(payload);
+        queued++;
+        failedDay = rollup.day;
+        break;
+      }
+      pushed++;
+    }
+    const nextConfig = { ...config, lastSyncedDay: today };
+    if (pushed > 0 || !failedDay) writeTeamConfig(nextConfig);
+    let queuedDrained = 0;
+    if (!failedDay) {
+      const backlog = dequeuePayloads();
+      for (let i = 0; i < backlog.length; i++) {
+        const qResult = await pushToTeamServer(config, backlog[i]);
+        if (!qResult.ok) {
+          for (const remaining of backlog.slice(i)) enqueuePayload(remaining);
+          break;
+        }
+        queuedDrained++;
+      }
+    }
+    if (pushed > 0) {
+      log("info", `team push ok: ${pushed} day${pushed === 1 ? "" : "s"} pushed` + (queuedDrained ? `, ${queuedDrained} queued retried` : "") + (queued ? `, ${queued} queued for retry` : ""));
+    }
+    return { paired: true, pushed, queued, queuedDrained, failedDay };
   } catch (err) {
-    if (err instanceof UsageApiError) {
-      console.error(`Error: ${err.message}`);
-      process.exit(1);
+    const message = err.message;
+    log("warn", `team push error: ${message}`);
+    return { paired: true, pushed: 0, queued: 0, queuedDrained: 0, error: message };
+  }
+}
+var noopLog;
+var init_sync = __esm({
+  "src/team/sync.ts"() {
+    "use strict";
+    init_config();
+    init_push();
+    init_queue();
+    noopLog = () => {
+    };
+  }
+});
+
+// src/commands/team.ts
+var team_exports = {};
+__export(team_exports, {
+  team: () => team
+});
+async function team(args2) {
+  const sub = args2[0];
+  switch (sub) {
+    case "join": {
+      const { joinTeam: joinTeam2 } = await Promise.resolve().then(() => (init_join(), join_exports));
+      await joinTeam2(args2.slice(1));
+      break;
     }
-    throw err;
+    case "status": {
+      const { teamStatus: teamStatus2 } = await Promise.resolve().then(() => (init_status2(), status_exports2));
+      await teamStatus2();
+      break;
+    }
+    case "leave": {
+      const { teamLeave: teamLeave2 } = await Promise.resolve().then(() => (init_leave(), leave_exports));
+      await teamLeave2();
+      break;
+    }
+    case "logs": {
+      const { teamLogs: teamLogs2 } = await Promise.resolve().then(() => (init_logs(), logs_exports));
+      await teamLogs2();
+      break;
+    }
+    case "sync": {
+      const { runTeamSync: runTeamSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+      const outcome = await runTeamSync2((level, msg) => console.log(`[${level}] ${msg}`));
+      if (!outcome.paired) {
+        console.error("Not paired. Run 'fleetlens team join <url> <device-token>' first.");
+        process.exit(1);
+      }
+      if (outcome.error) process.exit(1);
+      console.log(
+        `\u2713 ${outcome.pushed} day${outcome.pushed === 1 ? "" : "s"} pushed` + (outcome.queuedDrained ? `, ${outcome.queuedDrained} queued retried` : "") + (outcome.queued ? `, ${outcome.queued} queued for retry (will fire next cycle)` : "")
+      );
+      break;
+    }
+    default:
+      console.log(`Usage: fleetlens team <join|status|leave|logs|sync>
+
+  join <url> <device-token>    Pair daemon with a team server
+  status                       Show team pairing state and sync info
+  leave                        Unpair from the team server
+  logs                         Show recent team-related daemon log entries
+  sync                         Push any un-synced days now (skip 5-min wait)`);
   }
 }
-var USAGE_LOG2;
-var init_usage = __esm({
-  "src/commands/usage.ts"() {
+var init_team2 = __esm({
+  "src/commands/team.ts"() {
     "use strict";
-    init_api();
-    init_format();
-    init_storage();
-    USAGE_LOG2 = join5(homedir4(), ".cclens", "usage.jsonl");
   }
 });
 
@@ -1874,15 +4592,25 @@ async function main() {
       await usage2(args.slice(1));
       break;
     }
+    case "capsules": {
+      const { capsules: capsules2 } = await Promise.resolve().then(() => (init_capsules(), capsules_exports));
+      await capsules2(args.slice(1));
+      break;
+    }
     case "daemon": {
       const { daemon: daemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
       await daemon2(args.slice(1));
       break;
     }
+    case "team": {
+      const { team: team2 } = await Promise.resolve().then(() => (init_team2(), team_exports));
+      await team2(args.slice(1));
+      break;
+    }
     case "version":
     case "--version":
     case "-v":
-      console.log(`fleetlens ${"0.3.0"}`);
+      console.log(`fleetlens ${"0.4.0"}`);
       break;
     case "help":
     case "--help":
@@ -1896,14 +4624,22 @@ Common:
   update                            Update to the latest version
 
 Terminal:
-  stats [--live] [-s D] [--days N]  Daily token usage table
-  usage [--save]                    Plan utilization (5h/7d) in one shot
+  stats [--week|--4weeks|--days N] [--json]  Period aggregates (for insights pipeline)
+  usage [--save]                             Plan utilization snapshot (5h/7d)
+  usage --history [-s D] [--days N]          Daily token/cost table
+  capsules [--days N] [--json]               Per-session insight capsules
 
 Advanced:
   web [page] [--no-open]            Open dashboard in browser without auto-starting daemon
   start --no-daemon                 Start only the web server (no daemon)
   daemon <start|stop|status|logs>   Manage the usage daemon by itself
 
+Team:
+  team join <url> <token>           Pair with a team server
+  team status                       Show team pairing state
+  team leave                        Unpair from team server
+  team logs                         Show team-related daemon logs
+
   version                           Print version`);
       break;
     default: