@titan-design/session-analytics 0.6.0 → 0.8.0

package/README.md

@@ -6,7 +6,9 @@ reads a session graph through a read-only connection and never writes it; `write
 the one function here that writes.
 
 Tier 2 of the titan-platform DAG. It depends on `@titan-design/session-graph` for table
-names and on `@titan-design/store-sqlite` for the `Db` type. `zod` is a peer dependency.
+names, on `@titan-design/store-sqlite` for the `Db` type, and on `@titan-design/session-read`
+and `@titan-design/agent-protocol` for the observations the session timeline folds. `zod` is a
+peer dependency.
 
 ```ts
 import { classifySession, contextBand, priceRequest } from "@titan-design/session-analytics";
@@ -63,6 +65,9 @@ priceRequest(
   segmentation, written through session-graph's `replaceEpisodes`.
 - `initiativeFromCwd(cwd)`, `sessionInitiative(tasks, cwd)` — a session's initiative from its
   task edges, falling back to the `cf_analyze.py` cwd rule.
+- `buildSessionTimeline(observations, options?)`, `SessionTimelineAccumulator`,
+  `countAtOrBefore(sortedMs, targetMs)` and the `SessionTimeline` types — the read model behind
+  a session view; see "Session timeline" below.
 
 ```ts
 import { openDatabase } from "@titan-design/store-sqlite";
@@ -72,6 +77,57 @@ const report = costReport(openDatabase(graphPath, { readonly: true }), { days: 7
 process.stdout.write(renderCostReportText(report));
 ```
 
+## Session timeline
+
+`buildSessionTimeline(observations, { gapMinMs, maxTextChars, prices })` is a pure fold over
+session-read's normalized observations, so it reads Claude Code and Codex sessions alike and
+needs no graph. It returns one `SessionTimeline`, plain JSON that a daemon can send as it is:
+
+```ts
+import { claudeSourceFromPath, readSessionObservations } from "@titan-design/session-read";
+import { SessionTimelineAccumulator, countAtOrBefore } from "@titan-design/session-analytics";
+
+const accumulator = new SessionTimelineAccumulator();
+for await (const observation of readSessionObservations(claudeSourceFromPath(file, namespace))) {
+  accumulator.add(observation);
+}
+const timeline = accumulator.result();
+countAtOrBefore(timeline.tools.atMs, scrubbedMs); // tool calls made by that time
+```
+
+| Field | What it holds |
+|---|---|
+| `turns` | `TimelineTurn[]`. A user message opens a turn. Each has `user`, `assistant` messages, `toolCalls`, `errorCount`, `tokens`, `costUsd` and `gapBeforeMs`. Sort a turn's messages and tool calls by `seq` to interleave them. |
+| `buckets` | `TimelineMinuteBucket[]`, one per clock minute that held activity, with event, message, tool call and error counts, output tokens and cost. |
+| `gaps` | `TimelineGap[]`: each idle stretch of `TIMELINE_GAP_MIN_MS` (10 minutes) or more. The bucket and the turn after a gap carry `gapBeforeMs`. The wait on a tool call that later returned is not idle and is never a gap. |
+| `tokens` | `TokenTimeline`: one `TimelineTokenPoint` per API request (prompt size, output, cost, running totals, `afterCompaction`), the `CompactionMark`s and the models used. |
+| `tools`, `files`, `errors`, `agents` | Calls by name and by session-read tool family, first touch of each file by access, failed calls, and subagent dispatch spans. Each carries ascending `atMs` arrays for `countAtOrBefore`. |
+| `totals` | Counts, the four disjoint token classes and the cost. |
+
+Every `*Ms` field is epoch milliseconds. The model holds no time zone, so a session that
+crosses midnight is one unbroken run of buckets and the renderer picks the zone. Text is capped
+at `TIMELINE_TEXT_CAP` characters with `truncated` set, and each message and tool call keeps the
+`byteOffset` of its transcript line for reading the full record. `SESSION_TIMELINE_VERSION`
+changes when a field is removed or changes meaning.
+
+A turn's `origin` is `prompt`, `injected` (a harness block such as a channel message or a task
+notification, named in `injectedMarker`), `compaction` (a continuation summary) or `none`
+(activity before any user message). It is read from the head of the opening text with
+session-read's injected markers, so a typed prompt that the harness prefixed with a reminder
+block reads as `injected`.
+
+Cost comes from `priceRequest` over `PRICE_TABLE`. The normalized usage has no 5m and 1h split
+of cache writes, so every cache write is priced at the 5m rate and the figure under-reads a
+session that wrote 1h caches. A source that reports only running totals (`basis: "snapshot"`)
+gets token totals and no points, and nothing is priced: `totals.costUsd` and every turn's
+`costUsd` are 0, and `totals.requests` is null.
+
+Claude Code writes one compaction as a boundary line and then a summary line. The timeline
+reports it as one `CompactionMark`, at the boundary's time, with the summary.
+
+`result()` returns a fresh copy each time, so a result is safe to keep while more observations
+are added. `ToolFamily`, the type of a tool call's `family`, is re-exported from session-read.
+
 ## Wake episodes
 
 An episode is one arrival that wakes a session and the requests after it, up to the next

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { Db } from '@titan-design/store-sqlite';
 import { z } from 'zod';
 import { EpisodeRow, SessionGraph } from '@titan-design/session-graph';
