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

package/src/server.ts

@@ -2,26 +2,33 @@ import type { Dirent } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
-import { isEnoent } from "@oh-my-pi/pi-utils";
+import { isEnoent, logger } from "@oh-my-pi/pi-utils";
 import { $, type Server } from "bun";
 import {
-	getBehaviorDashboardStats,
 	getCostDashboardStats,
 	getDashboardStats,
 	getFolderStats,
 	getModelDashboardStats,
 	getOverviewStats,
 	getProviderDashboardStats,
+	getProviderWindowStats,
 	getRecentErrors,
 	getRecentRequests,
 	getRequestDetails,
 	getToolDashboardStats,
-	getTotalMessageCount,
-	syncAllSessions,
 } from "./aggregator";
 import { decodeEmbeddedClientArchive } from "./embedded-client";
 import embeddedClientArchiveTxt from "./embedded-client.generated.txt";
+import {
+	cancelFrustrationRun,
+	estimateFrustrationRun,
+	getFrustrationDashboardStats,
+	type StatsJudgeProvider,
+	setStatsJudgeProvider,
+	startFrustrationRun,
+} from "./frustration";
 import { getGainDashboardStats } from "./gain-aggregator";
+import { statsLive } from "./live";
 import {
 	prepareStatsPort,
 	recoverStatsPort,
@@ -30,6 +37,7 @@ import {
 	STATS_DASHBOARD_HOSTNAME_HEADER,
 	STATS_DASHBOARD_SECURITY_VERSION,
 } from "./port-conflict";
+import type { LiveStatus } from "./shared-types";
 import {
 	buildSessionTrace,
 	getTraceEntry,
@@ -145,15 +153,8 @@ async function getLatestMtime(dir: string): Promise<number> {
 const ensureClientBuild = async () => {
 	if (USE_EMBEDDED_CLIENT) return;
 	const indexPath = path.join(STATIC_DIR, "index.html");
-	const cssPath = path.join(STATIC_DIR, "styles.css");
-	const clientSourceMtime = await getLatestMtime(CLIENT_DIR);
-	const tailwindConfigPath = path.join(import.meta.dir, "..", "tailwind.config.js");
-	let tailwindConfigMtime = 0;
-	try {
-		const tailwindConfigStats = await fs.stat(tailwindConfigPath);
-		tailwindConfigMtime = tailwindConfigStats.mtimeMs;
-	} catch {}
-	const sourceMtime = Math.max(clientSourceMtime, tailwindConfigMtime);
+	const cssPath = path.join(STATIC_DIR, "index.css");
+	const sourceMtime = await getLatestMtime(CLIENT_DIR);
 	let shouldBuild = true;
 	try {
 		const [indexStats, cssStats] = await Promise.all([fs.stat(indexPath), fs.stat(cssPath)]);
@@ -173,7 +174,7 @@ const ensureClientBuild = async () => {
 
 	await fs.rm(STATIC_DIR, { recursive: true, force: true });
 
-	console.log("Building stats client...");
+	logger.debug("Building stats client");
 	const packageRoot = path.join(import.meta.dir, "..");
 	const buildResult = await $`bun run build.ts`.cwd(packageRoot).quiet().nothrow();
 	if (buildResult.exitCode !== 0) {
@@ -181,24 +182,15 @@ const ensureClientBuild = async () => {
 		const details = output ? `\n${output}` : "";
 		throw new Error(`Failed to build stats client (exit ${buildResult.exitCode})${details}`);
 	}
-
-	const indexHtml = `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AI Usage Statistics</title>
-    <link rel="stylesheet" href="styles.css">
-</head>
-<body>
-    <div id="root"></div>
-    <script src="index.js" type="module"></script>
-</body>
-</html>`;
-
-	await Bun.write(path.join(STATIC_DIR, "index.html"), indexHtml);
 };
 
+/**
+ * Required on every spending/mutating POST. A custom header forces a CORS
+ * preflight, which this server never approves, so a hostile page cannot
+ * trigger a paid judge run through a cross-site form or `fetch`.
+ */
+const STATS_ACTION_HEADER = "X-Omp-Stats-Action";
+
 /**
  * Handle API requests.
  */
@@ -206,9 +198,13 @@ export async function handleApi(req: Request): Promise<Response> {
 	const url = new URL(req.url);
 	const path = url.pathname;
 
-	// Stats reads are DB-only; explicit /api/sync does the expensive session scan.
+	// Stats reads are DB-only; ingest runs in the background (see `live.ts`).
 	const range = url.searchParams.get("range");
 
+	if (path === "/api/status") {
+		return Response.json(statsLive().status());
+	}
+
 	if (path === "/api/stats") {
 		const stats = await getDashboardStats(range);
 		return Response.json(stats);
@@ -229,16 +225,36 @@ export async function handleApi(req: Request): Promise<Response> {
 		return Response.json(stats);
 	}
 
-	if (path === "/api/stats/behavior") {
-		const stats = await getBehaviorDashboardStats(range);
+	if (path === "/api/stats/frustration") {
+		const stats = await getFrustrationDashboardStats(range);
 		return Response.json(stats);
 	}
 
+	if (path === "/api/frustration/estimate") {
+		const estimate = await estimateFrustrationRun(range);
+		return Response.json(estimate);
+	}
+
+	if (path === "/api/frustration/judge" || path === "/api/frustration/cancel") {
+		if (req.method !== "POST") return Response.json({ error: "POST required" }, { status: 405 });
+		if (req.headers.get(STATS_ACTION_HEADER) !== "1") {
+			return Response.json({ error: `${STATS_ACTION_HEADER}: 1 header required` }, { status: 403 });
+		}
+		if (path === "/api/frustration/cancel") return Response.json(cancelFrustrationRun());
+		const result = await startFrustrationRun(range);
+		if (!result.started) return Response.json({ error: result.error }, { status: result.status });
+		return Response.json(result.job, { status: 202 });
+	}
+
 	if (path === "/api/stats/tools") {
 		const stats = await getToolDashboardStats(range);
 		return Response.json(stats);
 	}
 
+	if (path === "/api/stats/provider-windows") {
+		return Response.json(await getProviderWindowStats(range, url.searchParams.get("provider")));
+	}
+
 	if (path === "/api/stats/providers") {
 		const stats = await getProviderDashboardStats(range);
 		return Response.json(stats);
@@ -280,9 +296,9 @@ export async function handleApi(req: Request): Promise<Response> {
 	}
 
 	if (path === "/api/sync") {
-		const result = await syncAllSessions();
-		const count = await getTotalMessageCount();
-		return Response.json({ ...result, totalMessages: count });
+		if (req.method !== "POST") return Response.json({ error: "POST required" }, { status: 405 });
+		statsLive().requestSync();
+		return Response.json(statsLive().status(), { status: 202 });
 	}
 
 	if (path === "/api/stats/gain") {
@@ -376,7 +392,7 @@ function createDashboardServer(port: number, hostname: string): Server<undefined
 	const server = Bun.serve({
 		port,
 		hostname,
-		async fetch(req) {
+		async fetch(req, server) {
 			const url = new URL(req.url);
 			const path = url.pathname;
 
@@ -391,6 +407,12 @@ function createDashboardServer(port: number, hostname: string): Server<undefined
 				return new Response(null, { headers: dashboardHeaders });
 			}
 
+			if (path === "/api/events") {
+				// Long-lived stream: exempt from the idle timeout.
+				server.timeout(req, 0);
+				return liveEventStream(dashboardHeaders);
+			}
+
 			try {
 				let response: Response;
 
@@ -411,7 +433,7 @@ function createDashboardServer(port: number, hostname: string): Server<undefined
 					headers,
 				});
 			} catch (error) {
-				console.error("Server error:", error);
+				logger.error("Stats dashboard request failed", { path, error: String(error) });
 				return Response.json(
 					{ error: error instanceof Error ? error.message : "Unknown error" },
 					{ status: 500, headers: dashboardHeaders },
@@ -422,6 +444,49 @@ function createDashboardServer(port: number, hostname: string): Server<undefined
 	return server;
 }
 
+/** Keep-alive comment cadence so proxies and the browser keep the stream open. */
+const EVENT_HEARTBEAT_MS = 15_000;
+
+/**
+ * Server-sent events of {@link LiveStatus}: the current status immediately,
+ * then every change (sync progress, data version bumps, indexing backlog).
+ */
+function liveEventStream(headers: Record<string, string>): Response {
+	const live = statsLive();
+	// Ingest starts when the first page connects, not when the server binds.
+	live.start();
+	const encoder = new TextEncoder();
+	let cleanup = () => {};
+	const stream = new ReadableStream<Uint8Array>({
+		start(controller) {
+			const send = (status: LiveStatus) => {
+				controller.enqueue(encoder.encode(`data: ${JSON.stringify(status)}\n\n`));
+			};
+			send(live.status());
+			const unsubscribe = live.subscribe(send);
+			const heartbeat = setInterval(
+				() => controller.enqueue(encoder.encode(": keep-alive\n\n")),
+				EVENT_HEARTBEAT_MS,
+			);
+			cleanup = () => {
+				unsubscribe();
+				clearInterval(heartbeat);
+			};
+		},
+		cancel() {
+			cleanup();
+		},
+	});
+	return new Response(stream, {
+		headers: {
+			...headers,
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+		},
+	});
+}
+
 /**
  * Start the HTTP server, reusing a live dashboard or reclaiming a stale omp listener.
  */
@@ -436,8 +501,20 @@ export interface StatsServerHandle {
 // the live handle: probing our own port can time out under load and would
 // then dead-end in the reclaim path's self-PID guard.
 const activeServers = new Map<string, StatsServerHandle>();
+/** Dashboards bound by this process (any port); background ingest stops when the last one does. */
+let liveServers = 0;
+
+export interface StartServerOptions {
+	/** Host judge for the Frustration dashboard's judge runs; replaces any previously registered one. */
+	judge?: StatsJudgeProvider;
+}
 
-export async function startServer(port = 3847, hostname = STATS_DASHBOARD_HOSTNAME): Promise<StatsServerHandle> {
+export async function startServer(
+	port = 3847,
+	hostname = STATS_DASHBOARD_HOSTNAME,
+	options: StartServerOptions = {},
+): Promise<StatsServerHandle> {
+	if (options.judge) setStatsJudgeProvider(options.judge);
 	const activeKey = `${hostname}:${port}`;
 	if (port !== 0) {
 		const active = activeServers.get(activeKey);
@@ -449,12 +526,18 @@ export async function startServer(port = 3847, hostname = STATS_DASHBOARD_HOSTNA
 		return { hostname, port, stop: () => {} };
 	}
 	const register = (server: Server<undefined>): StatsServerHandle => {
+		liveServers++;
+		let stopped = false;
 		const handle: StatsServerHandle = {
 			hostname,
 			port: server.port ?? port,
 			stop: () => {
 				activeServers.delete(activeKey);
-				server.stop();
+				server.stop(true);
+				if (stopped) return;
+				stopped = true;
+				// The last dashboard in this process takes background ingest down with it.
+				if (--liveServers === 0) statsLive().stop();
 			},
 		};
 		if (port !== 0) activeServers.set(activeKey, handle);

package/src/shared-types.ts

@@ -194,68 +194,95 @@ export interface AgentTypeStats {
 }
 
 /**
- * Behavior time-series point (daily bucket, per responding model).
+ * Frustration tallies over a set of user messages. Each message counts once,
+ * classified by its cached judge verdict when one exists, else by the regex
+ * behavior signals stored at ingest (see `frustration.ts` for both rules).
  */
-export interface BehaviorTimeSeriesPoint {
-	/** Bucket timestamp (start of day) */
-	timestamp: number;
-	/** Responding model ("unknown" if user msg never got a reply) */
-	model: string;
-	/** Responding provider */
-	provider: string;
-	/** Number of user messages in bucket */
+export interface FrustrationCounts {
+	/** User messages with non-empty prose. */
 	messages: number;
-	/** Total yelling sentences in bucket */
-	yelling: number;
-	/** Total profanity hits in bucket */
-	profanity: number;
-	/** Total anguish signal in bucket */
-	anguish: number;
-	/** Total corrective-negation hits in bucket */
-	negation: number;
-	/** Total user-repeating-themselves hits in bucket */
-	repetition: number;
-	/** Total second-person blame hits in bucket */
-	blame: number;
-	/** Total characters in bucket */
-	chars: number;
-}
-
-export interface BehaviorOverallStats {
-	totalMessages: number;
-	totalYelling: number;
-	totalProfanity: number;
-	totalAnguish: number;
-	totalNegation: number;
-	totalRepetition: number;
-	totalBlame: number;
-	totalChars: number;
-	firstTimestamp: number;
-	lastTimestamp: number;
+	/** Messages whose prose has a cached judge verdict; the rest use regex fallback. */
+	judged: number;
+	/** Annoyed at anything (the assistant, tooling, other people, ...). */
+	annoyed: number;
+	/** Annoyed and aimed at the assistant. Subset of `annoyed`. */
+	atAssistant: number;
+	/** Aimed at the assistant and hostile/angry. Subset of `atAssistant`. */
+	angry: number;
 }
 
 /**
- * Per-model behavioral aggregate over the active range.
+ * Frustration tallies for one model version. Provider/spelling variants of the
+ * same model (`claude-opus-4.6`, `anthropic/claude-opus-4-6`) merge under one
+ * catalog identity.
  */
-export interface BehaviorModelStats {
-	model: string;
-	provider: string;
-	totalMessages: number;
-	totalYelling: number;
-	totalProfanity: number;
-	totalAnguish: number;
-	totalNegation: number;
-	totalRepetition: number;
-	totalBlame: number;
-	totalChars: number;
-	lastTimestamp: number;
+export interface FrustrationModelStats extends FrustrationCounts {
+	/** Stable key: `class/family/revision` when classified, else the raw model id. */
+	key: string;
+	/** Display label, e.g. `opus 4.5`; the raw model id when unclassified. */
+	label: string;
+	/** Catalog identity class, e.g. `anthropic`; `unknown` when unclassified. */
+	modelClass: string;
+	/** Catalog family within the class, e.g. `opus`. */
+	family: string | null;
+	/** Canonical `major.minor.patch`, e.g. `4.5.0`. */
+	revision: string | null;
+	/** Raw model ids merged into this row. */
+	models: string[];
+	/** Earliest message timestamp (ms) in range. */
+	firstSeen: number;
 }
 
-export interface BehaviorDashboardStats {
-	overall: BehaviorOverallStats;
-	byModel: BehaviorModelStats[];
-	behaviorSeries: BehaviorTimeSeriesPoint[];
-}
+/** Lifecycle of the dashboard-host judge run that classifies unjudged messages. */
+export type FrustrationJobState = "idle" | "running" | "done" | "cancelled" | "failed";
+
+/** Progress of the (single, process-wide) frustration judge run. */
+export interface FrustrationJobStatus {
+	state: FrustrationJobState;
+	/** Unique prose texts queued for judgment. */
+	total: number;
+	/** Texts judged successfully. */
+	done: number;
+	/** Texts that exhausted their retries. */
+	failed: number;
+	/** Accumulated USD cost of every judge attempt, retries included. */
+	cost: number;
+	/** Judge label (`provider/model`) of the run, when known. */
+	judge: string | null;
+	/** Why the run failed; null otherwise. */
+	error: string | null;
+	startedAt: number | null;
+	finishedAt: number | null;
+	/** Judge requests the run currently keeps in flight (adapts to the judge's rate limits). */
+	concurrency: number;
+}
+
+/** Payload of `GET /api/stats/frustration`. */
+export interface FrustrationDashboardStats {
+	overall: FrustrationCounts;
+	/** Every model with messages in range, ordered by class, then revision, then family. */
+	byModel: FrustrationModelStats[];
+	/** Whether this dashboard host can run the judge (standalone `omp-stats` cannot). */
+	judgeAvailable: boolean;
+	job: FrustrationJobStatus;
+}
+
+/** Payload of `GET /api/frustration/estimate`: the pre-run cost quote shown before judging. */
+export type FrustrationEstimate =
+	| {
+			available: true;
+			/** Unique unjudged prose texts in range (identical messages share one verdict). */
+			messages: number;
+			/** Total prose characters sent. */
+			chars: number;
+			/** Estimated billed input tokens. */
+			inputTokens: number;
+			/** Estimated USD cost. */
+			cost: number;
+			/** Judge label (`provider/model`) the run will route to first. */
+			judge: string;
+	  }
+	| { available: false; reason: string };
 
 /** Token savings from a single source type. */
 export interface GainSourceTotals {
@@ -455,13 +482,50 @@ export interface ProviderWindowInsight {
 	exhaustedEvents: number;
 }
 
-/** Complete providers dashboard payload. */
+/** Ingest state of the dashboard host's background session sync. */
+export interface LiveSyncStatus {
+	phase: "idle" | "syncing" | "error";
+	/** Files completed in the running sync (0 when not yet known). */
+	current: number;
+	/** Files in the running sync's work set (0 while listing → indeterminate). */
+	total: number;
+	/** Rows inserted by the running (or last) sync. */
+	processed: number;
+	/** Wall-clock time the last sync finished, if any. */
+	lastSyncedAt: number | null;
+	/** Failure message of the last sync when `phase` is `"error"`. */
+	error: string | null;
+}
+
+/**
+ * Payload of every `GET /api/events` server-sent event (and `GET /api/status`).
+ * `version` increases whenever stored stats may have changed, so clients
+ * revalidate their queries when it moves.
+ */
+export interface LiveStatus {
+	version: number;
+	sync: LiveSyncStatus;
+	/** Hours whose rollups are still being (re)built; ranges covering them may be incomplete. */
+	indexingHours: number;
+}
+
+/** Providers dashboard payload: local request stats only (fast, DB-backed). */
 export interface ProviderDashboardStats {
 	providers: ProviderAggregate[];
 	hourly: ProviderHourlyPoint[];
 	series: ProviderTimeSeriesPoint[];
-	usageSeries: UsageWindowSeries[];
+}
+
+/**
+ * Subscription-window payload (`GET /api/stats/provider-windows`). Snapshots
+ * may come from the auth broker over the network, so it is fetched separately
+ * from {@link ProviderDashboardStats}. `usageSeries` only carries the
+ * requested provider's series (empty without a provider) — all of them can be
+ * thousands of series.
+ */
+export interface ProviderWindowStats {
 	windowInsights: ProviderWindowInsight[];
+	usageSeries: UsageWindowSeries[];
 }
 /**
  * One row of the Traces session list: a root session with every child

package/src/trace.ts

@@ -13,8 +13,9 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getBundledModel, type GeneratedProvider } from "@oh-my-pi/pi-catalog/models";
 import { getSessionsDir, isEnoent } from "@oh-my-pi/pi-utils";
-import { getSessionRollups, getToolCallCountsBySession, isScheduledCatalogModel } from "./db";
+import { initDb, isScheduledCatalogModel } from "./db";
 import { extractFolderFromPath, parseAllSessionEntries, resolveUsageTotal } from "./parser";
+import { getSessionRollups } from "./rollup";
 import type {
 	SessionEntry,
 	SessionSummary,
@@ -1069,17 +1070,22 @@ function basenameTimestamp(base: string): number | undefined {
 // poll is pure syscall churn. TTL is deliberately short so a just-created
 // session appears within seconds.
 let diskRootsMemo:
-	| { atMs: number; limit: number; roots: Array<{ file: string; mtimeMs: number; startedAt: number }> }
+	| {
+			atMs: number;
+			sessionsDir: string;
+			limit: number;
+			roots: Array<{ file: string; mtimeMs: number; startedAt: number }>;
+	  }
 	| undefined;
 const DISK_ROOTS_TTL_MS = 5_000;
 
 async function scanDiskRoots(limit: number): Promise<Array<{ file: string; mtimeMs: number; startedAt: number }>> {
 	const now = Date.now();
+	const sessionsDir = getSessionsDir();
 	const memo = diskRootsMemo;
-	if (memo && memo.limit >= limit && now - memo.atMs < DISK_ROOTS_TTL_MS) {
+	if (memo && memo.sessionsDir === sessionsDir && memo.limit >= limit && now - memo.atMs < DISK_ROOTS_TTL_MS) {
 		return memo.roots.slice(0, limit);
 	}
-	const sessionsDir = getSessionsDir();
 	let projects: string[] = [];
 	try {
 		projects = await fs.readdir(sessionsDir);
@@ -1111,7 +1117,7 @@ async function scanDiskRoots(limit: number): Promise<Array<{ file: string; mtime
 		}),
 	);
 	roots.sort((a, b) => b.mtimeMs - a.mtimeMs);
-	if (roots.length <= 1000) diskRootsMemo = { atMs: Date.now(), limit, roots };
+	if (roots.length <= 1000) diskRootsMemo = { atMs: Date.now(), sessionsDir, limit, roots };
 	return roots.slice(0, limit);
 }
 
@@ -1120,8 +1126,9 @@ async function scanDiskRoots(limit: number): Promise<Array<{ file: string; mtime
  * transcript (subagents, advisors) into its root row.
  */
 export async function listSessionSummaries(limit = 100, q?: string): Promise<SessionSummary[]> {
+	// The Traces page may be the first thing a dashboard serves.
+	await initDb();
 	const sessionsDir = getSessionsDir();
-	const toolCounts = getToolCallCountsBySession();
 	const byRoot = new Map<string, SummaryFold>();
 
 	for (const row of getSessionRollups()) {
@@ -1152,7 +1159,7 @@ export async function listSessionSummaries(limit = 100, q?: string): Promise<Ses
 			byRoot.set(rootFile, fold);
 		}
 		fold.requests += row.requests;
-		fold.toolCalls += toolCounts.get(row.sessionFile) ?? 0;
+		fold.toolCalls += row.toolCalls;
 		if (isChild) fold.subagents++;
 		if (row.startedAt < fold.startedAt) fold.startedAt = row.startedAt;
 		if (row.endedAt > fold.endedAt) fold.endedAt = row.endedAt;

package/src/types.ts

@@ -175,6 +175,10 @@ export interface UserMessageStats {
 	repetition: number;
 	/** Second-person reproach ("you didnt", "why did you", "stop X-ing") */
 	blame: number;
+	/** Judge-facing prose (see `judgeProse`); empty when the message was all markup. */
+	prose: string;
+	/** Hex `Bun.hash` of `prose`, keying the shared verdict cache; empty when `prose` is. */
+	proseHash: string;
 }
 
 /**

package/src/user-metrics.ts

@@ -611,6 +611,19 @@ function stripStructuredContent(text: string): string {
 		.replace(ANSI_ESCAPE_RE, "");
 }
 
+/** Cap on the judge-facing prose stored per user message; longer prose is truncated. */
+export const PROSE_MAX_CHARS = 4000;
+
+/**
+ * The prose a user message contributes to frustration judging: the same
+ * structured-content strip the regex signals score on, trimmed and capped at
+ * {@link PROSE_MAX_CHARS}. Empty when the message was nothing but markup.
+ */
+export function judgeProse(text: string): string {
+	const prose = stripStructuredContent(text.trim()).trim();
+	return prose.length > PROSE_MAX_CHARS ? prose.slice(0, PROSE_MAX_CHARS) : prose;
+}
+
 function countNonEmptyLines(text: string): number {
 	let count = 0;
 	for (const line of text.split("\n")) {