pi-mega-compact 0.11.4 → 0.11.6

package/dist/extensions/dashboard-server/api-contracts/cache-stripes.js

@@ -0,0 +1,8 @@
+/**
+ * api-contracts/cache-stripes.ts — Cache stripe API contract (A3, PLAN_V2 Phase 4).
+ *
+ * Response shape for GET /api/cache-stripes: per-stripe distribution counts,
+ * average stability, and a top-level health score. Loopback-only data;
+ * zero network (PREVENT-PI-004).
+ */
+export {};

package/dist/extensions/dashboard-server/api-contracts/endpoints.js

@@ -196,4 +196,36 @@ export const ENDPOINTS = {
         path: "/api/provider-cache",
         description: "Lifetime provider prompt cache hit-rate aggregates + dollar savings estimate.",
     },
+    // ─── A3 Cache Stripes (PLAN_V2 Phase 4) ───────────────────────────
+    /** GET /api/cache-stripes — Per-stripe distribution + health score. */
+    cacheStripes: {
+        method: "GET",
+        path: "/api/cache-stripes",
+        description: "Per-stripe distribution counts, average stability scores, and composite cache health.",
+    },
+    // ─── Memory Effectiveness (S53B) ───────────────────────────────────────
+    /** GET /api/memory-status — Memory store aggregate statistics. */
+    memoryStatus: {
+        method: "GET",
+        path: "/api/memory-status",
+        description: "Memory store statistics: total count, 30-day window, top-N stable memories, avg recall score.",
+    },
+    /** GET /api/setup-status — Current embedder configuration. */
+    setupStatus: {
+        method: "GET",
+        path: "/api/setup-status",
+        description: "Current embedder configuration (which embedder is active, embedding URL, cache, MiniLM flag).",
+    },
+    /** GET /api/setup-detect — Detect available local embedder backends. */
+    setupDetect: {
+        method: "GET",
+        path: "/api/setup-detect",
+        description: "Best-effort detection of local embedder backends (ollama, llama.cpp, ONNX) available on the machine.",
+    },
+    /** POST /api/setup-configure — Write embedder config to .mega-compact.env. */
+    setupConfigure: {
+        method: "POST",
+        path: "/api/setup-configure",
+        description: "Write the chosen embedder configuration to .mega-compact.env (loaded at next startup). Returns whether a restart is required.",
+    },
 };

package/dist/extensions/dashboard-server/api-contracts/memory-map.js

@@ -0,0 +1 @@
+export {};

package/dist/extensions/dashboard-server/api-contracts/memory.js

@@ -0,0 +1,8 @@
+/**
+ * api-contracts/memory.ts — Memory effectiveness stats contract (S53B).
+ *
+ * Response shape for GET /api/memory-status: aggregate memory-store statistics
+ * including total count, 30-day window, top-N stable memories by recall, and
+ * average recall score.
+ */
+export {};

package/dist/extensions/dashboard-server/api-contracts/provider-cache.js

@@ -3,5 +3,6 @@
  *
  * Response shape for GET /api/provider-cache: lifetime cache hit-rate
  * aggregates plus optional $ savings estimate priced from model snapshots.
+ * F4 adds per-model breakdown (byModel).
  */
 export {};

package/dist/extensions/dashboard-server/api-contracts/setup.js

@@ -0,0 +1,10 @@
+/**
+ * api-contracts/setup.ts — Setup wizard API response types.
+ *
+ * Types for the /api/setup-status and /api/setup-detect endpoints used
+ * by the /megasetup command and dashboard Setup tab.
+ *
+ * PREVENT-PI-004: type definitions only, no network code.
+ * PREVENT-011: no `any` type — all types are explicit.
+ */
+export {};

package/dist/extensions/dashboard-server/index-reader.js