+import { ToolFamily, NormalizedSessionObservation } from '@titan-design/session-read';
+export { ToolFamily } from '@titan-design/session-read';
 
 /** USD per million tokens. Fitted against 392 `cost-state` rows in the 2026-09-20 audit. */
 interface PriceRow {
@@ -1656,4 +1658,272 @@ declare function livenessReport(input: LivenessInput): LivenessReport;
 /** Each table's title names the JSON field its rows come from; the sources and the shared caveat close the report. */
 declare function renderLivenessText(report: LivenessReport): string;
 
-export { ACTION_CLASSES, AGENT_LIFECYCLE, ALL_REPOS, type ActionCall, type ActionClass, type ActionRule, type AgentNameRow, BLOCKED_FLOW_SOURCES, BOOT_TOOL, type Band, type BlockedFlowInput, type BlockedFlowReport, type BlockedFlowSource, type BrokerEntry, CHANNEL_CLUSTER_MS, CONTEXT_BANDS, CONTEXT_RESET_TOKENS, COORDINATOR_MERGE_DEDUPE_REQUESTS, COORDINATOR_MIN_EPISODE_REQUESTS, COORDINATOR_WAVE_QUIET_REQUESTS, COST_REPORT_SECTIONS, type CacheTtlBucket, type CacheTtlWhatIf, type CostBucket, type CostReport, type CostReportOptions, type CostReportSection, type CycleParams, DARK_MIN, 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, type DarkGap, type DenialRecord, type EpisodeInbound, type EpisodeInput, type EpisodeNames, type EpisodeRequest, type EpisodeRequestRow, type EpisodeSignal, GAP_BANDS, HEURISTIC_VERSIONS, type HandoffCohort, type HandoffOptions, type HandoffRequestRow, type HandoffSession, type HandoffTeleport, type HandoffThreshold, type Heuristic, type HumanRole, IDLE_GAP_MS, type IdleSlotRow, type KSweep, LIST_PRICE_CAVEAT, LIVENESS_SOURCES, type LastEventRecord, type LatencyRow, type LatencyStats, type LivenessInput, type LivenessReport, type LivenessSource, type MechanicalShare, type MergeOutcome, type MergeStatus, POOLED_REVIEWERS, PRICE_TABLE, PRICE_TABLE_VERSION, PROFILE_ROLES, PROMPT_STALE_MIN, type ParsedVerdict, type PriceRow, type PricedRequest, type PullState, REBUILD_GAP_BANDS, type ReportScope, type ReportWindow, type RequestTokens, type ReviewerComparison, type RoleActions, type RouteFailureRow, type RouteMiss, type RouteMissKind, STANDING_PEER_MIN_ASSIGNMENTS, STANDING_PEER_MIN_HOURS, type SeatJournal, type SessionClass, type SessionClassification, type SessionFacts, type SessionOrigin, type SlotTick, type SpawnRecord, type StalePromptRow, TELEPORT_EVENT, TICK_HOLD_MAX_MIN, TOKEN_CLASSES, type TaskInitiative, type TeleportEvent, type TokenClass, type TtlRequestRow, UNKNOWN_PROFILE, UNSTATED_REASON, type UnreportedExit, type UnreportedExitRow, type VerdictRecord, WAKE_FROM_KINDS, type WakeCauseBucket, type WakeCauseEpisodes, type WakeEpisode, type WakeEpisodes, type WakeEventRow, type WakeFromKind, type WakeGapCell, type WakePair, type WorkerFacts, type WorkerRole, type WrittenEpisodes, assignmentCount, bandOf, blockedFlowReport, blockedFlowSchema, buildEpisodes, buildWakeEpisodes, cacheTtlReport, cacheTtlWhatIf, cacheTtlWhatIfSchema, classifyDeniedAction, classifyRequest, classifySession, contextBand, costPerRequest, costReport, costReportSchema, countMisses, darkGaps, dedupeDenials, episodeNames, findPrice, gapBand, handoffThreshold, handoffThresholdSchema, heuristicFor, idleSlotMinutes, initiativeFromCwd, isBootAction, latencyStats, latencyStatsSchema, livenessReport, livenessSchema, mergeOutcomes, parseBrokerLog, parseDenials, parseSeatJournal, parseTeleportEvents, parseVerdict, prKey, priceRequest, readEpisodeInput, readRequestToolCalls, readTtlRows, renderBlockedFlowText, renderCacheTtlText, renderCostReportSections, renderCostReportText, renderLivenessText, roleFromProfile, routeFailureRows, routeMisses, scopeFilter, sessionInitiative, sessionRole, stalePromptRows, summarizeWakeEpisodes, sweepK, unreportedExitRows, wakeEpisodesSchema, workerRole, writeEpisodes };
+/** Bump when a field is removed or changes meaning. Adding a field keeps the version. */
+declare const SESSION_TIMELINE_VERSION = 1;
+/** Idle time between two events that counts as a gap. */
+declare const TIMELINE_GAP_MIN_MS: number;
+/** Default cap on each message text. The byte offset still points at the full record. */
+declare const TIMELINE_TEXT_CAP = 4000;
+/** `prompt` is typed or sent text, `injected` is a harness block, `compaction` is a continuation summary, `none` is activity before any user message. */
+type TimelineTurnOrigin = "prompt" | "injected" | "compaction" | "none";
+/** `unknown` is a result whose source did not report an error state; `pending` has no result yet. */
+type TimelineToolOutcome = "success" | "error" | "unknown" | "pending";
+interface TimelineMessage {
+    role: "user" | "assistant";
+    /** Source order across the whole session; sort a turn's messages and tool calls by it to interleave them. */
+    seq: number;
+    atMs: number | null;
+    text: string;
+    /** True when `text` was cut at the cap. */
+    truncated: boolean;
+    /** Offset of the transcript line, for reading the full record. */
+    byteOffset: number;
+}
+interface TimelineToolCall {
+    /** The harness's own call id, unique within the session. */
+    id: string;
+    seq: number;
+    turnIndex: number;
+    name: string;
+    family: ToolFamily;
+    atMs: number | null;
+    /** When the result arrived; null while pending. */
+    endMs: number | null;
+    /** Observed call-to-result span, not harness execution time. */
+    durationMs: number | null;
+    outcome: TimelineToolOutcome;
+    errorMessage: string | null;
+    /** One line naming what the call acted on: a path, a command, a pattern or a description. */
+    inputSummary: string;
+    filePath: string | null;
+    sidechain: boolean;
+    byteOffset: number;
+}
+/** Prompt-side counts are disjoint: `input` excludes cache reads and cache writes. */
+interface TimelineTokens {
+    input: number;
+    cacheRead: number;
+    /** All cache writes, `cacheWrite5m + cacheWrite1h`. */
+    cacheWrite: number;
+    /** Writes at the 5m rate, including a total the source reported without a split. */
+    cacheWrite5m: number;
+    /** Writes at the 1h rate. */
+    cacheWrite1h: number;
+    output: number;
+}
+interface TimelineTurn {
+    index: number;
+    origin: TimelineTurnOrigin;
+    /** The session-read injected-marker name when `origin` is `injected` or `compaction`. */
+    injectedMarker: string | null;
+    startMs: number | null;
+    endMs: number | null;
+    /** Idle time before this turn when it is `TIMELINE_GAP_MIN_MS` or more, else null. */
+    gapBeforeMs: number | null;
+    /** The message that opened the turn; null when `origin` is `none`. */
+    user: TimelineMessage | null;
+    assistant: TimelineMessage[];
+    toolCalls: TimelineToolCall[];
+    errorCount: number;
+    tokens: TimelineTokens;
+    costUsd: number;
+}
+/** One UTC clock minute that held activity. Minutes with none are omitted. */
+interface TimelineMinuteBucket {
+    /** Start of the minute. */
+    minuteMs: number;
+    /** Messages, tool calls and tool results. */
+    events: number;
+    messages: number;
+    toolCalls: number;
+    errors: number;
+    outputTokens: number;
+    costUsd: number;
+    /** Set on the first bucket after a gap. */
+    gapBeforeMs: number | null;
+}
+/** An idle stretch. Time spent waiting on a tool call that later returned is not idle, so it is never a gap. */
+interface TimelineGap {
+    startMs: number;
+    endMs: number;
+    durationMs: number;
+}
+/** One API request. Points are in source order and cumulative fields run over that order. */
+interface TimelineTokenPoint {
+    atMs: number;
+    turnIndex: number | null;
+    model: string | null;
+    /** The prompt size of this request: input plus cache read plus cache write. Null when the source omitted a count. */
+    contextTokens: number | null;
+    outputTokens: number;
+    cumulativeOutputTokens: number;
+    costUsd: number;
+    cumulativeCostUsd: number;
+    /** False when no price row covers the model; `costUsd` is then 0. */
+    priced: boolean;
+    /** True on the first request after a compaction. */
+    afterCompaction: boolean;
+}
+interface CompactionMark {
+    atMs: number | null;
+    turnIndex: number | null;
+    byteOffset: number;
+    summary: string | null;
+    summaryTruncated: boolean;
+}
+interface ModelRequests {
+    model: string;
+    requests: number;
+}
+interface TokenTimeline {
+    /** `delta` has per-request points. A `snapshot` source reports running totals only: `points` is empty and nothing is priced, so every `costUsd` is 0. */
+    basis: "delta" | "snapshot" | "unreported";
+    points: TimelineTokenPoint[];
+    compactions: CompactionMark[];
+    /** Most requests first. */
+    models: ModelRequests[];
+}
+interface ToolNameCount {
+    name: string;
+    family: ToolFamily;
+    calls: number;
+    errors: number;
+    durationMs: number;
+}
+interface ToolFamilyCount {
+    family: ToolFamily;
+    calls: number;
+    errors: number;
+    /** Call start times, ascending, for `countAtOrBefore`. */
+    atMs: number[];
+}
+interface TimelineToolBreakdown {
+    /** Most calls first. */
+    byName: ToolNameCount[];
+    byFamily: ToolFamilyCount[];
+    /** Every call start time, ascending. */
+    atMs: number[];
+}
+interface TimelineFileTouch {
+    path: string;
+    access: "read" | "write";
+    /** First touch of this path with this access. */
+    atMs: number | null;
+    calls: number;
+}
+interface TimelineFileBreakdown {
+    /** One row per path and access, ordered by first touch. */
+    touches: TimelineFileTouch[];
+    readCount: number;
+    writeCount: number;
+}
+interface TimelineError {
+    callId: string;
+    toolName: string;
+    turnIndex: number;
+    /** When the failing result arrived. */
+    atMs: number | null;
+    message: string;
+    sidechain: boolean;
+}
+interface TimelineErrorBreakdown {
+    /** Failed calls over all calls; 0 with no calls. */
+    rate: number;
+    items: TimelineError[];
+    atMs: number[];
+}
+/** A subagent dispatch, from its tool call to that call's result. */
+interface TimelineAgentSpan {
+    callId: string;
+    label: string;
+    startMs: number | null;
+    endMs: number | null;
+    outcome: TimelineToolOutcome;
+}
+interface TimelineTotals {
+    turns: number;
+    userMessages: number;
+    assistantMessages: number;
+    toolCalls: number;
+    errors: number;
+    compactions: number;
+    /** API requests with usage. Null on a `snapshot` basis, which cannot count them. */
+    requests: number | null;
+    unpricedRequests: number;
+    tokens: TimelineTokens;
+    /** 0 on a `snapshot` basis, which has no per-request usage to price. */
+    costUsd: number;
+}
+/**
+ * Everything a session view reads, as plain JSON. Every `*Ms` field is epoch milliseconds,
+ * so the model holds no time zone and a renderer picks one.
+ */
+interface SessionTimeline {
+    version: typeof SESSION_TIMELINE_VERSION;
+    sessionId: string | null;
+    harness: string | null;
+    startMs: number | null;
+    endMs: number | null;
+    durationMs: number;
+    totals: TimelineTotals;
+    turns: TimelineTurn[];
+    buckets: TimelineMinuteBucket[];
+    gaps: TimelineGap[];
+    tokens: TokenTimeline;
+    tools: TimelineToolBreakdown;
+    files: TimelineFileBreakdown;
+    errors: TimelineErrorBreakdown;
+    agents: TimelineAgentSpan[];
+}
+
+interface SessionTimelineOptions {
+    /** Idle time that counts as a gap. Defaults to `TIMELINE_GAP_MIN_MS`. */
+    gapMinMs?: number;
+    /** Cap on each message and compaction summary. Defaults to `TIMELINE_TEXT_CAP`. */
+    maxTextChars?: number;
+    /** Price rows for the cost series. Defaults to `PRICE_TABLE`. */
+    prices?: readonly PriceRow[];
+}
+/** Storage-free fold for a streamed read: `add` each observation, then `result`, which returns a fresh copy each time. */
+declare class SessionTimelineAccumulator {
+    private readonly turns;
+    private readonly tokens;
+    private readonly gapMinMs;
+    private conversation;
+    private startMs;
+    private endMs;
+    constructor(options?: SessionTimelineOptions);
+    add(observation: NormalizedSessionObservation): void;
+    result(): SessionTimeline;
+    private claim;
+    /** A record with no usable timestamp takes the latest one seen, so it still lands in order. */
+    private clock;
+}
+/** The read model behind every session view: turns, minute buckets, the token and cost series, and tool, file and error breakdowns. */
+declare function buildSessionTimeline(observations: Iterable<NormalizedSessionObservation>, options?: SessionTimelineOptions): SessionTimeline;
+
+/** How many of the ascending `sortedMs` are at or before `targetMs`, by binary search. */
+declare function countAtOrBefore(sortedMs: readonly number[], targetMs: number): number;
+
+declare const reviewFillSchema: z.ZodObject<{
+    window: z.ZodObject<{
+        since: z.ZodNullable<z.ZodString>;
+        until: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    unfilled: z.ZodNumber;
+    unresolved: z.ZodNumber;
+    rows: z.ZodArray<z.ZodObject<{
+        band: z.ZodString;
+        model: z.ZodString;
+        verdicts: z.ZodNumber;
+        changesRequested: z.ZodNumber;
+        changesRate: z.ZodNullable<z.ZodNumber>;
+        verdictErrors: z.ZodNumber;
+        errorRate: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ReviewFillReport = z.infer<typeof reviewFillSchema>;
+/** Review verdicts in the window by the reviewer's context fill when it issued them, and how often an approve was contradicted. */
+declare function reviewFillReport(db: Db, window: ReportWindow): ReviewFillReport;
+
+export { ACTION_CLASSES, AGENT_LIFECYCLE, ALL_REPOS, type ActionCall, type ActionClass, type ActionRule, type AgentNameRow, BLOCKED_FLOW_SOURCES, BOOT_TOOL, type Band, type BlockedFlowInput, type BlockedFlowReport, type BlockedFlowSource, type BrokerEntry, CHANNEL_CLUSTER_MS, CONTEXT_BANDS, CONTEXT_RESET_TOKENS, COORDINATOR_MERGE_DEDUPE_REQUESTS, COORDINATOR_MIN_EPISODE_REQUESTS, COORDINATOR_WAVE_QUIET_REQUESTS, COST_REPORT_SECTIONS, type CacheTtlBucket, type CacheTtlWhatIf, type CompactionMark, type CostBucket, type CostReport, type CostReportOptions, type CostReportSection, type CycleParams, DARK_MIN, 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, type DarkGap, type DenialRecord, type EpisodeInbound, type EpisodeInput, type EpisodeNames, type EpisodeRequest, type EpisodeRequestRow, type EpisodeSignal, GAP_BANDS, HEURISTIC_VERSIONS, type HandoffCohort, type HandoffOptions, type HandoffRequestRow, type HandoffSession, type HandoffTeleport, type HandoffThreshold, type Heuristic, type HumanRole, IDLE_GAP_MS, type IdleSlotRow, type KSweep, LIST_PRICE_CAVEAT, LIVENESS_SOURCES, type LastEventRecord, type LatencyRow, type LatencyStats, type LivenessInput, type LivenessReport, type LivenessSource, type MechanicalShare, type MergeOutcome, type MergeStatus, type ModelRequests, POOLED_REVIEWERS, PRICE_TABLE, PRICE_TABLE_VERSION, PROFILE_ROLES, PROMPT_STALE_MIN, type ParsedVerdict, type PriceRow, type PricedRequest, type PullState, REBUILD_GAP_BANDS, type ReportScope, type ReportWindow, type RequestTokens, type ReviewFillReport, type ReviewerComparison, type RoleActions, type RouteFailureRow, type RouteMiss, type RouteMissKind, SESSION_TIMELINE_VERSION, STANDING_PEER_MIN_ASSIGNMENTS, STANDING_PEER_MIN_HOURS, type SeatJournal, type SessionClass, type SessionClassification, type SessionFacts, type SessionOrigin, type SessionTimeline, SessionTimelineAccumulator, type SessionTimelineOptions, type SlotTick, type SpawnRecord, type StalePromptRow, TELEPORT_EVENT, TICK_HOLD_MAX_MIN, TIMELINE_GAP_MIN_MS, TIMELINE_TEXT_CAP, TOKEN_CLASSES, type TaskInitiative, type TeleportEvent, type TimelineAgentSpan, type TimelineError, type TimelineErrorBreakdown, type TimelineFileBreakdown, type TimelineFileTouch, type TimelineGap, type TimelineMessage, type TimelineMinuteBucket, type TimelineTokenPoint, type TimelineTokens, type TimelineToolBreakdown, type TimelineToolCall, type TimelineToolOutcome, type TimelineTotals, type TimelineTurn, type TimelineTurnOrigin, type TokenClass, type TokenTimeline, type ToolFamilyCount, type ToolNameCount, type TtlRequestRow, UNKNOWN_PROFILE, UNSTATED_REASON, type UnreportedExit, type UnreportedExitRow, type VerdictRecord, WAKE_FROM_KINDS, type WakeCauseBucket, type WakeCauseEpisodes, type WakeEpisode, type WakeEpisodes, type WakeEventRow, type WakeFromKind, type WakeGapCell, type WakePair, type WorkerFacts, type WorkerRole, type WrittenEpisodes, assignmentCount, bandOf, blockedFlowReport, blockedFlowSchema, buildEpisodes, buildSessionTimeline, buildWakeEpisodes, cacheTtlReport, cacheTtlWhatIf, cacheTtlWhatIfSchema, classifyDeniedAction, classifyRequest, classifySession, contextBand, costPerRequest, costReport, costReportSchema, countAtOrBefore, countMisses, darkGaps, dedupeDenials, episodeNames, findPrice, gapBand, handoffThreshold, handoffThresholdSchema, heuristicFor, idleSlotMinutes, initiativeFromCwd, isBootAction, latencyStats, latencyStatsSchema, livenessReport, livenessSchema, mergeOutcomes, parseBrokerLog, parseDenials, parseSeatJournal, parseTeleportEvents, parseVerdict, prKey, priceRequest, readEpisodeInput, readRequestToolCalls, readTtlRows, renderBlockedFlowText, renderCacheTtlText, renderCostReportSections, renderCostReportText, renderLivenessText, reviewFillReport, reviewFillSchema, roleFromProfile, routeFailureRows, routeMisses, scopeFilter, sessionInitiative, sessionRole, stalePromptRows, summarizeWakeEpisodes, sweepK, unreportedExitRows, wakeEpisodesSchema, workerRole, writeEpisodes };