@oh-my-pi/omp-stats 18.0.10 → 18.1.0

package/src/client/traces/time-scale.ts

@@ -0,0 +1,250 @@
+/**
+ * Virtual time axis for the trace flamegraph.
+ *
+ * All three axis modes are piecewise-linear monotonic maps over global wall
+ * time, so cross-track alignment is preserved in every mode:
+ * - `time`: identity, or idle-compressed (long gaps collapse to fixed bridges)
+ * - `turns`: each main-track turn interval gets equal virtual width
+ * - `calls`: each interval between consecutive span boundaries gets equal width
+ */
+
+import type { TraceTrack } from "../types";
+
+export type AxisMode = "time" | "turns" | "calls";
+
+export interface TraceScale {
+	/** ms epoch → virtual axis; monotonic non-decreasing. */
+	toU(t: number): number;
+	/** Inverse (clamped to domain). */
+	toT(u: number): number;
+	/** Virtual axis domain. */
+	domain: [number, number];
+	/** Idle bridges (time mode + compression): real gap [t0,t1] at virtual uMid. */
+	gaps: Array<{ t0: number; t1: number; uMid: number }>;
+}
+
+/** Padding added around activity segments before gap detection (ms). */
+const ACTIVITY_PAD_MS = 2000;
+/** Gaps longer than this get compressed (ms). */
+const GAP_THRESHOLD_MS = 30_000;
+/** Fixed virtual width of a compressed gap bridge (virtual ms). */
+const GAP_BRIDGE_U = 8000;
+
+/** Piecewise-linear map defined by matched breakpoints (t ascending, u non-decreasing). */
+function piecewise(tPoints: number[], uPoints: number[]): TraceScale {
+	const n = tPoints.length;
+	const domain: [number, number] = [uPoints[0], uPoints[n - 1]];
+
+	const segmentAt = (points: number[], value: number): number => {
+		// Binary search for the last breakpoint <= value.
+		let lo = 0;
+		let hi = n - 1;
+		while (lo < hi) {
+			const mid = (lo + hi + 1) >> 1;
+			if (points[mid] <= value) lo = mid;
+			else hi = mid - 1;
+		}
+		return Math.min(lo, n - 2);
+	};
+
+	return {
+		toU(t: number): number {
+			if (t <= tPoints[0]) return uPoints[0];
+			if (t >= tPoints[n - 1]) return uPoints[n - 1];
+			const i = segmentAt(tPoints, t);
+			const tSpan = tPoints[i + 1] - tPoints[i];
+			if (tSpan <= 0) return uPoints[i];
+			return uPoints[i] + ((t - tPoints[i]) / tSpan) * (uPoints[i + 1] - uPoints[i]);
+		},
+		toT(u: number): number {
+			if (u <= uPoints[0]) return tPoints[0];
+			if (u >= uPoints[n - 1]) return tPoints[n - 1];
+			const i = segmentAt(uPoints, u);
+			const uSpan = uPoints[i + 1] - uPoints[i];
+			if (uSpan <= 0) return tPoints[i];
+			return tPoints[i] + ((u - uPoints[i]) / uSpan) * (tPoints[i + 1] - tPoints[i]);
+		},
+		domain,
+		gaps: [],
+	};
+}
+
+/** All span intervals across tracks, sorted by start. */
+function collectIntervals(tracks: TraceTrack[]): Array<[number, number]> {
+	const intervals: Array<[number, number]> = [];
+	for (const track of tracks) {
+		for (const span of track.spans) intervals.push([span.start, span.end]);
+	}
+	intervals.sort((a, b) => a[0] - b[0]);
+	return intervals;
+}
+
+/** Trace time bounds across all spans (falls back to [0, 1]). */
+function traceBounds(tracks: TraceTrack[]): [number, number] {
+	let min = Number.POSITIVE_INFINITY;
+	let max = Number.NEGATIVE_INFINITY;
+	for (const track of tracks) {
+		for (const span of track.spans) {
+			if (span.start < min) min = span.start;
+			if (span.end > max) max = span.end;
+		}
+	}
+	if (!Number.isFinite(min)) return [0, 1];
+	return [min, Math.max(max, min + 1)];
+}
+
+/** Equal-virtual-width map over consecutive anchor times. */
+function equalWidthScale(anchors: number[], tMin: number, tMax: number): TraceScale {
+	const unique = [...new Set(anchors.filter(t => t >= tMin && t <= tMax))].sort((a, b) => a - b);
+	if (unique[0] !== tMin) unique.unshift(tMin);
+	if (unique[unique.length - 1] !== tMax) unique.push(tMax);
+	if (unique.length < 2) return piecewise([tMin, tMax], [tMin, tMax]);
+	// Keep the virtual domain the same length as the real one so zoom math is
+	// scale-independent; each anchor interval gets an equal slice of it.
+	const total = tMax - tMin;
+	const step = total / (unique.length - 1);
+	const uPoints = unique.map((_, i) => tMin + i * step);
+	return piecewise(unique, uPoints);
+}
+
+/** Idle-compressed time scale: activity segments identity, long gaps bridged. */
+function compressedTimeScale(tracks: TraceTrack[], tMin: number, tMax: number): TraceScale {
+	const intervals = collectIntervals(tracks);
+	// Merge padded activity intervals into segments.
+	const segments: Array<[number, number]> = [];
+	for (const [s, e] of intervals) {
+		const start = s - ACTIVITY_PAD_MS;
+		const end = e + ACTIVITY_PAD_MS;
+		const last = segments[segments.length - 1];
+		if (last && start <= last[1]) {
+			if (end > last[1]) last[1] = end;
+		} else {
+			segments.push([start, end]);
+		}
+	}
+	if (segments.length === 0) segments.push([tMin, tMax]);
+	// Clamp to the trace bounds.
+	segments[0][0] = Math.max(segments[0][0], tMin);
+	segments[segments.length - 1][1] = Math.min(
+		Math.max(segments[segments.length - 1][1], segments[segments.length - 1][0]),
+		tMax,
+	);
+
+	const tPoints: number[] = [];
+	const uPoints: number[] = [];
+	const gaps: TraceScale["gaps"] = [];
+	let u = segments[0][0];
+	for (let i = 0; i < segments.length; i++) {
+		const [s, e] = segments[i];
+		if (i === 0) {
+			tPoints.push(s);
+			uPoints.push(u);
+		} else {
+			const prevEnd = segments[i - 1][1];
+			const gap = s - prevEnd;
+			if (gap > GAP_THRESHOLD_MS) {
+				u += GAP_BRIDGE_U;
+				gaps.push({ t0: prevEnd, t1: s, uMid: u - GAP_BRIDGE_U / 2 });
+			} else {
+				u += gap;
+			}
+			tPoints.push(s);
+			uPoints.push(u);
+		}
+		u += Math.max(0, e - s);
+		tPoints.push(e);
+		uPoints.push(u);
+	}
+	const scale = piecewise(tPoints, uPoints);
+	return { ...scale, gaps };
+}
+
+/** Build the axis map for the given mode over all tracks. */
+export function buildScale(tracks: TraceTrack[], mode: AxisMode, compressIdle: boolean): TraceScale {
+	const [tMin, tMax] = traceBounds(tracks);
+
+	if (mode === "turns") {
+		const main = tracks.find(track => track.id === "main");
+		const anchors = (main?.spans ?? []).filter(span => span.kind === "turn").map(span => span.start);
+		return equalWidthScale(anchors, tMin, tMax);
+	}
+	if (mode === "calls") {
+		const anchors: number[] = [];
+		for (const track of tracks) {
+			for (const span of track.spans) {
+				if (span.kind === "model" || span.kind === "tool" || span.kind === "background") {
+					anchors.push(span.start, span.end);
+				}
+			}
+		}
+		return equalWidthScale(anchors, tMin, tMax);
+	}
+	if (compressIdle) return compressedTimeScale(tracks, tMin, tMax);
+	return piecewise([tMin, tMax], [tMin, tMax]);
+}
+
+export interface Tick {
+	u: number;
+	label: string;
+	major: boolean;
+}
+
+/** Target pixel spacing between ticks. */
+const TICK_TARGET_PX = 90;
+
+/** Round a raw step up to a "nice" 1/2/5 × 10ⁿ ms step. */
+function niceStep(raw: number): number {
+	const pow = 10 ** Math.floor(Math.log10(Math.max(raw, 1)));
+	for (const mult of [1, 2, 5, 10]) {
+		if (pow * mult >= raw) return pow * mult;
+	}
+	return pow * 10;
+}
+
+function formatWallClock(t: number): string {
+	const date = new Date(t);
+	const hh = String(date.getHours()).padStart(2, "0");
+	const mm = String(date.getMinutes()).padStart(2, "0");
+	const ss = String(date.getSeconds()).padStart(2, "0");
+	return `${hh}:${mm}:${ss}`;
+}
+
+/** Offset label from trace start: `+mm:ss.mmm`, hours prepended when needed. */
+export function formatOffset(deltaMs: number): string {
+	const sign = deltaMs < 0 ? "-" : "+";
+	const abs = Math.abs(deltaMs);
+	const hours = Math.floor(abs / 3_600_000);
+	const minutes = Math.floor((abs % 3_600_000) / 60_000);
+	const seconds = Math.floor((abs % 60_000) / 1000);
+	const millis = Math.floor(abs % 1000);
+	const withMs = abs % 1000 !== 0;
+	const mmss = `${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}${withMs ? "." : ""}${withMs ? String(millis).padStart(3, "0") : ""}`;
+	return hours > 0 ? `${sign}${hours}:${mmss}` : `${sign}${mmss}`;
+}
+
+/**
+ * Ruler ticks inside `[u0, u1]`. Ticks are placed at nice wall-time steps in
+ * the underlying t-space (per linear segment in compressed/sequence modes),
+ * with major ticks labelled as local wall clock and minors as offsets.
+ */
+export function buildTicks(scale: TraceScale, u0: number, u1: number, widthPx: number): Tick[] {
+	const uSpan = u1 - u0;
+	if (uSpan <= 0 || widthPx <= 0) return [];
+	const ticks: Tick[] = [];
+	const d0 = scale.domain[0];
+	// Nice step in u-space (u is virtual milliseconds).
+	const step = niceStep((uSpan * TICK_TARGET_PX) / widthPx);
+	// Anchor the grid to the trace start so offset labels come out round.
+	const first = d0 + Math.ceil((u0 - d0) / step) * step;
+	let count = 0;
+	for (let u = first; u <= u1 && count < 200; u += step, count++) {
+		const t = scale.toT(u);
+		const major = Math.round((u - d0) / step) % 5 === 0;
+		ticks.push({
+			u,
+			label: major ? formatWallClock(t) : formatOffset(u - d0),
+			major,
+		});
+	}
+	return ticks;
+}

