@oh-my-pi/omp-stats 18.3.5 → 18.4.0

package/dist/types/client/ui/index.d.ts

@@ -1,11 +1,10 @@
-export * from "./AsyncBoundary.js";
-export * from "./DataTable.js";
-export * from "./EmptyState.js";
-export * from "./ErrorState.js";
+export * from "./Badge.js";
+export * from "./Card.js";
+export * from "./Drawer.js";
 export * from "./JsonBlock.js";
-export * from "./MetricCluster.js";
-export * from "./Panel.js";
-export * from "./RequestDrawer.js";
-export * from "./SegmentedControl.js";
-export * from "./Skeleton.js";
-export * from "./StatusPill.js";
+export * from "./Modal.js";
+export * from "./SearchInput.js";
+export * from "./Segmented.js";
+export * from "./Stat.js";
+export * from "./States.js";
+export * from "./Table.js";

package/dist/types/db.d.ts

@@ -1,26 +1,58 @@
 import { Database } from "bun:sqlite";
 import { type ParseSessionResult, type SessionParserState } from "./parser.js";
-import type { AgentTypeStats, AggregatedStats, BehaviorModelStats, BehaviorOverallStats, BehaviorTimeSeriesPoint, CostTimeSeriesPoint, DailyActivityPoint, FolderStats, MessageStats, MessageStatsInput, ModelPerformancePoint, ModelStats, ModelTimeSeriesPoint, ProviderAggregate, ProviderHourlyPoint, ProviderTimeSeriesPoint, TimeSeriesPoint, ToolCallStats, ToolModelStats, ToolResultLink, ToolTimeSeriesPoint, ToolUsageStats, UserMessageLink, UserMessageStats } from "./types.js";
+import type { DailyActivityPoint, FrustrationCounts, MessageStats, MessageStatsInput, ToolCallStats, ToolResultLink, UserMessageLink, UserMessageStats } from "./types.js";
+/**
+ * Predicate counting one stored request as "unpriced" — the public rate card
+ * has no charge for it, so its zero is unknown spend rather than free usage.
+ * Two shapes store that zero:
+ *   - `xai-oauth` bills through the SuperGrok subscription, so ingestion
+ *     deliberately records no per-request price;
+ *   - `cost_unpriced = 1`, set by `insertMessageStats` when `resolveStoredCost`
+ *     refuses to price a scheduled (time-based) card whose entry carried no
+ *     recoverable request timestamp — the epoch would silently become the
+ *     tariff. Such a row keeps its real tokens and its zero until a re-parse
+ *     recovers the time.
+ *
+ * Nothing else sets the marker: an explicit recorded zero, a free flat card,
+ * and a model with no catalog card at all keep `cost_unpriced = 0` even at the
+ * parser's timestamp sentinel, because their zero is a real price.
+ * `prefix` qualifies the columns for queries that alias `messages`.
+ */
+export declare function unpricedRequestSql(prefix?: string): string;
+/** The open stats database, or null before {@link initDb}. Used by the rollup query layer. */
+export declare function currentDb(): Database | null;
 /**
  * Initialize the database and create tables.
  */
 export declare function initDb(): Promise<Database>;
 /** Whether the catalog prices this model on a time-based (scheduled) card. */
 export declare function isScheduledCatalogModel(provider: string, modelId: string): boolean;
-/**
- * Get the stored offset for a session file.
- */
-export declare function getFileOffset(sessionFile: string): {
+/** Persisted transcript identity and parser cursor used to resume stats ingestion. */
+export interface FileOffset {
     offset: number;
     lastModified: number;
     parserState?: SessionParserState;
-} | null;
+}
+/** Read one persisted cursor for callers inspecting an individual transcript. */
+export declare function getFileOffset(sessionFile: string): FileOffset | null;
+/** Read a bounded sync work set's cursors with one SQLite snapshot instead of one lookup per file. */
+export declare function getFileOffsets(sessionFiles: string[]): Map<string, FileOffset>;
 /**
  * Update the stored offset for a session file.
  */
 export declare function setFileOffset(sessionFile: string, offset: number, lastModified: number, parserState?: SessionParserState): void;
