pi-mega-compact 0.11.2 → 0.11.3

package/extensions/dashboard-server/api-contracts/endpoints.ts

@@ -14,6 +14,7 @@ import type { SnapshotResponse } from "./snapshot.js";
 import type { IndexesIndexRow, IndexesSummaryResponse } from "./multi-repo.js";
 import type { GameStateResponse } from "./game.js";
 import type { SseEvent } from "./index.js";
+import type { ProviderCacheResponse } from "./provider-cache.js";
 import type {
 	TurnsResponse,
 	ConversationTurnsResponse,
@@ -26,6 +27,13 @@ import type {
 	TopicMemoriesResponse,
 } from "./turns.js";
 
+import type {
+	DbStatsResponse,
+	MaintenanceActionResult,
+	MaintenanceAction,
+	SchemaHealthResponse,
+} from "./maintenance.js";
+
 import type {
 	GameScoreRow,
 	GameScoresQuery,
@@ -56,13 +64,6 @@ export type {
 	TopicDetailResponse,
 } from "./game-types.js";
 
-import type {
-	DbStatsResponse,
-	MaintenanceActionResult,
-	MaintenanceAction,
-	SchemaHealthResponse,
-} from "./maintenance.js";
-
 // ─── New Response Types (inline) ───────────────────────────────────────────
 
 /**
@@ -247,6 +248,15 @@ export interface ServerEntry {
 	} | null;
 	/** ISO timestamp of the live snapshot, or null. Present when a live snapshot has updatedAt. */
 	readonly updatedAt?: string | null;
+	/** Provider prompt-cache lifetime aggregates for this repo, or null when unavailable. */
+	readonly providerCache?: {
+		readonly avgHitPct: number;
+		readonly cacheRead: number;
+		readonly cacheWrite: number;
+		readonly totalInput: number;
+		readonly sampleCount: number;
+		readonly estimatedSaved: number | null;
+	} | null;
 }
 
 /**
@@ -352,6 +362,8 @@ export interface PerfResponse {
 	readonly diag: PerfDiag | null;
 }
 
+// ─── Provider Cache Lifetime (A.2) — see provider-cache.ts ─────────────────
+
 // ─── Game Score & Achievement Types ─────────────────────────────────────────
 // (moved to game-types.ts; re-exported for backwards compatibility)
 
@@ -367,7 +379,7 @@ export interface PerfResponse {
 // ─── ENDPOINTS Registry ─────────────────────────────────────────────────────
 
 /**
- * Central registry of all 13 dashboard API endpoints. Each entry is an
+ * Central registry of all 14 dashboard API endpoints. Each entry is an
  * `EndpointDef` or `SseEndpointDef` instance serving as the single source of
  * truth for route paths, methods, descriptions, and typed request/response
  * contracts.
@@ -583,4 +595,15 @@ export const ENDPOINTS = {
 		path: "/api/maintenance/action",
 		description: "Run vacuum, checkpoint, reindex, fts5-rebuild, reconcile-dedup, prune, or integrity-check.",
 	} as const satisfies EndpointDef<"POST", MaintenanceAction, MaintenanceActionResult>,
+
+	// ─── Provider Cache (Sprint A.2) ─────────────────────────────────
+
+	/** GET /api/provider-cache — Lifetime provider prompt cache aggregates + $ savings. */
+	providerCache: {
+		method: "GET",
+		path: "/api/provider-cache",
+		description:
+			"Lifetime provider prompt cache hit-rate aggregates + dollar savings estimate.",
+	} as const satisfies EndpointDef<"GET", undefined, ProviderCacheResponse>,
+
 } as const;

package/extensions/dashboard-server/api-contracts/index.ts

@@ -144,6 +144,10 @@ export type {
 	TopicsResponse,
 	TopicDetailResponse,
 } from "./endpoints.js";
+export type {
+	ProviderCacheSavings,
+	ProviderCacheResponse,
+} from "./provider-cache.js";
 
 export { ENDPOINTS } from "./endpoints.js";
 

package/extensions/dashboard-server/api-contracts/multi-repo.ts