package/src/client/traces/trace-colors.ts

@@ -0,0 +1,77 @@
+/**
+ * Category palette + canvas chrome tokens for the trace flamegraph, keyed by
+ * resolved theme. Hues align with the dashboard chip palette; chrome tokens
+ * mirror `CHART_THEMES` so the canvas matches the chart.js surfaces.
+ */
+
+import type { TraceSpanKind } from "../types";
+
+export interface TraceTheme {
+	/** Span fill per category. */
+	category: Record<TraceSpanKind, string>;
+	/** Error fill tint + left-edge accent. */
+	error: string;
+	/** Marker diamond fill. */
+	marker: string;
+	/** Alternating turn-band fill. */
+	turnBand: string;
+	/** Canvas background. */
+	surface: string;
+	/** Ruler/lane hairlines. */
+	grid: string;
+	/** Ruler tick labels. */
+	tick: string;
+	/** Span label text drawn inside blocks. */
+	spanText: string;
+	/** Selection outline (brand cyan focus ring). */
+	selection: string;
+	tooltipBackground: string;
+	tooltipTitle: string;
+	tooltipBody: string;
+	tooltipBorder: string;
+}
+
+export const TRACE_THEMES: Record<"dark" | "light", TraceTheme> = {
+	dark: {
+		category: {
+			turn: "#34d399",
+			model: "#a78bfa",
+			tool: "#fbbf24",
+			subagent: "#38bdf8",
+			background: "#94a3b8",
+		},
+		error: "#f87171",
+		marker: "#facc15",
+		turnBand: "rgba(255, 255, 255, 0.035)",
+		surface: "transparent",
+		grid: "rgba(255, 255, 255, 0.06)",
+		tick: "#867a93",
+		spanText: "#16121c",
+		selection: "#5ad8e6",
+		tooltipBackground: "#241a2e",
+		tooltipTitle: "#eae5ef",
+		tooltipBody: "#a89fb3",
+		tooltipBorder: "rgba(255, 255, 255, 0.12)",
+	},
+	light: {
+		category: {
+			turn: "#059669",
+			model: "#7c3aed",
+			tool: "#d97706",
+			subagent: "#0284c7",
+			background: "#64748b",
+		},
+		error: "#ef4444",
+		marker: "#ca8a04",
+		turnBand: "rgba(0, 0, 0, 0.04)",
+		surface: "transparent",
+		grid: "rgba(20, 12, 28, 0.08)",
+		tick: "#6a6275",
+		spanText: "#ffffff",
+		selection: "#0e7490",
+		tooltipBackground: "#ffffff",
+		tooltipTitle: "#241a2e",
+		tooltipBody: "#5a5462",
+		tooltipBorder: "rgba(20, 12, 28, 0.15)",
+	},
+};