-export declare function applySessionParseResult(sessionFile: string, result: ParseSessionResult, rebuild?: boolean): {
+/** Parsed transcript queued by the sync loop for an atomic database batch. */
+export interface ParsedSession {
+    sessionFile: string;
+    result: ParseSessionResult;
+    rebuild: boolean;
+    /** Recover missing rows from a full-history scan without rewriting unchanged records. */
+    replay: boolean;
+}
+/** Commit distinct transcripts' rows, reconciliation state, and cursors together; failure rolls back the batch. */
+export declare function applySessionParseResults(sessions: ParsedSession[]): {
     processed: number;
+    files: number;
     reconcile: boolean;
 };
 export declare function prepareSessionSync(): boolean;
@@ -41,54 +73,7 @@ export declare function completeSessionSync(reconcile: boolean): void;
  * stored cost (orchestration-aware) and keeps `premium_requests` monotonic, so
  * a forced re-parse repairs historical `premium_requests` and cost fix-ups.
  */
-export declare function insertMessageStats(stats: MessageStatsInput[]): number;
-/**
- * Get overall aggregated stats.
- */
-export declare function getOverallStats(cutoff?: number): AggregatedStats;
-/**
- * Get stats grouped by model.
- */
-export declare function getStatsByModel(cutoff?: number): ModelStats[];
-/**
- * Get stats grouped by folder.
- */
-export declare function getStatsByFolder(cutoff?: number): FolderStats[];
-/**
- * Get token usage grouped by agent type (main agent, task subagents, advisor).
- * Token columns are explicit so the dashboard's share denominator matches the
- * counts it renders. Rows missing `agent_type` (defensive) fall back to "main".
- */
-export declare function getStatsByAgentType(cutoff?: number): AgentTypeStats[];
-/**
- * Get time series data.
- */
-export declare function getTimeSeries(hours?: number, cutoff?: number | null, bucketMs?: number): TimeSeriesPoint[];
-/**
- * Get daily performance time series data for the last N days.
- */
-/**
- * Get daily model usage time series data for the last N days.
- */
-export declare function getModelTimeSeries(days?: number, cutoff?: number | null, bucketMs?: number): ModelTimeSeriesPoint[];
-/**
- * Get request/token/cost totals grouped by provider.
- */
-export declare function getStatsByProvider(cutoff?: number | null): ProviderAggregate[];
-/**
- * Get token burn grouped by provider and local hour of day (0-23).
- * Hours use the server's timezone — the dashboard is a localhost tool, so
- * server-local and viewer-local time coincide.
- */
-export declare function getProviderHourlyBurn(cutoff?: number | null): ProviderHourlyPoint[];
-/**
- * Get token/cost time series grouped by provider (bucketed like the model series).
- */
-export declare function getProviderTimeSeries(days?: number, cutoff?: number | null, bucketMs?: number): ProviderTimeSeriesPoint[];
-/**
- * Get daily model performance time series data for the last N days.
- */
-export declare function getModelPerformanceSeries(days?: number, cutoff?: number | null, bucketMs?: number): ModelPerformancePoint[];
+export declare function insertMessageStats(stats: Iterable<MessageStatsInput>): number;
 /**
  * Get total message count.
  */
@@ -100,26 +85,6 @@ export declare function closeDb(): void;
 export declare function getRecentRequests(limit?: number): MessageStats[];
 export declare function getRecentErrors(limit?: number, cutoff?: number | null): MessageStats[];
 export declare function getMessageById(id: number): MessageStats | null;
-/** Per-transcript-file rollup for the Traces session list. */
-export interface SessionRollupRow {
-    sessionFile: string;
-    requests: number;
-    startedAt: number;
-    endedAt: number;
-    totalTokens: number;
-    costTotal: number;
-    unpricedRequests: number;
-    /** Comma-joined DISTINCT models. */
-    models: string;
-}
-/** Aggregate every synced transcript file into one row (subagents unfolded). */
-export declare function getSessionRollups(): SessionRollupRow[];
-/** Tool-call counts keyed by transcript file, for the Traces session list. */
-export declare function getToolCallCountsBySession(): Map<string, number>;
-/**
- * Get daily cost time series data for the last N days, broken down by model.
- */
-export declare function getCostTimeSeries(days?: number, cutoff?: number | null): CostTimeSeriesPoint[];
 /**
  * Per-local-day activity aggregates for the last `days` days, oldest first.
  * Self-initializing (opens the stats DB on first use) so the coding-agent TUI
@@ -138,30 +103,61 @@ export declare function markSessionBackfillsComplete(): void;
  * copy user entries verbatim into the child JSONL, so the same
  * `(entry_id, timestamp)` must not land twice across different session files.
  */
-export declare function insertUserMessageStats(stats: UserMessageStats[]): number;
+export declare function insertUserMessageStats(stats: Iterable<UserMessageStats>): number;
 /**
  * Backfill the responding `model`/`provider` on user-message rows that were
- * persisted before their assistant reply was parsed (a side effect of
- * incremental `fromOffset` syncing: the `userByEntryId` map in
- * `parseSessionFile` only spans a single pass). Each row is updated at most
- * once because the `model IS NULL` guard short-circuits subsequent passes.
+ * persisted before their assistant reply was parsed by an incremental tail
+ * read. Each row is updated at most once because the `model IS NULL` guard
+ * short-circuits subsequent passes.
  *
  * Returns the number of rows actually updated.
  */
-export declare function updateUserMessageLinks(links: UserMessageLink[]): number;
-/**
- * Daily behavioral time series, grouped by responding model+provider.
- */
-export declare function getBehaviorTimeSeries(cutoff?: number | null): BehaviorTimeSeriesPoint[];
-/**
- * Overall behavioral totals across the cutoff window.
- */
-export declare function getBehaviorOverall(cutoff?: number | null): BehaviorOverallStats;
+export declare function updateUserMessageLinks(links: Iterable<UserMessageLink>): number;
+/** Frustration tallies of one responding (model, provider) pair, before identity merging. */
+export interface FrustrationModelRow extends FrustrationCounts {
+    model: string;
+    provider: string | null;
+    /** Earliest message timestamp (ms) in range. */
+    firstSeen: number;
+}
+/** One unique unjudged prose text: identical messages share a hash and one verdict. */
+export interface PendingProse {
+    hash: string;
+    prose: string;
+}
+/** Cached judge verdict for one prose hash. */
+export interface FrustrationVerdict {
+    proseHash: string;
+    /** P(clearly annoyed) + P(angry) on the `annoyed` score question. */
+    pAnnoyed: number;
+    /** P(angry, hostile, or swearing). */
+    pAngry: number;
+    /** Most likely `target` choice: `assistant`, `other`, or `none`. */
+    target: string;
+    /** `provider/model` that produced the verdict. */
+    judge: string;
+    judgedAt: number;
+}
+/** Frustration tallies over every user message with prose in range, linked to a model or not. */
+export declare function getFrustrationOverall(cutoff?: number | null): FrustrationCounts;
+/**
+ * Frustration tallies per responding (model, provider) over the range. User
+ * messages that never got a reply (null model) are only in the overall tally.
+ */
+export declare function getFrustrationByModel(cutoff?: number | null): FrustrationModelRow[];
+/** Unique prose texts in range that have no cached verdict yet. */
+export declare function getPendingFrustrationProse(cutoff?: number | null): PendingProse[];
+/** Count and total characters of {@link getPendingFrustrationProse} without loading the text. */
+export declare function getPendingFrustrationTotals(cutoff?: number | null): {
+    messages: number;
+    chars: number;
+};
 /**
- * Per-model behavioral totals over the cutoff window. "Unknown" represents
- * user messages that never received an assistant reply.
+ * Cache (or replace) verdicts, all in one transaction: a judge run lands
+ * dozens per second, and a commit per verdict would contend with ingest for
+ * the write lock every time.
  */
-export declare function getBehaviorByModel(cutoff?: number | null): BehaviorModelStats[];
+export declare function upsertFrustrationVerdicts(verdicts: readonly FrustrationVerdict[]): void;
 /**
  * Insert tool-call rows. Idempotent via UNIQUE(session_file, tool_call_id);
  * the `WHERE NOT EXISTS` guard mirrors {@link insertMessageStats}: forked
@@ -171,7 +167,7 @@ export declare function getBehaviorByModel(cutoff?: number | null): BehaviorMode
  * identity, not the call id alone — provider call ids are not a global
  * namespace across unrelated sessions.
  */
-export declare function insertToolCalls(calls: ToolCallStats[]): number;
+export declare function insertToolCalls(calls: Iterable<ToolCallStats>): number;
 /**
  * Attach result size / error flag to persisted tool-call rows. Results can
  * land in a later incremental sync pass than the call that produced them, so
@@ -179,16 +175,4 @@ export declare function insertToolCalls(calls: ToolCallStats[]): number;
  * guard makes re-syncs idempotent; rows skipped by the fork guard simply
  * never match.
  */
-export declare function updateToolResults(links: ToolResultLink[]): number;
-/**
- * Get tool usage aggregated by tool name.
- */
-export declare function getToolStats(cutoff?: number): ToolUsageStats[];
-/**
- * Get tool usage aggregated by (tool, model, provider).
- */
-export declare function getToolStatsByModel(cutoff?: number): ToolModelStats[];
-/**
- * Get tool-call time series (one point per bucket per tool).
- */
-export declare function getToolTimeSeries(days?: number, cutoff?: number | null, bucketMs?: number): ToolTimeSeriesPoint[];
+export declare function updateToolResults(links: Iterable<ToolResultLink>): number;

package/dist/types/frustration.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Frustration dashboard: per-model share of user messages that sound annoyed,
+ * annoyed at the assistant, and angry at the assistant.
+ *
+ * Each message is classified by its cached judge verdict when one exists:
+ *   annoyed     = P(level 2) + P(level 3) ≥ 0.5 on {@link FRUSTRATION_QUESTIONS}.annoyed
+ *   atAssistant = annoyed && target = `assistant`
+ *   angry       = atAssistant && P(level 3) ≥ 0.5
+ * and otherwise by the regex signals stored at ingest (`user-metrics.ts`):
+ *   annoyed     = yelling + profanity + anguish + negation + repetition + blame > 0
+ *   atAssistant = negation + repetition + blame > 0
+ *   angry       = atAssistant && (profanity > 0 || yelling > 0)
+ * The SQL implementing both lives in `db.ts` (`FRUSTRATION_COUNTS_SQL`).
+ *
+ * Verdicts come from a single process-wide judge run over the unjudged prose,
+ * using the judge the omp host registered through `startServer`. Standalone
+ * `omp-stats` has none and only shows the regex fallback.
+ */
+import type { ChoiceQuestion, Judge, Model, ScoreQuestion } from "@oh-my-pi/pi-ai";
+import { type FrustrationModelRow } from "./db.js";
+import type { FrustrationDashboardStats, FrustrationEstimate, FrustrationJobStatus, FrustrationModelStats } from "./shared-types.js";
+/** Judge supplied by the omp host process; `primaryModel` prices the pre-run estimate. */
+export interface StatsJudge extends Judge {
+    primaryModel(): Model | undefined;
+}
+/** Lazily resolves the host judge on first estimate/run so `omp stats` startup stays fast. */
+export type StatsJudgeProvider = () => Promise<StatsJudge>;
+/** Where the user's annoyance is aimed. */
+export type FrustrationTarget = "assistant" | "other" | "none";
+/**
+ * The two questions asked about every prose text, in ONE judge request.
+ * The cost constants below were measured with exactly these strings; changing
+ * them invalidates both the estimate and every cached verdict's meaning.
+ */
+export declare const FRUSTRATION_QUESTIONS: {
+    annoyed: ScoreQuestion;
+    target: ChoiceQuestion<FrustrationTarget>;
+};
+/** Register (or replace) the host judge. Called by `startServer`. */
+export declare function setStatsJudgeProvider(provider: StatsJudgeProvider | undefined): void;
+/** Snapshot of the current run's progress. */
+export declare function getFrustrationJobStatus(): FrustrationJobStatus;
+/**
+ * Merge per-(model, provider) rows into catalog identities (`class/family/revision`)
+ * so provider and spelling variants share a row. Classified rows sort by class,
+ * then revision ascending, then family; unclassified rows follow by first use.
+ */
+export declare function mergeFrustrationRows(rows: readonly FrustrationModelRow[]): FrustrationModelStats[];
+/** Payload of `GET /api/stats/frustration`. */
+export declare function getFrustrationDashboardStats(range?: string | null): Promise<FrustrationDashboardStats>;
+/** Pre-run cost quote for judging every unjudged prose text in range. */
+export declare function estimateFrustrationRun(range?: string | null): Promise<FrustrationEstimate>;
+/** Outcome of {@link startFrustrationRun}: the new job, or the HTTP status and reason it was refused. */
+export type StartFrustrationRunResult = {
+    started: true;
+    job: FrustrationJobStatus;
+    /** Settles once every worker has stopped (done, cancelled, or failed); never rejects. */
+    finished: Promise<void>;
+} | {
+    started: false;
+    status: 409 | 503;
+    error: string;
+};
+/**
+ * Start the process-wide judge run over the unique unjudged prose in range.
+ * Returns immediately after queueing; progress is read via {@link getFrustrationJobStatus}.
+ */
+export declare function startFrustrationRun(range?: string | null): Promise<StartFrustrationRunResult>;
+/** Abort the active run; in-flight judge requests are cancelled and no new text is taken. */
+export declare function cancelFrustrationRun(): FrustrationJobStatus;

package/dist/types/index.d.ts

@@ -1,8 +1,10 @@
 #!/usr/bin/env bun
 export { getDashboardStats, getToolDashboardStats, getTotalMessageCount, type SyncOptions, type SyncProgress, smokeTestSyncWorker, syncAllSessions, } from "./aggregator.js";
 export { closeDb } from "./db.js";
+export { refreshRollups } from "./rollup.js";
+export type { StatsJudge, StatsJudgeProvider } from "./frustration.js";
 export { getGainDashboardStats } from "./gain-aggregator.js";
-export { formatStatsDashboardUrl, startServer } from "./server.js";
+export { formatStatsDashboardUrl, type StartServerOptions, startServer } from "./server.js";
 export type { GainDashboardStats, GainSource, GainSourceTotals, GainTimeSeriesPoint } from "./shared-types.js";
 export type { AggregatedStats, DashboardStats, FolderStats, MessageStats, ModelPerformancePoint, ModelStats, ModelTimeSeriesPoint, TimeSeriesPoint, ToolDashboardStats, ToolModelStats, ToolTimeSeriesPoint, ToolUsageStats, } from "./types.js";
 /** Parsed arguments for the standalone `omp-stats` entry point. */

package/dist/types/live.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Live ingest for a running dashboard: background session sync, rollup
+ * refresh, and a status stream the client subscribes to (`/api/events`).
+ *
+ * The dashboard never waits for ingest. {@link StatsLive.start} kicks a full
+ * sync in the background and watches the sessions directory; changed
+ * transcripts are re-synced (only those files) shortly after they are written.
+ * Every committed batch bumps {@link LiveStatus.version} (throttled), so open
+ * pages refetch and fill in while parsing is still running.
+ */
+import type { LiveStatus } from "./shared-types.js";
+type Listener = (status: LiveStatus) => void;
+/** One per process; owned by the dashboard server (see `startServer`). */
+export declare class StatsLive {
+    #private;
+    status(): LiveStatus;
+    /** Receive every status change; returns the unsubscribe function. */
+    subscribe(listener: Listener): () => void;
+    /** Begin background ingest: an immediate full sync, the transcript watcher, and periodic resyncs. Idempotent. */
+    start(): void;
+    stop(): void;
+    /**
+     * Queue a sync of `files`, or of every session when omitted. Requests made
+     * while a sync runs coalesce into one follow-up run.
+     */
+    requestSync(files?: readonly string[]): void;
+}
+/** The process-wide live hub. */
+export declare function statsLive(): StatsLive;
+export {};

package/dist/types/rollup.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Hourly rollups of `messages` and `tool_calls`, and every range query the
+ * dashboard runs over them.
+ *
+ * The raw tables hold millions of rows; grouping them per request made every
+ * range switch cost seconds. Instead, `message_rollup` / `tool_rollup` keep one
+ * row per (hour, dimensions) with additive sums, so a 90-day query reads a few
+ * thousand rows.
+ *
+ * Freshness is trigger-driven: any INSERT/UPDATE/DELETE on the raw tables — from
+ * this process, a sync worker, or another omp process sharing the database —
+ * records the touched hour in `rollup_dirty`. {@link refreshRollups} recomputes
+ * dirty hours newest-first in short immediate transactions.
+ *
+ * Reads never wait for a refresh and are exact: each query unions
+ *   - clean rollup hours inside the range,
+ *   - raw rows for the partial hour at the range start, and
+ *   - raw rows for dirty hours (while few are dirty),
+ * so live ingest shows up before its hour is re-rolled. While the initial build
+ * (or a mass re-ingest) leaves many hours dirty, reads use the rollup rows as
+ * they stand (stale-but-present; not-yet-built hours are missing) and
+ * {@link getRollupStatus} reports the backlog so the UI can show progress.
+ *
+ * The 1h range needs 5-minute buckets, so it aggregates raw rows directly
+ * (an hour of data is small and indexed by timestamp).
+ */
+import type { Database } from "bun:sqlite";
+import type { AgentTypeStats, AggregatedStats, CostTimeSeriesPoint, FolderStats, ModelPerformancePoint, ModelStats, ModelTimeSeriesPoint, ProviderAggregate, ProviderHourlyPoint, ProviderTimeSeriesPoint, TimeSeriesPoint, ToolModelStats, ToolTimeSeriesPoint, ToolUsageStats } from "./types.js";
+/**
+ * Create (or rebuild after a version bump) the rollup tables and the triggers
+ * that mark hours dirty. Called from `initDb` after the raw tables exist.
+ */
+export declare function ensureRollupSchema(database: Database): void;
+/** Backlog of hours and transcripts whose rollups are stale. */
+export interface RollupStatus {
+    dirtyHours: number;
+    dirtySessions: number;
+}
+export declare function getRollupStatus(): RollupStatus;
+/**
+ * Recompute up to `limit` dirty hours, newest first, in one immediate
+ * transaction (so no writer can dirty an hour between its read and its
+ * dirty-mark removal). Returns the number of hours refreshed.
+ */
+export declare function refreshRollupBatch(limit: number): number;
+export interface RefreshOptions {
+    /** Called after each committed batch with the remaining backlog. */
+    onProgress?: (remaining: number) => void;
+    /** Stop early (between batches). */
+    signal?: AbortSignal;
+}
+/**
+ * Drain the dirty-hour backlog in small transactions, yielding to the event
+ * loop between batches so a host process (TUI, dashboard server) stays
+ * responsive during the initial build. Batch size adapts so each transaction
+ * takes about {@link REFRESH_TARGET_MS}; busy hours shrink it to one.
+ */
+export declare function refreshRollups(opts?: RefreshOptions): Promise<void>;
+/** A range query's time window. `cutoff` null = all time. */
+export interface RangeWindow {
+    cutoff: number | null;
+    /** Bucket size for time series (5 minutes, an hour, or a day). */
+    bucketMs: number;
+}
+/** Overall request/token/cost aggregate since `cutoff` (all time when null). */
+export declare function getOverallStats(cutoff?: number | null): AggregatedStats;
+/** Aggregates per (model, provider), busiest first. */
+export declare function getStatsByModel(cutoff?: number | null): ModelStats[];
+/** Aggregates per project folder, busiest first; at most `limit` folders. */
+export declare function getStatsByFolder(cutoff?: number | null, limit?: number): FolderStats[];
+/** Token usage per agent type (main, subagent, advisor). */
+export declare function getStatsByAgentType(cutoff?: number | null): AgentTypeStats[];
+/** Requests, errors, tokens and cost per bucket. */
+export declare function getTimeSeries({ cutoff, bucketMs }: RangeWindow): TimeSeriesPoint[];
+/** Requests per bucket per (model, provider). */
+export declare function getModelTimeSeries({ cutoff, bucketMs }: RangeWindow): ModelTimeSeriesPoint[];
+/** Average TTFT and output tokens/s per bucket per (model, provider). */
+export declare function getModelPerformanceSeries({ cutoff, bucketMs }: RangeWindow): ModelPerformancePoint[];
+/** Daily cost per (model, provider) with the per-component split. */
+export declare function getCostTimeSeries(cutoff?: number | null): CostTimeSeriesPoint[];
+/** Request/token/cost totals per provider, biggest token burn first. */
+export declare function getStatsByProvider(cutoff?: number | null): ProviderAggregate[];
+/**
+ * Token burn per provider per local hour of day (0-23). Hours use the
+ * server's timezone — a localhost tool, so server and viewer coincide. Rolled
+ * hours are attributed by their start, so half-hour UTC offsets shift burn by
+ * up to 30 minutes.
+ */
+export declare function getProviderHourlyBurn(cutoff?: number | null): ProviderHourlyPoint[];
+/** Tokens/cost per bucket per provider. */
+export declare function getProviderTimeSeries({ cutoff, bucketMs }: RangeWindow): ProviderTimeSeriesPoint[];
+/** Per-transcript-file rollup for the Traces session list. */
+export interface SessionRollupRow {
+    sessionFile: string;
+    requests: number;
+    startedAt: number;
+    endedAt: number;
+    totalTokens: number;
+    costTotal: number;
+    unpricedRequests: number;
+    /** Comma-joined DISTINCT models. */
+    models: string | null;
+    toolCalls: number;
+}
+/**
+ * One row per synced transcript file (subagents unfolded). Same exactness
+ * rules as the range queries: dirty transcripts are aggregated raw while few.
+ */
+export declare function getSessionRollups(): SessionRollupRow[];
+/** Tool usage per tool name, most-called first. */
+export declare function getToolStats(cutoff?: number | null): ToolUsageStats[];
+/** Tool usage per (tool, model, provider), most-called first. */
+export declare function getToolStatsByModel(cutoff?: number | null): ToolModelStats[];
+/** Calls and errors per bucket per tool. */
+export declare function getToolTimeSeries({ cutoff, bucketMs }: RangeWindow): ToolTimeSeriesPoint[];

package/dist/types/server.d.ts

@@ -1,3 +1,4 @@
+import { type StatsJudgeProvider } from "./frustration.js";
 /**
  * Handle API requests.
  */
@@ -12,4 +13,8 @@ export interface StatsServerHandle {
     port: number;
     stop: () => void;
 }
-export declare function startServer(port?: number, hostname?: string): Promise<StatsServerHandle>;
+export interface StartServerOptions {
+    /** Host judge for the Frustration dashboard's judge runs; replaces any previously registered one. */
+    judge?: StatsJudgeProvider;
+}
+export declare function startServer(port?: number, hostname?: string, options?: StartServerOptions): Promise<StatsServerHandle>;