@@ -172,6 +172,12 @@ export interface IndexesIndexRow {
   maxTokens: number | null;
   /** Whether reasoning/extended-thinking mode is enabled, or `null` if not configured. */
   reasoning: boolean | null;
+  /** Lifetime provider prompt-cache hit percentage, or `null` if no samples. */
+  providerCachePct: number | null;
+  /** Lifetime provider prompt-cache read tokens, or `null` if no samples. */
+  providerCacheRead: number | null;
+  /** Lifetime provider prompt-cache write tokens, or `null` if no samples. */
+  providerCacheWrite: number | null;
 }
 
 /**

package/extensions/dashboard-server/api-contracts/provider-cache.ts

@@ -0,0 +1,30 @@
+/**
+ * api-contracts/provider-cache.ts — Provider prompt cache contract (A.2).
+ *
+ * Response shape for GET /api/provider-cache: lifetime cache hit-rate
+ * aggregates plus optional $ savings estimate priced from model snapshots.
+ */
+
+/** Savings estimate derived from model pricing snapshot. */
+export interface ProviderCacheSavings {
+	readonly cacheReadSaved: number;
+	readonly cacheWriteCost: number;
+	readonly netSaved: number;
+	readonly model: string;
+	readonly inputRate: number;
+}
+
+/** Response body for GET /api/provider-cache. */
+export interface ProviderCacheResponse {
+	readonly cache: {
+		readonly avgHitPct: number;
+		readonly turnCount: number;
+		readonly totalCacheRead: number;
+		readonly totalCacheWrite: number;
+		readonly totalInput: number;
+		readonly firstTurnAt: string | null;
+		readonly latestTurnAt: string | null;
+	};
+	readonly savings: ProviderCacheSavings | null;
+	readonly updatedAt: string;
+}

package/extensions/dashboard-server/api-contracts.test.ts

@@ -162,7 +162,7 @@ void _c_achievements;
 // (Sprint 39 added /api/sessions + /api/sessions/timeseries.)
 
 const ENDPOINT_KEYS = Object.keys(ENDPOINTS) as (keyof typeof ENDPOINTS)[];