@@ -123,7 +123,9 @@ export function readIndex() {
         // paths that should never have been real repos, and collapse duplicate
         // display names to the most-recently-seen row (rows are last_seen DESC, so
         // the first occurrence wins). Keeps the All-repos list readable.
-        const isTransient = (p) => /^\/tmp\//.test(p) || /^\/private\/tmp\//.test(p) || /^\/var\/folders\//.test(p) ||
+        const isTransient = (p) => /^\/tmp\//.test(p) ||
+            /^\/private\/tmp\//.test(p) ||
+            /^\/var\/folders\//.test(p) ||
             /\/mc-(ext|e2e|resume|recall)-/.test(p);
         const seenName = new Set();
         const repos = [];
@@ -150,6 +152,8 @@ export function readIndex() {
         try {
             db?.close();
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
 }

package/dist/extensions/dashboard-server/routes-cache.js

@@ -3,6 +3,7 @@
  *
  * GET /api/provider-cache — Lifetime provider prompt cache hit-rate aggregates
  * plus dollar savings estimate (priced from latest model snapshot).
+ * Accepts optional ?minutes=N, ?since=<epoch-ms>, ?until=<epoch-ms> (S53A).
  *
  * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-001 (null-safe JSON parse),
  * PREVENT-002 (parameterized SQL). Loopback-only localhost dashboard endpoint.
@@ -15,64 +16,151 @@ import { computeCacheSavings } from "../../src/pricing.js";
 export function handleProviderCache(req, res, ctx) {
     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");
+    try {
+        const stateDir = ctx.stateDir;
+        // PREVENT-PI-004: loopback.
+        const pfReq = createRequire(import.meta.url);
+        const { readProviderCacheLifetime, readProviderCacheWindow, latestModelSnapshot } = pfReq("../../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;
+        }
+        // Parse query params: ?minutes=N | ?since=&until= (mutually exclusive).
+        let windowMinutes = null;
+        let sinceTs = 0;
+        let untilTs = 0;
+        if (req.url) {
+            const qIdx = req.url.indexOf("?");
+            if (qIdx !== -1) {
+                const params = new URLSearchParams(req.url.slice(qIdx));
+                const m = params.get("minutes");
+                if (m != null) {
+                    const n = parseInt(m, 10);
+                    if (Number.isFinite(n) && n > 0 && String(n) === m.trim()) {
+                        windowMinutes = n;
+                    }
+                }
+                // S53A: ?since=&until= epoch-ms timestamps.
+                const s = params.get("since");
+                const u = params.get("until");
+                if (s != null) {
+                    const sn = Number(s);
+                    if (Number.isFinite(sn) && sn >= 0)
+                        sinceTs = sn;
+                }
+                if (u != null) {
+                    const un = Number(u);
+                    if (Number.isFinite(un) && un > 0)
+                        untilTs = un;
+                }
+            }
+        }
+        // S53A: read prefix_break samples in the same window as the aggregates.
+        // Import lazily to avoid a circular dependency in the test harness.
+        let prefixBreaks = [];
+        try {
+            // guardrails-allow PREVENT-PI-004: local SQLite read (loopback dashboard)
+            const { readPrefixBreaks } = pfReq("../../src/store/sqlite/perf-samples.js");
+            // When ?since=&until= is used, pass those directly; otherwise derive
+            // from windowMinutes or 0 (no bounds = lifetime).
+            const pSince = sinceTs > 0 ? sinceTs : (windowMinutes != null ? Date.now() - windowMinutes * 60_000 : 0);
+            const pUntil = untilTs > 0 ? untilTs : (windowMinutes != null ? Date.now() : 0);
+            const rows = readPrefixBreaks(stateDir, pSince, pUntil);
+            prefixBreaks = rows.map((r) => ({
+                id: r.id,
+                ts: r.ts,
+                cause: r.meta.cause,
+                confidence: r.meta.confidence,
+                prevHitPct: r.meta.prevHitPct,
+                currHitPct: r.meta.currHitPct,
+                breakAt: r.meta.breakAt,
+            }));
+        }
+        catch {
+            /* prefix-break read unavailable — response still returns empty array */
+        }
+        try {
+            const lifetime = windowMinutes != null
+                ? readProviderCacheWindow(stateDir, windowMinutes)
+                : 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 = 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: lifetime.avgHitPct,
+                    turnCount: lifetime.sampleCount,
+                    totalCacheRead: lifetime.totalCacheRead,
+                    totalCacheWrite: lifetime.totalCacheWrite,
+                    totalInput: lifetime.totalInput,
+                    firstTurnAt: lifetime.firstSampleAt,
+                    latestTurnAt: lifetime.latestSampleAt,
+                    byModel: lifetime.byModel,
+                },
+                savings,
+                updatedAt: new Date().toISOString(),
+                windowMinutes,
+                prefixBreaks,
+            };
+            // 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;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// handleCacheStripes — "GET /api/cache-stripes"
+// ---------------------------------------------------------------------------
+export function handleCacheStripes(req, res, ctx) {
+    if (!req.url?.startsWith("/api/cache-stripes"))
+        return false;
     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 = 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: 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)
+        const stateDir = ctx.stateDir;
+        const pfReq = createRequire(import.meta.url);
+        const { readCacheStripes } = pfReq("../../src/store/sqlite/cache-stripes.js");
+        const result = readCacheStripes(stateDir);
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify(body));
+        res.end(JSON.stringify(result));
     }
     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",
+            error: "cache_stripes_unavailable",
             detail: String(e),
         }));
     }

