pi-mega-compact 0.11.4 → 0.11.6

package/dist/src/store/sqlite/schema.js

@@ -1,5 +1,5 @@
 import { ACHIEVEMENT_DEFS } from "../../game/scoring.js";
-const SCHEMA_VERSION = 2;
+const SCHEMA_VERSION = 4;
 /**
  * Add `column` (with `decl`, e.g. "INTEGER") to `table` if it does not already
  * exist. Idempotent: checks PRAGMA table_info first, so it is safe to run on
@@ -353,6 +353,65 @@ export function initSchema(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_perf_samples_ts ON perf_samples(ts);
     CREATE INDEX IF NOT EXISTS idx_perf_samples_kind_ts ON perf_samples(kind, ts);
+
+    -- A1 PLAN_V2 Phase 2: Message Separation tables (SCHEMA_VERSION 3).
+    -- Stable conversation thread: user + assistant turns ONLY. Tool results are
+    -- stored in tool_results to keep the conversation thread cache-predictable.
+    -- Parameterized queries only (PREVENT-002). CREATE TABLE IF NOT EXISTS is
+    -- a no-op on re-open — no migration needed.
+    CREATE TABLE IF NOT EXISTS conversation_thread (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      conversation_id TEXT NOT NULL,
+      role            TEXT NOT NULL CHECK(role IN ('user','assistant')),
+      content         TEXT NOT NULL,
+      turn_index      INTEGER NOT NULL,
+      timestamp       INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_conv_thread_conv_turn
+      ON conversation_thread(conversation_id, turn_index);
+
+    -- Volatile tool results: appended at END so they never disrupt the
+    -- conversation thread prefix (the prompt-cache-friendly prefix).
+    CREATE TABLE IF NOT EXISTS tool_results (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      conversation_id TEXT NOT NULL,
+      tool_call_id    TEXT NOT NULL,
+      tool_result     TEXT NOT NULL,
+      turn_index      INTEGER NOT NULL,
+      timestamp       INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_tool_results_conv_turn
+      ON tool_results(conversation_id, turn_index);
+
+    -- A2 PLAN_V2 Phase 3: Vector-Aware Cache Striping (SCHEMA_VERSION 4).
+    -- Cache stripe assignments: maps each context chunk to a cache stability
+    -- tier (stripe). Layer 0=permanent, 1=epoch, 2=topic, 3=thread, 4=volatile.
+    -- stability is the composite score (0.0-1.0) from computeStabilityScore.
+    -- Primary key is (chunk_id, epoch_id) so the same chunk can be reassigned
+    -- across epochs without conflict. See cache-stripe.ts for scoring details.
+    -- Parameterized queries only (PREVENT-002). IF NOT EXISTS is a no-op on re-open.
+    CREATE TABLE IF NOT EXISTS cache_stripes (
+      chunk_id      TEXT NOT NULL,
+      stripe        INTEGER NOT NULL,
+      stability     REAL NOT NULL,
+      assigned_at   INTEGER NOT NULL,
+      epoch_id      TEXT,
+      PRIMARY KEY (chunk_id, epoch_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_cs_stripe_stability
+      ON cache_stripes(stripe, stability DESC);
+
+    -- Embedding computation cache: avoids re-embedding content every time
+    -- stability scores are recomputed across epochs. Keyed by content_hash
+    -- (SHA-256 64-hex-char string). Embeddings are serialized via
+    -- Float64Array-to-Buffer to match the embedding_blob convention.
+    CREATE TABLE IF NOT EXISTS embedding_cache (
+      content_hash  TEXT PRIMARY KEY,
+      embedding     BLOB NOT NULL,
+      computed_at   INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_emb_cache_computed
+      ON embedding_cache(computed_at DESC);
   `);
     // Idempotent column migrations. `CREATE TABLE IF NOT EXISTS` is a no-op on a
     // pre-existing table, so new columns added to context_chunks after a store was

package/dist/src/store/sqlite.js

@@ -24,4 +24,5 @@ export * from "./sqlite/game-state.js";
 export * from "./sqlite/game-scores.js";
 export * from "./sqlite/game-achievements.js";
 export * from "./sqlite/perf-samples.js";
+export * from "./sqlite/cache-stripes.js";
 export * from "./sqlite/turns.js";

package/dist/src/store/turns/memory-store.js

@@ -7,6 +7,7 @@
  * PREVENT-PI-004: no network. PREVENT-002: no SQL here.
  */
 import { randomBytes } from "node:crypto";
