pi-mega-compact 0.21.2 → 0.21.4

package/dist/src/store/sqlite/context-health.js

@@ -14,6 +14,10 @@
  */
 import { getStateDir } from "../../store.js";
 import { openStore } from "./utils.js";
+/** A single cache_poison_events row (as stored + returned). */
+// Sprint H split: cache_poison_events accessors live in context-health-cache-poison.ts.
+// Re-exported here so existing importers (barrel `export *`) are unaffected.
+export { recordCachePoisonEvent, readCachePoisonEvents, } from "./context-health-cache-poison.js";
 // ─── context_health accessors ────────────────────────────────────────────────
 /**
  * Record one context health sample. All values are fully parameterized
@@ -100,7 +104,7 @@ export function readLatestContextHealth(stateDir = getStateDir()) {
     try {
         const db = openStore(stateDir);
         const row = db
-            .prepare(`SELECT composite, drift_score, output_quality, error_score,
+            .prepare(`SELECT composite, drift_score, output_quality, error_score, store_error_score,
 				        cache_health, cache_poison, ts, model_id
 				 FROM context_health
 				 ORDER BY ts DESC
@@ -113,6 +117,7 @@ export function readLatestContextHealth(stateDir = getStateDir()) {
             driftScore: row.drift_score,
             outputQuality: row.output_quality,
             errorScore: row.error_score,
+            storeErrorScore: row.store_error_score ?? 1,
             cacheHealth: row.cache_health,
             cachePoison: row.cache_poison,
             ts: row.ts,
@@ -144,50 +149,3 @@ export function readContextHealthTrend(stateDir = getStateDir(), limit) {
         return [];
     }
 }
-// ─── cache_poison_events accessors ───────────────────────────────────────────
-/**
- * Record one cache poison advisory event. Fully parameterized (PREVENT-002).
- * Non-fatal: write errors are logged to stderr and silently swallowed.
- */
-export function recordCachePoisonEvent(stateDir = getStateDir(), event) {
-    try {
-        const db = openStore(stateDir);
-        db.prepare(`INSERT INTO cache_poison_events
-			   (ts, turn_index, session_id, layer, detail, severity)
-			 VALUES (?, ?, ?, ?, ?, ?)`).run(event.ts, event.turnIndex, event.sessionId, event.layer, event.detail, event.severity);
-    }
-    catch (err) {
-        // Non-fatal: advisory logging must never block the agent loop.
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[context-health] recordCachePoisonEvent error: ${msg}\n`);
-    }
-}
-/**
- * Read cache poison events since `sinceTs`, ordered descending by ts (most
- * recent first), capped at 100 rows. Returns an empty array on any error
- * (non-fatal). SQL is fully parameterized (PREVENT-002).
- */
-export function readCachePoisonEvents(stateDir = getStateDir(), sinceTs) {
-    try {
-        const db = openStore(stateDir);
-        const rows = db
-            .prepare(`SELECT id, ts, turn_index, session_id, layer, detail, severity
-				 FROM cache_poison_events
-				 WHERE ts >= ?
-				 ORDER BY ts DESC
-				 LIMIT 100`)
-            .all(sinceTs);
-        return rows.map((r) => ({
-            id: r.id,
-            ts: r.ts,
-            turnIndex: r.turn_index,
-            sessionId: r.session_id,
-            layer: r.layer,
-            detail: r.detail,
-            severity: r.severity,
-        }));
-    }
-    catch {
-        return [];
-    }
-}

package/dist/src/store/sqlite/embedding-cache.js

@@ -66,6 +66,10 @@ export function getOrComputeEmbedding(db, content) {
         // Logger not imported here to keep this leaf self-contained; stderr is
         // acceptable for an error path that signals a bug, not a user‑facing log.
         process.stderr.write(`[embedding-cache] getOrComputeEmbedding error: ${msg}\n`);
+        // Sprint H (Option A): this leaf src/ cache-persist path has no runtime
+        // handle, so the embedder cache-write failure is recorded by callers that
+        // own a runtime, not here.
+        // guardrails-allow INTERNAL-ERR: src/ leaf cache writer, no runtime handle — callers record embedder cache failures
         return [];
     }
 }

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

@@ -51,6 +51,10 @@ export function initSchema(db) {
     // S43: conversation_id + last_turn_id on session_state (legacy DBs have NULL).
     ensureColumn(db, "session_state", "conversation_id", "TEXT");
     ensureColumn(db, "session_state", "last_turn_id", "INTEGER");
+    // Sprint H (B2): store_error_score column on context_health — the 6th health
+    // axis. Additive; DBs created before this version have NULL → the health
+    // handler degrades to 1.0 (no data → healthy), matching the empty-ring rule.
+    ensureColumn(db, "context_health", "store_error_score", "REAL");
     // S35: idempotent seed of the 9 achievement rows. ON CONFLICT(id) DO
     // NOTHING so a re-open never clobbers an already-unlocked row's
     // unlocked_at. No user input reaches this SQL (PREVENT-002 safe).

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

@@ -0,0 +1,119 @@
+import { allocId, normalizeSessionId, resetIdCounter, } from "./ctx.js";
+export function prune(ctx, policy) {
+    const cutoff = Date.now() - policy.maxTurnAgeMs;
+    let turnsRemoved = 0;
+    let recallRemoved = 0;
+    for (const [convId, turnIds] of ctx.convIndex.entries()) {
+        const total = turnIds.length;
+        const canDelete = Math.max(0, total - policy.keepMinPerConversation);
+        if (canDelete === 0)
+            continue;
+        // Find old turns to delete
+        const oldIds = turnIds
+            .filter((id) => {
+            const row = ctx.turns.get(id);
+            return row && row.entry.endedAt < cutoff;
+        })
+            .slice(0, canDelete);
+        for (const id of oldIds) {
+            // Remove recall for this turn, in place (preserve ctx.recall reference)
+            const before = ctx.recall.length;
+            let w = 0;
+            for (let i = 0; i < ctx.recall.length; i++) {
+                if (ctx.recall[i].turnId !== id)
+                    ctx.recall[w++] = ctx.recall[i];
+            }
+            ctx.recall.length = w;
+            recallRemoved += before - ctx.recall.length;
+            ctx.turns.delete(id);
+            turnsRemoved++;
+        }
+        // Update convIndex
+        ctx.convIndex.set(convId, turnIds.filter((id) => ctx.turns.has(id)));
+    }
+    const branchesPreserved = ctx.forks.length;
+    return {
+        turnsRemoved,
+        recallRemoved,
+        branchesPreserved,
+        freedBytes: 0, // in-memory — no file size to measure
+    };
+}
+export function vacuum(_ctx) {
+    // No-op for in-memory store
+}
+export function checkpoint(ctx) {
+    // Emit turns in a stable order (by internal ID / insertion order)
+    const sorted = [...ctx.turns.values()].sort((a, b) => a.id - b.id);
+    const turns = sorted.map((r) => r.entry);
+    // Build mapping: internal ID → 1-based position
+    const idToPos = new Map();
+    for (let i = 0; i < sorted.length; i++) {
+        idToPos.set(sorted[i].id, i + 1);
+    }
+    // Replace recall's turnId with the stable 1-based position
+    const recall = ctx.recall.map((r) => ({
+        turnId: String(idToPos.get(r.turnId) ?? r.turnId),
+        checkpointId: r.entry.checkpointId,
+        score: r.entry.score,
+        source: r.entry.source,
+        raptorLevel: r.entry.raptorLevel,
+    }));
+    return {
+        version: 1,
+        exportedAt: Date.now(),
+        turns,
+        recall,
+        forks: [...ctx.forks],
+    };
+}
+export function restore(ctx, from) {
+    clear(ctx);
+    // Map: 1-based position → new internal ID
+    const posToNewId = new Map();
+    for (let i = 0; i < from.turns.length; i++) {
+        const t = from.turns[i];
+        const newId = allocId();
+        const sid = normalizeSessionId(t.sessionId);
+        const normalized = { ...t, sessionId: sid };
+        ctx.turns.set(newId, { id: newId, entry: normalized });
+        // Update indices
+        const convIds = ctx.convIndex.get(t.conversationId) ?? [];
+        convIds.push(newId);
+        ctx.convIndex.set(t.conversationId, convIds);
+        ctx.sessionConv.set(sid, t.conversationId);
+        posToNewId.set(i + 1, newId);
+    }
+    // Re-attach recall with position-based TurnId → new internal ID mapping
+    for (const r of from.recall) {
+        const targetInternalId = posToNewId.get(Number(r.turnId));
+        if (targetInternalId !== undefined) {
+            ctx.recall.push({
+                turnId: targetInternalId,
+                entry: r,
+            });
+        }
+    }
+    // In-place replace forks (preserve ctx.forks reference)
+    ctx.forks.length = 0;
+    ctx.forks.push(...from.forks);
+}
+export function clear(ctx) {
+    ctx.turns.clear();
+    ctx.recall.length = 0;
+    ctx.forks.length = 0;
+    ctx.convIndex.clear();
+    ctx.sessionConv.clear();
+    resetIdCounter();
+}
+export function stampTurnsEpoch(ctx, sessionId, epochId) {
+    const sid = normalizeSessionId(sessionId);
+    let stamped = 0;
+    for (const row of ctx.turns.values()) {
+        if (row.epochId === undefined && row.entry.sessionId === sid) {
+            row.epochId = epochId;
+            stamped++;
+        }
+    }
+    return stamped;
+}

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

@@ -0,0 +1,28 @@
+/**
+ * ctx.ts — internal context interface for InMemoryTurnStore method bodies
+ * (extracted from memory-store.ts). Each free function in this directory
+ * operates on a MemoryTurnStoreCtx so the shell class can delegate without
+ * exposing its private fields.
+ *
+ * Mirrors sqlite-store/ctx.ts. The Map/array references are stable for the
+ * life of the store: arrays (recall, forks) are mutated IN PLACE
+ * (push/splice/length=0), never reassigned, so a ctx captured at any point
+ * sees the current contents. The id counter is module-scoped here so both the
+ * shell (writers) and admin.ts share one allocator.
+ */
+import { randomBytes } from "node:crypto";
+// Auto-increment counter — shared by writers (appendTurn/forkConversation) and
+// admin (restore). Module-scoped so a single counter spans the store's life.
+let nextId = 1;
+export function allocId() {
+    return nextId++;
+}
+export function resetIdCounter() {
+    nextId = 1;
+}
+export function newConversationId() {
+    return `conv_${randomBytes(8).toString("hex")}`;
+}
+export function normalizeSessionId(sid) {
+    return sid.replace(/-.*$/, "");
+}

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

@@ -0,0 +1,110 @@
+import { normalizeSessionId } from "./ctx.js";
+export function query(ctx, filter) {
+    let results = [...ctx.turns.values()].map((r) => r.entry);
+    if (filter.conversationId !== undefined) {
+        results = results.filter((t) => t.conversationId === filter.conversationId);
+    }
+    if (filter.sessionId !== undefined) {
+        results = results.filter((t) => normalizeSessionId(t.sessionId) ===
+            normalizeSessionId(filter.sessionId));
+    }
+    if (filter.sinceMs !== undefined) {
+        results = results.filter((t) => t.endedAt >= filter.sinceMs);
+    }
+    if (filter.untilMs !== undefined) {
+        results = results.filter((t) => t.endedAt <= filter.untilMs);
+    }
+    if (filter.pressureBand !== undefined) {
+        results = results.filter((t) => t.pressureBand === filter.pressureBand);
+    }
+    results.sort((a, b) => a.endedAt - b.endedAt);
+    const offset = filter.offset ?? 0;
+    const limit = filter.limit ?? 1000;
+    return results.slice(offset, offset + limit);
+}
+export function getTurn(ctx, turnId) {
+    const row = ctx.turns.get(Number(turnId));
+    return row ? { ...row.entry, epochId: row.epochId } : undefined;
+}
+export function getTurnByIndex(ctx, conversationId, turnIndex) {
+    const ids = ctx.convIndex.get(conversationId) ?? [];
+    for (const id of ids) {
+        const row = ctx.turns.get(id);
+        if (row && row.entry.turnIndex === turnIndex) {
+            return { ...row.entry, epochId: row.epochId };
+        }
+    }
+    return undefined;
+}
+export function listRecall(ctx, turnId) {
+    return ctx.recall
+        .filter((r) => r.turnId === Number(turnId))
+        .map((r) => r.entry)
+        .sort((a, b) => b.score - a.score);
+}
+export function listRecallByIndex(ctx, conversationId, turnIndex) {
+    const turn = getTurnByIndex(ctx, conversationId, turnIndex);
+    if (!turn)
+        return [];
+    // Resolve the numeric row id for this turn via the convIndex.
+    const ids = ctx.convIndex.get(conversationId) ?? [];
+    for (const id of ids) {
+        const row = ctx.turns.get(id);
+        if (row && row.entry.turnIndex === turnIndex) {
+            return listRecall(ctx, String(id));
+        }
+    }
+    return [];
+}
+export function listForks(ctx, conversationId) {
+    return ctx.forks
+        .filter((f) => f.parentConversationId === conversationId)
+        .sort((a, b) => a.createdAt - b.createdAt);
+}
+export function countTurns(ctx, conversationId) {
+    const ids = ctx.convIndex.get(conversationId);
+    return ids?.length ?? 0;
+}
+export function conversationStats(ctx, conversationId) {
+    const ids = ctx.convIndex.get(conversationId) ?? [];
+    const entries = ids
+        .map((id) => ctx.turns.get(id)?.entry)
+        .filter((e) => e !== undefined);
+    if (entries.length === 0) {
+        return {
+            turnCount: 0,
+            firstTurnAt: 0,
+            lastTurnAt: 0,
+            avgCtxPercent: 0,
+            pressureBands: {},
+        };
+    }
+    let ctxSum = 0;
+    let ctxCount = 0;
+    const bands = {};
+    for (const e of entries) {
+        if (e.ctxPercent !== undefined) {
+            ctxSum += e.ctxPercent;
+            ctxCount++;
+        }
+        if (e.pressureBand)
+            bands[e.pressureBand] = (bands[e.pressureBand] ?? 0) + 1;
+    }
+    return {
+        turnCount: entries.length,
+        firstTurnAt: entries[0].endedAt,
+        lastTurnAt: entries[entries.length - 1].endedAt,
+        avgCtxPercent: ctxCount > 0 ? ctxSum / ctxCount : 0,
+        pressureBands: bands,
+    };
+}
+export function nextTurnIndexFor(ctx, conversationId) {
+    let max = -1;
+    for (const [, row] of ctx.turns) {
+        if (row.entry.conversationId === conversationId &&
+            row.entry.turnIndex > max) {
+            max = row.entry.turnIndex;
+        }
+    }
+    return max + 1;
+}

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

@@ -0,0 +1,88 @@
+/**
+ * write.ts — TurnWriter method bodies for InMemoryTurnStore (extracted from
+ * memory-store.ts). Free functions operating on a MemoryTurnStoreCtx; the
+ * shell class delegates here. Mirrors sqlite-store/write.ts.
+ */
+import { DuplicateTurnError, } from "../types.js";
+import { allocId, newConversationId, normalizeSessionId, } from "./ctx.js";
+export function appendTurn(ctx, entry) {
+    // Check for duplicate (conversationId, turnIndex)
+    for (const [, row] of ctx.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 };
+    ctx.turns.set(id, { id, entry: normalized });
+    // Update indices
+    const convIds = ctx.convIndex.get(entry.conversationId) ?? [];
+    convIds.push(id);
+    ctx.convIndex.set(entry.conversationId, convIds);
+    ctx.sessionConv.set(sid, entry.conversationId);
+    return String(id);
+}
+export function appendRecall(ctx, entry) {
+    // De-dup by (turn_id, checkpoint_id)
+    const exists = ctx.recall.some((r) => r.turnId === Number(entry.turnId) &&
+        r.entry.checkpointId === entry.checkpointId);
+    if (!exists) {
+        ctx.recall.push({ turnId: Number(entry.turnId), entry });
+    }
+}
+export function ensureConversationId(ctx, sessionId) {
+    const sid = normalizeSessionId(sessionId);
+    const existing = ctx.sessionConv.get(sid);
+    if (existing)
+        return existing;
+    // Generate and store a new conversation ID for this session
+    const convId = newConversationId();
+    ctx.sessionConv.set(sid, convId);
+    return convId;
+}
+export function forkConversation(ctx, parentId, forkTurnIndex) {
+    const childId = newConversationId();
+    const now = Date.now();
+    // 1. Record the fork lineage
+    ctx.forks.push({
+        parentConversationId: parentId,
+        childConversationId: childId,
+        forkTurnIndex,
+        createdAt: now,
+    });
+    // 2. Find the parent's turn at forkTurnIndex
+    const parentTurnIds = ctx.convIndex.get(parentId) ?? [];
+    const parentTurnRow = parentTurnIds
+        .map((id) => ctx.turns.get(id))
+        .find((r) => r?.entry.turnIndex === forkTurnIndex);
+    if (!parentTurnRow)
+        return childId; // no parent turn — nothing to seed
+    // 3. Create a seed turn in the child conversation
+    const seedId = allocId();
+    const seedEntry = {
+        conversationId: childId,
+        sessionId: `fork_${childId}`,
+        turnIndex: 0,
+        role: "system",
+        endedAt: now,
+    };
+    ctx.turns.set(seedId, { id: seedId, entry: seedEntry });
+    ctx.convIndex.set(childId, [seedId]);
+    // 4. Copy the parent's recall entries into the child's seed turn
+    const parentRecall = ctx.recall.filter((r) => r.turnId === parentTurnRow.id);
+    for (const r of parentRecall) {
+        ctx.recall.push({
+            turnId: seedId,
+            entry: {
+                turnId: String(seedId),
+                checkpointId: r.entry.checkpointId,
+                score: r.entry.score,
+                source: r.entry.source,
+                raptorLevel: r.entry.raptorLevel,
+            },
+        });
+    }
+    return childId;
+}