pi-mega-compact 0.14.0 → 0.15.0

package/extensions/dashboard-server/routes-cache.ts

@@ -13,7 +13,8 @@ import { createRequire } from "node:module";
 import type { IncomingMessage, ServerResponse } from "node:http";
 
 import type { RouteContext } from "./routes-core.js";
-import { computeCacheSavings } from "../../src/pricing.js";
+import { computeCacheSavings, lookupModelInputRate } from "../../src/pricing.js";
+import { costApiConfig, lookupCostApiPricing } from "../../src/costApi.js";
 
 // ---------------------------------------------------------------------------
 // handleProviderCache — "/api/provider-cache"
@@ -118,18 +119,29 @@ export function handleProviderCache(
 			} | null = null;
 			try {
 				const snap = latestModelSnapshot(stateDir); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
-				if (snap && snap.inputRate > 0) {
+				let rate = snap?.inputRate ?? 0;
+				let modelName = snap?.modelName ?? snap?.modelId ?? "unknown";
+				// Fallback chain: SQLite snapshot → local pricing table → cost API
+				if (rate <= 0 && modelName !== "unknown") {
+					rate = lookupModelInputRate(modelName) ?? 0;
+				}
+				if (rate <= 0 && costApiConfig().enabled && modelName !== "unknown") {
+					// guardrails-allow PREVENT-PI-004: cost API pricing lookup (user-opted-in)
+					const apiPricing = lookupCostApiPricing(modelName);
+					rate = apiPricing?.inputRate ?? 0;
+				}
+				if (rate > 0) {
 					const s = computeCacheSavings(
 						lifetime.totalCacheRead,
 						lifetime.totalCacheWrite,
-						snap.inputRate,
+						rate,
 					);
 					savings = {
 						cacheReadSaved: s.cacheReadSaved,
 						cacheWriteCost: s.cacheWriteCost,
 						netSaved: s.netSaved,
-						model: snap.modelName ?? snap.modelId ?? "unknown",
-						inputRate: snap.inputRate,
+						model: modelName,
+						inputRate: rate,
 					};
 				}
 			} catch {

package/extensions/dashboard-server/routes-game.ts

@@ -8,6 +8,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 
 import type { RouteContext } from "./routes-core.js";
 import type { GameMetric } from "../../src/game/scoring.js";
+import type { PerfKind } from "../../src/store/sqlite/perf-samples.js";
 
 // ---------------------------------------------------------------------------
 // handleGameState — "/api/game-state" (GET + PUT)
@@ -351,6 +352,77 @@ export function handlePerf(
 	return true;
 }
 
+// ---------------------------------------------------------------------------
+// handlePerfSamples — "/api/perf/samples"
+// ---------------------------------------------------------------------------
+
+export function handlePerfSamples(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	if (!req.url?.startsWith("/api/perf/samples")) return false;
+
+	const { stateDir } = ctx;
+
+	// /api/perf/samples — dashboard Perf tab chart drill-down. GET returns raw
+	// perf_samples for a single kind (?kind=<k>&minutes=<n>) ascending by ts so
+	// the client can render a time-series for any perf metric (turn_latency_ms,
+	// tps, disk_write_ms, cache_hit_pct, db_recompute_ms, etc.). `kind` is
+	// required and validated against the PERF_KINDS allow-list (400 on unknown);
+	// `minutes` defaults to 60 and is capped at 1440 (24h). Reads perf_samples
+	// via the same require()'d sqlite helper as /api/perf — no new SQLite code.
+	// Non-GET -> 405. PREVENT-PI-004: loopback.
+	const psReq = createRequire(import.meta.url);
+	const { readPerfSamples, PERF_KINDS } = psReq(
+		"../../src/store/sqlite.js",
+	) as typeof import("../../src/store/sqlite.js");
+	if (req.method !== "GET") {
+		res.writeHead(405, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.end(JSON.stringify({ error: "method_not_allowed" }));
+		return true;
+	}
+	try {
+		const url = new URL(req.url, "http://x"); // guardrails-allow PREVENT-PI-004: localhost dashboard URL base (loopback-only)
+		const kindParam = url.searchParams.get("kind") ?? "";
+		if (!(PERF_KINDS as readonly string[]).includes(kindParam)) {
+			res.writeHead(400, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+			res.end(JSON.stringify({ error: "unknown_kind", kind: kindParam }));
+			return true;
+		}
+		let minutes = Number(url.searchParams.get("minutes") ?? "60");
+		if (!Number.isFinite(minutes) || minutes <= 0) minutes = 60;
+		minutes = Math.min(minutes, 1440); // cap at 24h
+		const sinceTs = Date.now() - minutes * 60_000;
+		const kind = kindParam as PerfKind; // validated against PERF_KINDS above
+		const rows = readPerfSamples(stateDir, sinceTs, kind); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+		const samples = rows.map((r) => ({
+			ts: r.ts,
+			value: r.value,
+			...((r.meta != null && typeof r.meta === "object"
+				? { meta: JSON.stringify(r.meta) }
+				: r.meta != null
+					? { meta: String(r.meta) }
+					: {}) as { meta?: string }),
+		}));
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({
+				samples,
+				kind: kindParam,
+				minutes,
+				updatedAt: Date.now(),
+			}),
+		);
+	} catch (e) {
+		res.writeHead(500, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({ error: "perf_samples_unavailable", detail: String(e) }),
+		);
+	}
+	return true;
+}
+
 // ---------------------------------------------------------------------------
 // handleAchievements — "/api/achievements"
 // ---------------------------------------------------------------------------

package/extensions/dashboard-server/routes.ts

@@ -13,6 +13,7 @@ export {
 	handleGameState,
 	handleGameScores,
 	handlePerf,
+	handlePerfSamples,
 	handleAchievements,
 } from "./routes-game.js";
 export { handleEvents, handleSessions } from "./routes-sessions.js";

package/extensions/dashboard-server/server.ts

@@ -33,6 +33,7 @@ import {
 	handleGameState,
 	handleGameScores,
 	handlePerf,
+	handlePerfSamples,
 	handleAchievements,
 	handleSessions,
 	handleTopics,
@@ -247,6 +248,7 @@ export async function launchDashboardServer(
 		if (handleEvents(req, res, ctx)) return;
 		if (handleGameState(req, res, ctx)) return;
 		if (handleGameScores(req, res, ctx)) return;
+		if (handlePerfSamples(req, res, ctx)) return;
 		if (handlePerf(req, res, ctx)) return;
 		if (handleAchievements(req, res, ctx)) return;
 		if (handleSessions(req, res, ctx)) return;

package/extensions/mega-runtime/capture-model.ts

@@ -11,6 +11,7 @@ import { resolveRepoRoot } from "../mega-config.js";
 import { recordModelSnapshot, recordRepoModel } from "../../src/store/sqlite.js";
 import type { ModelSnapshot } from "../../src/store/sqlite.js";
 import { lookupModelInputRate } from "../../src/pricing.js";
+import { costApiConfig, lookupCostApiPricing } from "../../src/costApi.js";
 
 // ---------------------------------------------------------------------- types
 
@@ -45,13 +46,24 @@ export function captureModelImpl(ctx: CaptureModelContext, ectx: ExtensionContex
 	}
 	const modelId = m.id;
 	const fallbackInput = lookupModelInputRate(modelId);
+	let inputRate = m.cost?.input || fallbackInput || 0;
+	let outputRate = m.cost?.output ?? 0;
+	// Cost API last-resort fallback for models not in the local pricing table
+	if (inputRate <= 0 && costApiConfig().enabled) {
+		// guardrails-allow PREVENT-PI-004: cost API pricing lookup (user-opted-in)
+		const apiPricing = lookupCostApiPricing(modelId);
+		if (apiPricing) {
+			inputRate = apiPricing.inputRate ?? 0;
+			if (outputRate <= 0) outputRate = apiPricing.outputRate ?? 0;
+		}
+	}
 	const snap: Omit<ModelSnapshot, "capturedAt"> = {
 		provider: m.provider,
 		providerName,
 		modelId,
 		modelName: m.name ?? null,
-		inputRate: m.cost?.input || fallbackInput || 0,
-		outputRate: m.cost?.output ?? 0,
+		inputRate,
+		outputRate,
 		contextWindow: m.contextWindow ?? 0,
 		maxTokens: m.maxTokens ?? 0,
 		reasoning: !!m.reasoning,

package/extensions/mega-runtime/runtime-snapshot.ts

@@ -72,6 +72,9 @@ export interface RuntimeSnapshotContext extends RuntimeHelpersContext {
 	lastSnapshotSig: string | null;
 	lastWidgetCtx?: ExtensionContext;
 	lastActivityAt: number;
+	/** Timestamp (ms) of the last session heartbeat write. Used by the
+	 *  material-change gate fast path to refresh heartbeats on a cadence. */
+	lastHeartbeatAt: number;
 	lastLevel: number;
 	diagCtxFastGate: number;
 	diagLiveTrimFires: number;
@@ -117,6 +120,12 @@ export function snapshotImpl(
 	const sig = materialSigImpl(self);
 	if (ctx && self.widgetData && self.lastSnapshotSig === sig) {
 		self.renderWidget(ctx);
+		// Refresh heartbeat on a time cadence even when material state hasn't
+		// changed, so the session doesn't appear stale and get pruned by the
+		// dashboard's 30-min cutoff. The full snapshot recompute is still gated
+		// (expensive SQLite opens + writeFileSync), but a heartbeat row is
+		// cheap (single INSERT OR REPLACE on the index DB).
+		refreshHeartbeatIfStale(self, ctx, 10_000);
 		return;
 	}
 	const perfT0 = performance.now();
@@ -313,4 +322,35 @@ export function snapshotImpl(
 		/* non-fatal: perf instrumentation never blocks the agent */
 	}
 	self.lastSnapshotSig = sig;
+	self.lastHeartbeatAt = Date.now();
+}
+
+// ----------------------------------------------------------- heartbeat refresh
+
+/** Refresh the session heartbeat if enough time has elapsed since the last
+ *  write. Called from the material-change gate fast path (where the full
+ *  snapshot recompute is skipped) so the session stays visible in the
+ *  dashboard during idle/typing periods. Non-fatal — best-effort like the
+ *  main heartbeat write. */
+function refreshHeartbeatIfStale(
+	self: RuntimeSnapshotContext,
+	ctx: ExtensionContext | undefined,
+	intervalMs: number,
+): void {
+	const now = Date.now();
+	if (now - self.lastHeartbeatAt < intervalMs) return;
+	try {
+		const repo =
+			resolveRepoRoot(ctx?.cwd ?? self.currentStateDir) ?? self.currentStateDir;
+		recordSessionHeartbeat(
+			process.pid,
+			self.rt.sessionId,
+			repo,
+			self.currentStateDir,
+			self.lastCtxWindow || 0,
+		);
+		self.lastHeartbeatAt = now;
+	} catch {
+		/* non-fatal: heartbeat refresh must never block the snapshot path */
+	}
 }

package/extensions/mega-runtime/runtime.ts

@@ -209,6 +209,7 @@ export class MegaRuntime {
 	// (already-registered) widget factory is refreshed. Kills the per-event
 	// main-thread block during typing/idle streaming with no material change.
 	lastSnapshotSig: string | null = null;
+	lastHeartbeatAt: number = 0;
 	// v0.8.5: bumped whenever the cached game-state memo is evicted (bumpGameState
 	// for in-process /mega-game writes, the fs.watch callback for cross-process
 	// dashboard-server writes, and bindRepo on repo switch) so the snapshot gate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mega-compact",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Layered, local, vector-backed context compressor for pi — supersede/collapse/cluster compaction with deduped inline recall.",
   "type": "module",
   "license": "BSD-3-Clause",