@titan-design/session-analytics 0.4.1 → 0.5.0

package/dist/index.js

@@ -131,14 +131,14 @@ function gapBand(millis) {
 }
 
 // src/cost-report.ts
-import { z } from "zod";
+import { z as z3 } from "zod";
 
 // src/cost-report-queries.ts
 import { AUDIT_FACET, EPISODE_TABLE, FACET_TABLE, KIT } from "@titan-design/session-graph";
 var IN_WINDOW = "(@since IS NULL OR ts >= @since) AND (@until IS NULL OR ts < @until)";
 var IN_SESSIONS = "session_id IN (SELECT value FROM json_each(@ids))";
 var COST_ROWS = `
-  SELECT session_id AS sessionId, model,
+  SELECT session_id AS sessionId, request_id AS requestId, ts, model, COALESCE(context_tokens, 0) AS contextTokens, is_sidechain AS isSidechain,
     input_tokens AS inputTokens, cache_read_tokens AS cacheReadTokens,
     CASE WHEN cache_creation_5m + cache_creation_1h = 0 THEN cache_creation_tokens ELSE cache_creation_5m END AS cacheWrite5mTokens,
     cache_creation_1h AS cacheWrite1hTokens, output_tokens AS outputTokens,
@@ -150,7 +150,7 @@ var COST_ROWS = `
 `;
 function readCostRows(db, window) {
   const rows = db.prepare(COST_ROWS).all(window);
-  return rows.map((row) => ({ ...row, priced: row.priced === 1, isCold: row.isCold === 1 }));
+  return rows.map((row) => ({ ...row, priced: row.priced === 1, isCold: row.isCold === 1, isSidechain: row.isSidechain === 1 }));
 }
 function readCompactions(db, window) {
   const sql = `SELECT trigger, mid_loop AS midLoop, dropped_tokens AS droppedTokens FROM compaction WHERE ${IN_WINDOW}`;
@@ -169,6 +169,46 @@ function readCoverage(db, facetVersion) {
   ).get({ facet: AUDIT_FACET, version: facetVersion });
   return { transcriptsIndexed: indexed.n, facetBacklog: backlog.n };
 }
+var EPISODE_DELIVERIES = "('turn_start', 'mid_loop')";
+var WAKE_EVENTS = `
+  WITH event AS (
+    SELECT transcript_id, byte_offset, MAX(block_index) AS block_index FROM inbound
+    WHERE ${IN_SESSIONS} AND ${IN_WINDOW} AND delivery IN ${EPISODE_DELIVERIES}
+    GROUP BY transcript_id, byte_offset
+  ), fanout AS (
+    SELECT msg_id, COUNT(DISTINCT session_id) AS receivers FROM inbound
+    WHERE msg_id IN (SELECT i.msg_id FROM event JOIN inbound i USING (transcript_id, byte_offset, block_index))
+    GROUP BY msg_id
+  )
+  SELECT i.transcript_id || ':' || i.byte_offset AS key, i.session_id AS sessionId, i.cause, i.delivery,
+    i.from_name AS fromName, COALESCE(f.receivers, 1) > 1 AS broadcast
+  FROM event JOIN inbound i USING (transcript_id, byte_offset, block_index)
+  LEFT JOIN fanout f ON f.msg_id = i.msg_id
+  ORDER BY i.transcript_id, i.byte_offset`;
+var REQUEST_EVENTS = `
+  SELECT d.request_id AS requestId, d.transcript_id || ':' || (
+    SELECT MAX(i.byte_offset) FROM inbound i
+    WHERE i.transcript_id = d.transcript_id AND i.session_id = d.session_id AND i.byte_offset < d.byte_offset
+      AND i.delivery IN ${EPISODE_DELIVERIES}) AS eventKey
+  FROM request_dedup d WHERE d.${IN_SESSIONS} AND (@since IS NULL OR d.ts >= @since) AND (@until IS NULL OR d.ts < @until)`;
+function readWakeEvents(db, window, sessionIds) {
+  const rows = db.prepare(WAKE_EVENTS).all({ ...window, ids: JSON.stringify(sessionIds) });
+  return rows.map((row) => ({ ...row, broadcast: row.broadcast === 1 }));
+}
+function readRequestEvents(db, window, sessionIds) {
+  const rows = db.prepare(REQUEST_EVENTS).all({ ...window, ids: JSON.stringify(sessionIds) });
+  return new Map(rows.map((row) => [row.requestId, row.eventKey]));
+}
+function readAgentNames(db) {
+  const sql = `SELECT session_id AS sessionId, agent_name AS agentName, origin_kind AS originKind, profile FROM session_origin WHERE agent_name IS NOT NULL`;
+  return db.prepare(sql).all();
+}
+function readAgentSessions(db) {
+  const sql = `SELECT agent_id AS agentId, session_id AS sessionId FROM session_origin WHERE agent_id IS NOT NULL`;
+  const sessions = /* @__PURE__ */ new Map();
+  for (const row of db.prepare(sql).all()) sessions.set(row.agentId, [...sessions.get(row.agentId) ?? [], row.sessionId]);
+  return sessions;
+}
 function readSessionContexts(db, sessionIds) {
   const ids = JSON.stringify(sessionIds);
   const contexts = new Map(sessionIds.map((id) => [id, emptyContext()]));
@@ -422,6 +462,232 @@ function writeEpisodes(graph, sessionIds) {
   return written;
 }
 
+// src/handoff-threshold.ts
+import { z } from "zod";
+var BOOT_TOOL = /(agent_(spawn|resume)|chat_(send|broadcast))$/;
+var DEFAULT_CONFIGURED_K = [17e4, 25e4];
+var DEFAULT_K_SWEEP = { fromK: 2e4, toK: 1e6, stepK: 5e3 };
+var DEFAULT_REVIEWER_ROLE = "worker:reviewer";
+var DEFAULT_STANDING_ROLE = "worker:standing_peer";
+var DEFAULT_REVIEWER_PRS = 10;
+var TELEPORT_EVENT = "teleport_started";
+var MTOK = 1e6;
+var count = z.number().int().nonnegative();
+var kCostSchema = z.object({ k: count, costPerRequest: z.number().nullable(), deltaPerRequest: z.number().nullable() });
+var sweepResultSchema = z.object({ bestK: count.nullable(), bestCostPerRequest: z.number().nullable(), atConfigured: z.array(kCostSchema) });
+var paramsSchema = z.object({ bootCostUsd: z.number(), bootFill: z.number(), growthPerRequest: z.number(), readPricePerMTok: z.number() });
+var sessionSchema = paramsSchema.extend({
+  sessionId: z.string(),
+  role: z.string(),
+  model: z.string(),
+  requests: count,
+  bootRequests: count,
+  exitFill: count,
+  /** Timestamp of the session's last request; orders reviewer cohorts by recency. */
+  lastTs: z.string(),
+  bestK: count.nullable()
+});
+var cohortSchema = paramsSchema.extend({
+  role: z.string(),
+  model: z.string(),
+  sessions: count,
+  ...sweepResultSchema.shape,
+  /** The same sweep when only half the boot is overhead the next session pays again. */
+  halfBoot: sweepResultSchema
+});
+var teleportSchema = z.object({
+  ts: z.string(),
+  name: z.string().nullable(),
+  sessionId: z.string(),
+  role: z.string(),
+  model: z.string(),
+  exitFill: count,
+  bestK: count.nullable(),
+  /** Exit fill minus each configured K; positive means the seat left late. */
+  overConfigured: z.array(z.object({ k: count, over: z.number() }))
+});
+var POOLED_REVIEWERS = "pooled";
+var reviewerCostSchema = z.object({
+  role: z.string(),
+  model: z.string(),
+  sessions: count,
+  /** Mean requests after boot of a per-PR reviewer: the work each PR adds. */
+  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(),
+  costUsd: z.number()
+});
+var reviewerSchema = z.object({ prs: count, fresh: z.array(reviewerCostSchema), standing: z.array(reviewerCostSchema) });
+var handoffThresholdSchema = z.object({
+  configuredK: z.array(count),
+  sweep: z.object({ fromK: count, toK: count, stepK: count }),
+  cohorts: z.array(cohortSchema),
+  sessions: z.array(sessionSchema),
+  /** Sessions with no dispatch, send or write, or none priced: they have no boot to measure. */
+  unbootedSessions: count,
+  teleports: z.array(teleportSchema),
+  unmatchedTeleports: count,
+  /** Boot and cache reads for `prs` reviews: a fresh reviewer per PR against one standing reviewer. */
+  reviewers: reviewerSchema
+});
+function isBootAction(calls) {
+  return calls.some((call) => BOOT_TOOL.test(call.tool) || (call.writePaths?.length ?? 0) > 0);
+}
+function parseTeleportEvents(lines) {
+  const events = [];
+  for (const line of lines) {
+    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 });
+  }
+  return events;
+}
+function parseJson(line) {
+  try {
+    const value = JSON.parse(line);
+    return typeof value === "object" && value !== null ? value : null;
+  } catch {
+    return null;
+  }
+}
+function costPerRequest(params, k) {
+  const requests = (k - params.bootFill) / params.growthPerRequest;
+  if (!(params.growthPerRequest > 0) || requests < 1) return null;
+  return params.bootCostUsd / requests + params.readPricePerMTok / MTOK * ((params.bootFill + k) / 2);
+}
+function sweepK(params, sweep, configuredK) {
+  let best = null;
+  for (let k = sweep.fromK; k <= sweep.toK; k += sweep.stepK) {
+    const cost = costPerRequest(params, k);
+    if (cost !== null && (best === null || cost < best.cost)) best = { k, cost };
+  }
+  const atConfigured = configuredK.map((k) => {
+    const cost = costPerRequest(params, k);
+    return { k, costPerRequest: cost, deltaPerRequest: cost === null || best === null ? null : cost - best.cost };
+  });
+  return { bestK: best?.k ?? null, bestCostPerRequest: best?.cost ?? null, atConfigured };
+}
+function handoffThreshold(rows, teleports, agentSessions2, options = {}) {
+  const configuredK = [...options.configuredK ?? DEFAULT_CONFIGURED_K];
+  const sweep = { ...options.sweep ?? DEFAULT_K_SWEEP };
+  const bySession = groupBy(rows, (row) => row.sessionId);
+  const fits = [...bySession.values()].map((requests) => fitSession(requests, options.prices ?? PRICE_TABLE, sweep));
+  const sessions = fits.filter((fit) => fit !== null).sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+  const cohorts = cohortsOf(sessions, sweep, configuredK);
+  const matched = teleports.map((event) => teleportExit(event, agentSessions2, bySession, cohorts, configuredK)).filter((t) => t !== null);
+  return {
+    configuredK,
+    sweep,
+    cohorts,
+    sessions,
+    unbootedSessions: fits.length - sessions.length,
+    teleports: matched.sort((a, b) => a.ts.localeCompare(b.ts)),
+    unmatchedTeleports: teleports.length - matched.length,
+    reviewers: reviewerComparison(sessions, options.reviewerRole ?? DEFAULT_REVIEWER_ROLE, options.standingRole ?? DEFAULT_STANDING_ROLE, options.reviewerPrs ?? DEFAULT_REVIEWER_PRS)
+  };
+}
+function fitSession(unsorted, prices, sweep) {
+  const requests = [...unsorted].sort((a, b) => a.ts.localeCompare(b.ts));
+  const first = requests[0];
+  const bootIndex = requests.findIndex((row) => row.bootAction);
+  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),
+    bootFill: requests[bootIndex].fill,
+    growthPerRequest: meanGrowth(requests.slice(bootIndex).map((row) => row.fill)),
+    readPricePerMTok: price.cacheRead
+  };
+  const { sessionId, role, model } = first;
+  const last = requests[requests.length - 1];
+  return { sessionId, role, model, requests: requests.length, bootRequests: bootIndex + 1, exitFill: last.fill, lastTs: last.ts, ...params, bestK: sweepK(params, sweep, []).bestK };
+}
+function meanGrowth(fills) {
+  if (fills.length < 2) return 0;
+  let rise = 0;
+  for (let i = 1; i < fills.length; i += 1) rise += Math.max(0, fills[i] - fills[i - 1]);
+  return rise / (fills.length - 1);
+}
+function cohortsOf(sessions, sweep, configuredK) {
+  return [...groupBy(sessions, (s) => JSON.stringify([s.role, s.model]))].map(([, members]) => {
+    const params = meanParams(members);
+    return {
+      role: members[0].role,
+      model: members[0].model,
+      sessions: members.length,
+      ...params,
+      ...sweepK(params, sweep, configuredK),
+      halfBoot: sweepK({ ...params, bootCostUsd: params.bootCostUsd / 2 }, 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;
+  return {
+    bootCostUsd: mean((s) => s.bootCostUsd),
+    bootFill: mean((s) => s.bootFill),
+    growthPerRequest: meanGrowthOf(sessions),
+    readPricePerMTok: mean((s) => s.readPricePerMTok)
+  };
+}
+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;
+}
+function teleportExit(event, agentSessions2, bySession, cohorts, configuredK) {
+  const candidates = (agentSessions2.get(event.fromAgentId) ?? []).flatMap((id) => bySession.get(id) ?? []);
+  const exit = candidates.filter((row) => row.ts <= event.ts).sort((a, b) => b.ts.localeCompare(a.ts))[0];
+  if (!exit) return null;
+  const cohort = cohorts.find((c) => c.role === exit.role && c.model === exit.model);
+  return {
+    ts: event.ts,
+    name: event.name,
+    sessionId: exit.sessionId,
+    role: exit.role,
+    model: exit.model,
+    exitFill: exit.fill,
+    bestK: cohort?.bestK ?? null,
+    overConfigured: configuredK.map((k) => ({ k, over: exit.fill - k }))
+  };
+}
+function readCost(params, requests) {
+  return (requests * params.bootFill + params.growthPerRequest * requests * (requests + 1) / 2) * params.readPricePerMTok / MTOK;
+}
+function reviewerComparison(sessions, reviewerRole, standingRole, prs) {
+  const cohorts = (role) => [...groupBy(sessions.filter((s) => s.role === role), (s) => s.model)].sort(([a], [b]) => a.localeCompare(b));
+  const reviewers = cohorts(reviewerRole);
+  const perPr = new Map(reviewers.map(([model, members]) => [model, meanRequestsAfterBoot(members)]));
+  const newest = newestCohort(reviewers);
+  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) };
+  });
+  return {
+    prs,
+    fresh: priced(reviewerRole, (params, requests) => prs * (params.bootCostUsd + readCost(params, requests))),
+    standing: priced(standingRole, (params, requests) => params.bootCostUsd + readCost(params, prs * requests))
+  };
+}
+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));
+  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;
+}
+function groupBy(rows, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = keyOf(row);
+    const members = groups.get(key);
+    if (members) members.push(row);
+    else groups.set(key, [row]);
+  }
+  return groups;
+}
+
 // src/initiative.ts
 function sessionInitiative(tasks, cwd) {
   const best = [...tasks].sort((a, b) => b.edges - a.edges || a.initiative.localeCompare(b.initiative))[0];
@@ -438,6 +704,50 @@ function initiativeFromCwd(cwd) {
   return `other:${trimmed.slice(trimmed.lastIndexOf("/") + 1)}`;
 }
 
+// src/request-owner.ts
+var CALL_SIGNALS = { command_heads: "heads", file_read: "readPaths", file_write: "writePaths" };
+var OWNED_CALLS = `
+  WITH scope AS (
+    SELECT DISTINCT transcript_id FROM request_dedup
+    WHERE (@since IS NULL OR ts >= @since) AND (@until IS NULL OR ts < @until)
+  ), stream AS (
+    SELECT transcript_id, byte_offset, -1 AS lane, 0 AS block_index, request_id, NULL AS tool_use_id, NULL AS name
+    FROM request WHERE transcript_id IN (SELECT transcript_id FROM scope)
+    UNION ALL
+    SELECT transcript_id, byte_offset, 0, block_index, NULL, tool_use_id, name
+    FROM tool_call WHERE transcript_id IN (SELECT transcript_id FROM scope)
+  ), ordered AS (
+    SELECT *, COUNT(request_id) OVER (PARTITION BY transcript_id ORDER BY byte_offset, lane, block_index ROWS UNBOUNDED PRECEDING) AS requests_seen
+    FROM stream
+  ), owned AS (
+    SELECT c.transcript_id, c.byte_offset, c.block_index, c.tool_use_id, c.name, r.request_id
+    FROM ordered c JOIN ordered r ON r.transcript_id = c.transcript_id AND r.lane = -1 AND r.requests_seen = c.requests_seen
+    WHERE c.lane = 0
+  )
+  SELECT o.request_id AS requestId, o.transcript_id || ':' || o.byte_offset || ':' || o.block_index AS callKey, o.name AS tool, s.signal, s.detail
+  FROM owned o
+  JOIN request_dedup d ON d.transcript_id = o.transcript_id AND d.request_id = o.request_id
+  LEFT JOIN session_signal s ON s.transcript_id = o.transcript_id AND s.tool_use_id = o.tool_use_id
+    AND s.signal IN ('command_heads', 'file_read', 'file_write')
+  WHERE (@since IS NULL OR d.ts >= @since) AND (@until IS NULL OR d.ts < @until)
+  ORDER BY o.transcript_id, o.byte_offset, o.block_index
+`;
+function readRequestToolCalls(db, window) {
+  const byRequest = /* @__PURE__ */ new Map();
+  for (const row of db.prepare(OWNED_CALLS).all(window)) {
+    const calls = byRequest.get(row.requestId) ?? /* @__PURE__ */ new Map();
+    byRequest.set(row.requestId, calls);
+    const call = calls.get(row.callKey) ?? { tool: row.tool };
+    calls.set(row.callKey, row.signal ? withSignal(call, row.signal, row.detail ?? "") : call);
+  }
+  return new Map([...byRequest].map(([requestId, calls]) => [requestId, [...calls.values()]]));
+}
+function withSignal(call, signal, detail) {
+  const field = CALL_SIGNALS[signal];
+  const values = signal === "command_heads" ? detail.split(";").filter(Boolean) : [detail];
+  return { ...call, [field]: [...call[field] ?? [], ...values] };
+}
+
 // src/roles.ts
 var PROFILE_ROLES = {
   implementer: "implementer",
@@ -445,13 +755,18 @@ var PROFILE_ROLES = {
   "relay-implementer": "implementer",
   "beat-builder": "implementer",
   "fable-optimizer": "implementer",
+  "bd-implementer": "implementer",
+  "bd-implementer-lite": "implementer",
   reviewer: "reviewer",
   "relay-reviewer": "reviewer",
+  "bd-reviewer": "reviewer",
   researcher: "researcher",
   explorer: "researcher",
   "fable-architect": "planner",
   planner: "planner",
+  "bd-planner": "planner",
   "fable-coordinator": "coordinator",
+  "opus-coordinator": "coordinator",
   peer: "standing_peer"
 };
 var STANDING_PEER_MIN_HOURS = 12;
@@ -470,42 +785,252 @@ function sessionRole(classification, worker) {
   return classification.sessionClass;
 }
 
+// src/scope.ts
+function scopeFilter(db, scope = {}) {
+  const ids = scope.sessionIds ? new Set(scope.sessionIds) : null;
+  const named = scope.agentPrefix === void 0 ? null : agentSessions(db, scope.agentPrefix);
+  const roles = scope.roles ? new Set(scope.roles) : null;
+  return (row) => (!ids || ids.has(row.sessionId)) && (!named || named.has(row.sessionId)) && (!roles || roles.has(row.role));
+}
+function agentSessions(db, prefix) {
+  return new Set(readAgentNames(db).filter((row) => row.agentName.startsWith(prefix)).map((row) => row.sessionId));
+}
+
+// src/turn-action.ts
+var ACTION_CLASSES = [
+  "journal-write",
+  "pr-ci-check",
+  "merge",
+  "dispatch",
+  "retire",
+  "task-state",
+  "budget-status",
+  "scorer",
+  "message",
+  "read-investigate",
+  "text-only",
+  "other"
+];
+var JOURNAL_BASENAME = String.raw`(?:(?:[^/]*[-_.])?(?:log|journal|events?)(?:[-_.][^/]*)?\.(?:md|jsonl)|[^/]*journal[^/]*)$`;
+var INTERPRETER = String.raw`(?:(?:python3?|node|tsx|bash|sh) )?`;
+var DEFAULT_ACTION_RULES = [
+  { cls: "journal-write", writePath: new RegExp(String.raw`(?:^|/)${JOURNAL_BASENAME}`, "i") },
+  { cls: "journal-write", head: new RegExp(`^>(?:[^/]*/)?${JOURNAL_BASENAME}`, "i") },
+  { cls: "pr-ci-check", head: /^gh pr (checks|view)\b/ },
+  { cls: "pr-ci-check", head: /^gh run\b/ },
+  { cls: "pr-ci-check", head: /^git merge-tree\b/ },
+  { cls: "pr-ci-check", head: /^gh api GET commits\/check-runs$/ },
+  { cls: "pr-ci-check", head: /^gh api GET commits\/status$/ },
+  { cls: "merge", head: /^gh pr merge\b/ },
+  { cls: "merge", head: /^gh api PUT pulls\/merge$/ },
+  { cls: "dispatch", tool: /agent_(spawn|resume)$/ },
+  { cls: "retire", head: /^(agent-chat )?agent retire\b/ },
+  { cls: "task-state", head: /^active-work task\b/ },
+  { cls: "budget-status", tool: /(session_budget|chat_status)$/ },
+  { cls: "budget-status", head: /^(agent-chat )?agent list\b/ },
+  { cls: "budget-status", head: /^(agent-chat )?agent (ls|budget|worktrees)\b/ },
+  { cls: "budget-status", head: /^git worktree list\b/ },
+  { cls: "budget-status", tool: /(agent_list|chat_list|ListAgents)$/ },
+  { cls: "scorer", tool: /(^|__)scor/i },
+  { cls: "scorer", head: new RegExp(`^${INTERPRETER}[\\w.-]*scor`, "i") },
+  { cls: "message", tool: /chat_send$/ },
+  { cls: "message", tool: /(chat_ask|chat_inbox|chat_claim|chat_release)$/ },
+  { cls: "read-investigate", tool: /^(Read|Grep|Glob)$/ },
+  { cls: "read-investigate", head: /^(cat|ls|grep|rg|head|tail|find|wc|git (log|diff|show|status))\b/ }
+];
+var DEFAULT_MECHANICAL_CLASSES = [
+  "journal-write",
+  "pr-ci-check",
+  "task-state",
+  "budget-status",
+  "retire",
+  "merge",
+  "scorer"
+];
+function callMatches(call, rule) {
+  if (rule.tool && !rule.tool.test(call.tool)) return false;
+  if (rule.head && !(call.heads ?? []).some((h) => rule.head?.test(h))) return false;
+  if (rule.readPath && !(call.readPaths ?? []).some((p) => rule.readPath?.test(p))) return false;
+  if (rule.writePath && !(call.writePaths ?? []).some((p) => rule.writePath?.test(p))) return false;
+  return true;
+}
+function classifyRequest(calls, rules = DEFAULT_ACTION_RULES) {
+  if (calls.length === 0) return "text-only";
+  const hit = rules.find((rule) => calls.some((call) => callMatches(call, rule)));
+  return hit?.cls ?? "other";
+}
+
+// src/wake-episodes.ts
+import { z as z2 } from "zod";
+var WAKE_FROM_KINDS = ["seat", "agent", "broadcast", "broker", "none"];
+var DEFAULT_EPISODE_ROLES = ["coordinator", "worker:coordinator"];
+var DEFAULT_NO_ACTION_CLASSES = ["read-investigate", "text-only", "other"];
+var BROKER_SENDER = "agent-chat";
+var AGENT_LIFECYCLE = "agent_lifecycle";
+var UNNAMED = "unnamed";
+var count2 = z2.number().int().nonnegative();
+var costFields = { episodes: count2, requests: count2, costUsd: z2.number(), noActionEpisodes: count2, noActionCostUsd: z2.number() };
+var fromSchema = z2.object({ key: z2.enum(WAKE_FROM_KINDS), ...costFields });
+var causeSchema = z2.object({
+  key: z2.string(),
+  ...costFields,
+  midLoopEpisodes: count2,
+  requestsPerEpisode: z2.number(),
+  costPerEpisode: z2.number(),
+  byFrom: z2.array(fromSchema)
+});
+var pairSchema = z2.object({ from: z2.string(), fromKind: z2.enum(WAKE_FROM_KINDS), to: z2.string(), ...costFields });
+var wakeEpisodesSchema = z2.object({
+  roles: z2.array(z2.string()),
+  noActionClasses: z2.array(z2.enum(ACTION_CLASSES)),
+  ...costFields,
+  /** Requests in the window that follow no event in it: the work an earlier arrival started. */
+  unattributed: z2.object({ requests: count2, costUsd: z2.number() }),
+  byCause: z2.array(causeSchema),
+  /** Sender by receiver; a seat is named, every other sender is its kind. */
+  pairs: z2.array(pairSchema)
+});
+function episodeNames(rows) {
+  const isSeat = (row) => row.originKind !== "spawned" || roleFromProfile(row.profile) === "coordinator";
+  return {
+    seats: new Set(rows.filter(isSeat).map((row) => row.agentName)),
+    receivers: new Map(rows.map((row) => [row.sessionId, row.agentName]))
+  };
+}
+function episodeCause(cause) {
+  return cause === "channel_system" ? AGENT_LIFECYCLE : cause;
+}
+function fromKindOf(event, seats) {
+  if (!event.cause.startsWith("channel_") || event.fromName === null) return "none";
+  if (event.fromName === BROKER_SENDER) return "broker";
+  if (event.broadcast) return "broadcast";
+  return seats.has(event.fromName) ? "seat" : "agent";
+}
+function buildWakeEpisodes(events, requests, names, noActionClasses) {
+  const byEvent = groupBy2(requests, (request) => request.eventKey ?? "");
+  return events.map((event) => {
+    const members = byEvent.get(event.key) ?? [];
+    const fromKind = fromKindOf(event, names.seats);
+    return {
+      key: event.key,
+      cause: episodeCause(event.cause),
+      midLoop: event.delivery === "mid_loop",
+      fromKind,
+      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),
+      noAction: members.every((row) => noActionClasses.includes(row.action))
+    };
+  });
+}
+function pairSender(kind, name, seats) {
+  if (kind === "seat" || kind === "broadcast" && name !== null && seats.has(name)) return name;
+  return kind === "broadcast" ? "agent" : kind;
+}
+function summarizeWakeEpisodes(episodes, requests, roles, noActionClasses) {
+  const keys = new Set(episodes.map((episode) => episode.key));
+  const unattributed = requests.filter((row) => row.eventKey === null || !keys.has(row.eventKey));
+  return {
+    roles: [...roles],
+    noActionClasses: [...noActionClasses],
+    ...costOf(episodes),
+    unattributed: { requests: unattributed.length, costUsd: unattributed.reduce((sum, row) => sum + 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);
+  return {
+    episodes: episodes.length,
+    requests: sum(episodes, (episode) => episode.requests),
+    costUsd: sum(episodes, (episode) => episode.costUsd),
+    noActionEpisodes: noAction.length,
+    noActionCostUsd: sum(noAction, (episode) => episode.costUsd)
+  };
+}
+function causeBuckets(episodes) {
+  return [...groupBy2(episodes, (episode) => episode.cause)].map(([key, members]) => {
+    const cost = costOf(members);
+    return {
+      key,
+      ...cost,
+      midLoopEpisodes: members.filter((episode) => episode.midLoop).length,
+      requestsPerEpisode: cost.requests / cost.episodes,
+      costPerEpisode: cost.costUsd / cost.episodes,
+      byFrom: [...groupBy2(members, (episode) => episode.fromKind)].map(([kind, part]) => ({ key: kind, ...costOf(part) })).sort(byCostThenKey)
+    };
+  }).sort(byCostThenKey);
+}
+function pairBuckets(episodes) {
+  const sent = episodes.filter((episode) => episode.fromKind !== "none");
+  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));
+}
+function groupBy2(rows, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = keyOf(row);
+    const members = groups.get(key);
+    if (members) members.push(row);
+    else groups.set(key, [row]);
+  }
+  return groups;
+}
+function byCostThenKey(a, b) {
+  return b.costUsd - a.costUsd || a.key.localeCompare(b.key);
+}
+
 // src/cost-report.ts
-var count = z.number().int().nonnegative();
-var bucketSchema = z.object({ key: z.string(), requests: count, sessions: count, costUsd: z.number() });
-var wakePartSchema = bucketSchema.extend({ midLoopRequests: count, midLoopCostUsd: z.number() });
-var cellSchema = z.object({ wakeCause: z.string(), gapBand: z.string(), requests: count, costUsd: z.number() });
+var count3 = z3.number().int().nonnegative();
+var bucketSchema = z3.object({ key: z3.string(), requests: count3, sessions: count3, costUsd: z3.number() });
+var wakePartSchema = bucketSchema.extend({ midLoopRequests: count3, midLoopCostUsd: z3.number() });
+var cellSchema = z3.object({ wakeCause: z3.string(), gapBand: z3.string(), requests: count3, costUsd: z3.number() });
+var fraction = z3.number().min(0).max(1);
+var roleShareSchema = z3.object({ role: z3.string(), costUsd: z3.number(), share: fraction });
 var TOKEN_CLASSES = ["input", "cache_read", "cache_write_5m", "cache_write_1h", "output"];
-var costReportSchema = z.object({
-  window: z.object({ since: z.string().nullable(), until: z.string().nullable() }),
-  priceTableVersion: z.number().int().nullable(),
-  totals: z.object({ requests: count, sessions: count, costUsd: z.number(), unpricedRequests: count }),
-  byTokenClass: z.array(z.object({ tokenClass: z.enum(TOKEN_CLASSES), tokens: count, costUsd: z.number() })),
-  byAccount: z.array(bucketSchema),
-  byModel: z.array(bucketSchema),
-  byClass: z.array(bucketSchema),
-  byRole: z.array(bucketSchema),
+var costReportSchema = z3.object({
+  window: z3.object({ since: z3.string().nullable(), until: z3.string().nullable() }),
+  priceTableVersion: z3.number().int().nullable(),
+  totals: z3.object({ requests: count3, sessions: count3, costUsd: z3.number(), unpricedRequests: count3 }),
+  byTokenClass: z3.array(z3.object({ tokenClass: z3.enum(TOKEN_CLASSES), tokens: count3, costUsd: z3.number() })),
+  byAccount: z3.array(bucketSchema),
+  byModel: z3.array(bucketSchema),
+  byClass: z3.array(bucketSchema),
+  byRole: z3.array(bucketSchema),
+  /** Per role, cost by the action class of each request, from the tool calls it issued. */
+  byAction: z3.array(z3.object({ role: z3.string(), buckets: z3.array(bucketSchema) })),
+  /** Cost of the mechanical action classes over the window total; each role's share is over that role's cost. */
+  mechanicalShare: z3.object({ classes: z3.array(z3.enum(ACTION_CLASSES)), costUsd: z3.number(), share: fraction, byRole: z3.array(roleShareSchema) }),
   /** Sessions by how many episodes their class's heuristic cut them into; `none` when not yet segmented. */
-  byEpisodeCount: z.array(bucketSchema),
-  byInitiative: z.array(bucketSchema),
-  byContextBand: z.array(bucketSchema),
-  byWakeCause: z.array(wakePartSchema.extend({ parts: z.array(wakePartSchema) })),
-  wakeCauseByGapBand: z.array(cellSchema),
-  coldRebuild: z.object({ requests: count, costUsd: z.number(), byGapBandAndCause: z.array(cellSchema) }),
-  compactions: z.object({ total: count, manual: count, auto: count, midLoop: count, droppedTokens: count }),
-  topSessions: z.array(
-    z.object({
-      sessionId: z.string(),
-      sessionClass: z.string(),
-      role: z.string(),
-      initiative: z.string(),
-      account: z.string(),
-      requests: count,
-      costUsd: z.number()
+  byEpisodeCount: z3.array(bucketSchema),
+  byInitiative: z3.array(bucketSchema),
+  byContextBand: z3.array(bucketSchema),
+  byWakeCause: z3.array(wakePartSchema.extend({ parts: z3.array(wakePartSchema) })),
+  /** Per wake episode of the episode roles: an arrival and the requests up to the next one, mid-loop deliveries included. */
+  wakeEpisodes: wakeEpisodesSchema,
+  /** Per role and model, the handoff threshold K that minimises boot plus cache-read cost per request. */
+  handoffThreshold: handoffThresholdSchema,
+  wakeCauseByGapBand: z3.array(cellSchema),
+  coldRebuild: z3.object({ requests: count3, costUsd: z3.number(), byGapBandAndCause: z3.array(cellSchema) }),
+  compactions: z3.object({ total: count3, manual: count3, auto: count3, midLoop: count3, droppedTokens: count3 }),
+  topSessions: z3.array(
+    z3.object({
+      sessionId: z3.string(),
+      sessionClass: z3.string(),
+      role: z3.string(),
+      initiative: z3.string(),
+      account: z3.string(),
+      requests: count3,
+      costUsd: z3.number()
     })
   ),
-  unpricedModels: z.array(z.object({ model: z.string(), requests: count, tokens: count })),
-  coverage: z.object({ transcriptsIndexed: count, transcriptsDiscovered: count.nullable(), facetBacklog: count })
+  unpricedModels: z3.array(z3.object({ model: z3.string(), requests: count3, tokens: count3 })),
+  coverage: z3.object({ transcriptsIndexed: count3, transcriptsDiscovered: count3.nullable(), facetBacklog: count3 })
 });
 var HUMAN_CAUSES = ["human_typed", "ask_user_answer"];
 var NONE = "none";
@@ -514,17 +1039,18 @@ var EPISODE_COUNT_CAP = 5;
 var DAY_MS = 864e5;
 function costReport(db, options = {}) {
   const window = resolveWindow(options);
-  const costRows = readCostRows(db, window);
-  const sessionIds = [...new Set(costRows.map((row) => row.sessionId))];
-  const tags = tagSessions(readSessionContexts(db, sessionIds));
-  const rows = costRows.map((row) => ({ ...row, ...tags.get(row.sessionId) }));
+  const rows = readTaggedRows(db, window, options.actionRules ?? DEFAULT_ACTION_RULES).filter(scopeFilter(db, options.scope));
   return {
     window,
     priceTableVersion: readPriceTableVersion(db),
-    totals: { ...sumOf(rows), sessions: sessionIds.length, unpricedRequests: rows.filter((row) => !row.priced).length },
+    totals: { ...sumOf(rows), sessions: new Set(rows.map((row) => row.sessionId)).size, unpricedRequests: rows.filter((row) => !row.priced).length },
     byTokenClass: tokenClasses(rows),
     ...dimensionBuckets(rows),
+    byAction: roleActions(rows),
+    mechanicalShare: mechanicalShare(rows, options.mechanicalClasses ?? DEFAULT_MECHANICAL_CLASSES),
     byWakeCause: wakeCauses(rows),
+    wakeEpisodes: wakeEpisodes(db, window, rows, options),
+    handoffThreshold: handoff(db, window, rows, options),
     wakeCauseByGapBand: gapCells(rows),
     coldRebuild: coldRebuild(rows),
     compactions: compactionCounts(readCompactions(db, window)),
@@ -533,6 +1059,15 @@ function costReport(db, options = {}) {
     coverage: { ...readCoverage(db, options.facetVersion ?? null), transcriptsDiscovered: options.transcriptsDiscovered ?? null }
   };
 }
+function readTaggedRows(db, window, rules) {
+  const costRows = readCostRows(db, window);
+  const tags = tagSessions(readSessionContexts(db, [...new Set(costRows.map((row) => row.sessionId))]));
+  const calls = readRequestToolCalls(db, window);
+  return costRows.map((row) => {
+    const requestCalls = calls.get(row.requestId) ?? [];
+    return { ...row, ...tags.get(row.sessionId), action: classifyRequest(requestCalls, rules), bootAction: isBootAction(requestCalls) };
+  });
+}
 function resolveWindow(options) {
   const until = options.until ?? null;
   if (options.since !== void 0) return { since: options.since, until };
@@ -587,9 +1122,24 @@ function dimensionBuckets(rows) {
     byContextBand: bucketsBy(rows, (row) => row.contextBand)
   };
 }
+function roleActions(rows) {
+  return [...groupRows(rows, (row) => row.role)].map(([role, members]) => ({ key: role, costUsd: sumOf(members).costUsd, buckets: bucketsBy(members, (row) => row.action) })).sort(byCostThenKey2).map(({ key, buckets: buckets2 }) => ({ role: key, buckets: buckets2 }));
+}
+function mechanicalShare(rows, classes) {
+  const isMechanical = (row) => classes.includes(row.action);
+  const shareOf = (members) => {
+    const costUsd = sumOf(members.filter(isMechanical)).costUsd;
+    return { costUsd, share: ratio(costUsd, sumOf(members).costUsd) };
+  };
+  const byRole = [...groupRows(rows, (row) => row.role)].map(([role, members]) => ({ role, ...shareOf(members) })).sort((a, b) => b.costUsd - a.costUsd || a.role.localeCompare(b.role));
+  return { classes: [...classes], ...shareOf(rows), byRole };
+}
+function ratio(part, whole) {
+  return whole > 0 ? Math.min(part / whole, 1) : 0;
+}
 function bucketsBy(rows, keyOf) {
   const groups = groupRows(rows, keyOf);
-  return [...groups].map(([key, members]) => ({ key, ...sumOf(members), sessions: new Set(members.map((row) => row.sessionId)).size })).sort(byCostThenKey);
+  return [...groups].map(([key, members]) => ({ key, ...sumOf(members), sessions: new Set(members.map((row) => row.sessionId)).size })).sort(byCostThenKey2);
 }
 function groupRows(rows, keyOf) {
   const groups = /* @__PURE__ */ new Map();
@@ -601,7 +1151,7 @@ function groupRows(rows, keyOf) {
   }
   return groups;
 }
-function byCostThenKey(a, b) {
+function byCostThenKey2(a, b) {
   return b.costUsd - a.costUsd || a.key.localeCompare(b.key);
 }
 function wakeCauses(rows) {
@@ -609,8 +1159,32 @@ function wakeCauses(rows) {
   const groupOf = (row) => HUMAN_CAUSES.includes(causeOf(row)) ? "human" : causeOf(row);
   return [...groupRows(rows, groupOf)].map(([key, members]) => ({
     ...wakePart(key, members),
-    parts: key === "human" ? [...groupRows(members, causeOf)].map(([cause, part]) => wakePart(cause, part)).sort(byCostThenKey) : []
-  })).sort(byCostThenKey);
+    parts: key === "human" ? [...groupRows(members, causeOf)].map(([cause, part]) => wakePart(cause, part)).sort(byCostThenKey2) : []
+  })).sort(byCostThenKey2);
+}
+function wakeEpisodes(db, window, rows, options) {
+  const roles = options.episodeRoles ?? DEFAULT_EPISODE_ROLES;
+  const noActionClasses = options.noActionClasses ?? DEFAULT_NO_ACTION_CLASSES;
+  const members = rows.filter((row) => roles.includes(row.role));
+  const sessionIds = [...new Set(members.map((row) => row.sessionId))];
+  const eventOf = readRequestEvents(db, window, sessionIds);
+  const requests = members.map((row) => ({ costUsd: row.costUsd, action: row.action, eventKey: eventOf.get(row.requestId) ?? null }));
+  const episodes = buildWakeEpisodes(readWakeEvents(db, window, sessionIds), requests, episodeNames(readAgentNames(db)), noActionClasses);
+  return summarizeWakeEpisodes(episodes, requests, roles, noActionClasses);
+}
+function handoff(db, window, rows, options) {
+  const inWindow = (ts) => (window.since === null || ts >= window.since) && (window.until === null || ts < window.until);
+  const teleports = parseTeleportEvents(options.brokerLogLines?.() ?? []).filter((event) => inWindow(event.ts));
+  const requests = rows.filter((row) => !row.isSidechain).map((row) => ({
+    sessionId: row.sessionId,
+    role: row.role,
+    model: row.model,
+    ts: row.ts,
+    fill: row.contextTokens,
+    tokens: { inputTokens: row.inputTokens, cacheReadTokens: row.cacheReadTokens, cacheCreation5mTokens: row.cacheWrite5mTokens, cacheCreation1hTokens: row.cacheWrite1hTokens, outputTokens: row.outputTokens },
+    bootAction: row.bootAction
+  }));
+  return handoffThreshold(requests, teleports, readAgentSessions(db), options.handoff);
 }
 function wakePart(key, rows) {
   const midLoop = rows.filter((row) => row.wakeDelivery === "mid_loop");
@@ -653,6 +1227,7 @@ function tokensOf(row) {
 
 // src/render-text.ts
 var LIST_PRICE_CAVEAT = "List prices, not a bill: the accounts behind these sessions may run on subscription plans. Rankings hold; the absolute figure is not what you paid.";
+var TOP_WAKE_ROWS = 10;
 function renderCostReportText(report) {
   const sections = [
     header(report),
@@ -661,10 +1236,17 @@ function renderCostReportText(report) {
     bucketTable("By model", report.byModel, report.totals.costUsd),
     bucketTable("By class", report.byClass, report.totals.costUsd),
     bucketTable("By role", report.byRole, report.totals.costUsd),
+    actionTable(report.byAction),
+    mechanicalTable(report.mechanicalShare),
     bucketTable("By episode count", report.byEpisodeCount, report.totals.costUsd),
     bucketTable("By initiative", report.byInitiative, report.totals.costUsd),
     bucketTable("By context band", report.byContextBand, report.totals.costUsd),
     wakeCauseTable(report),
+    episodeTable(report.wakeEpisodes),
+    pairTable(report.wakeEpisodes),
+    handoffTable(report.handoffThreshold),
+    teleportTable(report.handoffThreshold),
+    reviewerTable(report.handoffThreshold),
     cellTable("Wake cause by gap band", report.wakeCauseByGapBand),
     cellTable(`Cold rebuilds: ${report.coldRebuild.requests} requests, ${usd(report.coldRebuild.costUsd)}`, report.coldRebuild.byGapBandAndCause),
     compactionTable(report.compactions),
@@ -674,16 +1256,43 @@ function renderCostReportText(report) {
   ];
   return sections.join("\n\n") + "\n";
 }
+var COST_REPORT_SECTIONS = {
+  byRole: (report) => bucketTable("By role", report.byRole, report.totals.costUsd),
+  byAction: (report) => actionTable(report.byAction),
+  mechanicalShare: (report) => mechanicalTable(report.mechanicalShare),
+  byWakeCause: (report) => wakeCauseTable(report),
+  wakeEpisodes: (report) => episodeTable(report.wakeEpisodes),
+  wakePairs: (report) => pairTable(report.wakeEpisodes),
+  handoff: (report) => handoffTable(report.handoffThreshold),
+  teleports: (report) => teleportTable(report.handoffThreshold),
+  reviewers: (report) => reviewerTable(report.handoffThreshold)
+};
+function renderCostReportSections(report, sections) {
+  const body = sections.map((section) => COST_REPORT_SECTIONS[section](report));
+  return [header(report), ...body, [LIST_PRICE_CAVEAT, footer(report)].join("\n")].join("\n\n") + "\n";
+}
 function header(report) {
   const { since, until } = report.window;
   const { requests, sessions, costUsd } = report.totals;
   return `Cost report, ${since ?? "beginning"} to ${until ?? "now"}
 Total ${usd(costUsd)} over ${requests} requests in ${sessions} sessions`;
 }
-function bucketTable(title, buckets, total) {
-  const rows = buckets.map((b) => [b.key, b.requests, b.sessions, usd(b.costUsd), share(b.costUsd, total)]);
+function bucketTable(title, buckets2, total) {
+  const rows = buckets2.map((b) => [b.key, b.requests, b.sessions, usd(b.costUsd), share(b.costUsd, total)]);
   return table(title, ["key", "requests", "sessions", "cost", "share"], rows);
 }
+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);
+    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);
+}
+function mechanicalTable(m) {
+  const title = `Mechanical share: ${percent(m.share)} (${usd(m.costUsd)}) of total; classes ${m.classes.join(", ") || "none"}`;
+  return table(title, ["role", "mechanical cost", "share of role"], m.byRole.map((r) => [r.role, usd(r.costUsd), percent(r.share)]));
+}
 function wakeCauseTable(report) {
   const rows = report.byWakeCause.flatMap((group) => [
     [group.key, group.requests, usd(group.costUsd), group.midLoopRequests, usd(group.midLoopCostUsd)],
@@ -691,6 +1300,56 @@ function wakeCauseTable(report) {
   ]);
   return table("By wake cause", ["cause", "requests", "cost", "mid-loop", "mid-loop cost"], rows);
 }
+function episodeTable(w) {
+  const title = `Wake episodes of ${w.roles.join(", ")}: ${w.episodes} episodes, ${w.requests} requests, ${usd(w.costUsd)}; no-action means only ${w.noActionClasses.join(", ")}`;
+  const causes = [...w.byCause].sort((a, b) => b.costPerEpisode - a.costPerEpisode || a.key.localeCompare(b.key)).slice(0, TOP_WAKE_ROWS);
+  const rows = causes.flatMap((c) => [
+    [c.key, c.episodes, c.midLoopEpisodes, c.requests, c.requestsPerEpisode.toFixed(1), usd(c.costUsd), usd(c.costPerEpisode), noActionCell(c)],
+    ...c.byFrom.map((f) => [`  from ${f.key}`, f.episodes, "", f.requests, (f.requests / f.episodes).toFixed(1), usd(f.costUsd), usd(f.costUsd / f.episodes), noActionCell(f)])
+  ]);
+  return table(title, ["cause", "episodes", "mid-loop", "requests", "req/ep", "cost", "cost/ep", "no-action"], rows);
+}
+function noActionCell(bucket) {
+  return `${bucket.noActionEpisodes} (${share(bucket.noActionEpisodes, bucket.episodes)})`;
+}
+function pairTable(w) {
+  const rows = w.pairs.slice(0, TOP_WAKE_ROWS).map((p) => [p.from, p.fromKind, p.to, p.episodes, p.requests, usd(p.costUsd), noActionCell(p)]);
+  return table("Wake senders by receiver", ["from", "kind", "to", "episodes", "requests", "cost", "no-action"], rows);
+}
+function handoffTable(h) {
+  const title = `Handoff threshold per role, priced at package table v${PRICE_TABLE_VERSION}: best K over ${kilo(h.sweep.fromK)}-${kilo(h.sweep.toK)}, half-boot K in brackets`;
+  const head = ["role", "model", "sessions", "boot", "boot fill", "growth/req", "read $/MTok", "best K", "$/req", ...h.configuredK.map((k) => `+$/req @${kilo(k)}`)];
+  const rows = h.cohorts.map((c) => [
+    c.role,
+    c.model,
+    c.sessions,
+    usd(c.bootCostUsd),
+    kilo(c.bootFill),
+    Math.round(c.growthPerRequest),
+    c.readPricePerMTok.toFixed(3),
+    `${kiloOrDash(c.bestK)} (${kiloOrDash(c.halfBoot.bestK)})`,
+    c.bestCostPerRequest === null ? "-" : `$${c.bestCostPerRequest.toFixed(4)}`,
+    ...c.atConfigured.map((at) => at.deltaPerRequest === null ? "-" : `$${at.deltaPerRequest.toFixed(4)}`)
+  ]);
+  return table(title, head, rows);
+}
+function teleportTable(h) {
+  const title = `Teleport exit fill: ${h.teleports.length} matched, ${h.unmatchedTeleports} unmatched; the latest ${TOP_WAKE_ROWS}`;
+  const head = ["ts", "name", "role", "exit fill", "best K", ...h.configuredK.map((k) => `over ${kilo(k)}`)];
+  const rows = h.teleports.slice(-TOP_WAKE_ROWS).map((t) => [t.ts, t.name ?? "-", t.role, kilo(t.exitFill), kiloOrDash(t.bestK), ...t.overConfigured.map((o) => kilo(o.over))]);
+  return table(title, head, rows);
+}
+function reviewerTable(h) {
+  const row = (kind) => (c) => [kind, c.role, c.model, c.sessions, c.requestsPerPr.toFixed(1), c.requestsFrom, usd(c.costUsd)];
+  const rows = [...h.reviewers.fresh.map(row("fresh per PR")), ...h.reviewers.standing.map(row("standing"))];
+  return table(`Reviewers over ${h.reviewers.prs} PRs, boot and reads: fresh per PR against one standing`, ["reviewer", "role", "model", "sessions", "req/PR", "req/PR from", "cost"], rows);
+}
+function kilo(tokens) {
+  return `${Math.round(tokens / 1e3)}k`;
+}
+function kiloOrDash(tokens) {
+  return tokens === null ? "-" : kilo(tokens);
+}
 function cellTable(title, cells) {
   return table(title, ["cause", "gap", "requests", "cost"], cells.map((c) => [c.wakeCause, c.gapBand, c.requests, usd(c.costUsd)]));
 }
@@ -728,42 +1387,551 @@ function usd(value) {
   return `$${value.toFixed(2)}`;
 }
 function share(value, total) {
-  return total > 0 ? `${(value / total * 100).toFixed(1)}%` : "-";
+  return total > 0 ? percent(value / total) : "-";
+}
+function percent(fraction2) {
+  return `${(fraction2 * 100).toFixed(1)}%`;
+}
+
+// src/cache-ttl.ts
+import { z as z4 } from "zod";
+var FIVE_MINUTES_MS = 5 * 6e4;
+var MTOK2 = 1e6;
+var NO_PROFILE = "none";
+var REBUILD_GAP_BANDS = GAP_BANDS.filter((band) => band.lo >= FIVE_MINUTES_MS).map((band) => band.name);
+var count4 = z4.number().int().nonnegative();
+var effectFields = {
+  sessions: count4,
+  requests: count4,
+  write1hTokens: count4,
+  /** 1h writes repriced at the 5m write rate. */
+  repriceSavingUsd: z4.number(),
+  rebuilds: count4,
+  rebuildTokens: count4,
+  /** Each rebuild writes at the 5m rate what the 1h cache still served as a read. */
+  rebuildCostUsd: z4.number(),
+  netSavingUsd: z4.number(),
+  netPerSessionUsd: z4.number()
+};
+var bucketSchema2 = z4.object({ key: z4.string(), ...effectFields, fiveMinuteLoses: z4.boolean() });
+var cacheTtlWhatIfSchema = z4.object({
+  window: z4.object({ since: z4.string().nullable(), until: z4.string().nullable() }).optional(),
+  priceTableVersion: z4.number().int(),
+  rebuildGapBands: z4.array(z4.string()),
+  totals: z4.object(effectFields),
+  unpricedRequests: count4,
+  byRole: z4.array(bucketSchema2),
+  byProfile: z4.array(bucketSchema2),
+  /** Roles whose rebuilds after long gaps outweigh the cheaper writes. */
+  lossRoles: z4.array(z4.string())
+});
+function cacheTtlWhatIf(rows, prices = PRICE_TABLE) {
+  const effects = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const price = findPrice(row.model, row.ts, prices);
+    if (price) effects.set(row, requestEffect(row, price));
+  }
+  const priced = [...effects.keys()];
+  const byRole = buckets(priced, effects, (row) => row.role);
+  return {
+    priceTableVersion: PRICE_TABLE_VERSION,
+    rebuildGapBands: [...REBUILD_GAP_BANDS],
+    totals: sumEffects([...effects.values()]),
+    unpricedRequests: rows.length - priced.length,
+    byRole,
+    byProfile: buckets(priced, effects, (row) => row.profile),
+    lossRoles: byRole.filter((bucket) => bucket.fiveMinuteLoses).map((bucket) => bucket.key)
+  };
+}
+function requestEffect(row, price) {
+  const band = row.gapMs === null ? null : gapBand(row.gapMs);
+  const rebuildTokens = band !== null && REBUILD_GAP_BANDS.includes(band) ? row.cacheReadTokens : 0;
+  return {
+    sessionId: row.sessionId,
+    write1hTokens: row.cacheWrite1hTokens,
+    repriceSavingUsd: row.cacheWrite1hTokens * (price.cacheWrite1h - price.cacheWrite5m) / MTOK2,
+    rebuildTokens,
+    rebuildCostUsd: rebuildTokens * (price.cacheWrite5m - price.cacheRead) / MTOK2
+  };
+}
+function sumEffects(effects) {
+  const sum = (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);
+  return {
+    sessions,
+    requests: effects.length,
+    write1hTokens: sum((effect) => effect.write1hTokens),
+    repriceSavingUsd: sum((effect) => effect.repriceSavingUsd),
+    rebuilds: effects.filter((effect) => effect.rebuildTokens > 0).length,
+    rebuildTokens: sum((effect) => effect.rebuildTokens),
+    rebuildCostUsd: sum((effect) => effect.rebuildCostUsd),
+    netSavingUsd,
+    netPerSessionUsd: sessions > 0 ? netSavingUsd / sessions : 0
+  };
+}
+function buckets(rows, effects, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = keyOf(row);
+    const members = groups.get(key);
+    if (members) members.push(effects.get(row));
+    else groups.set(key, [effects.get(row)]);
+  }
+  return [...groups].map(([key, members]) => {
+    const totals = sumEffects(members);
+    return { key, ...totals, fiveMinuteLoses: totals.netSavingUsd < 0 };
+  }).sort((a, b) => b.netSavingUsd - a.netSavingUsd || a.key.localeCompare(b.key));
+}
+var IN_WINDOW2 = "(@since IS NULL OR ts >= @since) AND (@until IS NULL OR ts < @until)";
+var TTL_ROWS = `
+  WITH member AS (SELECT DISTINCT session_id FROM request_dedup WHERE ${IN_WINDOW2}),
+  timed AS (
+    SELECT session_id, model, ts, cache_read_tokens, cache_creation_1h, gap_ms,
+      LAG(ts) OVER (PARTITION BY session_id, is_sidechain ORDER BY ts, request_id) AS previous_ts
+    FROM request_dedup WHERE session_id IN member
+  )
+  SELECT session_id AS sessionId, model, ts, cache_read_tokens AS cacheReadTokens, cache_creation_1h AS cacheWrite1hTokens,
+    COALESCE(gap_ms, CAST(ROUND((julianday(ts) - julianday(previous_ts)) * 86400000) AS INTEGER)) AS gapMs
+  FROM timed WHERE ${IN_WINDOW2}`;
+function cacheTtlReport(db, options = {}, prices = PRICE_TABLE) {
+  const window = resolveWindow(options);
+  return { window, ...cacheTtlWhatIf(readTtlRows(db, window).filter(scopeFilter(db, options.scope)), prices) };
+}
+function readTtlRows(db, window) {
+  const rows = db.prepare(TTL_ROWS).all(window);
+  const contexts = readSessionContexts(db, [...new Set(rows.map((row) => row.sessionId))]);
+  const tags = tagSessions(contexts);
+  return rows.map((row) => ({
+    ...row,
+    role: tags.get(row.sessionId).role,
+    profile: contexts.get(row.sessionId).facts.origin?.profile ?? NO_PROFILE
+  }));
+}
+function renderCacheTtlText(whatIf) {
+  const { totals, window } = whatIf;
+  const span = window ? `, ${window.since ?? "beginning"} to ${window.until ?? "now"}` : "";
+  const header2 = [
+    `Cache TTL what-if, 5m against 1h${span}`,
+    `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");
+  const footer2 = `Price table v${whatIf.priceTableVersion}; ${whatIf.unpricedRequests} unpriced requests left out.`;
+  return [header2, ttlTable("By role", whatIf.byRole), ttlTable("By profile", whatIf.byProfile), [LIST_PRICE_CAVEAT, footer2].join("\n")].join("\n\n") + "\n";
+}
+function ttlTable(title, rows) {
+  const head = ["key", "sessions", "requests", "reprice saving", "rebuilds", "rebuild cost", "net", "net per session", "5m"];
+  const cells = rows.map((b) => [b.key, b.sessions, b.requests, usd(b.repriceSavingUsd), b.rebuilds, usd(b.rebuildCostUsd), usd(b.netSavingUsd), usd(b.netPerSessionUsd), b.fiveMinuteLoses ? "loss" : "saves"]);
+  return table(title, head, cells);
+}
+
+// src/blocked-flow-merge.ts
+import { z as z5 } from "zod";
+var VERDICT_LINE = /^Verdict:\s*([A-Z_]+)/;
+var PR_LINE = /^PR:\s*(?:https:\/\/github\.com\/)?([\w.-]+\/[\w.-]+)(?:#|\/pull\/)(\d+)/m;
+var HEAD_LINE = /^Head:\s*`?([0-9a-f]{7,40})\b/m;
+function parseVerdict(body) {
+  const verdict = VERDICT_LINE.exec(body)?.[1];
+  const pr = PR_LINE.exec(body);
+  const head = HEAD_LINE.exec(body)?.[1];
+  if (!verdict || !pr || !head) return null;
+  return { verdict, repo: pr[1], pr: Number(pr[2]), head };
+}
+var MINUTE_MS2 = 6e4;
+function mergeOutcomes(verdicts, pulls, asOf) {
+  const byPr = /* @__PURE__ */ new Map();
+  for (const v of verdicts) if (v.verdict === "MERGE") byPr.set(prKey(v), [...byPr.get(prKey(v)) ?? [], v]);
+  const pullByKey = new Map(pulls.map((p) => [prKey(p), p]));
+  return [...byPr.values()].map((held) => outcome(held, pullByKey.get(prKey(held[0])), asOf));
+}
+function prKey(row) {
+  return `${row.repo}#${row.pr}`;
+}
+function outcome(held, pull, asOf) {
+  const { repo, pr } = held[0];
+  if (!pull) return { repo, pr, status: "unknown", verdict: null, minutes: null };
+  const atHead = held.filter((v) => sameSha(v.head, pull.headSha)).sort((a, b) => a.at.localeCompare(b.at))[0];
+  const mergedBy = pull.mergedAt !== null && pull.mergedAt <= asOf;
+  if (!atHead) return { repo, pr, status: pull.mergedAt !== null || pull.state === "open" ? "stale-head" : "closed", verdict: null, minutes: null };
+  if (mergedBy) return { repo, pr, status: "merged", verdict: atHead, minutes: Math.max(0, minutesBetween(atHead.at, pull.mergedAt)) };
+  if (pull.state === "open" || pull.mergedAt !== null) return { repo, pr, status: "open", verdict: atHead, minutes: minutesBetween(atHead.at, asOf) };
+  return { repo, pr, status: "closed", verdict: atHead, minutes: null };
+}
+function sameSha(a, b) {
+  return a.startsWith(b) || b.startsWith(a);
+}
+function minutesBetween(from, to) {
+  return (Date.parse(to) - Date.parse(from)) / MINUTE_MS2;
+}
+var minutes = z5.number().nullable();
+var latencyStatsSchema = z5.object({
+  merged: z5.number().int().nonnegative(),
+  medianMin: minutes,
+  meanMin: minutes,
+  p90Min: minutes,
+  maxMin: minutes,
+  /** Open PRs holding MERGE at their current head; their ages are lower bounds on the wait. */
+  censored: z5.number().int().nonnegative(),
+  oldestCensoredMin: minutes,
+  censoredPrMinutes: z5.number().nonnegative(),
+  /** Median over merged waits and censored ages together: a lower bound on the true median. */
+  medianWithCensoredMin: minutes
+});
+function latencyStats(outcomes) {
+  const merged = sorted(outcomes.filter((o) => o.status === "merged").map((o) => o.minutes));
+  const censored = sorted(outcomes.filter((o) => o.status === "open").map((o) => o.minutes));
+  return {
+    merged: merged.length,
+    medianMin: median(merged),
+    meanMin: merged.length === 0 ? null : round(merged.reduce((a, b) => a + b, 0) / merged.length),
+    p90Min: nearestRank(merged, 0.9),
+    maxMin: merged.at(-1) === void 0 ? null : round(merged.at(-1)),
+    censored: censored.length,
+    oldestCensoredMin: censored.at(-1) === void 0 ? null : round(censored.at(-1)),
+    censoredPrMinutes: round(censored.reduce((a, b) => a + b, 0)),
+    medianWithCensoredMin: median(sorted([...merged, ...censored]))
+  };
+}
+function sorted(values) {
+  return values.sort((a, b) => a - b);
+}
+function median(values) {
+  if (values.length === 0) return null;
+  const mid = Math.floor(values.length / 2);
+  return round(values.length % 2 === 1 ? values[mid] : (values[mid - 1] + values[mid]) / 2);
+}
+function nearestRank(values, p) {
+  return values.length === 0 ? null : round(values[Math.ceil(p * values.length) - 1]);
+}
+function round(value) {
+  return Math.round(value * 10) / 10;
+}
+
+// src/blocked-flow-denials.ts
+var DENIAL = /^Permission for this action (?:was|has been) denied by the Claude Code auto mode classifier\. Reason: \[([^\]]+)\]/;
+var BASH_ACTIONS = [
+  ["merge", /\bgh pr merge\b|\/pulls\/\d+\/merge\b/],
+  ["retire", /\bagent[ _-]retire\b|\bagent\s+retire\b/],
+  ["worktree-remove", /\bgit\b.*\bworktree (?:remove|prune)\b/],
+  ["branch-delete", /\bgit branch -[dD]\b|\bpush\b.*--delete\b|\/git\/refs\/heads\/\S*.*-X DELETE|-X DELETE\b.*\/git\/refs\//],
+  ["push", /\bgit\b.*\bpush\b/],
+  ["github-write", /\bgh (?:pr|issue) (?:create|edit|comment|close)\b|\bgh api\b.*(?:-X|--method)\s*(?:POST|PATCH|PUT|DELETE)\b/],
+  ["service-restart", /\bservice restart\b|\blaunchctl\b/],
+  ["process-kill", /\b(?:pkill|kill)\b/],
+  ["file-write", /\s>>?\s*(?!\/dev\/null|&)\S|\bopen\([^)]*["'][wa]["']\)|\bsed -i\b/]
+];
+var FILE_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function classifyDeniedAction(tool, input) {
+  if (tool === "Bash") return bashAction(String(input?.command ?? ""));
+  if (FILE_TOOLS.has(tool)) return "file-edit";
+  if (tool.startsWith("mcp__")) return `mcp:${tool.split("__").at(-1)}`;
+  return `tool:${tool}`;
+}
+function bashAction(command) {
+  return BASH_ACTIONS.find(([, pattern]) => pattern.test(command))?.[0] ?? "bash-other";
+}
+function parseDenials(lines, seat) {
+  const calls = /* @__PURE__ */ new Map();
+  const denials = [];
+  for (const line of lines) {
+    if (!line.includes('"tool_use"') && !line.includes("auto mode classifier")) continue;
+    const entry = parseLine(line);
+    for (const block of blocksOf(entry)) {
+      if (block.type === "tool_use" && block.id) calls.set(block.id, { tool: block.name ?? "unknown", input: block.input });
+      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 });
+    }
+  }
+  return denials;
+}
+function parseLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function blocksOf(entry) {
+  const content = entry?.message?.content;
+  return Array.isArray(content) ? content : [];
+}
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  const first = content.find((part) => part.type === "text");
+  return first?.text ?? "";
+}
+
+// src/blocked-flow-idle.ts
+var UNSTATED_REASON = "unstated";
+var TICK_HOLD_MAX_MIN = 60;
+var STAMP = /^(\d{1,2}):(\d{2})(?::(\d{2}))?\s/;
+var IMPL = /\bimpl(?:ementers?)?\s+(\d+)\s*\/\s*(\d+)/i;
+var REASON = /\b(?:no dispatch|dispatch 0)\s*:\s*([^.;(]+)/i;
+function parseSeatJournal(text, seat, date, utcOffsetMin) {
+  const ticks = [];
+  let lastAt = null;
+  text.split("\n").forEach((raw, index) => {
+    const stamp = STAMP.exec(raw);
+    if (!stamp) return;
+    const at = journalTime(date, stamp, utcOffsetMin);
+    lastAt = at;
+    const impl = IMPL.exec(raw);
+    if (!impl) return;
+    const used = Number(impl[1]);
+    const cap = Number(impl[2]);
+    const reason = used < cap ? REASON.exec(raw)?.[1]?.trim().toLowerCase() ?? UNSTATED_REASON : "";
+    ticks.push({ seat, at, used, cap, reason, line: index + 1 });
+  });
+  return { ticks, lastAt };
+}
+function journalTime(date, stamp, utcOffsetMin) {
+  const [year, month, day] = date.split("-").map(Number);
+  const local = Date.UTC(year, month - 1, day, Number(stamp[1]), Number(stamp[2]), Number(stamp[3] ?? 0));
+  return new Date(local - utcOffsetMin * 6e4).toISOString();
+}
+function idleSlotMinutes(journals, window) {
+  const rows = /* @__PURE__ */ new Map();
+  for (const journal of journals) {
+    journal.ticks.forEach((tick, i) => {
+      const free = Math.max(0, tick.cap - tick.used);
+      const held = heldMinutes(tick.at, journal.ticks[i + 1]?.at ?? journal.lastAt ?? tick.at, window);
+      if (free === 0 || held <= 0) return;
+      const key = `${tick.seat}\0${tick.reason}`;
+      const row = rows.get(key) ?? { seat: tick.seat, reason: tick.reason, slotMinutes: 0, ticks: 0, lines: [] };
+      rows.set(key, { ...row, slotMinutes: row.slotMinutes + free * held, ticks: row.ticks + 1, lines: [...row.lines, tick.line] });
+    });
+  }
+  return [...rows.values()].map((r) => ({ ...r, slotMinutes: Math.round(r.slotMinutes) })).sort((a, b) => b.slotMinutes - a.slotMinutes);
+}
+function heldMinutes(from, to, window) {
+  const start = Math.max(Date.parse(from), window.since ? Date.parse(window.since) : -Infinity);
+  const capped = Math.min(Date.parse(to), Date.parse(from) + TICK_HOLD_MAX_MIN * 6e4);
+  const end = Math.min(capped, window.until ? Date.parse(window.until) : Infinity);
+  return Math.max(0, (end - start) / 6e4);
+}
+
+// src/blocked-flow.ts
+import { z as z6 } from "zod";
+var BLOCKED_FLOW_SOURCES = {
+  verdicts: {
+    command: `sqlite3 -readonly <events.db> "SELECT id, ts, target, body FROM events WHERE kind='message' AND body LIKE 'Verdict:%'"`,
+    field: "events.ts, events.target, events.body lines Verdict:, PR:, Head:"
+  },
+  pulls: { command: "gh api repos/<owner>/<repo>/pulls/<n>", field: ".state, .merged_at, .head.sha" },
+  denials: {
+    command: "grep 'auto mode classifier. Reason: \\[' <seat transcript>.jsonl",
+    field: "tool_result.content Reason: [<class>], joined to tool_use.input by tool_use_id"
+  },
+  journals: { command: "grep -nE 'impl [0-9]+/[0-9]+' <seat journal>.md", field: "impl <used>/<cap>, No dispatch: <reason>" }
+};
+var source = z6.enum(["verdicts", "pulls", "denials", "journals"]);
+var count5 = z6.number().int().nonnegative();
+var latencyRowSchema = z6.object({
+  repo: z6.string(),
+  prs: count5,
+  staleHead: count5,
+  closed: count5,
+  unknown: count5,
+  all: latencyStatsSchema,
+  before: latencyStatsSchema.optional(),
+  after: latencyStatsSchema.optional()
+});
+var openRowSchema = z6.object({
+  repo: z6.string(),
+  pr: count5,
+  head: z6.string(),
+  seat: z6.string(),
+  verdictAt: z6.string(),
+  ageMin: z6.number(),
+  eventId: count5
+});
+var blockedFlowSchema = z6.object({
+  asOf: z6.string(),
+  window: z6.object({ since: z6.string().optional(), until: z6.string().optional() }),
+  splitAt: z6.string().optional(),
+  sources: z6.record(source, z6.object({ command: z6.string(), field: z6.string() })),
+  verdictToMerge: z6.object({ cites: z6.array(source), rows: z6.array(latencyRowSchema) }),
+  openHoldingMerge: z6.object({ cites: z6.array(source), prMinutes: z6.number(), rows: z6.array(openRowSchema) }),
+  denials: z6.object({
+    cites: z6.array(source),
+    total: count5,
+    rows: z6.array(z6.object({ reason: z6.string(), action: z6.string(), seat: z6.string(), count: count5 }))
+  }),
+  idleSlots: z6.object({
+    cites: z6.array(source),
+    holdMaxMin: z6.number(),
+    total: z6.number(),
+    rows: z6.array(z6.object({ seat: z6.string(), reason: z6.string(), slotMinutes: z6.number(), ticks: count5, lines: z6.array(count5) }))
+  })
+});
+var ALL_REPOS = "all";
+function blockedFlowReport(input) {
+  const window = input.window ?? {};
+  const inScope = scopeTest(input.seats, window);
+  const outcomes = mergeOutcomes(input.verdicts.filter((v) => inScope(v.seat, v.at)), input.pulls, input.asOf);
+  const open = openRows(outcomes);
+  const journals = input.journals.map((j) => ({ ...j, ticks: j.ticks.filter((t) => inScope(t.seat)) }));
+  const idle = idleSlotMinutes(journals, window);
+  return {
+    asOf: input.asOf,
+    window,
+    ...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 }
+  };
+}
+function scopeTest(seats, window) {
+  const named = seats ? new Set(seats) : null;
+  return (seat, at) => (!named || named.has(seat)) && (at === void 0 || (!window.since || at >= window.since) && (!window.until || at < window.until));
+}
+function latencyRows(outcomes, splitAt) {
+  const repos = [...new Set(outcomes.map((o) => o.repo))];
+  const rows = repos.map((repo) => latencyRow(repo, outcomes.filter((o) => o.repo === repo), splitAt));
+  return [...rows.sort((a, b) => b.prs - a.prs || a.repo.localeCompare(b.repo)), latencyRow(ALL_REPOS, outcomes, splitAt)];
+}
+function latencyRow(repo, outcomes, splitAt) {
+  const status = (s) => outcomes.filter((o) => o.status === s).length;
+  const row = { repo, prs: outcomes.length, staleHead: status("stale-head"), closed: status("closed"), unknown: status("unknown"), all: latencyStats(outcomes) };
+  if (!splitAt) return row;
+  const timed = outcomes.filter((o) => o.verdict !== null);
+  return { ...row, before: latencyStats(timed.filter((o) => o.verdict.at < splitAt)), after: latencyStats(timed.filter((o) => o.verdict.at >= splitAt)) };
+}
+function openRows(outcomes) {
+  return outcomes.filter((o) => o.status === "open").map((o) => ({ repo: o.repo, pr: o.pr, head: o.verdict.head, seat: o.verdict.seat, verdictAt: o.verdict.at, ageMin: round(o.minutes), eventId: o.verdict.eventId })).sort((a, b) => b.ageMin - a.ageMin);
+}
+function denialSection(denials) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const d of denials) {
+    const key = [d.reason, d.action, d.seat].join("\0");
+    const row = counts.get(key) ?? { reason: d.reason, action: d.action, seat: d.seat, count: 0 };
+    counts.set(key, { ...row, count: row.count + 1 });
+  }
+  const rows = [...counts.values()].sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason) || a.action.localeCompare(b.action));
+  return { cites: ["denials"], total: denials.length, rows };
+}
+function renderBlockedFlowText(report) {
+  const scope = `Blocked flow as of ${report.asOf}${report.window.since ? `, since ${report.window.since}` : ""}${report.window.until ? `, until ${report.window.until}` : ""}`;
+  const latency = [latencyTable("Verdict to merge, minutes from the first MERGE at the final head [verdictToMerge.rows[].all]", report.verdictToMerge.rows, "all")];
+  if (report.splitAt) latency.push(...["before", "after"].map((part) => latencyTable(`Verdict to merge, verdicts ${part} ${report.splitAt} [verdictToMerge.rows[].${part}]`, report.verdictToMerge.rows, part)));
+  return [scope, ...latency, openTable(report), denialTable(report), idleTable(report), sourceLines(report), LIST_PRICE_CAVEAT].join("\n\n") + "\n";
+}
+function latencyTable(title, rows, part) {
+  const cells = rows.map((r) => [r.repo, r.prs, ...statCells(r[part]), r.staleHead]);
+  return table(title, ["repo", "prs", "merged", "median", "mean", "p90", "max", "open", "oldest open", "median incl. open", "stale head"], cells);
+}
+function statCells(s) {
+  const n = (v) => v === null ? "-" : v;
+  return [s.merged, n(s.medianMin), n(s.meanMin), n(s.p90Min), n(s.maxMin), s.censored, n(s.oldestCensoredMin), n(s.medianWithCensoredMin)];
+}
+function openTable(report) {
+  const rows = report.openHoldingMerge.rows.map((r) => [r.repo, `#${r.pr}`, r.head.slice(0, 7), r.seat, r.verdictAt, r.ageMin, `events#${r.eventId}`]);
+  const title = `Open PRs holding MERGE at their current head, ${report.openHoldingMerge.prMinutes} PR-minutes [openHoldingMerge.rows[].ageMin]`;
+  return table(title, ["repo", "pr", "head", "seat", "verdict at", "age min", "verdict"], rows);
+}
+function denialTable(report) {
+  const rows = report.denials.rows.map((r) => [r.reason, r.action, r.seat, r.count]);
+  return table(`Classifier denials, ${report.denials.total} in all [denials.rows[].count]`, ["reason", "action", "seat", "count"], rows);
+}
+function idleTable(report) {
+  const rows = report.idleSlots.rows.map((r) => [r.seat, r.reason, r.slotMinutes, r.ticks, r.lines.join(",")]);
+  const title = `Idle implementer slot-minutes by stated reason, ${report.idleSlots.total} in all, each tick held at most ${report.idleSlots.holdMaxMin} min [idleSlots.rows[].slotMinutes]`;
+  return table(title, ["seat", "reason", "slot-min", "ticks", "journal lines"], rows);
+}
+function sourceLines(report) {
+  return ["Sources", ...Object.entries(report.sources).map(([name, s]) => `${name}: ${s.command} (${s.field})`)].join("\n");
 }
 export {
+  ACTION_CLASSES,
+  AGENT_LIFECYCLE,
+  ALL_REPOS,
+  BLOCKED_FLOW_SOURCES,
+  BOOT_TOOL,
   CHANNEL_CLUSTER_MS,
   CONTEXT_BANDS,
   CONTEXT_RESET_TOKENS,
   COORDINATOR_MERGE_DEDUPE_REQUESTS,
   COORDINATOR_MIN_EPISODE_REQUESTS,
   COORDINATOR_WAVE_QUIET_REQUESTS,
+  COST_REPORT_SECTIONS,
+  DEFAULT_ACTION_RULES,
+  DEFAULT_CONFIGURED_K,
+  DEFAULT_EPISODE_ROLES,
+  DEFAULT_K_SWEEP,
+  DEFAULT_MECHANICAL_CLASSES,
+  DEFAULT_NO_ACTION_CLASSES,
+  DEFAULT_REVIEWER_PRS,
+  DEFAULT_REVIEWER_ROLE,
+  DEFAULT_STANDING_ROLE,
   GAP_BANDS,
   HEURISTIC_VERSIONS,
   IDLE_GAP_MS,
   LIST_PRICE_CAVEAT,
+  POOLED_REVIEWERS,
   PRICE_TABLE,
   PRICE_TABLE_VERSION,
   PROFILE_ROLES,
+  REBUILD_GAP_BANDS,
   STANDING_PEER_MIN_ASSIGNMENTS,
   STANDING_PEER_MIN_HOURS,
+  TELEPORT_EVENT,
+  TICK_HOLD_MAX_MIN,
   TOKEN_CLASSES,
+  UNSTATED_REASON,
+  WAKE_FROM_KINDS,
   assignmentCount,
   bandOf,
+  blockedFlowReport,
+  blockedFlowSchema,
   buildEpisodes,
+  buildWakeEpisodes,
+  cacheTtlReport,
+  cacheTtlWhatIf,
+  cacheTtlWhatIfSchema,
+  classifyDeniedAction,
+  classifyRequest,
   classifySession,
   contextBand,
+  costPerRequest,
   costReport,
   costReportSchema,
+  episodeNames,
   findPrice,
   gapBand,
+  handoffThreshold,
+  handoffThresholdSchema,
   heuristicFor,
+  idleSlotMinutes,
   initiativeFromCwd,
+  isBootAction,
+  latencyStats,
+  latencyStatsSchema,
+  mergeOutcomes,
+  parseDenials,
+  parseSeatJournal,
+  parseTeleportEvents,
+  parseVerdict,
+  prKey,
   priceRequest,
   readEpisodeInput,
+  readRequestToolCalls,
+  readTtlRows,
+  renderBlockedFlowText,
+  renderCacheTtlText,
+  renderCostReportSections,
   renderCostReportText,
   roleFromProfile,
+  scopeFilter,
   sessionInitiative,
   sessionRole,
+  summarizeWakeEpisodes,
+  sweepK,
+  wakeEpisodesSchema,
   workerRole,
   writeEpisodes
 };