fleetlens 0.2.9 → 0.4.0

package/dist/daemon-worker.js

@@ -1,7 +1,2590 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../parser/dist/types.js
+var init_types = __esm({
+  "../parser/dist/types.js"() {
+    "use strict";
+  }
+});
+
+// ../parser/dist/parser.js
+function cleanText(s) {
+  return s.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+function truncate(s, n = 200) {
+  const one = cleanText(s);
+  return one.length > n ? one.slice(0, n - 1) + "\u2026" : one;
+}
+function classifyTeammateMessage(text) {
+  const m = text.match(TEAMMATE_MSG_RE);
+  if (!m)
+    return void 0;
+  const teammateId = m[1];
+  const body = m[2].trim();
+  let kind = "message";
+  if (body.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(body);
+      if (parsed.type === "idle_notification")
+        kind = "idle-notification";
+      else if (parsed.type === "shutdown_request")
+        kind = "shutdown-request";
+      else if (parsed.type === "shutdown_approved")
+        kind = "shutdown-approved";
+      else if (parsed.type === "task_assignment")
+        kind = "task-assignment";
+      else if (parsed.type === "teammate_terminated")
+        kind = "teammate-terminated";
+    } catch {
+    }
+  }
+  return { teammateId, body, kind };
+}
+function extractUsage(u) {
+  if (!u || typeof u !== "object")
+    return void 0;
+  const r = u;
+  const toNum = (v) => typeof v === "number" ? v : 0;
+  return {
+    input: toNum(r.input_tokens),
+    output: toNum(r.output_tokens),
+    cacheRead: toNum(r.cache_read_input_tokens),
+    cacheWrite: toNum(r.cache_creation_input_tokens)
+  };
+}
+function toEvent(raw, index) {
+  if (!raw || typeof raw !== "object")
+    return null;
+  const r = raw;
+  const rawType = String(r.type ?? "");
+  const uuid = r.uuid;
+  const parentUuid = r.parentUuid ?? null;
+  const timestamp = r.timestamp;
+  if (rawType === "assistant") {
+    const msg = r.message ?? {};
+    const content = msg.content ?? [];
+    const usage = extractUsage(msg.usage);
+    const model = msg.model;
+    const requestId = r.requestId;
+    const messageId = msg.id;
+    const stopReason = msg.stop_reason;
+    const first = content[0];
+    let role = "agent";
+    let preview;
+    let toolName;
+    let toolUseId;
+    if (first?.type === "thinking") {
+      role = "agent-thinking";
+      preview = "[thinking] " + truncate(first.thinking, 140);
+    } else if (first?.type === "tool_use") {
+      role = "tool-call";
+      toolName = first.name;
+      toolUseId = first.id;
+      preview = `${first.name} ` + truncate(JSON.stringify(first.input ?? {}), 100);
+    } else if (first?.type === "text") {
+      preview = truncate(first.text, 200);
+    } else {
+      preview = `<assistant:${first?.type ?? "empty"}>`;
+    }
+    return {
+      index,
+      uuid,
+      parentUuid,
+      timestamp,
+      role,
+      rawType,
+      preview,
+      blocks: content,
+      usage,
+      model,
+      requestId,
+      messageId,
+      stopReason,
+      toolName,
+      toolUseId,
+      raw
+    };
+  }
+  if (rawType === "user") {
+    const msg = r.message ?? {};
+    const c = msg.content;
+    if (typeof c === "string") {
+      const tm = classifyTeammateMessage(c);
+      return {
+        index,
+        uuid,
+        parentUuid,
+        timestamp,
+        role: "user",
+        rawType,
+        preview: truncate(c, 200),
+        blocks: [{ type: "text", text: c }],
+        raw,
+        teammateMessage: tm
+      };
+    }
+    if (Array.isArray(c)) {
+      const first = c[0];
+      if (first?.type === "tool_result") {
+        const resultText = typeof first.content === "string" ? first.content : JSON.stringify(first.content);
+        return {
+          index,
+          uuid,
+          parentUuid,
+          timestamp,
+          role: "tool-result",
+          rawType,
+          preview: truncate(resultText, 200),
+          blocks: c,
+          toolUseId: first.tool_use_id,
+          toolResult: r.toolUseResult,
+          raw
+        };
+      }
+      const textBlock = c.find((b) => b?.type === "text");
+      const tm = textBlock ? classifyTeammateMessage(textBlock.text) : void 0;
+      return {
+        index,
+        uuid,
+        parentUuid,
+        timestamp,
+        role: "user",
+        rawType,
+        preview: textBlock ? truncate(textBlock.text, 200) : truncate(JSON.stringify(c), 200),
+        blocks: c,
+        raw,
+        teammateMessage: tm
+      };
+    }
+  }
+  if (rawType === "attachment") {
+    const a = r.attachment ?? {};
+    const at = String(a.type ?? "attachment");
+    let preview = `<attachment: ${at}>`;
+    if (typeof a.content === "string" && a.content.length > 0) {
+      preview = `[${at}] ` + truncate(a.content, 140);
+    } else if (Array.isArray(a.addedNames)) {
+      preview = `[${at}] +${a.addedNames.length} names`;
+    }
+    return {
+      index,
+      uuid,
+      parentUuid,
+      timestamp,
+      role: "system",
+      rawType,
+      preview,
+      blocks: [{ type: "text", text: JSON.stringify(a, null, 2) }],
+      attachmentType: at,
+      raw
+    };
+  }
+  return {
+    index,
+    uuid,
+    parentUuid,
+    timestamp,
+    role: "meta",
+    rawType: rawType || "unknown",
+    preview: `${rawType}: ${truncate(JSON.stringify(r), 140)}`,
+    blocks: [{ type: "text", text: JSON.stringify(r, null, 2) }],
+    raw
+  };
+}
+function parseTranscript(rawLines) {
+  const events = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    const ev = toEvent(rawLines[i], i);
+    if (ev)
+      events.push(ev);
+  }
+  const timestamped = events.map((e) => e.timestamp ? Date.parse(e.timestamp) : void 0).filter((n) => typeof n === "number" && !Number.isNaN(n));
+  const startMs = timestamped.length ? Math.min(...timestamped) : void 0;
+  const endMs = timestamped.length ? Math.max(...timestamped) : void 0;
+  const firstTs = startMs !== void 0 ? new Date(startMs).toISOString() : void 0;
+  const lastTs = endMs !== void 0 ? new Date(endMs).toISOString() : void 0;
+  for (const ev of events) {
+    if (!ev.timestamp)
+      continue;
+    const ms = Date.parse(ev.timestamp);
+    if (Number.isNaN(ms))
+      continue;
+    if (startMs !== void 0)
+      ev.tOffsetMs = Math.max(0, ms - startMs);
+  }
+  const isConversational = (r) => r === "user" || r === "agent" || r === "agent-thinking" || r === "tool-call" || r === "tool-result";
+  const chrono = events.filter((e) => e.timestamp && isConversational(e.role)).map((e) => ({ e, ms: Date.parse(e.timestamp) })).filter((x) => !Number.isNaN(x.ms)).sort((a, b) => a.ms - b.ms);
+  for (let i = 1; i < chrono.length; i++) {
+    chrono[i].e.gapMs = Math.max(0, chrono[i].ms - chrono[i - 1].ms);
+  }
+  const IDLE_THRESHOLD_MS = 3 * 60 * 1e3;
+  const allChrono = events.filter((e) => e.timestamp).map((e) => Date.parse(e.timestamp)).filter((ms) => !Number.isNaN(ms)).sort((a, b) => a - b);
+  const activeSegments = [];
+  let airTimeMs = 0;
+  if (allChrono.length > 0) {
+    let segStart = allChrono[0];
+    let segEnd = allChrono[0];
+    for (let i = 1; i < allChrono.length; i++) {
+      const t = allChrono[i];
+      const gap = t - segEnd;
+      if (gap > IDLE_THRESHOLD_MS) {
+        activeSegments.push({ startMs: segStart, endMs: segEnd });
+        segStart = t;
+      } else if (gap > 0) {
+        airTimeMs += gap;
+      }
+      segEnd = t;
+    }
+    activeSegments.push({ startMs: segStart, endMs: segEnd });
+  }
+  const totalUsage = { ...BLANK_USAGE };
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  let model;
+  let sessionId = "";
+  let cwd;
+  let gitBranch;
+  let teamName;
+  let agentName;
+  let hasTeamCreate = false;
+  let hasOutboundDispatch = false;
+  let toolCallCount = 0;
+  let turnCount = 0;
+  let firstUserPreview;
+  let lastAgentPreview;
+  let lastUserPreview;
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  const filesEdited = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.role === "tool-call") {
+      toolCallCount++;
+      const toolBlock = e.blocks.find((b) => b && b.type === "tool_use");
+      if (toolBlock) {
+        const input = toolBlock.input ?? {};
+        if (toolBlock.name === "TeamCreate")
+          hasTeamCreate = true;
+        if (toolBlock.name === "SendMessage") {
+          const to = typeof input.to === "string" ? input.to : "";
+          if (to && to !== "team-lead")
+            hasOutboundDispatch = true;
+        }
+        const fp = typeof input.file_path === "string" ? input.file_path : void 0;
+        if (toolBlock.name === "Edit" && fp) {
+          filesEdited.add(fp);
+          const oldStr = typeof input.old_string === "string" ? input.old_string : "";
+          const newStr = typeof input.new_string === "string" ? input.new_string : "";
+          const oldLines = oldStr ? oldStr.split("\n").length : 0;
+          const newLines = newStr ? newStr.split("\n").length : 0;
+          linesAdded += Math.max(0, newLines - oldLines);
+          linesRemoved += Math.max(0, oldLines - newLines);
+        } else if (toolBlock.name === "Write" && fp) {
+          filesEdited.add(fp);
+          const content = typeof input.content === "string" ? input.content : "";
+          linesAdded += content ? content.split("\n").length : 0;
+        }
+      }
+    }
+    if (e.role === "user") {
+      const rawMsg = e.raw?.message;
+      const rawContent = typeof rawMsg?.content === "string" ? rawMsg.content : "";
+      const isHidden = rawContent.startsWith("<command-name>") || rawContent.startsWith("<local-command-caveat>") || rawContent.startsWith("Base directory for this skill:") || rawContent.startsWith("<task-notification>");
+      const isTeamNoise = e.teammateMessage !== void 0 && !agentName;
+      if (!isHidden && !isTeamNoise) {
+        if (!firstUserPreview) {
+          firstUserPreview = e.teammateMessage ? e.teammateMessage.body : e.preview;
+        }
+        turnCount++;
+        lastUserPreview = e.preview;
+      }
+    }
+    if (e.role === "agent") {
+      lastAgentPreview = e.preview;
+    }
+  }
+  for (const r of rawLines) {
+    if (!r || typeof r !== "object")
+      continue;
+    const o = r;
+    if (typeof o.sessionId === "string" && !sessionId)
+      sessionId = o.sessionId;
+    if (typeof o.cwd === "string" && !cwd)
+      cwd = o.cwd;
+    if (typeof o.gitBranch === "string" && !gitBranch)
+      gitBranch = o.gitBranch;
+    if (typeof o.teamName === "string" && !teamName)
+      teamName = o.teamName;
+    if (typeof o.agentName === "string" && !agentName)
+      agentName = o.agentName;
+    if (o.type === "assistant") {
+      const m = o.message;
+      if (m) {
+        if (typeof m.model === "string" && !model)
+          model = m.model;
+        const mid = typeof m.id === "string" ? m.id : void 0;
+        const rid = typeof o.requestId === "string" ? o.requestId : void 0;
+        const dedupKey = mid != null ? `${mid}:${rid ?? ""}` : void 0;
+        if (dedupKey && seenMessageIds.has(dedupKey))
+          continue;
+        if (dedupKey)
+          seenMessageIds.add(dedupKey);
+        const u = extractUsage(m.usage);
+        if (u) {
+          totalUsage.input += u.input;
+          totalUsage.output += u.output;
+          totalUsage.cacheRead += u.cacheRead;
+          totalUsage.cacheWrite += u.cacheWrite;
+        }
+      }
+    }
+  }
+  return {
+    events,
+    meta: {
+      sessionId,
+      firstTimestamp: firstTs,
+      lastTimestamp: lastTs,
+      durationMs: startMs !== void 0 && endMs !== void 0 ? endMs - startMs : void 0,
+      eventCount: events.length,
+      model,
+      cwd,
+      gitBranch,
+      totalUsage,
+      status: "idle",
+      firstUserPreview,
+      lastUserPreview,
+      lastAgentPreview,
+      toolCallCount,
+      turnCount,
+      airTimeMs,
+      activeSegments,
+      linesAdded,
+      linesRemoved,
+      filesEdited: filesEdited.size,
+      teamName,
+      agentName,
+      isTeamLead: teamName !== void 0 && agentName === void 0 && (hasTeamCreate || hasOutboundDispatch)
+    }
+  };
+}
+var BLANK_USAGE, TEAMMATE_MSG_RE;
+var init_parser = __esm({
+  "../parser/dist/parser.js"() {
+    "use strict";
+    BLANK_USAGE = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    TEAMMATE_MSG_RE = /^\s*<teammate-message\s+teammate_id="([^"]+)"[^>]*>([\s\S]*?)<\/teammate-message>/;
+  }
+});
+
+// ../parser/dist/presentation.js
+function rowPrimaryIndex(r) {
+  if (r.kind === "tool-group")
+    return r.events[0].index;
+  return r.event.index;
+}
+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 usage = r.event.usage;
+        if (msgId && !seenMsgIds.has(msgId) && usage) {
+          seenMsgIds.add(msgId);
+          tokens.input += usage.input;
+          tokens.output += usage.output;
+          tokens.cacheRead += usage.cacheRead;
+          tokens.cacheWrite += usage.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 start = first.tOffsetMs;
+    const end = last.tOffsetMs;
+    const durationMs = start !== void 0 && end !== void 0 ? end - start : void 0;
+    out.push({
+      kind: "turn",
+      rows: buffer,
+      firstPrimaryIndex: rowPrimaryIndex(first),
+      tOffsetMs: start,
+      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 status = "unknown";
+  if (statusRaw === "success" || statusRaw === "ok" || statusRaw === "done" || statusRaw === "completed")
+    status = "success";
+  else if (statusRaw === "failed" || statusRaw === "error" || statusRaw === "fail")
+    status = "failed";
+  else if (statusRaw === "running" || statusRaw === "in_progress")
+    status = "running";
+  return {
+    status,
+    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 start = i;
+      while (i + 1 < visible.length && visible[i + 1].role === "tool-call") {
+        i++;
+      }
+      const group = visible.slice(start, 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 args = (slashMatch[2] ?? "").trim();
+        const pretty = args ? `${cmd} ${args}` : 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/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 start = new Date(ys, ms - 1, ds);
+  const end = new Date(ye, me - 1, de);
+  const out = [];
+  for (let d = new Date(start); 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 start = Date.parse(s.firstTimestamp);
+      const end = Date.parse(s.lastTimestamp);
+      if (Number.isNaN(start) || Number.isNaN(end) || end < start)
+        return [];
+      return [{ startMs: start, 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 command = typeof input?.command === "string" ? input.command : "";
+    if (!PR_CREATE_RE.test(command))
+      continue;
+    const titleMatch = command.match(TITLE_FLAG_RE);
+    const numberMatch = command.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: command.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/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 usage = msg.usage;
+      if (cur && msgId && !cur.seenMsgIds.has(msgId) && usage) {
+        cur.seenMsgIds.add(msgId);
+        cur.tokensIn += usage.input_tokens ?? 0;
+        cur.tokensOut += usage.output_tokens ?? 0;
+        cur.tokensCacheR += usage.cache_read_input_tokens ?? 0;
+        cur.tokensCacheW += usage.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(start, end) {
+  const out = [];
+  const cur = new Date(start.getFullYear(), start.getMonth(), start.getDate());
+  const stop = new Date(end.getFullYear(), end.getMonth(), end.getDate());
+  while (cur.getTime() <= stop.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 start = new Date(end);
+  start.setDate(end.getDate() - 27);
+  return { start, end };
+}
+function calendarMonth(ref = /* @__PURE__ */ new Date()) {
+  const start = new Date(ref.getFullYear(), ref.getMonth(), 1);
+  const end = new Date(ref.getFullYear(), ref.getMonth() + 1, 0);
+  return { start, end };
+}
+function priorCalendarMonth(ref = /* @__PURE__ */ new Date()) {
+  const start = new Date(ref.getFullYear(), ref.getMonth() - 1, 1);
+  const end = new Date(ref.getFullYear(), ref.getMonth(), 0);
+  return { start, 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/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";
+  }
+});
+
+// ../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();
+  }
+});
+
+// ../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";
+function decodeProjectName(dir) {
+  if (!dir.startsWith("-"))
+    return dir;
+  return "/" + dir.slice(1).replace(/-/g, "/");
+}
+async function readJsonlFile(filePath) {
+  const raw = await fs.readFile(filePath, "utf8");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    try {
+      out.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return out;
+}
+function 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;
+  try {
+    topEntries = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const projectDirs = topEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+  const perProject = await Promise.all(projectDirs.map(async (projectDir) => {
+    const projectPath = path.join(root, projectDir);
+    let files;
+    try {
+      files = await fs.readdir(projectPath);
+    } catch {
+      return [];
+    }
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    const refs = await Promise.all(jsonlFiles.map(async (f) => {
+      const fullPath = path.join(projectPath, f);
+      try {
+        const stat = await fs.stat(fullPath);
+        return {
+          projectDir,
+          fileName: f,
+          fullPath,
+          mtimeMs: stat.mtimeMs,
+          sizeBytes: stat.size
+        };
+      } catch {
+        return null;
+      }
+    }));
+    return refs.filter((r) => r !== null);
+  }));
+  const all = perProject.flat();
+  fileListCache = { files: all, capturedAtMs: Date.now(), root };
+  return all;
+}
+function sessionIdFromFileName(fileName) {
+  return fileName.replace(/\.jsonl$/i, "");
+}
+function aggregateUsageFromLines(lines, seenKeys, usage) {
+  for (const raw of lines) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const r = raw;
+    if (r.type !== "assistant")
+      continue;
+    const m = r.message;
+    if (!m)
+      continue;
+    const mid = typeof m.id === "string" ? m.id : void 0;
+    const rid = typeof r.requestId === "string" ? r.requestId : void 0;
+    const key = mid != null && rid != null ? `${mid}:${rid}` : void 0;
+    if (key && seenKeys.has(key))
+      continue;
+    if (key)
+      seenKeys.add(key);
+    const u = m.usage;
+    if (u) {
+      const toNum = (v) => typeof v === "number" ? v : 0;
+      usage.input += toNum(u.input_tokens);
+      usage.output += toNum(u.output_tokens);
+      usage.cacheRead += toNum(u.cache_read_input_tokens);
+      usage.cacheWrite += toNum(u.cache_creation_input_tokens);
+    }
+  }
+}
+async function computeSessionUsageWithSubagents(parentLines, projectDirPath, sessionId) {
+  const usage = { ...BLANK_USAGE3 };
+  const seenKeys = /* @__PURE__ */ new Set();
+  aggregateUsageFromLines(parentLines, seenKeys, usage);
+  const subagentsDir = path.join(projectDirPath, sessionId, "subagents");
+  let entries;
+  try {
+    entries = await fs.readdir(subagentsDir);
+  } catch {
+    return usage;
+  }
+  const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
+  if (jsonlFiles.length === 0)
+    return usage;
+  await Promise.all(jsonlFiles.map(async (f) => {
+    try {
+      const lines = await readJsonlFile(path.join(subagentsDir, f));
+      aggregateUsageFromLines(lines, seenKeys, usage);
+    } catch {
+    }
+  }));
+  return usage;
+}
+async function getCachedMeta(f) {
+  const cached = metaCache.get(f.fullPath);
+  if (cached && cached.mtimeMs === f.mtimeMs && cached.sizeBytes === f.sizeBytes) {
+    return cached.meta;
+  }
+  try {
+    const rawLines = await readJsonlFile(f.fullPath);
+    const { meta } = parseTranscript(rawLines);
+    const sessionId = sessionIdFromFileName(f.fileName);
+    const projectDirPath = path.dirname(f.fullPath);
+    meta.totalUsage = await computeSessionUsageWithSubagents(rawLines, projectDirPath, sessionId);
+    const full = {
+      ...meta,
+      id: sessionId,
+      filePath: f.fullPath,
+      projectDir: f.projectDir,
+      projectName: meta.cwd ?? decodeProjectName(f.projectDir)
+    };
+    metaCache.set(f.fullPath, { meta: full, mtimeMs: f.mtimeMs, sizeBytes: f.sizeBytes });
+    return full;
+  } catch {
+    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);
+  if (projectDir)
+    files = files.filter((f) => f.projectDir === projectDir);
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const sliced = files.slice(0, limit);
+  const metas = await Promise.all(sliced.map((f) => getCachedMeta(f)));
+  return metas.filter((m) => m !== null);
+}
+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(start, end) {
+  let raw;
+  try {
+    raw = await fs.readFile(USAGE_LOG, "utf8");
+  } catch {
+    return { by_day: [] };
+  }
+  const startMs = new Date(start.getFullYear(), start.getMonth(), start.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(start.getFullYear(), start.getMonth(), start.getDate());
+  const stop = new Date(end.getFullYear(), end.getMonth(), end.getDate());
+  while (cur.getTime() <= stop.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_LOG;
+var init_fs = __esm({
+  "../parser/dist/fs.js"() {
+    "use strict";
+    init_parser();
+    init_analytics();
+    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_USAGE3 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+    USAGE_LOG = path.join(os.homedir(), ".cclens", "usage.jsonl");
+  }
+});
+
 // src/daemon-worker.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname2, join as join2 } from "node:path";
-import { homedir as homedir2 } from "node:os";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync4 } from "node:fs";
+import { dirname as dirname3, join as join4 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 
 // src/usage/token.ts
 import { execFileSync } from "node:child_process";
@@ -31,9 +2614,9 @@ function readFromCredentialsFile() {
     join(homedir(), ".claude", ".credentials.json"),
     join(homedir(), ".config", "claude", "credentials.json")
   ];
-  for (const path of candidates) {
+  for (const path2 of candidates) {
     try {
-      const blob = readFileSync(path, "utf8");
+      const blob = readFileSync(path2, "utf8");
       const creds = extractCredentials(blob);
       if (creds) return creds;
     } catch {
@@ -156,17 +2739,187 @@ function nextIntervalMs(current, outcome) {
   return Math.min(Math.max(current, BASE_INTERVAL_MS) * 2, MAX_INTERVAL_MS);
 }
 
+// src/team/config.ts
+import { readFileSync as readFileSync3, writeFileSync, unlinkSync, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var DEFAULT_DIR = join2(homedir2(), ".cclens");
+var CONFIG_FILE = "team.json";
+function readTeamConfig(dir = DEFAULT_DIR) {
+  try {
+    return JSON.parse(readFileSync3(join2(dir, CONFIG_FILE), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeTeamConfig(config, dir = DEFAULT_DIR) {
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync(join2(dir, CONFIG_FILE), JSON.stringify(config, null, 2), { mode: 384 });
+}
+
+// src/team/push.ts
+init_dist();
+import { randomUUID } from "node:crypto";
+function bucketToRollup(b) {
+  return {
+    day: b.date,
+    agentTimeMs: b.airTimeMs,
+    sessions: b.sessions,
+    toolCalls: b.toolCalls,
+    turns: b.turns,
+    tokens: { ...b.tokens }
+  };
+}
+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 {
+    ingestId: randomUUID(),
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dailyRollup: rollup
+  };
+}
+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 };
+}
+
+// src/team/queue.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, appendFileSync as appendFileSync2, statSync, mkdirSync as mkdirSync3 } from "node:fs";
+import { join as join3, dirname as dirname2 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+var QUEUE_PATH = join3(homedir3(), ".cclens", "ingest-queue.jsonl");
+var MAX_SIZE_BYTES = 10 * 1024 * 1024;
+var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function enqueuePayload(payload, queuePath = QUEUE_PATH) {
+  mkdirSync3(dirname2(queuePath), { recursive: true });
+  const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  appendFileSync2(queuePath, JSON.stringify(entry) + "\n", "utf8");
+  try {
+    const { size } = statSync(queuePath);
+    if (size > MAX_SIZE_BYTES) {
+      pruneOldest(queuePath);
+    }
+  } catch {
+  }
+}
+function dequeuePayloads(queuePath = QUEUE_PATH) {
+  let lines;
+  try {
+    lines = readFileSync4(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 {
+    }
+  }
+  writeFileSync2(queuePath, "", "utf8");
+  return valid.map((e) => e.payload);
+}
+function pruneOldest(queuePath) {
+  let lines;
+  try {
+    lines = readFileSync4(queuePath, "utf8").trim().split("\n").filter(Boolean);
+  } catch {
+    return;
+  }
+  const keep = lines.slice(Math.floor(lines.length / 2));
+  writeFileSync2(queuePath, keep.join("\n") + "\n", "utf8");
+}
+
+// src/team/sync.ts
+var noopLog = () => {
+};
+async function runTeamSync(log2 = noopLog) {
+  const config = readTeamConfig();
+  if (!config) return { paired: false, pushed: 0, queued: 0, queuedDrained: 0 };
+  try {
+    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) {
+      log2("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) {
+        log2("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) {
+      log2("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) {
+    const message = err.message;
+    log2("warn", `team push error: ${message}`);
+    return { paired: true, pushed: 0, queued: 0, queuedDrained: 0, error: message };
+  }
+}
+
 // src/daemon-worker.ts
-var STATE_DIR = join2(homedir2(), ".cclens");
-var USAGE_LOG = join2(STATE_DIR, "usage.jsonl");
-var DAEMON_LOG = join2(STATE_DIR, "daemon.log");
+var STATE_DIR = join4(homedir4(), ".cclens");
+var USAGE_LOG2 = join4(STATE_DIR, "usage.jsonl");
+var DAEMON_LOG = join4(STATE_DIR, "daemon.log");
 var WATCHDOG_INTERVAL_MS = 5 * 1e3;
-mkdirSync2(dirname2(USAGE_LOG), { recursive: true });
+mkdirSync4(dirname3(USAGE_LOG2), { recursive: true });
 function log(level, message) {
   const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${level.toUpperCase()} ${message}
 `;
   try {
-    appendFileSync2(DAEMON_LOG, line, "utf8");
+    appendFileSync3(DAEMON_LOG, line, "utf8");
   } catch {
   }
 }
@@ -176,7 +2929,7 @@ var waitingForRefresh = false;
 async function tick() {
   try {
     const snapshot = await fetchUsage();
-    appendSnapshot(USAGE_LOG, snapshot);
+    appendSnapshot(USAGE_LOG2, snapshot);
     log(
       "info",
       `snapshot 5h=${snapshot.five_hour.utilization}% 7d=${snapshot.seven_day.utilization}%`
@@ -233,6 +2986,7 @@ async function runLoop() {
         const outcome = await tick();
         scheduleAfter(Date.now(), outcome);
       }
+      await runTeamSync(log);
     }
     await sleep(WATCHDOG_INTERVAL_MS);
   }