-const EXPECTED_ENDPOINT_COUNT = 26; // 23 base + 3 S49B maintenance
+const EXPECTED_ENDPOINT_COUNT = 27; // 23 base + 3 S49B maintenance + 1 provider-cache
 
 /** All `/api/*` paths served by server.ts (extracted from the route handlers). */
 const SERVER_TS_PATHS: string[] = [
@@ -181,12 +181,13 @@ const SERVER_TS_PATHS: string[] = [
 	"/api/sessions",
 	"/api/sessions/timeseries",
 	"/api/topics",
+	"/api/provider-cache",
 ];
 
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("ENDPOINTS registry", () => {
-	test("has exactly 16 endpoint entries", () => {
+	test("has exactly the expected endpoint count", () => {
 		assert.equal(
 			ENDPOINT_KEYS.length,
 			EXPECTED_ENDPOINT_COUNT,

package/extensions/dashboard-server/index-reader.ts

@@ -58,6 +58,9 @@ export function readIndex(): IndexIndex | null {
       contextWindow: null,
       maxTokens: null,
       reasoning: null,
+      providerCachePct: null,
+      providerCacheRead: null,
+      providerCacheWrite: null,
     }));
     // Enrich each repo with per-store token + model detail read directly via
     // node:sqlite (same zero-dependency invariant as readIndex; no store graph
@@ -91,6 +94,26 @@ export function readIndex(): IndexIndex | null {
               repo.maxTokens = Number(mrow.max_tokens ?? 0) || null;
               repo.reasoning = Number(mrow.reasoning ?? 0) === 1;
             }
+            // Provider prompt-cache stats (E.3)
+            try {
+              const pRow = sdb
+                .prepare(
+                  `SELECT
+                    SUM(cache_read) AS totalRead,
+                    SUM(cache_write) AS totalWrite,
+                    SUM(cache_read + cache_write) * 1.0 / MAX(SUM(cache_read + cache_write + tokens_in), 1) AS hitPct
+                   FROM perf_samples
+                   WHERE cache_read > 0 OR cache_write > 0`,
+                )
+                .get() as { totalRead: number; totalWrite: number; hitPct: number } | undefined;
+              if (pRow && pRow.totalRead > 0) {
+                repo.providerCacheRead = Number(pRow.totalRead);
+                repo.providerCacheWrite = Number(pRow.totalWrite);
+                repo.providerCachePct = Number((pRow.hitPct * 100).toFixed(1));
+              }
+            } catch {
+              /* best-effort — perf_samples may not exist */
+            }
           } finally {
             sdb.close();
           }

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

@@ -0,0 +1,302 @@
+/**
+ * routes-cache.test.ts — Sprint A /api/provider-cache endpoint tests.
+ *
+ * Covers the A.4 spec:
+ * - GET 200 → shape matches ProviderCacheResponse
+ * - POST → 405
+ * - empty perf_samples → zeros/nulls
+ * - no model snapshot → savings: null
+ * - with model snapshot → priced savings fields
+ *
+ * Uses the same spawn-and-fetch harness as perf-server.test.ts.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import {
+	recordPerfSample,
+	recordModelSnapshot,
+} from "../../src/store/sqlite.js";
+
+const SERVER_ENTRY = new URL("./server.js", import.meta.url).pathname;
+
+function waitFor(
+	cond: () => boolean | Promise<boolean>,
+	timeoutMs = 6000,
+): Promise<void> {
+	const start = Date.now();
+	return new Promise((resolve, reject) => {
+		const tick = async () => {
+			if (await cond()) return resolve();
+			if (Date.now() - start > timeoutMs) return reject(new Error("timeout"));
+			setTimeout(tick, 50);
+		};
+		tick();
+	});
+}
+
+function freshDir(prefix: string): string {
+	return mkdtempSync(join(tmpdir(), prefix));
+}
+
+async function withServer<T>(
+	port: string,
+	dir: string,
+	fn: (port: number) => Promise<T>,
+): Promise<T> {
+	process.env.MEGACOMPACT_DASHBOARD_PORT = port;
+	const child = spawn(process.execPath, [SERVER_ENTRY, dir], {
+		stdio: "ignore",
+	});
+	try {
+		await waitFor(async () => {
+			try {
+				const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+				const res = await fetch(`http://localhost:${raw.port}/api/version`);
+				return res.ok;
+			} catch {
+				return false;
+			}
+		});
+		const raw = JSON.parse(readFileSync(join(dir, "port.pid"), "utf-8"));
+		return await fn(raw.port);
+	} finally {
+		child.kill("SIGTERM");
+		delete process.env.MEGACOMPACT_DASHBOARD_PORT;
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
+interface ProviderCacheResponse {
+	cache: {
+		avgHitPct: number;
+		turnCount: number;
+		totalCacheRead: number;
+		totalCacheWrite: number;
+		totalInput: number;
+		firstTurnAt: string | null;
+		latestTurnAt: string | null;
+	};
+	savings: {
+		cacheReadSaved: number;
+		cacheWriteCost: number;
+		netSaved: number;
+		model: string;
+		inputRate: number;
+	} | null;
+	updatedAt: string;
+}
+
+describe("/api/provider-cache", () => {
+	test("GET 200 — shape matches ProviderCacheResponse", async () => {
+		const dir = freshDir("dash-pcache-agg-");
+		// Seed one cache_hit_pct sample with full meta.
+		recordPerfSample(dir, "cache_hit_pct", 42, {
+			cacheRead: 100,
+			cacheWrite: 20,
+			input: 500,
+		});
+		await withServer("19450", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			// Shape assertions
+			assert.ok("cache" in body, "should have cache");
+			assert.ok("savings" in body, "should have savings");
+			assert.ok("updatedAt" in body, "should have updatedAt");
+			assert.equal(body.cache.turnCount, 1);
+			assert.equal(body.cache.totalCacheRead, 100);
+			assert.equal(body.cache.totalCacheWrite, 20);
+			assert.equal(body.cache.totalInput, 500);
+			assert.ok(typeof body.cache.firstTurnAt === "string");
+			assert.ok(typeof body.cache.latestTurnAt === "string");
+			assert.ok(typeof body.updatedAt === "string");
+		});
+	});
+
+	test("GET 200 — empty perf_samples returns zeros/nulls", async () => {
+		const dir = freshDir("dash-pcache-empty-");
+		await withServer("19451", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			assert.equal(body.cache.turnCount, 0);
+			assert.equal(body.cache.avgHitPct, 0);
+			assert.equal(body.cache.totalCacheRead, 0);
+			assert.equal(body.cache.totalCacheWrite, 0);
+			assert.equal(body.cache.totalInput, 0);
+			assert.equal(body.cache.firstTurnAt, null);
+			assert.equal(body.cache.latestTurnAt, null);
+			assert.equal(body.savings, null);
+		});
+	});
+
+	test("POST → 405", async () => {
+		const dir = freshDir("dash-pcache-meth-");
+		await withServer("19452", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`, {
+				method: "POST",
+			});
+			assert.equal(res.status, 405);
+			const body = (await res.json()) as { error: string };
+			assert.equal(body.error, "method_not_allowed");
+		});
+	});
+
+	test("no model snapshot → savings: null", async () => {
+		const dir = freshDir("dash-pcache-nosnap-");
+		recordPerfSample(dir, "cache_hit_pct", 50, {
+			cacheRead: 200,
+			cacheWrite: 30,
+			input: 1000,
+		});
+		await withServer("19453", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			assert.equal(body.savings, null);
+		});
+	});
+
+	test("with model snapshot → priced savings fields", async () => {
+		const dir = freshDir("dash-pcache-savings-");
+		recordPerfSample(dir, "cache_hit_pct", 50, {
+			cacheRead: 2000,
+			cacheWrite: 400,
+			input: 10000,
+		});
+		// Record a model snapshot with a known input rate.
+		recordModelSnapshot(
+			"/tmp/test-repo",
+			{
+				provider: "anthropic",
+				providerName: "Anthropic",
+				modelId: "claude-sonnet-4-20250514",
+				modelName: "Claude Sonnet 4",
+				inputRate: 3e-6, // $3 / 1M tokens
+				outputRate: 15e-6,
+				contextWindow: 200000,
+				maxTokens: 32000,
+				reasoning: false,
+			},
+			dir,
+		);
+		await withServer("19454", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			assert.ok(body.savings, "savings should not be null");
+			// cacheReadSaved = 2000 * 3e-6 * 0.9 = 0.0054
+			assert.ok(body.savings!.cacheReadSaved > 0, "cacheReadSaved > 0");
+			// cacheWriteCost = 400 * 3e-6 * 0.25 = 0.0003
+			assert.ok(body.savings!.cacheWriteCost > 0, "cacheWriteCost > 0");
+			assert.ok(
+				body.savings!.netSaved ===
+					body.savings!.cacheReadSaved - body.savings!.cacheWriteCost,
+				"netSaved = cacheReadSaved - cacheWriteCost",
+			);
+			assert.equal(body.savings!.model, "Claude Sonnet 4");
+			assert.equal(body.savings!.inputRate, 3e-6);
+		});
+	});
+
+	test("partial meta (missing fields) → treated as 0", async () => {
+		const dir = freshDir("dash-pcache-partial-");
+		// Only input in meta; cacheRead/cacheWrite missing → treated as 0.
+		recordPerfSample(dir, "cache_hit_pct", 30, { input: 800 });
+		// Only cacheRead in meta; input/cacheWrite missing → treated as 0.
+		recordPerfSample(dir, "cache_hit_pct", 60, { cacheRead: 150 });
+		await withServer("19455", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			// First sample: input=800, cacheRead=0, cacheWrite=0
+			// Second sample: cacheRead=150, input=0, cacheWrite=0
+			assert.equal(body.cache.turnCount, 2);
+			assert.equal(body.cache.totalCacheRead, 150);
+			assert.equal(body.cache.totalCacheWrite, 0);
+			assert.equal(body.cache.totalInput, 800);
+		});
+	});
+
+	test("NULL meta → counted in turnCount, contributes 0 tokens + 0 avg", async () => {
+		const dir = freshDir("dash-pcache-nullmeta-");
+		// avgHitPct is derived from (cacheRead / (cacheRead + input + cacheWrite)) * 100,
+		// NOT from the `value` column. NULL meta → no tokens → avg 0, not 25.
+		recordPerfSample(dir, "cache_hit_pct", 25, undefined);
+		await withServer("19456", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			assert.equal(body.cache.turnCount, 1);
+			assert.equal(body.cache.avgHitPct, 0);
+			assert.equal(body.cache.totalCacheRead, 0);
+			assert.equal(body.cache.totalCacheWrite, 0);
+			assert.equal(body.cache.totalInput, 0);
+		});
+	});
+
+	test("model snapshot with modelName=null → falls back to modelId", async () => {
+		const dir = freshDir("dash-pcache-modelid-");
+		recordPerfSample(dir, "cache_hit_pct", 10, {
+			cacheRead: 100,
+			cacheWrite: 10,
+			input: 1000,
+		});
+		recordModelSnapshot(
+			"/tmp/test-repo",
+			{
+				provider: "openai",
+				providerName: null,
+				modelId: "gpt-4o",
+				modelName: null,
+				inputRate: 2.5e-6,
+				outputRate: 10e-6,
+				contextWindow: 128000,
+				maxTokens: 16384,
+				reasoning: false,
+			},
+			dir,
+		);
+		await withServer("19457", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			assert.ok(body.savings);
+			assert.equal(body.savings!.model, "gpt-4o");
+		});
+	});
+
+	test("model snapshot with zero inputRate → savings: null", async () => {
+		const dir = freshDir("dash-pcache-zerorate-");
+		recordPerfSample(dir, "cache_hit_pct", 10, {
+			cacheRead: 100,
+			cacheWrite: 10,
+			input: 1000,
+		});
+		recordModelSnapshot(
+			"/tmp/test-repo",
+			{
+				provider: "local",
+				providerName: null,
+				modelId: "local-llm",
+				modelName: null,
+				inputRate: 0,
+				outputRate: 0,
+				contextWindow: 4096,
+				maxTokens: 2048,
+				reasoning: false,
+			},
+			dir,
+		);
+		await withServer("19458", dir, async (port) => {
+			const res = await fetch(`http://localhost:${port}/api/provider-cache`);
+			assert.equal(res.status, 200);
+			const body = (await res.json()) as ProviderCacheResponse;
+			assert.equal(body.savings, null);
+		});
+	});
+});

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

@@ -0,0 +1,123 @@
+/**
+ * dashboard-server/routes-cache.ts — Provider prompt-cache stats route handler.
+ *
+ * GET /api/provider-cache — Lifetime provider prompt cache hit-rate aggregates
+ * plus dollar savings estimate (priced from latest model snapshot).
+ *
+ * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-001 (null-safe JSON parse),
+ * PREVENT-002 (parameterized SQL). Loopback-only localhost dashboard endpoint.
+ */
+
+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";
+
+// ---------------------------------------------------------------------------
+// handleProviderCache — "/api/provider-cache"
+// ---------------------------------------------------------------------------
+
+export function handleProviderCache(
+	req: IncomingMessage,
+	res: ServerResponse,
+	ctx: RouteContext,
+): boolean {
+	if (!req.url?.startsWith("/api/provider-cache")) return false;
+
+	const { stateDir } = ctx;
+
+	// /api/provider-cache — GET returns lifetime provider prompt cache aggregates
+	// from perf_samples (cache_hit_pct rows with meta JSON) plus an optional
+	// dollar savings estimate priced from the latest model snapshot. The dashboard
+	// server is a detached child with no MegaRuntime ref, so it reads via a
+	// require()'d sqlite helper (same pattern as /api/perf). Non-GET → 405.
+	// PREVENT-PI-004: loopback.
+	const pfReq = createRequire(import.meta.url);
+	const { readProviderCacheLifetime, latestModelSnapshot } = pfReq(
+		"../../src/store/sqlite.js",
+	) as typeof import("../../src/store/sqlite.js");
+	if (req.method !== "GET") {
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(405, { "Content-Type": "application/json" });
+		res.end(JSON.stringify({ error: "method_not_allowed" }));
+		return true;
+	}
+	try {
+		const lifetime = readProviderCacheLifetime(stateDir); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+
+		// D3: compute dollar savings from the latest model snapshot.  Null-safe:
+		// when no snapshot or zero input rate, savings stays null (UI shows "—").
+		let savings: {
+			cacheReadSaved: number;
+			cacheWriteCost: number;
+			netSaved: number;
+			model: string;
+			inputRate: number;
+		} | null = null;
+		try {
+			const snap = latestModelSnapshot(stateDir); // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+			if (snap && snap.inputRate > 0) {
+				const s = computeCacheSavings(
+					lifetime.totalCacheRead,
+					lifetime.totalCacheWrite,
+					snap.inputRate,
+				);
+				savings = {
+					cacheReadSaved: s.cacheReadSaved,
+					cacheWriteCost: s.cacheWriteCost,
+					netSaved: s.netSaved,
+					model: snap.modelName ?? snap.modelId ?? "unknown",
+					inputRate: snap.inputRate,
+				};
+			}
+		} catch {
+			/* pricing unavailable — savings stays null */
+		}
+
+		const body: {
+			cache: {
+				avgHitPct: number;
+				turnCount: number;
+				totalCacheRead: number;
+				totalCacheWrite: number;
+				totalInput: number;
+				firstTurnAt: string | null;
+				latestTurnAt: string | null;
+			};
+			savings: {
+				cacheReadSaved: number;
+				cacheWriteCost: number;
+				netSaved: number;
+				model: string;
+				inputRate: number;
+			} | null;
+			updatedAt: string;
+		} = {
+			cache: {
+				avgHitPct: lifetime.avgHitPct,
+				turnCount: lifetime.sampleCount,
+				totalCacheRead: lifetime.totalCacheRead,
+				totalCacheWrite: lifetime.totalCacheWrite,
+				totalInput: lifetime.totalInput,
+				firstTurnAt: lifetime.firstSampleAt,
+				latestTurnAt: lifetime.latestSampleAt,
+			},
+			savings,
+			updatedAt: new Date().toISOString(),
+		};
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(200, { "Content-Type": "application/json" });
+		res.end(JSON.stringify(body));
+	} catch (e) {
+		// guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+		res.writeHead(500, { "Content-Type": "application/json" });
+		res.end(
+			JSON.stringify({
+				error: "provider_cache_unavailable",
+				detail: String(e),
+			}),
+		);
+	}
+	return true;
+}

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

@@ -140,9 +140,9 @@ function sendSchemaHealth(res: ServerResponse, ctx: RouteContext): void {
 		const schemaVersion = metaRow ? Number(metaRow.value) : 0;
 
 		// PRAGMA foreign_key_check
-		const fkRows = db
-			.prepare("PRAGMA foreign_key_check")
-			.all() as Array<Record<string, unknown>>;
+		const fkRows = db.prepare("PRAGMA foreign_key_check").all() as Array<
+			Record<string, unknown>
+		>;
 		const fkCheck = fkRows.map((r) => JSON.stringify(r));
 
 		// Per-column audit: every ensureColumn migration column declared in
@@ -152,7 +152,11 @@ function sendSchemaHealth(res: ServerResponse, ctx: RouteContext): void {
 			column: string;
 			decl: string;
 		}> = [
-			{ table: "context_chunks", column: "original_token_estimate", decl: "INTEGER" },
+			{
+				table: "context_chunks",
+				column: "original_token_estimate",
+				decl: "INTEGER",
+			},
 			{ table: "raw_transcript", column: "content_ref", decl: "TEXT" },
 			{ table: "memories", column: "category", decl: "TEXT" },
 			{ table: "memories", column: "target", decl: "TEXT" },
@@ -165,9 +169,9 @@ function sendSchemaHealth(res: ServerResponse, ctx: RouteContext): void {
 		];
 
 		const columns = expectedColumns.map((ec) => {
-			const cols = db
-				.prepare(`PRAGMA table_info(${ec.table})`)
-				.all() as Array<{ name: string }>;
+			const cols = db.prepare(`PRAGMA table_info(${ec.table})`).all() as Array<{
+				name: string;
+			}>;
 			const present = cols.some((c) => c.name === ec.column);
 			return {
 				table: ec.table,
@@ -223,7 +227,7 @@ function handleMaintenanceAction(
 			return;
 		}
 
-			try {
+		try {
 			const m = lazyMaintenance();
 			const u = lazyStoreUtils();
 			// All destructive actions: temp backup first
@@ -284,9 +288,12 @@ function handleMaintenanceAction(
 				case "reconcile-dedup": {
 					const r = m.reconcileDedupMirror(ctx.stateDir);
 					const lines: string[] = [];
-					if (r.fixedRefCount) lines.push(`${r.fixedRefCount} ref_counts corrected`);
-					if (r.orphansDeleted) lines.push(`${r.orphansDeleted} orphans deleted`);
-					if (r.refsBackfilled) lines.push(`${r.refsBackfilled} refs backfilled`);
+					if (r.fixedRefCount)
+						lines.push(`${r.fixedRefCount} ref_counts corrected`);
+					if (r.orphansDeleted)
+						lines.push(`${r.orphansDeleted} orphans deleted`);
+					if (r.refsBackfilled)
+						lines.push(`${r.refsBackfilled} refs backfilled`);
 					sendJson(res, 200, {
 						operation: "reconcile-dedup",
 						success: true,