@titan-design/session-analytics 0.6.0 → 0.8.0

package/dist/index.js

@@ -1515,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");
@@ -2138,6 +2138,612 @@ function promptTable(report) {
     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,
@@ -2172,10 +2778,14 @@ export {
   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,
@@ -2185,6 +2795,7 @@ export {
   blockedFlowReport,
   blockedFlowSchema,
   buildEpisodes,
+  buildSessionTimeline,
   buildWakeEpisodes,
   cacheTtlReport,
   cacheTtlWhatIf,
@@ -2196,6 +2807,7 @@ export {
   costPerRequest,
   costReport,
   costReportSchema,
+  countAtOrBefore,
   countMisses,
   darkGaps,
   dedupeDenials,
@@ -2228,6 +2840,8 @@ export {
   renderCostReportSections,
   renderCostReportText,
   renderLivenessText,
+  reviewFillReport,
+  reviewFillSchema,
   roleFromProfile,
   routeFailureRows,
   routeMisses,