+import { DuplicateTurnError, } from "./types.js";
 function newConversationId() {
     return `conv_${randomBytes(8).toString("hex")}`;
 }
@@ -134,6 +135,13 @@ export class InMemoryTurnStore {
     }
     // ── TurnWriter ──────────────────────────────────────────────
     appendTurn(entry) {
+        // Check for duplicate (conversationId, turnIndex)
+        for (const [, row] of this.turns) {
+            if (row.entry.conversationId === entry.conversationId &&
+                row.entry.turnIndex === entry.turnIndex) {
+                throw new DuplicateTurnError(entry.conversationId, entry.turnIndex);
+            }
+        }
         const id = allocId();
         const sid = normalizeSessionId(entry.sessionId);
         const normalized = { ...entry, sessionId: sid };

package/dist/src/store/turns/sqlite-store.js

@@ -13,6 +13,7 @@ import { randomBytes } from "node:crypto";
 import { statSync } from "node:fs";
 import { join } from "node:path";
 import { openTurnDb, closeTurnDb } from "./connection.js";
+import { DuplicateTurnError } from "./types.js";
 // ─── Helpers ──────────────────────────────────────────────────────
 function newConversationId() {
     return `conv_${randomBytes(8).toString("hex")}`;
@@ -172,11 +173,21 @@ export class SqliteTurnStore {
     appendTurn(entry) {
         const sid = normalizeSessionId(entry.sessionId);
         this.persistSessionConv(sid, entry.conversationId);
-        this.db
-            .prepare(`INSERT INTO turns (conversation_id, session_id, turn_index, role, ended_at,
+        try {
+            this.db
+                .prepare(`INSERT INTO turns (conversation_id, session_id, turn_index, role, ended_at,
                                    ctx_tokens, ctx_percent, pressure_band, model)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(entry.conversationId, sid, entry.turnIndex, entry.role, entry.endedAt, entry.ctxTokens ?? null, entry.ctxPercent ?? null, entry.pressureBand ?? null, entry.model ?? null);
+                .run(entry.conversationId, sid, entry.turnIndex, entry.role, entry.endedAt, entry.ctxTokens ?? null, entry.ctxPercent ?? null, entry.pressureBand ?? null, entry.model ?? null);
+        }
+        catch (e) {
+            if (e instanceof Error &&
+                e.message.includes("UNIQUE constraint") &&
+                e.code === "ERR_SQLITE_ERROR") {
+                throw new DuplicateTurnError(entry.conversationId, entry.turnIndex);
+            }
+            throw e;
+        }
         const row = this.db
             .prepare("SELECT id FROM turns WHERE conversation_id = ? AND turn_index = ?")
             .get(entry.conversationId, entry.turnIndex);

package/dist/src/store/turns/types.js

@@ -13,4 +13,21 @@
  *
  * PREVENT-PI-004: zero network. PREVENT-002: no SQL here (private to impls).
  */
-export {};
+// ─── Domain types ───────────────────────────────────────────────────
+/**
+ * Thrown when appendTurn is called with a (conversationId, turnIndex) pair
+ * that already exists. Both backends must throw this in lieu of a raw
+ * SQLite error (SqliteTurnStore) or silent success (InMemoryTurnStore).
+ */
+export class DuplicateTurnError extends Error {
+    /** The conversation that already has this turn index. */
+    conversationId;
+    /** The duplicate turn index. */
+    turnIndex;
+    constructor(conversationId, turnIndex) {
+        super(`Duplicate turn: conversation "${conversationId}" already has turnIndex ${turnIndex}`);
+        this.name = "DuplicateTurnError";
+        this.conversationId = conversationId;
+        this.turnIndex = turnIndex;
+    }
+}

package/dist/src/store/vectorIndex.js

@@ -195,10 +195,15 @@ export async function upsertEmbedding(repoId, sessionId, checkpointId, embedding
         if (!pg)
             return;
         const lit = toVectorLiteral(embedding);
-        await pg.query(`INSERT INTO vector_index (repo_id, session_id, checkpoint_id, embedding)
-       VALUES ($1, $2, $3, $4::vector)
-       ON CONFLICT (repo_id, session_id, checkpoint_id)
-       DO UPDATE SET embedding = EXCLUDED.embedding;`, [repoId, sessionId, checkpointId, lit]);
+        const upserted = await withOpenTimeout(pg.query(`INSERT INTO vector_index (repo_id, session_id, checkpoint_id, embedding)
+         VALUES ($1, $2, $3, $4::vector)
+         ON CONFLICT (repo_id, session_id, checkpoint_id)
+         DO UPDATE SET embedding = EXCLUDED.embedding;`, [repoId, sessionId, checkpointId, lit]), (reason) => {
+            disabled = true;
+            logWarn(`upsert query timed out after ${queryTimeoutMs()}ms: ${reason}`);
+        }, queryTimeoutMs());
+        if (upserted === undefined)
+            return; // timed out — non-fatal
     }
     catch (err) {
         disabled = true;
@@ -227,7 +232,12 @@ export async function searchAsync(query, opts = {}) {
             params.push(repoId);
         }
         sql += " ORDER BY embedding <=> $1::vector LIMIT $2";
-        const res = await pg.query(sql, params);
+        const res = await withOpenTimeout(pg.query(sql, params), (reason) => {
+            disabled = true;
+            logWarn(`search query timed out after ${queryTimeoutMs()}ms: ${reason}`);
+        }, queryTimeoutMs());
+        if (!res)
+            return []; // query timed out — degrade to empty (non-fatal)
         return res.rows.map((r) => ({
             repoId: r.repo_id,
             sessionId: r.session_id,
@@ -241,14 +251,49 @@ export async function searchAsync(query, opts = {}) {
         return [];
     }
 }
+/** Default cap for the WASM close (PGlite can stall ~40 min on teardown). */
+export const DEFAULT_CLOSE_TIMEOUT_MS = 5_000;
+function closeTimeoutMs() {
+    const raw = process.env.MEGACOMPACT_PGLITE_CLOSE_TIMEOUT_MS;
+    if (raw) {
+        const n = Number(raw);
+        if (Number.isFinite(n) && n > 0)
+            return n;
+    }
+    return DEFAULT_CLOSE_TIMEOUT_MS;
+}
+/** Default cap for a PGlite search query. A WASM query that never resolves would
+ *  otherwise hang the calling turn (and node --test) forever — the catch below
+ *  only handles thrown errors, not a stalled promise. 0 disables the guard
+ *  (preserve original unbounded behavior). Mirrors the open/close timeouts. */
+export const DEFAULT_QUERY_TIMEOUT_MS = 10_000;
+function queryTimeoutMs() {
+    const raw = process.env.MEGACOMPACT_PGLITE_QUERY_TIMEOUT_MS;
+    if (raw !== undefined) {
+        const n = Number(raw);
+        if (Number.isFinite(n) && n >= 0)
+            return n;
+    }
+    return DEFAULT_QUERY_TIMEOUT_MS;
+}
+/**
+ * Race a promise against a timeout. If the inner promise never settles, the
+ * timer fires, resolves with `undefined`, and the caller proceeds. This mirrors
+ * `withOpenTimeout` (pgOpenGuard.ts) but is local to the close path.
+ */
+function withCloseTimeout(promise, timeoutMs) {
+    return Promise.race([
+        promise,
+        new Promise((resolve) => setTimeout(() => resolve(undefined), timeoutMs)),
+    ]);
+}
 /** Close the index (test teardown / shutdown). Safe to call when unopened. */
 export async function closeVectorIndex() {
     if (db) {
-        try {
-            await db.close();
-        }
-        catch {
-            /* ignore */
+        const closePromise = db.close().catch(() => { });
+        const result = await withCloseTimeout(closePromise, closeTimeoutMs());
+        if (result === undefined) {
+            logWarn(`close timed out after ${closeTimeoutMs()}ms (WASM teardown stalled; OS will reclaim)`);
         }
     }
     db = undefined;

package/dist/src/tiered-router/types.js

@@ -0,0 +1,18 @@
+/**
+ * tiered-router/types.ts — S44 tiered router types, interfaces, and defaults.
+ *
+ * Shell file: pure data/type definitions. Zero runtime dependencies on store
+ * internals. Imported by tieredRouter.ts and any consumer that needs the
+ * RecallResult / TieredRouterMetrics shapes.
+ */
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+/** Default LRU cache size. */
+export const DEFAULT_CACHE_SIZE = 256;
+/** Default latency budgets per tier (ms). */
+export const DEFAULT_BUDGET_L0_MS = 1;
+export const DEFAULT_BUDGET_L1_MS = 50;
+export const DEFAULT_BUDGET_L2_MS = 500;
+/** Default cadence for tiered-metrics logging (every N queries). */
+export const DEFAULT_LOG_CADENCE = 100;