package/src/db.ts

@@ -18,6 +18,7 @@ import type {
 	BehaviorOverallStats,
 	BehaviorTimeSeriesPoint,
 	CostTimeSeriesPoint,
+	DailyActivityPoint,
 	FolderStats,
 	MessageStats,
 	ModelPerformancePoint,
@@ -1150,6 +1151,47 @@ export function getMessageById(id: number): MessageStats | null {
 	const row = stmt.get(id);
 	return row ? rowToMessageStats(row) : 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;
+	/** Comma-joined DISTINCT models. */
+	models: string;
+}
+
+/** Aggregate every synced transcript file into one row (subagents unfolded). */
+export function getSessionRollups(): SessionRollupRow[] {
+	if (!db) return [];
+	const stmt = db.prepare(`
+		SELECT session_file AS sessionFile,
+		       COUNT(*) AS requests,
+		       MIN(timestamp) AS startedAt,
+		       MAX(timestamp + COALESCE(duration, 0)) AS endedAt,
+		       SUM(total_tokens) AS totalTokens,
+		       SUM(cost_total) AS costTotal,
+		       GROUP_CONCAT(DISTINCT model) AS models
+		FROM messages
+		GROUP BY session_file
+	`);
+	return stmt.all() as SessionRollupRow[];
+}
+
+/** Tool-call counts keyed by transcript file, for the Traces session list. */
+export function getToolCallCountsBySession(): Map<string, number> {
+	const counts = new Map<string, number>();
+	if (!db) return counts;
+	const stmt = db.prepare(
+		"SELECT session_file AS sessionFile, COUNT(*) AS calls FROM tool_calls GROUP BY session_file",
+	);
+	for (const row of stmt.all() as Array<{ sessionFile: string; calls: number }>) {
+		counts.set(row.sessionFile, row.calls);
+	}
+	return counts;
+}
 
 /**
  * Get daily cost time series data for the last N days, broken down by model.
@@ -1193,6 +1235,41 @@ export function getCostTimeSeries(days = 90, cutoff?: number | null): CostTimeSe
 	}));
 }
 
+/**
+ * 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
+ * can query without the dashboard server's init flow. Days use the machine's
+ * timezone — this is a localhost tool, same rationale as
+ * {@link getProviderHourlyBurn}.
+ */
+export async function getDailyActivity(days = 371): Promise<DailyActivityPoint[]> {
+	const database = await initDb();
+	const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+	const stmt = database.prepare(`
+		SELECT
+			date(timestamp / 1000, 'unixepoch', 'localtime') as day,
+			SUM(cost_total) as cost,
+			COUNT(*) as requests,
+			SUM(total_tokens) as total_tokens
+		FROM messages
+		WHERE timestamp >= ?
+		GROUP BY day
+		ORDER BY day ASC
+	`);
+	const rows = stmt.all(cutoff) as Array<{
+		day: string;
+		cost: number | null;
+		requests: number;
+		total_tokens: number | null;
+	}>;
+	return rows.map(row => ({
+		day: row.day,
+		cost: row.cost ?? 0,
+		requests: row.requests,
+		totalTokens: row.total_tokens ?? 0,
+	}));
+}
+
 /**
  * Reset `file_offsets` (and any existing `user_messages` rows) so the next
  * successful sync re-parses every session and re-derives behavioral metrics.

package/src/index.ts

@@ -18,12 +18,7 @@ export {
 export { closeDb } from "./db";
 export { getGainDashboardStats } from "./gain-aggregator";
 export { formatStatsDashboardUrl, startServer } from "./server";
-export type {
-	GainDashboardStats,
-	GainSource,
-	GainSourceTotals,
-	GainTimeSeriesPoint,
-} from "./shared-types";
+export type { GainDashboardStats, GainSource, GainSourceTotals, GainTimeSeriesPoint } from "./shared-types";
 export type {
 	AggregatedStats,
 	DashboardStats,

package/src/parser.ts

@@ -10,12 +10,14 @@ import {
 	type ToolResultMessage,
 	type Usage,
 } from "@oh-my-pi/pi-ai";
+import { classifyModel } from "@oh-my-pi/pi-catalog/compat/taxonomy";
 import { getSessionsDir, isEnoent, readLines } from "@oh-my-pi/pi-utils";
 import type {
 	AgentType,
 	MessageStats,
 	SessionEntry,
 	SessionMessageEntry,
+	SessionModelUsageEntry,
 	SessionServiceTierChangeEntry,
 	ToolCallStats,
 	ToolResultLink,
@@ -52,7 +54,7 @@ export function classifyAgentType(sessionPath: string): AgentType {
  * Session files are named like: --work--pi--/timestamp_uuid.jsonl
  * The folder part uses -- as path separator.
  */
-function extractFolderFromPath(sessionPath: string): string {
+export function extractFolderFromPath(sessionPath: string): string {
 	const sessionsDir = getSessionsDir();
 	const rel = path.relative(sessionsDir, sessionPath);
 	const projectDir = rel.split(path.sep)[0];
@@ -73,6 +75,12 @@ function isAssistantMessage(entry: SessionEntry): entry is SessionMessageEntry {
 	return msgEntry.message?.role === "assistant";
 }
 
+function isModelUsage(entry: SessionEntry): entry is SessionModelUsageEntry {
+	if (entry.type !== "model_usage") return false;
+	const usageEntry = entry as SessionModelUsageEntry;
+	return typeof usageEntry.id === "string" && usageEntry.id.length > 0;
+}
+
 /**
  * Check if an entry is a user message (non-toolResult).
  */
@@ -173,7 +181,11 @@ function extractStats(
 	// non-zero value already in `usage.premiumRequests` (Copilot multipliers or
 	// the new AI code path) and only synthesise when the field is missing/zero.
 	const recorded = rawUsage.premiumRequests ?? 0;
-	const model = { provider: msg.provider, api: msg.api, id: msg.model };
+	const model = {
+		provider: msg.provider,
+		api: msg.api,
+		identity: classifyModel(msg.provider, msg.model, { lenient: true }),
+	};
 	const tier = resolveModelServiceTier(currentServiceTier, model);
 	const derived = recorded > 0 ? recorded : getPriorityPremiumRequests(tier, model);
 	const wellFormed =
@@ -215,6 +227,38 @@ function extractStats(
 	};
 }
 
+function extractModelUsageStats(
+	sessionFile: string,
+	folder: string,
+	entry: SessionModelUsageEntry,
+	agentType: AgentType,
+): MessageStats | null {
+	const timestamp = Date.parse(entry.timestamp);
+	return extractStats(
+		sessionFile,
+		folder,
+		{
+			type: "message",
+			id: entry.id,
+			parentId: entry.parentId,
+			timestamp: entry.timestamp,
+			message: {
+				role: "assistant",
+				content: [],
+				api: entry.api,
+				provider: entry.provider,
+				model: entry.model,
+				usage: entry.usage,
+				stopReason: entry.stopReason ?? "stop",
+				errorMessage: entry.errorMessage,
+				timestamp: Number.isFinite(timestamp) ? timestamp : 0,
+			},
+		},
+		undefined,
+		agentType,
+	);
+}
+
 /** Message timestamp, falling back to the entry's ISO timestamp, then 0. */
 function coerceEntryTimestamp(timestamp: number | undefined, entry: SessionMessageEntry): number {
 	if (typeof timestamp === "number" && Number.isFinite(timestamp)) return timestamp;
@@ -336,6 +380,10 @@ function parseSessionEntriesLenient(bytes: Uint8Array): { entries: SessionEntry[
 	const read = visitSessionEntriesLenient(bytes, entry => entries.push(entry));
 	return { entries, read };
 }
+/** Parse every well-formed entry in a transcript buffer (malformed lines skipped). */
+export function parseAllSessionEntries(bytes: Uint8Array): SessionEntry[] {
+	return parseSessionEntriesLenient(bytes).entries;
+}
 
 function scanLastServiceTier(bytes: Uint8Array): ServiceTierByFamily | undefined {
 	let currentServiceTier: ServiceTierByFamily | undefined;
@@ -411,6 +459,11 @@ export async function parseSessionFile(sessionPath: string, fromOffset = 0): Pro
 			if (link) toolResults.push(link);
 			continue;
 		}
+		if (isModelUsage(entry)) {
+			const modelUsageStats = extractModelUsageStats(sessionPath, folder, entry, agentType);
+			if (modelUsageStats) stats.push(modelUsageStats);
+			continue;
+		}
 		if (isAssistantMessage(entry)) {
 			const msgStats = extractStats(sessionPath, folder, entry, currentServiceTier, agentType);
 			if (msgStats) stats.push(msgStats);

package/src/server.ts

@@ -3,7 +3,7 @@ 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 { $ } from "bun";
+import { $, type Server } from "bun";
 import {
 	getBehaviorDashboardStats,
 	getCostDashboardStats,
@@ -30,6 +30,7 @@ import {
 	STATS_DASHBOARD_HOSTNAME_HEADER,
 	STATS_DASHBOARD_SECURITY_VERSION,
 } from "./port-conflict";
+import { buildSessionTrace, getTraceEntry, listSessionSummaries, TRACE_ETAG_VERSION, TracePathError } from "./trace";
 
 const EMBEDDED_CLIENT_ARCHIVE = decodeEmbeddedClientArchive(embeddedClientArchiveTxt);
 
@@ -282,6 +283,41 @@ export async function handleApi(req: Request): Promise<Response> {
 		const stats = await getGainDashboardStats(range, project);
 		return Response.json(stats);
 	}
+	if (path === "/api/sessions") {
+		const limitParam = Number(url.searchParams.get("limit") ?? "100");
+		const limit = Number.isFinite(limitParam) && limitParam > 0 ? Math.floor(limitParam) : 100;
+		const q = url.searchParams.get("q") ?? undefined;
+		return Response.json(await listSessionSummaries(limit, q));
+	}
+
+	if (path === "/api/session/trace") {
+		const file = url.searchParams.get("file");
+		if (!file) return Response.json({ error: "file required" }, { status: 400 });
+		try {
+			const trace = await buildSessionTrace(file);
+			const etag = `"${TRACE_ETAG_VERSION}:${trace.mtimeMs}"`;
+			if (req.headers.get("if-none-match") === etag) return new Response(null, { status: 304 });
+			return Response.json(trace, { headers: { ETag: etag } });
+		} catch (err) {
+			if (err instanceof TracePathError) return Response.json({ error: err.message }, { status: 400 });
+			if (isEnoent(err)) return Response.json({ error: "session not found" }, { status: 404 });
+			throw err;
+		}
+	}
+
+	if (path === "/api/session/entry") {
+		const file = url.searchParams.get("file");
+		const id = url.searchParams.get("id");
+		if (!file || !id) return Response.json({ error: "file and id required" }, { status: 400 });
+		try {
+			const entry = await getTraceEntry(file, id);
+			if (!entry) return Response.json({ error: "entry not found" }, { status: 404 });
+			return Response.json({ entry });
+		} catch (err) {
+			if (err instanceof TracePathError) return Response.json({ error: err.message }, { status: 400 });
+			throw err;
+		}
+	}
 
 	return new Response("Not Found", { status: 404 });
 }
@@ -314,7 +350,7 @@ export function formatStatsDashboardUrl(hostname: string, port: number): string
 	return `http://${urlHostname}:${port}`;
 }
 
-function createDashboardServer(port: number, hostname: string) {
+function createDashboardServer(port: number, hostname: string): Server<undefined> {
 	const server = Bun.serve({
 		port,
 		hostname,
@@ -367,23 +403,44 @@ function createDashboardServer(port: number, hostname: string) {
 /**
  * Start the HTTP server, reusing a live dashboard or reclaiming a stale omp listener.
  */
-export async function startServer(
-	port = 3847,
-	hostname = STATS_DASHBOARD_HOSTNAME,
-): Promise<{ hostname: string; port: number; stop: () => void }> {
+export interface StatsServerHandle {
+	hostname: string;
+	port: number;
+	stop: () => void;
+}
+
+// Dashboards this process already bound, keyed by requested `hostname:port`.
+// A second in-process start (e.g. `/trace` twice in one session) must return
+// 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>();
+
+export async function startServer(port = 3847, hostname = STATS_DASHBOARD_HOSTNAME): Promise<StatsServerHandle> {
+	const activeKey = `${hostname}:${port}`;
+	if (port !== 0) {
+		const active = activeServers.get(activeKey);
+		if (active) return active;
+	}
 	await ensureClientBuild();
 	const preparation = await prepareStatsPort(port, hostname);
 	if (preparation === "reuse") {
 		return { hostname, port, stop: () => {} };
 	}
-
-	try {
-		const server = createDashboardServer(port, hostname);
-		return {
+	const register = (server: Server<undefined>): StatsServerHandle => {
+		const handle: StatsServerHandle = {
 			hostname,
 			port: server.port ?? port,
-			stop: () => server.stop(),
+			stop: () => {
+				activeServers.delete(activeKey);
+				server.stop();
+			},
 		};
+		if (port !== 0) activeServers.set(activeKey, handle);
+		return handle;
+	};
+
+	try {
+		return register(createDashboardServer(port, hostname));
 	} catch (error) {
 		if (!(error instanceof Error && "code" in error && error.code === "EADDRINUSE")) throw error;
 
@@ -393,12 +450,7 @@ export async function startServer(
 		}
 
 		try {
-			const server = createDashboardServer(port, hostname);
-			return {
-				hostname,
-				port: server.port ?? port,
-				stop: () => server.stop(),
-			};
+			return register(createDashboardServer(port, hostname));
 		} catch (retryError) {
 			throw new Error(`Failed to start stats dashboard on ${hostname}:${port} after reclaiming it.`, {
 				cause: retryError,