pi-mega-compact 0.20.82 → 0.20.84

package/extensions/mega-config-types.ts

@@ -112,9 +112,6 @@ export interface MegaConfig {
 	/** S51: auto-categorizing wiki (k-means + TF-IDF over real embeddings). Default ON.
 	 *  Mirrors TurnsConfig.AUTO_WIKI_ENABLED. Rebuild fires every Nth compaction. */
 	autoWikiEnabled: boolean;
-	/** PMA: provider/model analytics (isolated analytics.db). Default ON. OFF =
-	 *  no analytics.db open/write — pre-program behavior byte-for-byte. */
-	providerModelAnalytics: boolean;
 	/** Cross-repo recall enabled (S17). Resume + /mega-recall --cross-repo can
 	 *  pull checkpoints from OTHER repos via the PGlite HNSW index. Default true. */
 	crossRepoEnabled: boolean;
@@ -139,6 +136,10 @@ export interface MegaConfig {
 	 *  the tail of the view when auto is OFF AND no trim action is needed. Default ON
 	 *  (true). When false, restores the pre-sprint systemPrompt prepend behavior. */
 	recallTailInject: boolean;
+	/** 3WF-1: TriggerGuard — re-stage a recall block at the context event seam when
+	 *  session_start never fired, so every session has a staged block (recall hits,
+	 *  else a provenance floor). Default ON; OFF = byte-identical pre-sprint. */
+	threeWayFailback: boolean;
 	/** A1 PLAN_V2 Phase 2: Message Separation — isolate user/assistant turns
 	 *  from volatile tool results so the prompt-cache prefix stays stable.
 	 *  PC-A: positive sprint flag, now default ON; flag-OFF (=0) is byte-identical

package/extensions/mega-config.ts

@@ -196,8 +196,6 @@ export function loadConfig(): MegaConfig {
 		// turn path (S48 behavior). Mirrors src/config/turns.ts TURNS_DB_ENABLED.
 		turnsDbEnabled: envBool("MEGACOMPACT_TURNS_DB", true),
 		autoWikiEnabled: envBool("MEGACOMPACT_AUTO_WIKI", true),
-		// PMA: provider/model analytics (isolated analytics.db). Default ON.
-		providerModelAnalytics: envBool("MEGACOMPACT_PROVIDER_MODEL_ANALYTICS", true),
 		crossRepoEnabled: envBool("MEGACOMPACT_CROSSREPO_ENABLED", true),
 		crossRepoCosine: Number(process.env.MEGACOMPACT_CROSSREPO_COSINE ?? "0.90"),
 		memoryAutoReview: envBool("MEGACOMPACT_MEMORY_AUTO_REVIEW", true),
@@ -205,6 +203,9 @@ export function loadConfig(): MegaConfig {
 		recallMaxTokens: envFlag("MEGACOMPACT_RECALL_MAX_TOKENS", 1500),
 		windowDedupe: envBool("MEGACOMPACT_WINDOW_DEDUPE", true),
 		recallTailInject: envBool("MEGACOMPACT_RECALL_TAIL_INJECT", true),
+		// 3WF-1: TriggerGuard — guarantee a staged recall block on every context
+		// event even when session_start never fires. Default ON; OFF = byte-identical.
+		threeWayFailback: envBool("MEGACOMPACT_THREE_WAY_FAILBACK", true),
 		// PC-A: positive sprint flag, default ON. =0 byte-identical to the
 		// pre-change OFF state (single gate lives at the call site in tailResult.ts).
 		messageSeparation: envBool("MEGACOMPACT_MESSAGE_SEPARATION", true),

package/extensions/mega-events/agent-handlers/turnEndHandler/recordTurnRow.ts

@@ -51,23 +51,6 @@ export function recordTurnRow(
 			turnsDbEnabled: config.turnsDbEnabled,
 		});
 	} catch (e) {
-		// DuplicateTurnError: the turn was already persisted (the same turnIndex
-		// was written by an earlier code path — a double-write race). This is a
-		// SUCCESS, not a failure: the turn IS in turns.db. Emit turn_written with
-		// duplicate:true so events.log stops showing 289 false "turn_write_failed"
-		// entries (which made the Turns tab + context engine look broken).
-		// Uses the same message-pattern idiom as write.ts's UNIQUE constraint guard
-		// (no new import; DuplicateTurnError isn't re-exported through mega-turn-store
-		// and the append-only invariant forbids UPDATE/UPSERT in the store layer).
-		if (e instanceof Error && /Duplicate turn:/.test(e.message)) {
-			runtime.dashboard.event("turn_written", {
-				turnIndex: event.turnIndex,
-				pressureBand: runtime.pressureBand ?? null,
-				turnsDbEnabled: config.turnsDbEnabled,
-				duplicate: true,
-			});
-			return;
-		}
 		runtime.dashboard.event("turn_write_failed", {
 			turnIndex: event.turnIndex,
 			turnsDbEnabled: config.turnsDbEnabled,

package/extensions/mega-events/context-handler/triggerGuard.ts

@@ -0,0 +1,137 @@
+/**
+ * extensions/mega-events/context-handler/triggerGuard.ts — 3WF-1 TriggerGuard.
+ *
+ * Production-incident fix: `session_start` can silently never fire (pi host
+ * behavior), so the only recall staging point (session-handlers.ts) is skipped
+ * and a session replays with NO recall block and NO telemetry. TriggerGuard
+ * re-stages at the `context` event seam — the one place that ALWAYS runs and
+ * where the staged block is composed into the model view on this same event.
+ *
+ * Stack position (context-handler.ts): run DIRECTLY BEFORE `buildTailResult` is
+ * built, so a freshly staged block is picked up by the existing tail machinery
+ * (recall-tail.ts) with zero changes to it.
+ *
+ * Contract:
+ *  - one-shot per MegaRuntime (WeakMap) — recall does NOT re-run on every event.
+ *  - if runtime.pendingRecallBlock != null already, no-op (session_start won).
+ *  - read-only recall via engine.recall -> formatRecallBlock; no vectorMarkInjected,
+ *    no S43 telemetry, no turn writes (this is a guard, not an inline).
+ *  - an empty store (checkpointCount == 0) is a genuinely new session: no crash,
+ *    no floor staged, just marked done.
+ *  - a store WITH checkpoints whose recall returns nothing: stage the provenance
+ *    floor (newest checkpoint summary) instead of silence.
+ *  - never throws (whole body guarded), non-fatal, PREVENT-PI-003 (block is plain
+ *    text; role decided downstream by withRecallTail as user).
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { MegaRuntime } from "../../mega-runtime.js";
+import type { MegaConfig } from "../../mega-config.js";
+import { normalizeSessionId } from "../../../src/store.js";
+import { recall } from "../../../src/engine.js";
+import { formatRecallBlock } from "../../../src/recall.js";
+import { vectorStats, vectorList } from "../../../src/vectorStore.js";
+import { recentUserQuery } from "../../mega-runtime.js";
+
+/** One-shot completion marker per MegaRuntime (dies with the runtime). */
+const guardDone = new WeakMap<MegaRuntime, { done: true }>();
+
+/** The minimal ctx surface the guard reads (query + session id). Accepted instead
+ *  of the full ExtensionContext so tests can pass a thin stub without a full
+ *  pi ctx; structurally satisfied by the real ExtensionContext. */
+interface GuardCtx {
+	sessionManager: { getSessionId(): string };
+}
+
+
+/**
+ * Run the TriggerGuard for this context event. Best-effort: never throws; any
+ * failure degrades to the pre-sprint path (no staged block).
+ */
+export function runTriggerGuard(
+	runtime: MegaRuntime,
+	config: MegaConfig,
+	ctx: GuardCtx,
+): void {
+	try {
+		// Flag OFF => byte-identical pre-sprint behavior (no touch, no telemetry).
+		if (!config.threeWayFailback) return;
+		// session_start already staged a block => the normal path wins, no-op.
+		if (runtime.pendingRecallBlock != null) return;
+		// One-shot: we've already decided for this runtime.
+		if (guardDone.has(runtime)) return;
+
+		// recentUserQuery only reads sessionManager.getEntries(); the structural
+		// GuardCtx satisfies it at runtime (cast to the full type it expects).
+		const query = recentUserQuery(ctx as unknown as ExtensionContext);
+		if (!query) {
+			guardDone.set(runtime, { done: true });
+			return;
+		}
+
+		const sid = normalizeSessionId(ctx.sessionManager.getSessionId());
+		const stats = vectorStats(runtime.store, sid);
+		// Empty store => genuinely new session; not a recall failure. Mark done so
+		// we don't re-check forever, stage nothing (no crash, no floor).
+		if (stats.checkpointCount <= 0) {
+			guardDone.set(runtime, { done: true });
+			return;
+		}
+
+		// Read-only recall: search + rank only; skipInjected:false means we keep
+		// hits already injected this session, but we never call vectorMarkInjected
+		// ourselves (A1) — formatRecallBlock does the same as session_start uses.
+		const hits = recall(
+			{ sessionId: sid, query, limit: config.autoInlineK, skipInjected: false },
+			runtime.store,
+		).hits;
+
+		if (hits.length > 0) {
+			runtime.pendingRecallBlock = formatRecallBlock(hits);
+			guardDone.set(runtime, { done: true });
+			runtime.appendEvent("three_way_guard_fired", {
+				source: "recall",
+				hitCount: hits.length,
+				topScore: hits[0]?.score ?? null,
+			});
+			return;
+		}
+
+		// Store HAS checkpoints but recall found nothing relevant: stage a
+		// provenance floor built from the newest checkpoint summary rather than
+		// silence (the incident's "recall silently never ran" shape).
+		const floor = buildFloorBlock(runtime, sid);
+		runtime.pendingRecallBlock = floor;
+		guardDone.set(runtime, { done: true });
+		runtime.appendEvent("three_way_floor_used", { basis: "lastCheckpoint" });
+	} catch {
+		/* never throws; best-effort guard */
+	}
+}
+
+/** Build the provenance floor string from the session's newest checkpoint. */
+function buildFloorBlock(runtime: MegaRuntime, sid: string): string {
+	try {
+		const cps = vectorList(runtime.store, sid);
+		let newest = cps[0];
+		for (const cp of cps) {
+			if (!newest || (cp.timestamp ?? 0) > (newest.timestamp ?? 0)) newest = cp;
+		}
+		const summary = newest?.summary?.trim();
+		if (summary) {
+			return (
+				"The following compacted context is the most recent checkpoint from " +
+				"this session (recall found no query-relevant match):\n\n" + summary
+			);
+		}
+		return (
+			"This session has compacted context but recall could not surface a " +
+			"checkpoint relevant to the current request; the most recent checkpoint " +
+			"summary is unavailable."
+		);
+	} catch {
+		return (
+			"This session has compacted context but recall could not surface a " +
+			"checkpoint relevant to the current request."
+		);
+	}
+}

package/extensions/mega-events/context-handler.ts

@@ -23,6 +23,7 @@ import type { MegaRuntime } from "../mega-runtime.js";
 import { piCompactWouldNoop } from "../mega-pipeline.js";
 import type { MegaConfig } from "../mega-config.js";
 import { buildTailResult } from "./context-handler/tailResult.js";
+import { runTriggerGuard } from "./context-handler/triggerGuard.js";
 import { persistEpochAndMaintain } from "./context-handler/afterCompact.js";
 import { appendMirrorAndLedger } from "./context-handler/dbMirrorAppend.js";
 import { evaluateGate } from "./context-handler/gateCheck.js";
@@ -53,6 +54,16 @@ export function registerContextHandler(
 		const usage = ctx.getContextUsage();
 		const pct = usage?.percent;
 		const messages = event.messages;
+		// 3WF-1 TriggerGuard: guarantee a staged recall block on this event even
+		// when session_start never fired. One-shot per session; a block already
+		// staged by session_start takes precedence (no-op). Run BEFORE building the
+		// tail factory so a freshly staged block is composed into THIS event's view.
+		// Best-effort — a failure falls through to the pre-sprint path.
+		try {
+			runTriggerGuard(runtime, config, ctx);
+		} catch {
+			/* non-fatal */
+		}
 		// S53: helper to inject the staged recall/memory block as a user-role
 		// tail message at any view-return point. Returns undefined when nothing
 		// is staged (or the flag is OFF) so the caller falls through to its

package/extensions/mega-events/register.ts

@@ -13,7 +13,6 @@ import { registerAgentHandlers } from "./agent-handlers.js";
 import { registerContextHandler } from "./context-handler.js";
 import { registerCompactHandlers } from "./compact-handlers.js";
 import { registerPerfHandler } from "./perf-handler.js";
-import { registerAnalyticsHandler } from "./analytics-handler.js";
 import { registerVectorCortexRender } from "../mega-context/vector-cortex.js";
 
 /**
@@ -50,6 +49,4 @@ export function registerEventHandlers(
 	registerContextHandler(pi, runtime, config);
 	registerCompactHandlers(pi, runtime, config);
 	registerPerfHandler(pi, runtime);
-	// PMA-2: analytics ingestion — flag-gated (OFF = no-op, no DB opened).
-	registerAnalyticsHandler(pi, runtime, config);
 }

package/package.json

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

package/src/failback/types.ts

@@ -0,0 +1,46 @@
+/**
+ * src/failback/types.ts — 3WF Three-Way Failback contract types (contract-first).
+ *
+ * Pure, pi-agnostic interfaces describing the staged-recall guarantee chain:
+ * every session should have a staged recall block even when `session_start`
+ * never fires. 3WF-1 (TriggerGuard) is the first consumer; 3WF-2/3/4 extend
+ * these shapes for the compaction ladder, the 3-source recall vote, and
+ * InjectionConfirm. No pi runtime imports, no store mutation — these are the
+ * shape contract only.
+ */
+
+/** One-shot guard state for a session (observable result of a TriggerGuard run). */
+export interface TriggerGuardState {
+	/** True once a recall/floor attempt has run for this session. */
+	recallRan: boolean;
+	/** The block staged into runtime.pendingRecallBlock (null when nothing staged). */
+	stagedBlock: string | null;
+	/** True when the provenance floor (not a recall hit) was staged. */
+	usedFloor: boolean;
+}
+
+/** A provenance floor string built from the newest checkpoint / session basis. */
+export interface FloorBlock {
+	/** The model-visible floor text. */
+	text: string;
+	/** Why this floor was produced. */
+	basis: "lastCheckpoint" | "sessionProvenance" | "none";
+}
+
+/** Result of a single TriggerGuard evaluation (for tests + telemetry). */
+export interface GuardRunResult {
+	/** How the block (or non-block) was produced. */
+	source: "already-staged" | "recall" | "floor" | "none";
+	/** The staged block text; null when nothing was staged. */
+	block: string | null;
+}
+
+/** Options the TriggerGuard needs to run a staged recall. */
+export interface GuardOpts {
+	/** The latest user message used as the recall query; empty => 'none'. */
+	query: string | null;
+	/** Normalized session id. */
+	sessionId: string;
+	/** Max hits to recall (mirrors autoInlineK). */
+	limit: number;
+}

package/dist/extensions/mega-events/analytics-handler.js

@@ -1,169 +0,0 @@
-import { createAnalyticsStore, closeAllAnalyticsDbs, } from "../../src/store/analytics/index.js";
-// ── Per-stateDir store cache (mirrors mega-turn-store.ts storeFor) ─────
-const stores = new Map();
-function storeFor(stateDir) {
-    let s = stores.get(stateDir);
-    if (!s) {
-        s = createAnalyticsStore({ stateDir });
-        stores.set(stateDir, s);
-    }
-    return s;
-}
-/** Close all cached analytics stores (test teardown / shutdown). */
-export function closeAnalyticsStores() {
-    closeAllAnalyticsDbs();
-    stores.clear();
-}
-const pmaTimings = new WeakMap();
-function getPma(rt) {
-    let s = pmaTimings.get(rt);
-    if (!s) {
-        s = { providerStart: 0, ttft: 0, correlationId: null };
-        pmaTimings.set(rt, s);
-    }
-    return s;
-}
-/** @internal Test-only accessor — production code uses getPma() in-module. */
-export function __pmaTimingForTest(rt) {
-    return getPma(rt);
-}
-function usageOf(msg) {
-    if (msg.role === "assistant" && msg.usage)
-        return msg.usage;
-    return null;
-}
-// ── Helpers ───────────────────────────────────────────────────────────
-/** Build a QualityNote with provider/model availability. */
-function qualityFor(provider, model) {
-    if (!provider || !model)
-        return { unavailable: true, note: "provider/model not captured" };
-    return {};
-}
-// ── Registration ──────────────────────────────────────────────────────
-/** Register the analytics event handlers. Flag-gated: OFF = complete no-op. */
-export function registerAnalyticsHandler(pi, runtime, config) {
-    if (!config.providerModelAnalytics)
-        return; // flag OFF — no DB, no handlers
-    // ── turn_start: stamp the request start + emit request_started ──────
-    pi.on("turn_start", async (event) => {
-        try {
-            const now = Date.now();
-            const corrId = `req_${runtime.rt.sessionId}_${event.turnIndex}`;
-            const pma = getPma(runtime);
-            pma.correlationId = corrId;
-            pma.providerStart = 0; // reset; stamped at before_provider_request
-            pma.ttft = 0;
-            const provider = runtime.currentModel?.provider;
-            const model = runtime.currentModel?.modelId;
-            const fact = {
-                id: `${corrId}_started`,
-                correlationId: corrId,
-                sessionId: runtime.rt.sessionId,
-                turnId: String(event.turnIndex),
-                eventKind: "request_started",
-                observedAt: now,
-                provider,
-                model,
-                source: "host_adapter",
-                quality: qualityFor(provider, model),
-            };
-            storeFor(runtime.currentStateDir).asWriter().appendRequestEvent(fact);
-        }
-        catch {
-            /* non-fatal: analytics never breaks the agent loop */
-        }
-    });
-    // ── before_provider_request: stamp provider start + emit provider_selected
-    pi.on("before_provider_request", async () => {
-        try {
-            const pma = getPma(runtime);
-            pma.providerStart = Date.now();
-            const corrId = pma.correlationId;
-            if (!corrId)
-                return;
-            const provider = runtime.currentModel?.provider;
-            const model = runtime.currentModel?.modelId;
-            const fact = {
-                id: `${corrId}_selected`,
-                correlationId: corrId,
-                sessionId: runtime.rt.sessionId,
-                eventKind: "provider_selected",
-                observedAt: pma.providerStart,
-                provider,
-                model,
-                source: "host_adapter",
-                quality: qualityFor(provider, model),
-            };
-            storeFor(runtime.currentStateDir).asWriter().appendRequestEvent(fact);
-        }
-        catch {
-            /* non-fatal */
-        }
-    });
-    // ── message_update: capture TTFT on first text token ────────────────
-    // Net-new seam — no existing handler registers message_update.
-    // Proven available in PMA-0 (agent-loop.js:201-227).
-    pi.on("message_update", async (event) => {
-        try {
-            const pma = getPma(runtime);
-            if (pma.ttft > 0)
-                return; // already captured this turn
-            if (pma.providerStart <= 0)
-                return; // no provider start stamp
-            const chunkType = event
-                .assistantMessageEvent?.type;
-            if (chunkType !== "text_start" && chunkType !== "text_delta")
-                return;
-            pma.ttft = Date.now() - pma.providerStart;
-        }
-        catch {
-            /* non-fatal */
-        }
-    });
-    // ── turn_end: emit terminal fact with tokens, latency, ttft, status ─
-    pi.on("turn_end", async (event) => {
-        try {
-            const pma = getPma(runtime);
-            const corrId = pma.correlationId;
-            if (!corrId)
-                return;
-            const now = Date.now();
-            const durationMs = runtime.perfTurnStart > 0 ? now - runtime.perfTurnStart : undefined;
-            const u = usageOf(event.message);
-            const stopReason = event.message.stopReason;
-            const provider = runtime.currentModel?.provider;
-            const model = runtime.currentModel?.modelId;
-            const isFailed = stopReason === "error" || stopReason === "aborted";
-            const eventKind = isFailed ? "request_failed" : "request_completed";
-            const fact = {
-                id: `${corrId}_${eventKind}`,
-                correlationId: corrId,
-                sessionId: runtime.rt.sessionId,
-                turnId: String(event.turnIndex),
-                eventKind,
-                observedAt: now,
-                provider,
-                model,
-                status: stopReason ?? undefined,
-                inputTokens: u?.input,
-                outputTokens: u?.output,
-                cacheReadTokens: u?.cacheRead,
-                cacheWriteTokens: u?.cacheWrite,
-                durationMs,
-                ttftMs: pma.ttft > 0 ? pma.ttft : undefined,
-                source: "host_adapter",
-                quality: {
-                    ...qualityFor(provider, model),
-                    ...(pma.ttft > 0 ? {} : { note: "TTFT not captured (no first-token event)" }),
-                },
-            };
-            storeFor(runtime.currentStateDir).asWriter().appendRequestEvent(fact);
-            // Reset per-turn state.
-            pma.correlationId = null;
-            pma.ttft = 0;
-        }
-        catch {
-            /* non-fatal */
-        }
-    });
-}

package/dist/src/store/analytics/connection.js

@@ -1,114 +0,0 @@
-/**
- * connection.ts — PMA-1 connection manager for analytics.db.
- *
- * Own module-level connection cache, deliberately SEPARATE from the main
- * memory store (openStore) and the turns store (openTurnDb) so an analytics-DB
- * failure can never touch the authoritative memory DB or the turns DB (PMA §3.1).
- *
- * Mirrors src/store/turns/connection.ts. PREVENT-PI-004: node:sqlite in-process,
- * no network. PREVENT-002: parameterized path binding.
- */
-import { existsSync, mkdirSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { DatabaseSync as Db } from "node:sqlite";
-import { initAnalyticsSchema } from "./schema.js";
-export const ANALYTICS_DB_FILE = "analytics.db";
-/** Resolve the analytics DB path, honoring the env override. */
-export function analyticsDbPath(stateDir) {
-    const env = process.env.MEGACOMPACT_ANALYTICS_DB_PATH;
-    if (env && env.trim() !== "")
-        return env.trim();
-    return join(stateDir, ANALYTICS_DB_FILE);
-}
-// Module-private cache — separate from openStore's cache and turns' cache.
-const cache = new Map();
-/** File size helper (0 for in-memory). */
-function dbFileSize(dbPath) {
-    try {
-        return statSync(dbPath).size;
-    }
-    catch {
-        return 0;
-    }
-}
-/**
- * Open (or reuse from cache) the analytics.db for `stateDir`.
- * Sets PRAGMAs, initializes the schema, and caches the connection.
- * In-memory mode (`:memory:`) is supported for tests.
- */
-export function openAnalyticsDb(stateDir, options) {
-    const inMemory = options?.inMemory === true;
-    const resolvedPath = inMemory ? ":memory:" : (options?.dbPath ?? analyticsDbPath(stateDir));
-    const cacheKey = inMemory ? `:memory:${stateDir}` : resolvedPath;
-    const cached = cache.get(cacheKey);
-    if (cached) {
-        try {
-            cached.exec("SELECT 1");
-            return cached;
-        }
-        catch {
-            // Stale handle — evict and re-open.
-            cache.delete(cacheKey);
-        }
-    }
-    // Ensure the state dir exists for file-backed mode.
-    if (!inMemory && !existsSync(stateDir)) {
-        mkdirSync(stateDir, { recursive: true });
-    }
-    const db = inMemory ? new Db(":memory:") : new Db(resolvedPath);
-    db.exec("PRAGMA busy_timeout = 5000");
-    db.exec("PRAGMA journal_mode = WAL");
-    db.exec("PRAGMA foreign_keys = ON");
-    initAnalyticsSchema(db);
-    cache.set(cacheKey, db);
-    return db;
-}
-/** Close and evict the analytics DB for `stateDir` (idempotent). */
-export function closeAnalyticsDb(stateDir, options) {
-    const inMemory = options?.inMemory === true;
-    const resolvedPath = inMemory ? ":memory:" : (options?.dbPath ?? analyticsDbPath(stateDir));
-    const cacheKey = inMemory ? `:memory:${stateDir}` : resolvedPath;
-    const db = cache.get(cacheKey);
-    if (!db)
-        return;
-    try {
-        db.close();
-    }
-    catch {
-        /* already closed */
-    }
-    cache.delete(cacheKey);
-}
-/** Close ALL cached analytics DBs (test teardown / graceful shutdown). */
-export function closeAllAnalyticsDbs() {
-    for (const db of cache.values()) {
-        try {
-            db.close();
-        }
-        catch {
-            /* already closed */
-        }
-    }
-    cache.clear();
-}
-/** Report the file size of analytics.db for a state dir (0 if absent/in-memory). */
-export function analyticsDbSize(stateDir) {
-    return dbFileSize(analyticsDbPath(stateDir));
-}
-/**
- * SAVEPOINT-based transaction wrapper (nests safely under an outer transaction).
- * Uses a distinct savepoint name from the turns store (`turns_tx`) and the main
- * store (`mc_tx`) to avoid collisions.
- */
-export function withTx(db, fn) {
-    db.exec("SAVEPOINT analytics_tx");
-    try {
-        fn();
-        db.exec("RELEASE analytics_tx");
-    }
-    catch (e) {
-        db.exec("ROLLBACK TO analytics_tx");
-        db.exec("RELEASE analytics_tx");
-        throw e;
-    }
-}

package/dist/src/store/analytics/contract-compliance.test/_helpers.js

@@ -1,39 +0,0 @@
-let counter = 0;
-/** Create a valid RequestEventFact with sensible defaults + overrides. */
-export function makeRequestEvent(overrides = {}) {
-    return {
-        id: `evt_${++counter}`,
-        correlationId: "corr_test",
-        sessionId: "sess_test",
-        eventKind: "request_started",
-        observedAt: Date.now(),
-        provider: "anthropic",
-        model: "claude-sonnet-4",
-        source: "test",
-        quality: {},
-        ...overrides,
-    };
-}
-/** Create a valid MeasurementFact. */
-export function makeMeasurement(overrides = {}) {
-    return {
-        observedAt: Date.now(),
-        sampleKind: "cache_hit_pct",
-        value: 72.5,
-        unit: "percent",
-        source: "test",
-        quality: {},
-        ...overrides,
-    };
-}
-/** Create a valid IdentityObservation. */
-export function makeIdentity(overrides = {}) {
-    return {
-        observedAt: Date.now(),
-        provider: "anthropic",
-        model: "claude-sonnet-4",
-        source: "test",
-        metadata: { contextWindow: 200000 },
-        ...overrides,
-    };
-}

package/dist/src/store/analytics/index.js

@@ -1,25 +0,0 @@
-/**
- * index.ts — Barrel for src/store/analytics/ (PMA-1).
- *
- * Hosts import types + the factory. SQL schemas + internals stay private.
- *
- * PREVENT-PI-004: no network. PREVENT-002: parameterized SQL only.
- */
-export { SqliteAnalyticsStore } from "./sqlite-store.js";
-export { InMemoryAnalyticsStore } from "./memory-store.js";
-export { openAnalyticsDb, closeAnalyticsDb, closeAllAnalyticsDbs, analyticsDbPath, analyticsDbSize, ANALYTICS_DB_FILE, withTx, } from "./connection.js";
-export { initAnalyticsSchema, getAnalyticsSchemaVersion } from "./schema.js";
-import { SqliteAnalyticsStore } from "./sqlite-store.js";
-import { InMemoryAnalyticsStore } from "./memory-store.js";
-/**
- * Factory: create an AnalyticsStore from options.
- *
- * - Default: SqliteAnalyticsStore backed by analytics.db in stateDir
- * - inMemory: InMemoryAnalyticsStore (no file I/O)
- */
-export function createAnalyticsStore(options) {
-    if (options.inMemory) {
-        return new InMemoryAnalyticsStore(options);
-    }
-    return new SqliteAnalyticsStore(options);
-}