package/dist/extensions/dashboard-server/routes-game.js

@@ -256,6 +256,9 @@ export function handlePerf(req, res, ctx) {
                 avg: avg(get("cache_hit_pct")),
                 latest: latest(get("cache_hit_pct")),
                 n: get("cache_hit_pct").length,
+                samples: rows
+                    .filter((r) => r.kind === "cache_hit_pct")
+                    .map((r) => ({ pct: r.value, ts: r.ts })),
             },
             db_recompute_ms: {
                 p50: pct(get("db_recompute_ms"), 50),

package/dist/extensions/dashboard-server/routes-memory-map.js

@@ -0,0 +1,50 @@
+/**
+ * routes-memory-map.ts — GET /api/memory-map route handler (S46).
+ *
+ * Builds a memory graph from the local SQLite store and returns it as JSON.
+ * Uses an inline require to the pi-agnostic src/memoryGraph.ts builder.
+ */
+import { createRequire } from "node:module";
+import { parse as parseUrl } from "node:url";
+const _req = createRequire(import.meta.url);
+// guardrails-allow PREVENT-PI-004: localhost-only dashboard API endpoint that reads from the local SQLite store — zero remote network calls.
+export function handleMemoryMap(req, res, ctx) {
+    if (req.method !== "GET")
+        return false;
+    const parsed = parseUrl(req.url ?? "", true);
+    if (parsed.pathname !== "/api/memory-map")
+        return false;
+    // guardrails-allow PREVENT-PI-004: local loopback-only dashboard server — reads the local SQLite store for graph data.
+    const { buildMemoryGraph } = _req("../../src/memoryGraph.js");
+    const sessionId = typeof parsed.query.sessionId === "string" ? parsed.query.sessionId : undefined;
+    const threshold = typeof parsed.query.threshold === "string" ? Number.parseFloat(parsed.query.threshold) : undefined;
+    const maxEdges = typeof parsed.query.maxEdgesPerNode === "string" ? Number.parseInt(parsed.query.maxEdgesPerNode, 10) : undefined;
+    const raptorEdges = parsed.query.includeRaptorEdges === "false" ? false : true;
+    const temporalEdges = parsed.query.includeTemporalEdges === "false" ? false : true;
+    const graph = buildMemoryGraph({
+        sessionId,
+        similarityThreshold: threshold,
+        maxEdgesPerNode: maxEdges,
+        stateDir: ctx.stateDir,
+        includeRaptorEdges: raptorEdges,
+        includeTemporalEdges: temporalEdges,
+    });
+    const nodes = graph.nodes.map((n) => ({
+        id: n.id,
+        sessionId: n.sessionId,
+        label: n.label,
+        summaryTruncated: n.summaryTruncated,
+        tokenEstimate: n.tokenEstimate,
+        timestamp: n.timestamp,
+        dedupStatus: n.dedupStatus,
+        raptorLevel: n.raptorLevel,
+        topicSummary: n.topicSummary,
+        decisionCount: n.decisionCount,
+        textSnippet: n.textSnippet,
+    }));
+    const edges = graph.edges;
+    const response = { nodes, edges, metadata: graph.metadata };
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(response));
+    return true;
+}

