@titan-design/session-analytics 0.5.0 → 0.8.0

package/dist/index.js

@@ -515,6 +515,8 @@ var reviewerCostSchema = z.object({
   requestsPerPr: z.number(),
   /** The reviewer model whose sessions give `requestsPerPr`: the row's own, else the newest reviewer cohort; `pooled` with none. */
   requestsFrom: z.string(),
+  /** Sessions in the `requestsFrom` cohort; 1 means the per-PR figure rests on one session. */
+  requestsFromSessions: count,
   costUsd: z.number()
 });
 var reviewerSchema = z.object({ prs: count, fresh: z.array(reviewerCostSchema), standing: z.array(reviewerCostSchema) });
@@ -533,9 +535,9 @@ var handoffThresholdSchema = z.object({
 function isBootAction(calls) {
   return calls.some((call) => BOOT_TOOL.test(call.tool) || (call.writePaths?.length ?? 0) > 0);
 }
-function parseTeleportEvents(lines) {
+function parseTeleportEvents(lines2) {
   const events = [];
-  for (const line of lines) {
+  for (const line of lines2) {
     const entry = parseJson(line);
     if (entry?.event !== TELEPORT_EVENT || typeof entry.from !== "string" || typeof entry.ts !== "string") continue;
     events.push({ ts: entry.ts, name: typeof entry.name === "string" ? entry.name : null, fromAgentId: entry.from });
@@ -593,7 +595,7 @@ function fitSession(unsorted, prices, sweep) {
   const price = findPrice(first.model, first.ts, prices);
   if (bootIndex < 0 || price === null) return null;
   const params = {
-    bootCostUsd: requests.slice(0, bootIndex + 1).reduce((sum, row) => sum + priceRequest(row.tokens, row.model, row.ts, prices).costUsd, 0),
+    bootCostUsd: requests.slice(0, bootIndex + 1).reduce((sum2, row) => sum2 + priceRequest(row.tokens, row.model, row.ts, prices).costUsd, 0),
     bootFill: requests[bootIndex].fill,
     growthPerRequest: meanGrowth(requests.slice(bootIndex).map((row) => row.fill)),
     readPricePerMTok: price.cacheRead
@@ -622,7 +624,7 @@ function cohortsOf(sessions, sweep, configuredK) {
   }).sort((a, b) => a.role.localeCompare(b.role) || a.model.localeCompare(b.model));
 }
 function meanParams(sessions) {
-  const mean = (pick) => sessions.reduce((sum, s) => sum + pick(s), 0) / sessions.length;
+  const mean = (pick) => sessions.reduce((sum2, s) => sum2 + pick(s), 0) / sessions.length;
   return {
     bootCostUsd: mean((s) => s.bootCostUsd),
     bootFill: mean((s) => s.bootFill),
@@ -632,7 +634,7 @@ function meanParams(sessions) {
 }
 function meanGrowthOf(sessions) {
   const grown = sessions.filter((s) => s.growthPerRequest > 0);
-  return grown.length === 0 ? 0 : grown.reduce((sum, s) => sum + s.growthPerRequest, 0) / grown.length;
+  return grown.length === 0 ? 0 : grown.reduce((sum2, s) => sum2 + s.growthPerRequest, 0) / grown.length;
 }
 function teleportExit(event, agentSessions2, bySession, cohorts, configuredK) {
   const candidates = (agentSessions2.get(event.fromAgentId) ?? []).flatMap((id) => bySession.get(id) ?? []);
@@ -661,7 +663,8 @@ function reviewerComparison(sessions, reviewerRole, standingRole, prs) {
   const priced = (role, costOf2) => cohorts(role).map(([model, members]) => {
     const from = perPr.has(model) ? model : newest;
     const requestsPerPr = from === null ? 0 : perPr.get(from);
-    return { role, model, sessions: members.length, requestsPerPr, requestsFrom: from ?? POOLED_REVIEWERS, costUsd: costOf2(meanParams(members), requestsPerPr) };
+    const requestsFromSessions = from === null ? 0 : reviewers.find(([name]) => name === from)?.[1].length ?? 0;
+    return { role, model, sessions: members.length, requestsPerPr, requestsFrom: from ?? POOLED_REVIEWERS, requestsFromSessions, costUsd: costOf2(meanParams(members), requestsPerPr) };
   });
   return {
     prs,
@@ -670,12 +673,13 @@ function reviewerComparison(sessions, reviewerRole, standingRole, prs) {
   };
 }
 function newestCohort(reviewers) {
-  const latest = reviewers.map(([model, members]) => ({ model, ts: members.reduce((max, s) => s.lastTs > max ? s.lastTs : max, "") }));
-  latest.sort((a, b) => b.ts.localeCompare(a.ts) || b.model.localeCompare(a.model));
+  const epoch = (ts) => Number.isNaN(Date.parse(ts)) ? Number.NEGATIVE_INFINITY : Date.parse(ts);
+  const latest = reviewers.map(([model, members]) => ({ model, at: Math.max(...members.map((s) => epoch(s.lastTs))) }));
+  latest.sort((a, b) => a.at === b.at ? b.model.localeCompare(a.model) : b.at - a.at);
   return latest[0]?.model ?? null;
 }
 function meanRequestsAfterBoot(sessions) {
-  return sessions.length === 0 ? 0 : sessions.reduce((sum, s) => sum + s.requests - s.bootRequests, 0) / sessions.length;
+  return sessions.length === 0 ? 0 : sessions.reduce((sum2, s) => sum2 + s.requests - s.bootRequests, 0) / sessions.length;
 }
 function groupBy(rows, keyOf) {
   const groups = /* @__PURE__ */ new Map();
@@ -765,6 +769,7 @@ var PROFILE_ROLES = {
   "fable-architect": "planner",
   planner: "planner",
   "bd-planner": "planner",
+  decider: "planner",
   "fable-coordinator": "coordinator",
   "opus-coordinator": "coordinator",
   peer: "standing_peer"
@@ -919,7 +924,7 @@ function buildWakeEpisodes(events, requests, names, noActionClasses) {
       from: pairSender(fromKind, event.fromName, names.seats),
       to: names.receivers.get(event.sessionId) ?? UNNAMED,
       requests: members.length,
-      costUsd: members.reduce((sum, row) => sum + row.costUsd, 0),
+      costUsd: members.reduce((sum2, row) => sum2 + row.costUsd, 0),
       noAction: members.every((row) => noActionClasses.includes(row.action))
     };
   });
@@ -935,20 +940,20 @@ function summarizeWakeEpisodes(episodes, requests, roles, noActionClasses) {
     roles: [...roles],
     noActionClasses: [...noActionClasses],
     ...costOf(episodes),
-    unattributed: { requests: unattributed.length, costUsd: unattributed.reduce((sum, row) => sum + row.costUsd, 0) },
+    unattributed: { requests: unattributed.length, costUsd: unattributed.reduce((sum2, row) => sum2 + row.costUsd, 0) },
     byCause: causeBuckets(episodes),
     pairs: pairBuckets(episodes)
   };
 }
 function costOf(episodes) {
   const noAction = episodes.filter((episode) => episode.noAction);
-  const sum = (list, pick) => list.reduce((total, episode) => total + pick(episode), 0);
+  const sum2 = (list, pick) => list.reduce((total, episode) => total + pick(episode), 0);
   return {
     episodes: episodes.length,
-    requests: sum(episodes, (episode) => episode.requests),
-    costUsd: sum(episodes, (episode) => episode.costUsd),
+    requests: sum2(episodes, (episode) => episode.requests),
+    costUsd: sum2(episodes, (episode) => episode.costUsd),
     noActionEpisodes: noAction.length,
-    noActionCostUsd: sum(noAction, (episode) => episode.costUsd)
+    noActionCostUsd: sum2(noAction, (episode) => episode.costUsd)
   };
 }
 function causeBuckets(episodes) {
@@ -969,7 +974,7 @@ function pairBuckets(episodes) {
   return [...groupBy2(sent, (episode) => JSON.stringify([episode.from, episode.fromKind, episode.to]))].map(([key, members]) => {
     const [from, fromKind, to] = JSON.parse(key);
     return { from, fromKind, to, ...costOf(members) };
-  }).sort((a, b) => b.costUsd - a.costUsd || a.from.localeCompare(b.from) || a.to.localeCompare(b.to));
+  }).sort((a, b) => b.costUsd - a.costUsd || a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.fromKind.localeCompare(b.fromKind));
 }
 function groupBy2(rows, keyOf) {
   const groups = /* @__PURE__ */ new Map();
@@ -1096,7 +1101,7 @@ function episodeCountKey(episodes) {
   return episodes >= EPISODE_COUNT_CAP ? `${EPISODE_COUNT_CAP}+` : String(episodes);
 }
 function sumOf(rows) {
-  return { requests: rows.length, costUsd: rows.reduce((sum, row) => sum + row.costUsd, 0) };
+  return { requests: rows.length, costUsd: rows.reduce((sum2, row) => sum2 + row.costUsd, 0) };
 }
 function tokenClasses(rows) {
   const pick = {
@@ -1108,7 +1113,7 @@ function tokenClasses(rows) {
   };
   return TOKEN_CLASSES.map((tokenClass) => {
     const pairs = rows.map(pick[tokenClass]);
-    return { tokenClass, tokens: pairs.reduce((sum, [tokens]) => sum + tokens, 0), costUsd: pairs.reduce((sum, [, cost]) => sum + cost, 0) };
+    return { tokenClass, tokens: pairs.reduce((sum2, [tokens]) => sum2 + tokens, 0), costUsd: pairs.reduce((sum2, [, cost]) => sum2 + cost, 0) };
   });
 }
 function dimensionBuckets(rows) {
@@ -1208,7 +1213,7 @@ function compactionCounts(rows) {
     manual: rows.filter((row) => row.trigger === "manual").length,
     auto: rows.filter((row) => row.trigger === "auto").length,
     midLoop: rows.filter((row) => row.midLoop).length,
-    droppedTokens: rows.reduce((sum, row) => sum + (row.droppedTokens ?? 0), 0)
+    droppedTokens: rows.reduce((sum2, row) => sum2 + (row.droppedTokens ?? 0), 0)
   };
 }
 function topSessions(rows, top) {
@@ -1219,7 +1224,7 @@ function topSessions(rows, top) {
 }
 function unpricedModels(rows) {
   const unpriced = rows.filter((row) => !row.priced);
-  return [...groupRows(unpriced, (row) => row.model)].map(([model, members]) => ({ model, requests: members.length, tokens: members.reduce((sum, row) => sum + tokensOf(row), 0) })).sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
+  return [...groupRows(unpriced, (row) => row.model)].map(([model, members]) => ({ model, requests: members.length, tokens: members.reduce((sum2, row) => sum2 + tokensOf(row), 0) })).sort((a, b) => b.tokens - a.tokens || a.model.localeCompare(b.model));
 }
 function tokensOf(row) {
   return row.inputTokens + row.cacheReadTokens + row.cacheWrite5mTokens + row.cacheWrite1hTokens + row.outputTokens;
@@ -1283,8 +1288,8 @@ function bucketTable(title, buckets2, total) {
 }
 function actionTable(roles) {
   const rows = roles.flatMap(({ role, buckets: buckets2 }) => {
-    const total = buckets2.reduce((sum, b) => sum + b.costUsd, 0);
-    const requests = buckets2.reduce((sum, b) => sum + b.requests, 0);
+    const total = buckets2.reduce((sum2, b) => sum2 + b.costUsd, 0);
+    const requests = buckets2.reduce((sum2, b) => sum2 + b.requests, 0);
     return [[role, requests, usd(total), share(total, total)], ...buckets2.map((b) => [`  ${b.key}`, b.requests, usd(b.costUsd), share(b.costUsd, total)])];
   });
   return table("By action per role", ["role / action", "requests", "cost", "share"], rows);
@@ -1377,8 +1382,8 @@ function table(title, head, rows) {
   const widths = head.map((_, i) => Math.max(...text.map((row) => row[i].length)));
   const rightAligned = head.map((_, i) => rows.every((row) => isNumeric(row[i])));
   const pad = (cell, i) => rightAligned[i] ? cell.padStart(widths[i]) : cell.padEnd(widths[i]);
-  const lines = text.map((row) => row.map(pad).join("  ").trimEnd());
-  return [title, ...lines].join("\n");
+  const lines2 = text.map((row) => row.map(pad).join("  ").trimEnd());
+  return [title, ...lines2].join("\n");
 }
 function isNumeric(cell) {
   return typeof cell === "number" || /^\$|%$/.test(cell);
@@ -1455,17 +1460,17 @@ function requestEffect(row, price) {
   };
 }
 function sumEffects(effects) {
-  const sum = (pick) => effects.reduce((total, effect) => total + pick(effect), 0);
+  const sum2 = (pick) => effects.reduce((total, effect) => total + pick(effect), 0);
   const sessions = new Set(effects.map((effect) => effect.sessionId)).size;
-  const netSavingUsd = sum((effect) => effect.repriceSavingUsd - effect.rebuildCostUsd);
+  const netSavingUsd = sum2((effect) => effect.repriceSavingUsd - effect.rebuildCostUsd);
   return {
     sessions,
     requests: effects.length,
-    write1hTokens: sum((effect) => effect.write1hTokens),
-    repriceSavingUsd: sum((effect) => effect.repriceSavingUsd),
+    write1hTokens: sum2((effect) => effect.write1hTokens),
+    repriceSavingUsd: sum2((effect) => effect.repriceSavingUsd),
     rebuilds: effects.filter((effect) => effect.rebuildTokens > 0).length,
-    rebuildTokens: sum((effect) => effect.rebuildTokens),
-    rebuildCostUsd: sum((effect) => effect.rebuildCostUsd),
+    rebuildTokens: sum2((effect) => effect.rebuildTokens),
+    rebuildCostUsd: sum2((effect) => effect.rebuildCostUsd),
     netSavingUsd,
     netPerSessionUsd: sessions > 0 ? netSavingUsd / sessions : 0
   };
@@ -1510,9 +1515,9 @@ function readTtlRows(db, window) {
 }
 function renderCacheTtlText(whatIf) {
   const { totals, window } = whatIf;
-  const span = window ? `, ${window.since ?? "beginning"} to ${window.until ?? "now"}` : "";
+  const span2 = window ? `, ${window.since ?? "beginning"} to ${window.until ?? "now"}` : "";
   const header2 = [
-    `Cache TTL what-if, 5m against 1h${span}`,
+    `Cache TTL what-if, 5m against 1h${span2}`,
     `Net ${usd(totals.netSavingUsd)} over ${totals.sessions} sessions: 1h writes repriced save ${usd(totals.repriceSavingUsd)}, ${totals.rebuilds} rebuilds after gaps in ${whatIf.rebuildGapBands.join(", ")} cost ${usd(totals.rebuildCostUsd)}`,
     `Roles where 5m loses: ${whatIf.lossRoles.join(", ") || "none"}`
   ].join("\n");
@@ -1630,10 +1635,10 @@ function classifyDeniedAction(tool, input) {
 function bashAction(command) {
   return BASH_ACTIONS.find(([, pattern]) => pattern.test(command))?.[0] ?? "bash-other";
 }
-function parseDenials(lines, seat) {
+function parseDenials(lines2, seat) {
   const calls = /* @__PURE__ */ new Map();
   const denials = [];
-  for (const line of lines) {
+  for (const line of lines2) {
     if (!line.includes('"tool_use"') && !line.includes("auto mode classifier")) continue;
     const entry = parseLine(line);
     for (const block of blocksOf(entry)) {
@@ -1641,11 +1646,22 @@ function parseDenials(lines, seat) {
       const reason = block.type === "tool_result" ? DENIAL.exec(resultText(block.content))?.[1] : void 0;
       if (reason === void 0) continue;
       const call = calls.get(block.tool_use_id ?? "") ?? { tool: "unknown", input: null };
-      denials.push({ seat, at: entry?.timestamp ?? "", reason, action: classifyDeniedAction(call.tool, call.input), tool: call.tool });
+      const toolUseId = block.tool_use_id ? { toolUseId: block.tool_use_id } : {};
+      denials.push({ seat, at: entry?.timestamp ?? "", reason, action: classifyDeniedAction(call.tool, call.input), tool: call.tool, ...toolUseId });
     }
   }
   return denials;
 }
+function dedupeDenials(denials) {
+  const seen = /* @__PURE__ */ new Set();
+  return denials.filter((d) => {
+    if (d.toolUseId === void 0) return true;
+    const key = `${d.seat}\0${d.toolUseId}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
 function parseLine(line) {
   try {
     return JSON.parse(line);
@@ -1781,9 +1797,9 @@ function blockedFlowReport(input) {
     ...input.splitAt ? { splitAt: input.splitAt } : {},
     sources: BLOCKED_FLOW_SOURCES,
     verdictToMerge: { cites: ["verdicts", "pulls"], rows: latencyRows(outcomes, input.splitAt) },
-    openHoldingMerge: { cites: ["verdicts", "pulls"], prMinutes: round(open.reduce((sum, r) => sum + r.ageMin, 0)), rows: open },
-    denials: denialSection(input.denials.filter((d) => inScope(d.seat, d.at))),
-    idleSlots: { cites: ["journals"], holdMaxMin: TICK_HOLD_MAX_MIN, total: idle.reduce((sum, r) => sum + r.slotMinutes, 0), rows: idle }
+    openHoldingMerge: { cites: ["verdicts", "pulls"], prMinutes: round(open.reduce((sum2, r) => sum2 + r.ageMin, 0)), rows: open },
+    denials: denialSection(dedupeDenials(input.denials).filter((d) => inScope(d.seat, d.at))),
+    idleSlots: { cites: ["journals"], holdMaxMin: TICK_HOLD_MAX_MIN, total: idle.reduce((sum2, r) => sum2 + r.slotMinutes, 0), rows: idle }
   };
 }
 function scopeTest(seats, window) {
@@ -1846,6 +1862,888 @@ function idleTable(report) {
 function sourceLines(report) {
   return ["Sources", ...Object.entries(report.sources).map(([name, s]) => `${name}: ${s.command} (${s.field})`)].join("\n");
 }
+
+// src/liveness-broker.ts
+function parseBrokerLog(lines2) {
+  const entries = [];
+  let line = 0;
+  for (const text of lines2) {
+    line += 1;
+    const fields = text.startsWith("{") ? parseObject(text) : null;
+    if (fields && typeof fields.ts === "string" && typeof fields.event === "string") entries.push({ line, ts: fields.ts, event: fields.event, fields });
+  }
+  return entries;
+}
+function parseObject(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function stringField(entry, key) {
+  const value = entry.fields[key];
+  return typeof value === "string" ? value : null;
+}
+function splitNames(to) {
+  return (to ?? "").split(",").map((name) => name.trim()).filter((name) => name.length > 0);
+}
+function minutesBetween2(from, to) {
+  return Math.round((Date.parse(to) - Date.parse(from)) / 6e3) / 10;
+}
+
+// src/liveness-routes.ts
+var INBOX_KINDS = /* @__PURE__ */ new Set(["answer", "decided"]);
+function routeMisses(entries) {
+  return entries.filter((e) => e.event === "route").flatMap((entry) => {
+    const base = { line: entry.line, at: entry.ts, from: stringField(entry, "from") ?? "", kind: stringField(entry, "kind") ?? "" };
+    return missedRecipients(entry).map(({ recipient, miss }) => ({ ...base, recipient, miss }));
+  });
+}
+function missedRecipients(entry) {
+  const to = stringField(entry, "to");
+  const kind = stringField(entry, "kind") ?? "";
+  if (to === null || to.startsWith("tag ") || kind === "broadcast") return [];
+  const named = splitNames(to);
+  if (entry.fields.delivered === false) {
+    const miss = entry.fields.held !== void 0 || INBOX_KINDS.has(kind) ? "queued" : "failed";
+    return named.map((recipient) => ({ recipient, miss }));
+  }
+  const reached = entry.fields.recipients;
+  if (entry.fields.delivered !== true || !Array.isArray(reached)) return [];
+  return named.filter((name) => !reached.includes(name)).map((recipient) => ({ recipient, miss: "partial" }));
+}
+function routeFailureRows(misses) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const m of misses) {
+    const row = rows.get(m.recipient) ?? { recipient: m.recipient, failed: 0, partial: 0, queued: 0, first: m.at, last: m.at, lines: [] };
+    rows.set(m.recipient, { ...row, [m.miss]: row[m.miss] + 1, last: m.at, lines: [...row.lines, m.line] });
+  }
+  const total = (r) => r.failed + r.partial + r.queued;
+  return [...rows.values()].sort((a, b) => total(b) - total(a) || a.recipient.localeCompare(b.recipient));
+}
+function countMisses(misses) {
+  return { failed: misses.filter((m) => m.miss === "failed").length, partial: misses.filter((m) => m.miss === "partial").length, queued: misses.filter((m) => m.miss === "queued").length };
+}
+
+// src/liveness-dark.ts
+var DARK_MIN = 5;
+var TELEPORT_EVENTS = /* @__PURE__ */ new Set(["teleport_started", "teleport_completed", "teleport_failed", "teleport_aborted"]);
+function darkGaps(entries, misses, asOf) {
+  return gapsByLifecycle(entries, asOf).filter((gap) => minutesBetween2(gap.from, gap.to ?? asOf) > DARK_MIN).map((gap) => toDarkGap(gap, misses, asOf)).filter((gap) => gap.to !== null || gap.failedRoutes + gap.partialRoutes + gap.queuedRoutes > 0).sort((a, b) => a.from.localeCompare(b.from) || a.seat.localeCompare(b.seat));
+}
+function gapsByLifecycle(entries, asOf) {
+  const states = /* @__PURE__ */ new Map();
+  const gaps = [];
+  const keep = (state, gap) => {
+    if (!state.exited || gap.teleportLines.length > 0) gaps.push(gap);
+  };
+  for (const entry of entries) {
+    const seat = stringField(entry, "name");
+    if (seat === null || entry.ts >= asOf) continue;
+    const state = states.get(seat) ?? { open: null, teleportLines: [], exited: false };
+    states.set(seat, state);
+    step(state, entry, (gap) => keep(state, { ...gap, seat, to: entry.ts, closeLine: entry.line }));
+  }
+  for (const [seat, state] of states) if (state.open) keep(state, { ...state.open, seat, to: null });
+  return gaps;
+}
+function step(state, entry, close) {
+  if (entry.event === "agent_exited") {
+    state.exited ||= exitedCleanly(entry);
+  } else if (TELEPORT_EVENTS.has(entry.event)) {
+    state.teleportLines.push(entry.line);
+    state.open?.teleportLines.push(entry.line);
+  } else if (entry.event === "deregistered" && !state.open) {
+    state.open = { from: entry.ts, lines: [entry.line], teleportLines: [...state.teleportLines] };
+  } else if (entry.event === "registered") {
+    if (state.open) close(state.open);
+    state.open = null;
+    state.teleportLines = [];
+    state.exited = false;
+  }
+}
+function exitedCleanly(entry) {
+  return entry.fields.code === 0 && entry.fields.inferred !== true;
+}
+function toDarkGap(gap, misses, asOf) {
+  const end = gap.to ?? asOf;
+  const missed = misses.filter((m) => m.recipient === gap.seat && m.at >= gap.from && m.at < end);
+  const counts = countMisses(missed);
+  return {
+    seat: gap.seat,
+    from: gap.from,
+    to: gap.to,
+    minutes: minutesBetween2(gap.from, end),
+    teleport: gap.teleportLines.length > 0,
+    failedRoutes: counts.failed,
+    partialRoutes: counts.partial,
+    queuedRoutes: counts.queued,
+    lines: [...gap.lines, ...gap.closeLine === void 0 ? [] : [gap.closeLine], ...gap.teleportLines],
+    routeLines: missed.map((m) => m.line)
+  };
+}
+
+// src/liveness-exits.ts
+var UNKNOWN_PROFILE = "unknown";
+function unreportedExitRows(entries, spawns) {
+  const byAgent = new Map(spawns.map((s) => [s.agentId, s]));
+  const rows = /* @__PURE__ */ new Map();
+  for (const entry of entries.filter((e) => e.event === "unreported-exit")) {
+    const agentId = stringField(entry, "agentId") ?? "";
+    const spawn = byAgent.get(agentId);
+    const profile = spawn?.profile ?? UNKNOWN_PROFILE;
+    const exit = {
+      at: entry.ts,
+      line: entry.line,
+      agentId,
+      name: stringField(entry, "name") ?? spawn?.name ?? "",
+      spawner: stringField(entry, "spawner") ?? "",
+      lastAction: stringField(entry, "lastAction") ?? "",
+      spawnEventId: spawn?.eventId ?? null
+    };
+    rows.set(profile, [...rows.get(profile) ?? [], exit]);
+  }
+  return [...rows.entries()].map(([profile, exits]) => ({ profile, count: exits.length, exits })).sort((a, b) => b.count - a.count || a.profile.localeCompare(b.profile));
+}
+
+// src/liveness-prompts.ts
+var PROMPT_STALE_MIN = 10;
+function stalePromptRows(lastEvents, broker, asOf) {
+  const gone = goneSinceRestart(broker, asOf);
+  return lastEvents.filter((e) => e.kind === "approval_request" && e.at < asOf && e.endEventId === null && !gone(e)).map((e) => ({ agent: e.actor, at: e.at, ageMin: minutesBetween2(e.at, asOf), tool: e.tool, eventId: e.eventId, resolutionEventId: e.resolutionEventId })).filter((row) => row.ageMin > PROMPT_STALE_MIN).sort((a, b) => b.ageMin - a.ageMin || a.agent.localeCompare(b.agent));
+}
+function goneSinceRestart(broker, asOf) {
+  const before = broker.filter((e) => e.ts < asOf);
+  const restart = before.filter((e) => e.event === "broker_started").at(-1)?.ts;
+  if (restart === void 0) return () => false;
+  const live = new Set(before.filter((e) => e.event === "registered" && e.ts >= restart).map((e) => stringField(e, "name")));
+  return (e) => e.at < restart && !live.has(e.actor);
+}
+
+// src/liveness.ts
+import { z as z7 } from "zod";
+var LIVENESS_SOURCES = {
+  registrations: {
+    command: `grep -nE '"event":"(registered|deregistered|agent_exited|teleport_started|teleport_completed|teleport_failed|teleport_aborted)"' <broker.log>`,
+    field: "ts, event, name; cited as broker.log line numbers; a gap with a clean agent_exited (code 0, not inferred) and no teleport is a resume"
+  },
+  routes: { command: `grep -n '"event":"route"' <broker.log>`, field: "to, delivered, recipients" },
+  exits: { command: `grep -n '"event":"unreported-exit"' <broker.log>`, field: "agentId, name, spawner, lastAction" },
+  spawns: {
+    command: `sqlite3 -readonly <events.db> "SELECT id, msg_id, target, json_extract(meta,'$.profile') FROM events WHERE kind='agent_spawned'"`,
+    field: "events.msg_id (agent id), events.meta.profile"
+  },
+  prompts: {
+    command: `sqlite3 -readonly <events.db> "SELECT e.* FROM events e JOIN (SELECT actor, max(id) id FROM events WHERE ts < <asOf> AND kind != 'resolution' GROUP BY actor) l ON e.id = l.id WHERE e.kind='approval_request'"`,
+    field: "events.ts, events.actor, events.meta.tool_name; a resolution row's events.ref; skipped after the actor's agent_exited or agent_retired, or a broker_started it never re-registered after"
+  }
+};
+var source2 = z7.enum(["registrations", "routes", "exits", "spawns", "prompts"]);
+var count6 = z7.number().int().nonnegative();
+var lines = z7.array(count6);
+var darkRow = z7.object({
+  seat: z7.string(),
+  from: z7.string(),
+  to: z7.string().nullable(),
+  minutes: z7.number(),
+  teleport: z7.boolean(),
+  failedRoutes: count6,
+  partialRoutes: count6,
+  queuedRoutes: count6,
+  lines,
+  routeLines: lines
+});
+var exitRow = z7.object({ at: z7.string(), line: count6, agentId: z7.string(), name: z7.string(), spawner: z7.string(), lastAction: z7.string(), spawnEventId: count6.nullable() });
+var promptRow = z7.object({ agent: z7.string(), at: z7.string(), ageMin: z7.number(), tool: z7.string().nullable(), eventId: count6, resolutionEventId: count6.nullable() });
+var livenessSchema = z7.object({
+  asOf: z7.string(),
+  window: z7.object({ since: z7.string().optional(), until: z7.string().optional() }),
+  thresholds: z7.object({ darkMin: z7.number(), promptStaleMin: z7.number() }),
+  sources: z7.record(source2, z7.object({ command: z7.string(), field: z7.string() })),
+  darkSeats: z7.object({ cites: z7.array(source2), withTeleport: count6, withoutTeleport: count6, rows: z7.array(darkRow) }),
+  routeFailures: z7.object({
+    cites: z7.array(source2),
+    failed: count6,
+    partial: count6,
+    queued: count6,
+    rows: z7.array(z7.object({ recipient: z7.string(), failed: count6, partial: count6, queued: count6, first: z7.string(), last: z7.string(), lines }))
+  }),
+  unreportedExits: z7.object({ cites: z7.array(source2), total: count6, rows: z7.array(z7.object({ profile: z7.string(), count: count6, exits: z7.array(exitRow) })) }),
+  stalePrompts: z7.object({ cites: z7.array(source2), rows: z7.array(promptRow), resolvedRows: z7.array(promptRow) })
+});
+function livenessReport(input) {
+  const window = input.window ?? {};
+  const keep = scopeTest2(input.seats, window);
+  const broker = input.broker.filter((e) => e.ts < input.asOf);
+  const misses = routeMisses(broker);
+  const dark = darkGaps(broker, misses, input.asOf).filter((g) => keep([g.seat], g.from));
+  const routeMissesInScope = misses.filter((m) => keep([m.recipient], m.at));
+  const routes = routeFailureRows(routeMissesInScope);
+  const prompts = stalePromptRows(input.lastEvents, broker, input.asOf).filter((p) => !input.seats || input.seats.includes(p.agent));
+  const exits = unreportedExitRows(broker.filter((e) => keep([stringField(e, "name") ?? "", stringField(e, "spawner") ?? ""], e.ts)), input.spawns);
+  return {
+    asOf: input.asOf,
+    window,
+    thresholds: { darkMin: DARK_MIN, promptStaleMin: PROMPT_STALE_MIN },
+    sources: LIVENESS_SOURCES,
+    darkSeats: { cites: ["registrations", "routes"], withTeleport: dark.filter((g) => g.teleport).length, withoutTeleport: dark.filter((g) => !g.teleport).length, rows: dark },
+    routeFailures: { cites: ["routes"], ...countMisses(routeMissesInScope), rows: routes },
+    unreportedExits: { cites: ["exits", "spawns"], total: sum(exits.map((r) => r.count)), rows: exits },
+    stalePrompts: { cites: ["prompts"], rows: prompts.filter((p) => p.resolutionEventId === null), resolvedRows: prompts.filter((p) => p.resolutionEventId !== null) }
+  };
+}
+function scopeTest2(seats, window) {
+  const named = seats ? new Set(seats) : null;
+  return (names, at) => (!named || names.some((n) => named.has(n))) && (!window.since || at >= window.since) && (!window.until || at < window.until);
+}
+function sum(values) {
+  return values.reduce((total, v) => total + v, 0);
+}
+var CITED_LINES = 4;
+function cite(prefix, ids) {
+  if (ids.length === 0) return "-";
+  const shown = ids.slice(0, CITED_LINES).map((id) => `${prefix}${id}`).join(",");
+  return ids.length > CITED_LINES ? `${shown} +${ids.length - CITED_LINES}` : shown;
+}
+function renderLivenessText(report) {
+  const scope = `Liveness as of ${report.asOf}${report.window.since ? `, since ${report.window.since}` : ""}${report.window.until ? `, until ${report.window.until}` : ""}`;
+  const sources = ["Sources", ...Object.entries(report.sources).map(([name, s]) => `${name}: ${s.command} (${s.field})`)].join("\n");
+  return [scope, darkTable(report), routeTable(report), exitTable(report), promptTable(report), sources, LIST_PRICE_CAVEAT].join("\n\n") + "\n";
+}
+function darkTable(report) {
+  const { rows, withTeleport, withoutTeleport } = report.darkSeats;
+  const cells = rows.map((r) => [r.seat, r.from, r.to ?? "still dark", r.minutes, r.teleport ? "yes" : "no", r.failedRoutes, r.partialRoutes, r.queuedRoutes, cite("broker.log:", [...r.lines, ...r.routeLines])]);
+  const title = `Seats dark over ${report.thresholds.darkMin} min, ${withTeleport} with a teleport and ${withoutTeleport} without [darkSeats.rows[]]`;
+  return table(title, ["seat", "from", "to", "min", "teleport", "failed routes", "partial routes", "queued routes", "cites"], cells);
+}
+function routeTable(report) {
+  const { rows, failed, partial, queued } = report.routeFailures;
+  const cells = rows.map((r) => [r.recipient, r.failed, r.partial, r.queued, r.first, r.last, cite("broker.log:", r.lines)]);
+  const title = `Routes that missed a recipient, ${failed} dropped, ${partial} partial and ${queued} held or queued for later [routeFailures.rows[]]`;
+  return table(title, ["recipient", "failed", "partial", "queued", "first", "last", "cites"], cells);
+}
+function exitTable(report) {
+  const cells = report.unreportedExits.rows.flatMap((r) => r.exits.map((e) => [r.profile, e.name, e.spawner, e.lastAction, e.at, cite("broker.log:", [e.line]), e.spawnEventId === null ? "-" : `events#${e.spawnEventId}`]));
+  const title = `Unreported exits by profile, ${report.unreportedExits.total} in all [unreportedExits.rows[].exits[]]`;
+  return table(title, ["profile", "agent", "spawner", "last action", "at", "exit", "spawn"], cells);
+}
+function promptTable(report) {
+  const cells = (rows) => rows.map((r) => [r.agent, r.tool ?? "-", r.at, r.ageMin, `events#${r.eventId}`, r.resolutionEventId === null ? "-" : `events#${r.resolutionEventId}`]);
+  const head = ["agent", "tool", "at", "age min", "prompt", "resolution"];
+  const over = `over ${report.thresholds.promptStaleMin} min old`;
+  return [
+    table(`Agents whose last event is an unresolved permission prompt ${over} [stalePrompts.rows[]]`, head, cells(report.stalePrompts.rows)),
+    table(`Agents silent since a resolved permission prompt ${over} [stalePrompts.resolvedRows[]]`, head, cells(report.stalePrompts.resolvedRows))
+  ].join("\n\n");
+}
+
+// src/timeline-types.ts
+var SESSION_TIMELINE_VERSION = 1;
+var TIMELINE_GAP_MIN_MS = 10 * 6e4;
+var TIMELINE_TEXT_CAP = 4e3;
+
+// src/timeline-breakdowns.ts
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function ascending(times) {
+  return times.filter((time) => time !== null).sort((a, b) => a - b);
+}
+function toolBreakdown(calls) {
+  const byName = /* @__PURE__ */ new Map();
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const failed = call.outcome === "error" ? 1 : 0;
+    const name = byName.get(call.name) ?? { name: call.name, family: call.family, calls: 0, errors: 0, durationMs: 0 };
+    name.calls++;
+    name.errors += failed;
+    name.durationMs += call.durationMs ?? 0;
+    byName.set(call.name, name);
+    const family = byFamily.get(call.family) ?? { family: call.family, calls: 0, errors: 0, atMs: [] };
+    family.calls++;
+    family.errors += failed;
+    if (call.atMs !== null) family.atMs.push(call.atMs);
+    byFamily.set(call.family, family);
+  }
+  for (const family of byFamily.values()) family.atMs.sort((a, b) => a - b);
+  return {
+    byName: [...byName.values()].sort((a, b) => b.calls - a.calls || a.name.localeCompare(b.name)),
+    byFamily: [...byFamily.values()].sort((a, b) => b.calls - a.calls || a.family.localeCompare(b.family)),
+    atMs: ascending(calls.map((call) => call.atMs))
+  };
+}
+function fileBreakdown(calls) {
+  const touches = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    if (!call.filePath) continue;
+    const access = WRITE_TOOLS.has(call.name) ? "write" : "read";
+    const key = `${access}:${call.filePath}`;
+    const touch2 = touches.get(key) ?? { path: call.filePath, access, atMs: call.atMs, calls: 0 };
+    touch2.calls++;
+    touches.set(key, touch2);
+  }
+  const rows = [...touches.values()].sort((a, b) => (a.atMs ?? Infinity) - (b.atMs ?? Infinity));
+  return {
+    touches: rows,
+    readCount: rows.filter((row) => row.access === "read").length,
+    writeCount: rows.filter((row) => row.access === "write").length
+  };
+}
+function errorBreakdown(calls) {
+  const items = calls.filter((call) => call.outcome === "error").map((call) => ({
+    callId: call.id,
+    toolName: call.name,
+    turnIndex: call.turnIndex,
+    atMs: call.endMs ?? call.atMs,
+    message: call.errorMessage ?? "",
+    sidechain: call.sidechain
+  }));
+  return { rate: calls.length > 0 ? items.length / calls.length : 0, items, atMs: ascending(items.map((item) => item.atMs)) };
+}
+function agentSpans(calls) {
+  return calls.filter((call) => call.family === "subagent").map((call) => ({ callId: call.id, label: call.inputSummary || call.name, startMs: call.atMs, endMs: call.endMs, outcome: call.outcome }));
+}
+
+// src/timeline-buckets.ts
+var MINUTE_MS3 = 6e4;
+function activityTimes(input) {
+  const times = input.points.map((point) => point.atMs);
+  for (const turn of input.turns) {
+    times.push(turn.user?.atMs ?? null, ...turn.assistant.map((message) => message.atMs));
+  }
+  for (const call of input.calls) times.push(call.atMs, call.endMs);
+  return times.filter((time) => time !== null).sort((a, b) => a - b);
+}
+function findGaps(sortedMs, gapMinMs, calls) {
+  const gaps = [];
+  for (let i = 1; i < sortedMs.length; i++) {
+    const startMs = sortedMs[i - 1];
+    const endMs = sortedMs[i];
+    if (endMs - startMs < gapMinMs || calls.some((call) => inFlightAcross(call, startMs, endMs))) continue;
+    gaps.push({ startMs, endMs, durationMs: endMs - startMs });
+  }
+  return gaps;
+}
+function inFlightAcross(call, startMs, endMs) {
+  return call.atMs !== null && call.endMs !== null && call.atMs <= startMs && call.endMs >= endMs;
+}
+function minuteBuckets(input, gaps) {
+  const buckets2 = /* @__PURE__ */ new Map();
+  const at = (ms) => bucketAt(buckets2, ms);
+  for (const turn of input.turns) {
+    for (const message of [turn.user, ...turn.assistant]) {
+      if (message?.atMs != null) countEvent(at(message.atMs), "messages");
+    }
+  }
+  for (const call of input.calls) countCall(call, at);
+  for (const point of input.points) {
+    const bucket = at(point.atMs);
+    bucket.outputTokens += point.outputTokens;
+    bucket.costUsd += point.costUsd;
+  }
+  for (const gap of gaps) at(gap.endMs).gapBeforeMs = gap.durationMs;
+  return [...buckets2.values()].sort((a, b) => a.minuteMs - b.minuteMs);
+}
+function markTurnGaps(turns, gapMinMs) {
+  let previousEndMs = null;
+  for (const turn of turns) {
+    const idleMs = previousEndMs !== null && turn.startMs !== null ? turn.startMs - previousEndMs : 0;
+    turn.gapBeforeMs = idleMs >= gapMinMs ? idleMs : null;
+    previousEndMs = turn.endMs ?? previousEndMs;
+  }
+}
+function bucketAt(buckets2, ms) {
+  const minuteMs = Math.floor(ms / MINUTE_MS3) * MINUTE_MS3;
+  let bucket = buckets2.get(minuteMs);
+  if (!bucket) {
+    bucket = { minuteMs, events: 0, messages: 0, toolCalls: 0, errors: 0, outputTokens: 0, costUsd: 0, gapBeforeMs: null };
+    buckets2.set(minuteMs, bucket);
+  }
+  return bucket;
+}
+function countEvent(bucket, field) {
+  bucket.events++;
+  if (field) bucket[field]++;
+}
+function countCall(call, at) {
+  if (call.atMs !== null) countEvent(at(call.atMs), "toolCalls");
+  if (call.endMs !== null) countEvent(at(call.endMs), null);
+  const errorMs = call.endMs ?? call.atMs;
+  if (call.outcome === "error" && errorMs !== null) at(errorMs).errors++;
+}
+
+// src/timeline-tokens.ts
+import { foldUsage } from "@titan-design/agent-protocol";
+
+// src/timeline-turns.ts
+import { findInjectedMarker, toolFamily } from "@titan-design/session-read";
+var ERROR_TEXT_CAP = 500;
+var SUMMARY_CAP = 160;
+var SUMMARY_KEYS = ["command", "pattern", "description", "query", "url", "prompt"];
+var PATH_KEYS = ["file_path", "notebook_path", "path"];
+function capText(text, cap) {
+  return text.length <= cap ? { text, truncated: false } : { text: text.slice(0, cap), truncated: true };
+}
+function isSidechain(observation) {
+  return observation.nativeExtensions?.some((entry) => entry.name === "isSidechain" && entry.value === true) ?? false;
+}
+var TurnFold = class {
+  constructor(maxTextChars) {
+    this.maxTextChars = maxTextChars;
+  }
+  maxTextChars;
+  turns = [];
+  calls = [];
+  callsById = /* @__PURE__ */ new Map();
+  seenMessages = /* @__PURE__ */ new Set();
+  seq = 0;
+  currentIndex() {
+    return this.turns.length > 0 ? this.turns.length - 1 : null;
+  }
+  message(observation, atMs) {
+    if (isSidechain(observation) || this.isRepeat(observation)) return;
+    const raw = observation.content.map((part) => part.text).join("\n");
+    const message = {
+      role: observation.role,
+      seq: this.seq++,
+      atMs,
+      ...capText(raw, this.maxTextChars),
+      byteOffset: observation.evidence.line.byteOffset
+    };
+    if (observation.role === "user") this.open(message, raw);
+    else touch(this.current(atMs), atMs).assistant.push(message);
+  }
+  toolCall(observation, atMs) {
+    const turn = touch(this.current(atMs), atMs);
+    const call = {
+      id: observation.call.nativeId,
+      seq: this.seq++,
+      turnIndex: turn.index,
+      name: observation.name,
+      family: toolFamily(observation.name).family,
+      atMs,
+      endMs: null,
+      durationMs: null,
+      outcome: "pending",
+      errorMessage: null,
+      inputSummary: inputSummary(observation.input),
+      filePath: firstString(observation.input, PATH_KEYS),
+      sidechain: isSidechain(observation),
+      byteOffset: observation.evidence.line.byteOffset
+    };
+    turn.toolCalls.push(call);
+    this.calls.push(call);
+    this.callsById.set(call.id, call);
+  }
+  /** A result whose call was never seen, as in a resumed slice, is dropped. */
+  toolResult(observation, atMs) {
+    const call = this.callsById.get(observation.call.nativeId);
+    const turn = call ? this.turns[call.turnIndex] : void 0;
+    if (!call || !turn) return;
+    call.endMs = atMs;
+    call.durationMs = span(call.atMs, atMs);
+    call.outcome = outcomeOf(observation.isError);
+    touch(turn, atMs);
+    if (call.outcome !== "error") return;
+    call.errorMessage = capText(outputText(observation.output), ERROR_TEXT_CAP).text;
+    turn.errorCount++;
+  }
+  isRepeat(observation) {
+    const key = observation.item?.nativeId;
+    if (!key) return false;
+    if (this.seenMessages.has(key)) return true;
+    this.seenMessages.add(key);
+    return false;
+  }
+  open(user, raw) {
+    const marker = findInjectedMarker(raw);
+    this.turns.push({ ...emptyTurn(this.turns.length, originOf(marker), user.atMs), injectedMarker: marker, user });
+  }
+  current(atMs) {
+    const last = this.turns[this.turns.length - 1];
+    if (last) return last;
+    const turn = emptyTurn(0, "none", atMs);
+    this.turns.push(turn);
+    return turn;
+  }
+};
+function emptyTurn(index, origin, atMs) {
+  return {
+    index,
+    origin,
+    injectedMarker: null,
+    startMs: atMs,
+    endMs: atMs,
+    gapBeforeMs: null,
+    user: null,
+    assistant: [],
+    toolCalls: [],
+    errorCount: 0,
+    tokens: { input: 0, cacheRead: 0, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 0 },
+    costUsd: 0
+  };
+}
+function originOf(marker) {
+  if (marker === null) return "prompt";
+  return marker === "compaction_summary" ? "compaction" : "injected";
+}
+function touch(turn, atMs) {
+  if (atMs === null) return turn;
+  if (turn.startMs === null || atMs < turn.startMs) turn.startMs = atMs;
+  if (turn.endMs === null || atMs > turn.endMs) turn.endMs = atMs;
+  return turn;
+}
+function span(startMs, endMs) {
+  if (startMs === null || endMs === null || endMs < startMs) return null;
+  return endMs - startMs;
+}
+function outcomeOf(isError) {
+  if (isError === null) return "unknown";
+  return isError ? "error" : "success";
+}
+function firstString(input, keys) {
+  if (typeof input !== "object" || input === null) return null;
+  const record = input;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return null;
+}
+function inputSummary(input) {
+  const text = firstString(input, PATH_KEYS) ?? firstString(input, SUMMARY_KEYS) ?? "";
+  const firstLine = text.split("\n", 1)[0] ?? "";
+  return capText(firstLine, SUMMARY_CAP).text;
+}
+function outputText(output) {
+  if (typeof output === "string") return output;
+  if (!Array.isArray(output)) return "";
+  for (const block of output) {
+    const text = firstString(block, ["text"]);
+    if (text) return text;
+  }
+  return "";
+}
+
+// src/timeline-tokens.ts
+function emptyTokens() {
+  return { input: 0, cacheRead: 0, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 0 };
+}
+function addTokens(into, from) {
+  into.input += from.input;
+  into.cacheRead += from.cacheRead;
+  into.cacheWrite += from.cacheWrite;
+  into.cacheWrite5m += from.cacheWrite5m;
+  into.cacheWrite1h += from.cacheWrite1h;
+  into.output += from.output;
+}
+var TokenFold = class {
+  constructor(maxTextChars, prices) {
+    this.maxTextChars = maxTextChars;
+    this.prices = prices;
+  }
+  maxTextChars;
+  prices;
+  compactions = [];
+  requests = /* @__PURE__ */ new Map();
+  snapshots = [];
+  compactedSinceRequest = false;
+  usage(observation, atMs, turnIndex) {
+    const { measurement } = observation;
+    if (measurement.kind === "snapshot") {
+      this.snapshots.push(measurement);
+      return;
+    }
+    const held = this.requests.get(measurement.responseId);
+    const tokens = disjointTokens(measurement.tokens, "cacheWriteSplit" in observation ? observation.cacheWriteSplit : void 0);
+    const priced = priceRequest(priceInput(tokens), measurement.model ?? "", isoOf(held ? held.atMs : atMs), this.prices);
+    this.requests.set(measurement.responseId, {
+      atMs: held ? held.atMs : atMs,
+      turnIndex: held ? held.turnIndex : turnIndex,
+      model: measurement.model,
+      contextTokens: measurement.tokens.input,
+      tokens,
+      costUsd: priced.costUsd,
+      priced: priced.priced,
+      afterCompaction: held ? held.afterCompaction : this.takeCompactionFlag()
+    });
+  }
+  /**
+   * Claude Code writes one compaction as a boundary line and then a summary line, and the
+   * decoder reports both. The second joins the first: the mark keeps the boundary's time and gains the summary.
+   */
+  compaction(observation, atMs, turnIndex) {
+    const summary = observation.nativeExtensions?.find((entry) => entry.name === "compactionSummary")?.value;
+    const capped = typeof summary === "string" ? capText(summary, this.maxTextChars) : null;
+    const open = this.compactedSinceRequest ? this.compactions.at(-1) : void 0;
+    if (open && open.summary === null) {
+      open.summary = capped?.text ?? null;
+      open.summaryTruncated = capped?.truncated ?? false;
+      return;
+    }
+    this.compactions.push({
+      atMs,
+      turnIndex,
+      byteOffset: observation.evidence.line.byteOffset,
+      summary: capped?.text ?? null,
+      summaryTruncated: capped?.truncated ?? false
+    });
+    this.compactedSinceRequest = true;
+  }
+  result() {
+    const requests = [...this.requests.values()];
+    const basis = requests.length > 0 ? "delta" : this.snapshots.length > 0 ? "snapshot" : "unreported";
+    const timeline2 = { basis, points: cumulativePoints(requests), compactions: this.compactions, models: modelCounts(requests) };
+    if (basis === "snapshot") return { timeline: timeline2, requests, requestCount: null, tokens: snapshotTokens(this.snapshots) };
+    const tokens = emptyTokens();
+    for (const request of requests) addTokens(tokens, request.tokens);
+    return { timeline: timeline2, requests, requestCount: requests.length, tokens };
+  }
+  takeCompactionFlag() {
+    const flag = this.compactedSinceRequest;
+    this.compactedSinceRequest = false;
+    return flag;
+  }
+};
+function disjointTokens(counts, split) {
+  const cacheRead = counts.cachedInput ?? 0;
+  const cacheWrite = counts.cacheWriteInput ?? 0;
+  const input = Math.max(0, (counts.input ?? 0) - cacheRead - cacheWrite);
+  return { input, cacheRead, cacheWrite, ...cacheWriteByTtl(cacheWrite, split), output: counts.output ?? 0 };
+}
+function cacheWriteByTtl(total, split) {
+  if (split && split.ttl5m + split.ttl1h > 0) return { cacheWrite5m: split.ttl5m, cacheWrite1h: split.ttl1h };
+  return { cacheWrite5m: total, cacheWrite1h: 0 };
+}
+function priceInput(tokens) {
+  return {
+    inputTokens: tokens.input,
+    cacheReadTokens: tokens.cacheRead,
+    cacheCreation5mTokens: tokens.cacheWrite5m,
+    cacheCreation1hTokens: tokens.cacheWrite1h,
+    outputTokens: tokens.output
+  };
+}
+function isoOf(atMs) {
+  return atMs === null ? "" : new Date(atMs).toISOString();
+}
+function cumulativePoints(requests) {
+  const points = [];
+  let cumulativeOutputTokens = 0;
+  let cumulativeCostUsd = 0;
+  for (const request of requests) {
+    cumulativeOutputTokens += request.tokens.output;
+    cumulativeCostUsd += request.costUsd;
+    if (request.atMs === null) continue;
+    const { atMs, turnIndex, model, contextTokens, costUsd, priced, afterCompaction } = request;
+    points.push({ atMs, turnIndex, model, contextTokens, outputTokens: request.tokens.output, cumulativeOutputTokens, costUsd, cumulativeCostUsd, priced, afterCompaction });
+  }
+  return points;
+}
+function modelCounts(requests) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const request of requests) {
+    if (request.model) counts.set(request.model, (counts.get(request.model) ?? 0) + 1);
+  }
+  return [...counts].map(([model, count8]) => ({ model, requests: count8 })).sort((a, b) => b.requests - a.requests || a.model.localeCompare(b.model));
+}
+function snapshotTokens(snapshots) {
+  const tokens = emptyTokens();
+  for (const measurement of foldUsage(snapshots).measurements) addTokens(tokens, disjointTokens(measurement.tokens));
+  return tokens;
+}
+
+// src/timeline.ts
+var SessionTimelineAccumulator = class {
+  turns;
+  tokens;
+  gapMinMs;
+  conversation = null;
+  startMs = null;
+  endMs = null;
+  constructor(options = {}) {
+    const maxTextChars = options.maxTextChars ?? TIMELINE_TEXT_CAP;
+    this.gapMinMs = options.gapMinMs ?? TIMELINE_GAP_MIN_MS;
+    this.turns = new TurnFold(maxTextChars);
+    this.tokens = new TokenFold(maxTextChars, options.prices);
+  }
+  add(observation) {
+    this.claim(observation);
+    if (observation.historyOrigin) return;
+    const atMs = this.clock(observation.timestamp);
+    if (observation.kind === "message") this.turns.message(observation, atMs);
+    if (observation.kind === "tool_call") this.turns.toolCall(observation, atMs);
+    if (observation.kind === "tool_result") this.turns.toolResult(observation, atMs);
+    if (observation.kind === "usage") this.tokens.usage(observation, atMs, this.turns.currentIndex());
+    if (observation.kind === "compaction") this.tokens.compaction(observation, atMs, this.turns.currentIndex());
+  }
+  result() {
+    const { turns, calls } = this.turns;
+    const tokens = this.tokens.result();
+    attributeRequests(turns, tokens);
+    markTurnGaps(turns, this.gapMinMs);
+    const bucketInput = { turns, calls, points: tokens.timeline.points };
+    const gaps = findGaps(activityTimes(bucketInput), this.gapMinMs, calls);
+    const errors = errorBreakdown(calls);
+    return structuredClone({
+      version: SESSION_TIMELINE_VERSION,
+      sessionId: this.conversation?.nativeId ?? null,
+      harness: this.conversation?.harness ?? null,
+      startMs: this.startMs,
+      endMs: this.endMs,
+      durationMs: this.startMs !== null && this.endMs !== null ? this.endMs - this.startMs : 0,
+      totals: totalsOf(turns, calls.length, errors.items.length, tokens),
+      turns,
+      buckets: minuteBuckets(bucketInput, gaps),
+      gaps,
+      tokens: tokens.timeline,
+      tools: toolBreakdown(calls),
+      files: fileBreakdown(calls),
+      errors,
+      agents: agentSpans(calls)
+    });
+  }
+  claim(observation) {
+    const { harness, namespace, nativeId } = observation.conversation;
+    this.conversation ??= observation.conversation;
+    const held = this.conversation;
+    if (held.harness !== harness || held.namespace !== namespace || held.nativeId !== nativeId) {
+      throw new TypeError("cannot build one timeline from observations of different conversations");
+    }
+  }
+  /** A record with no usable timestamp takes the latest one seen, so it still lands in order. */
+  clock(timestamp) {
+    const parsed = timestamp === null ? Number.NaN : Date.parse(timestamp);
+    if (!Number.isFinite(parsed)) return this.endMs;
+    if (this.startMs === null || parsed < this.startMs) this.startMs = parsed;
+    if (this.endMs === null || parsed > this.endMs) this.endMs = parsed;
+    return parsed;
+  }
+};
+function buildSessionTimeline(observations, options = {}) {
+  const accumulator = new SessionTimelineAccumulator(options);
+  for (const observation of observations) accumulator.add(observation);
+  return accumulator.result();
+}
+function attributeRequests(turns, tokens) {
+  for (const turn of turns) {
+    turn.tokens = emptyTokens();
+    turn.costUsd = 0;
+  }
+  for (const request of tokens.requests) {
+    const turn = request.turnIndex === null ? void 0 : turns[request.turnIndex];
+    if (!turn) continue;
+    addTokens(turn.tokens, request.tokens);
+    turn.costUsd += request.costUsd;
+  }
+}
+function totalsOf(turns, toolCalls, errors, tokens) {
+  return {
+    turns: turns.length,
+    userMessages: turns.filter((turn) => turn.user !== null).length,
+    assistantMessages: turns.reduce((sum2, turn) => sum2 + turn.assistant.length, 0),
+    toolCalls,
+    errors,
+    compactions: tokens.timeline.compactions.length,
+    requests: tokens.requestCount,
+    unpricedRequests: tokens.requests.filter((request) => !request.priced).length,
+    tokens: tokens.tokens,
+    costUsd: tokens.requests.reduce((sum2, request) => sum2 + request.costUsd, 0)
+  };
+}
+
+// src/count-at-or-before.ts
+function countAtOrBefore(sortedMs, targetMs) {
+  let lo = 0;
+  let hi = sortedMs.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (sortedMs[mid] <= targetMs) lo = mid + 1;
+    else hi = mid;
+  }
+  return lo;
+}
+
+// src/review-fill.ts
+import { z as z8 } from "zod";
+var APPROVE = "approve";
+var CHANGES_REQUESTED = "changes_requested";
+var CHAT_KEY = /^chat:([^:]+):/;
+var VERDICTS = `
+  SELECT source_key AS sourceKey, verdict, ts, pr_ref AS prRef, transcript_id AS transcriptId FROM pr_review
+  WHERE (@since IS NULL OR ts >= @since) AND (@until IS NULL OR ts < @until)
+`;
+var CHANGES = `SELECT pr_ref AS prRef, ts FROM pr_review WHERE verdict = '${CHANGES_REQUESTED}' AND pr_ref IS NOT NULL`;
+var ISSUER = `
+  SELECT r.model, r.context_tokens AS tokens FROM tool_call c
+  JOIN request r ON r.transcript_id = c.transcript_id AND r.byte_offset <= c.byte_offset
+  WHERE c.tool_use_id = @toolUseId AND c.transcript_id = @transcriptId
+  ORDER BY r.byte_offset DESC LIMIT 1
+`;
+var count7 = z8.number().int().nonnegative();
+var rate = z8.number().min(0).max(1).nullable();
+var reviewFillSchema = z8.object({
+  window: z8.object({ since: z8.string().nullable(), until: z8.string().nullable() }),
+  /** Verdicts with no fill: GitHub-surface reviews, and chat verdicts whose issuing request is not in the graph. */
+  unfilled: count7,
+  /** Verdicts whose `pr_ref` is not resolved; they count in their band but are never matched to another review. */
+  unresolved: count7,
+  rows: z8.array(
+    z8.object({
+      band: z8.string(),
+      model: z8.string(),
+      verdicts: count7,
+      changesRequested: count7,
+      changesRate: rate,
+      verdictErrors: count7,
+      /** Verdict errors over all verdicts in the cell, not over approvals. */
+      errorRate: rate
+    })
+  )
+});
+function reviewFillReport(db, window) {
+  const changesByPr = readChangesByPr(db);
+  const cells = /* @__PURE__ */ new Map();
+  let unfilled = 0;
+  let unresolved = 0;
+  for (const row of db.prepare(VERDICTS).all(window)) {
+    if (!row.prRef) unresolved += 1;
+    const issuer = issuerOf(db, row);
+    const band = issuer ? contextBand(issuer.tokens) : null;
+    if (!issuer || !band) {
+      unfilled += 1;
+      continue;
+    }
+    const key = `${band}|${issuer.model}`;
+    cells.set(key, tally(cells.get(key) ?? emptyCell(band, issuer.model), row, changesByPr));
+  }
+  return { window, unfilled, unresolved, rows: [...cells.values()].map(withRates) };
+}
+function issuerOf(db, row) {
+  const toolUseId = CHAT_KEY.exec(row.sourceKey)?.[1];
+  if (!toolUseId || row.transcriptId === null) return null;
+  return db.prepare(ISSUER).get({ toolUseId, transcriptId: row.transcriptId }) ?? null;
+}
+function readChangesByPr(db) {
+  const byPr = /* @__PURE__ */ new Map();
+  for (const { prRef, ts } of db.prepare(CHANGES).all()) byPr.set(prRef, [...byPr.get(prRef) ?? [], ts]);
+  return byPr;
+}
+function tally(cell, row, changesByPr) {
+  const contradicted = row.verdict === APPROVE && row.prRef !== null && (changesByPr.get(row.prRef) ?? []).some((ts) => ts > row.ts);
+  return {
+    ...cell,
+    verdicts: cell.verdicts + 1,
+    changesRequested: cell.changesRequested + (row.verdict === CHANGES_REQUESTED ? 1 : 0),
+    verdictErrors: cell.verdictErrors + (contradicted ? 1 : 0)
+  };
+}
+function emptyCell(band, model) {
+  return { band, model, verdicts: 0, changesRequested: 0, changesRate: null, verdictErrors: 0, errorRate: null };
+}
+function withRates(cell) {
+  return { ...cell, changesRate: cell.changesRequested / cell.verdicts, errorRate: cell.verdictErrors / cell.verdicts };
+}
 export {
   ACTION_CLASSES,
   AGENT_LIFECYCLE,
@@ -1859,6 +2757,7 @@ export {
   COORDINATOR_MIN_EPISODE_REQUESTS,
   COORDINATOR_WAVE_QUIET_REQUESTS,
   COST_REPORT_SECTIONS,
+  DARK_MIN,
   DEFAULT_ACTION_RULES,
   DEFAULT_CONFIGURED_K,
   DEFAULT_EPISODE_ROLES,
@@ -1872,16 +2771,23 @@ export {
   HEURISTIC_VERSIONS,
   IDLE_GAP_MS,
   LIST_PRICE_CAVEAT,
+  LIVENESS_SOURCES,
   POOLED_REVIEWERS,
   PRICE_TABLE,
   PRICE_TABLE_VERSION,
   PROFILE_ROLES,
+  PROMPT_STALE_MIN,
   REBUILD_GAP_BANDS,
+  SESSION_TIMELINE_VERSION,
   STANDING_PEER_MIN_ASSIGNMENTS,
   STANDING_PEER_MIN_HOURS,
+  SessionTimelineAccumulator,
   TELEPORT_EVENT,
   TICK_HOLD_MAX_MIN,
+  TIMELINE_GAP_MIN_MS,
+  TIMELINE_TEXT_CAP,
   TOKEN_CLASSES,
+  UNKNOWN_PROFILE,
   UNSTATED_REASON,
   WAKE_FROM_KINDS,
   assignmentCount,
@@ -1889,6 +2795,7 @@ export {
   blockedFlowReport,
   blockedFlowSchema,
   buildEpisodes,
+  buildSessionTimeline,
   buildWakeEpisodes,
   cacheTtlReport,
   cacheTtlWhatIf,
@@ -1900,6 +2807,10 @@ export {
   costPerRequest,
   costReport,
   costReportSchema,
+  countAtOrBefore,
+  countMisses,
+  darkGaps,
+  dedupeDenials,
   episodeNames,
   findPrice,
   gapBand,
@@ -1911,7 +2822,10 @@ export {
   isBootAction,
   latencyStats,
   latencyStatsSchema,
+  livenessReport,
+  livenessSchema,
   mergeOutcomes,
+  parseBrokerLog,
   parseDenials,
   parseSeatJournal,
   parseTeleportEvents,
@@ -1925,12 +2839,19 @@ export {
   renderCacheTtlText,
   renderCostReportSections,
   renderCostReportText,
+  renderLivenessText,
+  reviewFillReport,
+  reviewFillSchema,
   roleFromProfile,
+  routeFailureRows,
+  routeMisses,
   scopeFilter,
   sessionInitiative,
   sessionRole,
+  stalePromptRows,
   summarizeWakeEpisodes,
   sweepK,
+  unreportedExitRows,
   wakeEpisodesSchema,
   workerRole,
   writeEpisodes