pi-mega-compact 0.9.2 → 0.10.1

package/README.md

@@ -8,12 +8,13 @@ A local context compressor for the [pi coding agent](https://github.com/earendil
 - **Two-layer compaction** — every LLM call sees a live trim of the context window, and every trim is checkpointed to SQLite so a crash or a `/clear` never loses the work.
 - **Semantic dedup, three layers deep** — exact hash → MinHash/LSH → cosine over trigram embeddings. You rarely notice it; that's the point.
 - **RAPTOR memory hierarchy** — decisions you made an hour ago don't scroll off; they get packed up as hierarchical checkpoints and re-inlined the moment your next session asks for them. Multi-level retrieval (leaves + summary clusters) is on by default and tunes itself off the build history.
-- **Per-turn tracking.** Every turn, checkpoint, and recall hit lands as a row in the local DB — `conversation_branches`, `turns`, `turn_recall`. When things go wrong (or when you want to fork a detour off the main thread), the history is there.
+- **Per-turn tracking + rewind.** Every turn, checkpoint, and recall hit lands as a row in an isolated `turns.db` — `turns`, `turn_recall`, `conversation_forks`. The dashboard **Turns tab** shows turn-by-turn memory: context pressure, the compact epoch that superseded each turn, and the exact checkpoints recalled into it. A **fork** action branches a conversation at any turn (carrying its recall set); a **rewind** action queues an intent the host consumes at the next `before_agent_start`. The `TurnStore` is contract-first (capability-gated reader/writer/admin views) so the same spine backs the dashboard, the TUI, or an API gateway.
 - **Cross-repo recall** — doors I close in one repo don't reopen when I move to another. A decision stored while hacking repo A is a recall hit the next time I'm in repo B.
 - **Durable memory** — every ten turns the store auto-reviews and safe-keeps decisions, facts, and preferences as first-class RAG memories, so long-running projects remember what mattered.
 - **Fully local** — node:sqlite + trigram embeddings by default. Bring your own localhost embedder (ONNX, Ollama, TEI) for better semantic matches. Zero calls off your machine except the optional, localhost-only dashboard.
 - **Team-run aware** — fine-grained durable trim fires at agent settle during sub-agent runs, so long multi-agent work doesn't just collapse at the end.
-- **Multi-pi dashboard** — one dashboard tab per active pi process with the context stack, per-repo stats, and a live SSE feed across all of them.
+- **Multi-pi dashboard** — one dashboard tab per active pi process with the context stack, per-repo stats, and a live SSE feed across all of them. The React SPA now has lazy-loaded tabs: Overview, Repos, Events, Config, Metrics, Cache, Game, Achievements, Sessions, Topics (wiki), and Turns (per-turn memory + recall + rewind).
+- **Auto-categorizing wiki.** Every ten compactions, the store clusters your real memory embeddings (k-means) and labels each cluster with its most discriminative terms (TF-IDF) — no LLM, no Ollama, fully local. The dashboard **Wiki tab** browses topics, searches by label or term, and drills down into the member memories of each cluster.
 
 ## Install
 

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

@@ -31,94 +31,142 @@
 export const ENDPOINTS = {
     /** GET /api/snapshot — Full session, store, compression, and context snapshot. */
     snapshot: {
-        method: 'GET',
-        path: '/api/snapshot',
-        description: 'Full session, store, compression, and context snapshot.',
+        method: "GET",
+        path: "/api/snapshot",
+        description: "Full session, store, compression, and context snapshot.",
     },
     /** GET /api/version — Dashboard server version string. */
     version: {
-        method: 'GET',
-        path: '/api/version',
-        description: 'Dashboard server version for stale-server detection.',
+        method: "GET",
+        path: "/api/version",
+        description: "Dashboard server version for stale-server detection.",
     },
     /** GET /api/index — Multi-repo aggregate index (or fallback when unavailable). */
     index: {
-        method: 'GET',
-        path: '/api/index',
-        description: 'Machine-wide multi-repo registry with checkpoints, tokens, and model info.',
+        method: "GET",
+        path: "/api/index",
+        description: "Machine-wide multi-repo registry with checkpoints, tokens, and model info.",
     },
     /** GET /api/repos — Registry list with optional active-window filter. */
     repos: {
-        method: 'GET',
-        path: '/api/repos',
-        description: 'Repo registry list, optionally filtered by recent activity.',
+        method: "GET",
+        path: "/api/repos",
+        description: "Repo registry list, optionally filtered by recent activity.",
     },
     /** GET /api/summary — Lightweight header tiles without the full repo list. */
     summary: {
-        method: 'GET',
-        path: '/api/summary',
-        description: 'Aggregate summary with active/total repo counts (no repo list).',
+        method: "GET",
+        path: "/api/summary",
+        description: "Aggregate summary with active/total repo counts (no repo list).",
     },
     /** GET /api/drift — Cross-repo drift report. */
     drift: {
-        method: 'GET',
-        path: '/api/drift',
-        description: 'Cross-repo drift report flagging stale repos, compaction lag, and model churn.',
+        method: "GET",
+        path: "/api/drift",
+        description: "Cross-repo drift report flagging stale repos, compaction lag, and model churn.",
     },
     /** GET /api/servers — Recently-active repo servers with live snapshot data. */
     servers: {
-        method: 'GET',
-        path: '/api/servers',
-        description: 'Recently-active repo servers with live snapshot data.',
+        method: "GET",
+        path: "/api/servers",
+        description: "Recently-active repo servers with live snapshot data.",
     },
     /** GET /api/events — SSE stream of dashboard events. */
     events: {
-        type: 'sse',
-        method: 'GET',
-        path: '/api/events',
-        description: 'Server-Sent Events stream of all dashboard events.',
-        event: 'data',
+        type: "sse",
+        method: "GET",
+        path: "/api/events",
+        description: "Server-Sent Events stream of all dashboard events.",
+        event: "data",
     },
     /** GET /api/game-state — Current game-mode settings. */
     getGameState: {
-        method: 'GET',
-        path: '/api/game-state',
-        description: 'Current game-mode configuration and active ritual state.',
+        method: "GET",
+        path: "/api/game-state",
+        description: "Current game-mode configuration and active ritual state.",
     },
     /** PUT /api/game-state — Apply a partial patch to game-mode settings. */
     putGameState: {
-        method: 'PUT',
-        path: '/api/game-state',
-        description: 'Apply a partial patch to game-mode settings and return the updated state.',
+        method: "PUT",
+        path: "/api/game-state",
+        description: "Apply a partial patch to game-mode settings and return the updated state.",
     },
     /** GET /api/game-scores — High-score leaderboard for a metric. */
     gameScores: {
-        method: 'GET',
-        path: '/api/game-scores',
-        description: 'High-score leaderboard for a game metric.',
+        method: "GET",
+        path: "/api/game-scores",
+        description: "High-score leaderboard for a game metric.",
     },
     /** GET /api/perf — Rolling-window performance aggregates. */
     perf: {
-        method: 'GET',
-        path: '/api/perf',
-        description: 'Rolling-window performance aggregates over perf_samples.',
+        method: "GET",
+        path: "/api/perf",
+        description: "Rolling-window performance aggregates over perf_samples.",
     },
     /** GET /api/achievements — Achievement tiles with unlock state. */
     achievements: {
-        method: 'GET',
-        path: '/api/achievements',
-        description: 'All achievement rows with unlock state.',
+        method: "GET",
+        path: "/api/achievements",
+        description: "All achievement rows with unlock state.",
     },
     /** GET /api/sessions — Active sessions with latest token usage (S39). */
     sessions: {
-        method: 'GET',
-        path: '/api/sessions',
-        description: 'Active pi sessions with latest token usage + heartbeat.',
+        method: "GET",
+        path: "/api/sessions",
+        description: "Active pi sessions with latest token usage + heartbeat.",
     },
     /** GET /api/sessions/timeseries — Stacked per-session token timeseries (S39). */
     sessionTimeseries: {
-        method: 'GET',
-        path: '/api/sessions/timeseries',
-        description: 'Recharts-ready per-session token timeseries for the stacked memory graph.',
+        method: "GET",
+        path: "/api/sessions/timeseries",
+        description: "Recharts-ready per-session token timeseries for the stacked memory graph.",
+    },
+    /** GET /api/topics — Auto-categorizing wiki topics (S51). */
+    topics: {
+        method: "GET",
+        path: "/api/topics",
+        description: "Auto-categorized wiki topics from k-means + TF-IDF over real embeddings.",
+    },
+    /** GET /api/turns — Turn-by-turn memory tracking + recall (S52). */
+    turns: {
+        method: "GET",
+        path: "/api/turns",
+        description: "Per-conversation turn list with recall + epoch provenance (turn-by-turn memory tracking).",
+    },
+    /** GET /api/turns/conversation/:convId — per-turn detail + recall hits. */
+    conversationTurns: {
+        method: "GET",
+        path: "/api/turns/conversation/:convId",
+        description: "Per-turn metrics + injected-checkpoint recall provenance for one conversation.",
+    },
+    /** GET /api/turns/intents — pending rewind intents (S52A). */
+    turnIntents: {
+        method: "GET",
+        path: "/api/turns/intents",
+        description: "Pending rewind intents queued by the dashboard for the host to consume.",
+    },
+    /** POST /api/turns/intent — post a rewind intent. */
+    postTurnIntent: {
+        method: "POST",
+        path: "/api/turns/intent",
+        description: "Queue a rewind-to-turn-N intent for the host to apply at before_agent_start.",
+    },
+    /** POST /api/fork — fork a conversation at a turn. */
+    fork: {
+        method: "POST",
+        path: "/api/fork",
+        description: "Branch a child conversation off a parent turn + return the recall set to rehydrate.",
+    },
+    /** POST /api/turns/prune — admin prune (capability-gated). */
+    pruneTurns: {
+        method: "POST",
+        path: "/api/turns/prune",
+        description: "Prune old turns (admin capability — dashboard uses asAdmin()).",
+    },
+    /** GET /api/topics/:topicId/memories — wiki topic drill-down (S52). */
+    topicMemories: {
+        method: "GET",
+        path: "/api/topics/:topicId/memories",
+        description: "Member memories assigned to a wiki topic (drill-down).",
     },
 };

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

@@ -6,4 +6,4 @@
  *   // or explicitly:
  *   import type { SnapshotResponse } from '../api-contracts/snapshot';
  */
-export { ENDPOINTS } from './endpoints.js';
+export { ENDPOINTS } from "./endpoints.js";

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

@@ -0,0 +1,10 @@
+/**
+ * api-contracts/turns.ts — S52 turn-by-turn memory tracking + recall contracts.
+ *
+ * The dashboard Turns tab surfaces the S49/S50/S51 data spine: per-conversation
+ * turn lists with per-turn metrics (ctx tokens/percent, recall hits, dedup,
+ * compression, epoch) and per-turn recall provenance (which checkpoints were
+ * injected at each turn), plus the S52 rewind-intent queue. Read-mostly via
+ * `asReader()`; prune/vacuum via `asAdmin()`; fork/intent via the queue.
+ */
+export {};

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

@@ -76,7 +76,7 @@ void _c_achievements;
 // Verify the ENDPOINTS registry has exactly 15 entries with correct paths.
 // (Sprint 39 added /api/sessions + /api/sessions/timeseries.)
 const ENDPOINT_KEYS = Object.keys(ENDPOINTS);
-const EXPECTED_ENDPOINT_COUNT = 15;
+const EXPECTED_ENDPOINT_COUNT = 23;
 /** All `/api/*` paths served by server.ts (extracted from the route handlers). */
 const SERVER_TS_PATHS = [
     "/api/snapshot",
@@ -93,10 +93,11 @@ const SERVER_TS_PATHS = [
     "/api/achievements",
     "/api/sessions",
     "/api/sessions/timeseries",
+    "/api/topics",
 ];
 // ─── Tests ───────────────────────────────────────────────────────────────────
 describe("ENDPOINTS registry", () => {
-    test("has exactly 15 endpoint entries", () => {
+    test("has exactly 16 endpoint entries", () => {
         assert.equal(ENDPOINT_KEYS.length, EXPECTED_ENDPOINT_COUNT, `ENDPOINTS must have ${EXPECTED_ENDPOINT_COUNT} entries, got ${ENDPOINT_KEYS.length}`);
     });
     test("every server.ts /api/* path has a corresponding ENDPOINTS entry", () => {

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

@@ -0,0 +1,87 @@
+/**
+ * routes-topics.ts — S51 auto-categorizing wiki topics route handler.
+ *
+ * GET /api/topics — Returns topic list with memory counts + TF-IDF labels.
+ * Read-only (PREVENT-PI-001/002); parameterized queries (PREVENT-002);
+ * pure local node:sqlite (PREVENT-PI-004).
+ */
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import { createTopicStore } from "../../src/topics/store.js";
+export function handleTopics(req, res, ctx) {
+    const url = req.url ?? "";
+    // ── GET /api/topics/:topicId/memories — wiki topic drill-down (S52) ──
+    const drillMatch = req.method === "GET"
+        ? url.match(/^\/api\/topics\/([^/?]+)\/memories$/)
+        : null;
+    if (drillMatch) {
+        try {
+            const topicId = decodeURIComponent(drillMatch[1]);
+            const store = createTopicStore(ctx.stateDir);
+            const topics = store.getTopics();
+            const topic = topics.find((t) => t.id === topicId);
+            const assignments = store.getMemoriesForTopic(topicId, 200);
+            const body = {
+                topicId,
+                label: topic?.label ?? topicId,
+                assignments: assignments.map((a) => ({
+                    memoryId: a.memoryId,
+                    confidence: a.confidence ?? null,
+                    assignedAt: a.assignedAt ?? null,
+                })),
+            };
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(body));
+        }
+        catch (e) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: String(e) }));
+        }
+        return true;
+    }
+    if (url !== "/api/topics")
+        return false;
+    try {
+        const tdb = openTurnStore(ctx.stateDir);
+        const topics = tdb
+            .prepare(`SELECT id, label, term_scores, memory_count, last_updated
+           FROM topics ORDER BY memory_count DESC, id ASC`)
+            .all().map((r) => ({
+            id: r.id,
+            label: r.label,
+            memoryCount: r.memory_count,
+            lastUpdated: r.last_updated ?? 0,
+            termScore: safeParse(r.term_scores),
+        }));
+        const totalAssigned = tdb.prepare("SELECT COUNT(*) AS c FROM memory_topics").get().c;
+        const lastRebuildAt = tdb
+            .prepare("SELECT MAX(cluster_model_built_at) AS m FROM topics")
+            .get().m;
+        const body = {
+            updatedAt: new Date().toISOString(),
+            totalTopics: topics.length,
+            totalAssigned,
+            lastRebuildAt,
+            topics,
+        };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(body));
+    }
+    catch (e) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: String(e) }));
+    }
+    return true;
+}
+function safeParse(json) {
+    if (!json)
+        return [];
+    try {
+        const v = JSON.parse(json);
+        return Array.isArray(v)
+            ? v
+            : [];
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -0,0 +1,251 @@
+/**
+ * routes-turns.ts — S52 turn-by-turn memory tracking + recall + rewind routes.
+ *
+ * GET  /api/turns                         — conversation list (turns tab payload)
+ * GET  /api/turns/conversation/:convId    — per-turn detail + recall provenance
+ * GET  /api/turns/intents                 — pending rewind intents (S52A)
+ * POST /api/turns/intent                  — post a rewind intent
+ * POST /api/fork                          — fork a conversation at a turn
+ * POST /api/turns/prune                   — admin prune (capability-gated)
+ * POST /api/turns/vacuum                  — admin vacuum
+ *
+ * Capability-gated per the S49 contract: display via `asReader()`, prune/vacuum
+ * via `asAdmin()`, fork via `asWriter()`. Read-mostly. The store never calls
+ * back into the host (ledger protocol). Loopback-only (PREVENT-PI-004).
+ * Parameterized (PREVENT-002).
+ */
+import { createTurnStore } from "../../src/store/turns/index.js";
+import { openTurnStore } from "../../src/store/turns/connection.js";
+import { openIntentQueue } from "../../src/intent.js";
+import { forkFromConversation } from "../../src/fork.js";
+function sendJson(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json" }); // guardrails-allow PREVENT-PI-004: loopback dashboard response (local)
+    res.end(JSON.stringify(body));
+}
+/** Read a capped JSON body; returns { ok, value } or { error }. */
+function readJsonBody(req, cb) {
+    let body = "";
+    let tooBig = false;
+    req.on("data", (chunk) => {
+        if (body.length > 65536) {
+            tooBig = true;
+            return;
+        }
+        body += chunk.toString();
+    });
+    req.on("end", () => {
+        if (tooBig)
+            return cb({ ok: false, error: "body_too_large" });
+        try {
+            const v = body ? JSON.parse(body) : {};
+            if (typeof v !== "object" || v === null || Array.isArray(v)) {
+                return cb({ ok: false, error: "invalid_object" });
+            }
+            cb({ ok: true, value: v });
+        }
+        catch {
+            cb({ ok: false, error: "invalid_json" });
+        }
+    });
+}
+export function handleTurns(req, res, ctx) {
+    const url = req.url ?? "";
+    if (!url.startsWith("/api/turns") && url !== "/api/fork")
+        return false;
+    // ── GET /api/turns — conversation list ─────────────────────────────
+    if (req.method === "GET" && url === "/api/turns") {
+        try {
+            const store = createTurnStore({ stateDir: ctx.stateDir });
+            const reader = store.asReader();
+            // Enumerate conversations via session_conversations + a distinct scan.
+            const tdb = openTurnStore(ctx.stateDir);
+            const convRows = tdb
+                .prepare(`SELECT DISTINCT conversation_id FROM turns ORDER BY conversation_id ASC`)
+                .all();
+            const conversations = convRows.map((r) => {
+                const stats = reader.conversationStats(r.conversation_id);
+                const epochCount = tdb
+                    .prepare("SELECT COUNT(DISTINCT epoch_id) AS c FROM turns WHERE conversation_id = ? AND epoch_id IS NOT NULL")
+                    .get(r.conversation_id).c;
+                const totalRecall = tdb
+                    .prepare(`SELECT COUNT(*) AS c FROM turn_recall tr JOIN turns t ON tr.turn_id = t.id
+							WHERE t.conversation_id = ?`)
+                    .get(r.conversation_id).c;
+                return {
+                    conversationId: r.conversation_id,
+                    turnCount: stats.turnCount,
+                    firstTurnAt: stats.firstTurnAt,
+                    lastTurnAt: stats.lastTurnAt,
+                    avgCtxPercent: stats.avgCtxPercent,
+                    epochCount,
+                    totalRecall,
+                };
+            });
+            // Active conversation = the one with the most recent turn across all.
+            let activeConversationId = null;
+            let lastSeen = 0;
+            for (const c of conversations) {
+                if (c.lastTurnAt > lastSeen) {
+                    lastSeen = c.lastTurnAt;
+                    activeConversationId = c.conversationId;
+                }
+            }
+            sendJson(res, 200, { conversations, activeConversationId });
+            return true;
+        }
+        catch (e) {
+            sendJson(res, 500, { error: String(e) });
+            return true;
+        }
+    }
+    // ── GET /api/turns/conversation/:convId — per-turn detail + recall ─
+    const convMatch = req.method === "GET"
+        ? url.match(/^\/api\/turns\/conversation\/([^/?]+)$/)
+        : null;
+    if (convMatch) {
+        try {
+            const convId = decodeURIComponent(convMatch[1]);
+            const store = createTurnStore({ stateDir: ctx.stateDir });
+            const reader = store.asReader();
+            const entries = reader.query({ conversationId: convId, limit: 10000 });
+            const turns = entries.map((e) => ({
+                turnIndex: e.turnIndex,
+                conversationId: e.conversationId,
+                sessionId: e.sessionId,
+                role: e.role,
+                endedAt: e.endedAt,
+                ctxTokens: e.ctxTokens ?? null,
+                ctxPercent: e.ctxPercent ?? null,
+                pressureBand: e.pressureBand ?? null,
+                model: e.model ?? null,
+                epochId: e.epochId ?? null,
+                recall: reader
+                    .listRecallByIndex(convId, e.turnIndex)
+                    .map((r) => ({
+                    checkpointId: r.checkpointId,
+                    score: r.score,
+                    source: r.source,
+                    raptorLevel: r.raptorLevel ?? null,
+                })),
+            }));
+            sendJson(res, 200, { conversationId: convId, turns });
+            return true;
+        }
+        catch (e) {
+            sendJson(res, 500, { error: String(e) });
+            return true;
+        }
+    }
+    // ── GET /api/turns/intents — pending rewind intents ───────────────
+    if (req.method === "GET" && url === "/api/turns/intents") {
+        try {
+            const tdb = openTurnStore(ctx.stateDir);
+            const q = openIntentQueue(tdb);
+            const intents = q.pendingIntents().map((i) => ({
+                id: i.id,
+                conversationId: i.conversationId,
+                targetTurnIndex: i.targetTurnIndex,
+                createdAt: i.createdAt,
+                status: i.status,
+            }));
+            sendJson(res, 200, { intents });
+            return true;
+        }
+        catch (e) {
+            sendJson(res, 500, { error: String(e) });
+            return true;
+        }
+    }
+    // ── POST /api/turns/intent — post a rewind intent ─────────────────
+    if (req.method === "POST" && url === "/api/turns/intent") {
+        readJsonBody(req, (result) => {
+            if (!result.ok)
+                return sendJson(res, 400, { error: result.error });
+            const v = result.value;
+            const conversationId = typeof v.conversationId === "string" ? v.conversationId : "";
+            const targetTurnIndex = typeof v.targetTurnIndex === "number" ? v.targetTurnIndex : -1;
+            if (!conversationId || targetTurnIndex < 0) {
+                return sendJson(res, 400, { error: "missing_conversationId_or_targetTurnIndex" });
+            }
+            try {
+                const tdb = openTurnStore(ctx.stateDir);
+                const q = openIntentQueue(tdb);
+                const intent = q.postIntent({ conversationId, targetTurnIndex });
+                sendJson(res, 201, intent);
+            }
+            catch (e) {
+                sendJson(res, 500, { error: String(e) });
+            }
+        });
+        return true;
+    }
+    // ── POST /api/fork — fork a conversation at a turn ─────────────────
+    if (req.method === "POST" && url === "/api/fork") {
+        readJsonBody(req, (result) => {
+            if (!result.ok)
+                return sendJson(res, 400, { error: result.error });
+            const v = result.value;
+            const conversationId = typeof v.conversationId === "string" ? v.conversationId : "";
+            const turnIndex = typeof v.turnIndex === "number" ? v.turnIndex : -1;
+            if (!conversationId || turnIndex < 0) {
+                return sendJson(res, 400, { error: "missing_conversationId_or_turnIndex" });
+            }
+            try {
+                const store = createTurnStore({ stateDir: ctx.stateDir });
+                const out = forkFromConversation(store, conversationId, turnIndex);
+                sendJson(res, 201, {
+                    childConversationId: out.childConversationId,
+                    recalledCount: out.recalled.length,
+                    checkpointIds: out.checkpointIds,
+                });
+            }
+            catch (e) {
+                sendJson(res, 400, { error: String(e) });
+            }
+        });
+        return true;
+    }
+    // ── POST /api/turns/prune — admin prune ───────────────────────────
+    if (req.method === "POST" && url === "/api/turns/prune") {
+        readJsonBody(req, (result) => {
+            if (!result.ok)
+                return sendJson(res, 400, { error: result.error });
+            const v = result.value;
+            const maxTurnAgeMs = typeof v.maxTurnAgeMs === "number" ? v.maxTurnAgeMs : 0;
+            const keepMinPerConversation = typeof v.keepMinPerConversation === "number" ? v.keepMinPerConversation : 50;
+            if (maxTurnAgeMs <= 0) {
+                return sendJson(res, 400, { error: "invalid_maxTurnAgeMs" });
+            }
+            try {
+                const store = createTurnStore({ stateDir: ctx.stateDir });
+                const report = store.asAdmin().prune({
+                    maxTurnAgeMs,
+                    keepMinPerConversation,
+                    vacuumAfterPrune: true,
+                });
+                sendJson(res, 200, {
+                    turnsRemoved: report.turnsRemoved,
+                    recallRemoved: report.recallRemoved,
+                    branchesPreserved: report.branchesPreserved,
+                    freedBytes: report.freedBytes,
+                });
+            }
+            catch (e) {
+                sendJson(res, 500, { error: String(e) });
+            }
+        });
+        return true;
+    }
+    // ── POST /api/turns/vacuum — admin vacuum ────────────────────────
+    if (req.method === "POST" && url === "/api/turns/vacuum") {
+        try {
+            createTurnStore({ stateDir: ctx.stateDir }).asAdmin().vacuum();
+            sendJson(res, 200, { ok: true });
+        }
+        catch (e) {
+            sendJson(res, 500, { error: String(e) });
+        }
+        return true;
+    }
+    return false;
+}

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

@@ -6,5 +6,7 @@
  */
 export { buildRouteContext } from "./routes-core.js";
 export { handleIndex, handleRepoIndex, handleStatic } from "./routes-repo.js";
-export { handleGameState, handleGameScores, handlePerf, handleAchievements } from "./routes-game.js";
+export { handleGameState, handleGameScores, handlePerf, handleAchievements, } from "./routes-game.js";
 export { handleEvents, handleSessions } from "./routes-sessions.js";
+export { handleTopics } from "./routes-topics.js";
+export { handleTurns } from "./routes-turns.js";

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

@@ -12,7 +12,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { log, setLogPath, setDashboardServerVersion } from "./state.js";
-import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleStatic, } from "./routes.js";
+import { buildRouteContext, handleIndex, handleRepoIndex, handleEvents, handleGameState, handleGameScores, handlePerf, handleAchievements, handleSessions, handleTopics, handleTurns, handleStatic, } from "./routes.js";
 export async function launchDashboardServer(stateDir) {
     // Our own package version — exposed at /api/version so the launcher can
     // detect a stale server (started by an older build) and replace it on
@@ -163,7 +163,7 @@ export async function launchDashboardServer(stateDir) {
             res.setHeader("Access-Control-Allow-Origin", origin);
             res.setHeader("Vary", "Origin");
         }
-        res.setHeader("Access-Control-Allow-Methods", "GET, PUT, OPTIONS");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, OPTIONS");
         res.setHeader("Access-Control-Allow-Headers", "Content-Type");
         if (req.method === "OPTIONS") {
             res.writeHead(204);
@@ -187,6 +187,10 @@ export async function launchDashboardServer(stateDir) {
             return;
         if (handleSessions(req, res, ctx))
             return;
+        if (handleTopics(req, res, ctx))
+            return;
+        if (handleTurns(req, res, ctx))
+            return;
         handleStatic(req, res, ctx);
     });
     // Bind base + range are env-configurable so tests can use a private,