package/dist/extensions/dashboard-server/routes-memory.js

@@ -0,0 +1,51 @@
+/**
+ * dashboard-server/routes-memory.ts — Memory effectiveness stats route handler (S53B).
+ *
+ * GET /api/memory-status — Returns memoryStats() aggregated data:
+ *   totalMemories, memoriesInLast30Days, topStableMemories, avgRecallScore.
+ *
+ * Guardrails: PREVENT-PI-004 (loopback-only), PREVENT-001 (null-safe JSON),
+ * PREVENT-002 (parameterized SQL — memoryStats uses openStore internally).
+ * Loopback-only localhost dashboard endpoint.
+ */
+import { createRequire } from "node:module";
+// PREVENT-PI-004: memoryStats is a pure local module (no network, no side-effects at import time).
+// guardrails-allow PREVENT-PI-004: local TypeScript module import (loopback-only).
+const { memoryStats } = createRequire(import.meta.url)("../../src/memoryStats.js");
+// ---------------------------------------------------------------------------
+// handleMemoryStatus — "/api/memory-status"
+// ---------------------------------------------------------------------------
+export function handleMemoryStatus(req, res, ctx) {
+    if (!req.url?.startsWith("/api/memory-status"))
+        return false;
+    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;
+    }
+    // PREVENT-PI-004: loopback-only — memoryStats reads from local SQLite store.
+    memoryStats(ctx.stateDir)
+        .then((stats) => {
+        const body = {
+            totalMemories: stats.totalMemories,
+            memoriesInLast30Days: stats.memoriesInLast30Days,
+            topStableMemories: stats.topStableMemories.map((m) => ({
+                id: m.id,
+                text: m.text,
+                recallCount: m.recallCount,
+                lastRecalledAt: m.lastRecalledAt,
+            })),
+            avgRecallScore: stats.avgRecallScore,
+        };
+        // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(body));
+    })
+        .catch(() => {
+        // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "memory_stats_unavailable" }));
+    });
+    return true;
+}

package/dist/extensions/dashboard-server/routes-repo.js

@@ -8,7 +8,7 @@ import { dashboardHtml } from "./html.js";
 import { readIndex, getIndexDir } from "./index-reader.js";
 import { ACTIVE_WINDOW_SEC } from "./types.js";
 import { readProviderCacheForRepo } from "../../src/store/sqlite/perf-samples.js";
-import { computeCacheSavings, lookupModelInputRate } from "../../src/pricing.js";
+import { computeCacheSavings, lookupModelInputRate, } from "../../src/pricing.js";
 import { latestModelSnapshot } from "../../src/store/sqlite/model-snapshots.js";
 // ---------------------------------------------------------------------------
 // handleIndex — "/" | "/index.html" | "/api/snapshot" | "/api/version"
@@ -142,7 +142,7 @@ export function handleRepoIndex(req, res, ctx) {
                             const modelSnap = latestModelSnapshot(r.stateDir);
                             const inputRate = modelSnap
                                 ? modelSnap.inputRate
-                                : lookupModelInputRate(r.modelName ?? "") ?? 0;
+                                : (lookupModelInputRate(r.modelName ?? "") ?? 0);
                             const savings = computeCacheSavings(pc.totalCacheRead, pc.totalCacheWrite, inputRate);
                             out.providerCache = {
                                 avgHitPct: pc.avgHitPct,