pi-mega-compact 0.20.23 → 0.20.24

package/dist/extensions/dashboard-server/routes-rag-settings-helpers.js

@@ -50,6 +50,8 @@ export const SETTINGS = [
             boolFlag("MEGACOMPACT_MEMORY_GRAPH", "Memory Graph", "Dashboard-oriented memory graph traversal", true),
             boolFlag("MEGACOMPACT_HYDE", "HyDE", "Generate hypothetical answer via LLM, embed it, RRF-fuse", true, true),
             boolFlag("MEGACOMPACT_NEW_UI", "New Dashboard UI", "Tailwind + shadcn visual design (sidebar, glass panels)", true),
+            boolDirect("MEGACOMPACT_MESSAGE_SEPARATION", "Message Separation (P2)", "PLAN_V2: split conversation thread from tool results to grow stable cache prefix", false),
+            boolDirect("MEGACOMPACT_CACHE_STRIPING", "Cache Striping (P3)", "PLAN_V2: order stable context by stability score so durable chunks lead the prompt", false),
         ],
     },
     {

package/dist/extensions/mega-events/agent-handlers/turnEndHandler/cacheStripe.js

@@ -10,12 +10,23 @@ export function cacheStripe(event, runtime, config) {
             const currentTurn = event.turnIndex;
             const embedder = defaultEmbedder();
             // (a) Extract text from the assistant's response for topic embedding.
+            // pi's assistant content may be a plain string OR an array of parts.
+            // Discriminate by type and only reach into `.text` after confirming the
+            // part is an object carrying a string `.text` — never assume shape.
             let textToEmbed = "";
             const msg = event.message;
-            if (msg.role === "assistant" && Array.isArray(msg.content)) {
-                for (const part of msg.content) {
-                    if ("text" in part && typeof part.text === "string") {
-                        textToEmbed += part.text + " ";
+            if (msg.role === "assistant") {
+                const c = msg.content;
+                if (typeof c === "string") {
+                    textToEmbed = c;
+                }
+                else if (Array.isArray(c)) {
+                    for (const part of c) {
+                        if (part && typeof part === "object" && "text" in part) {
+                            const t = part.text;
+                            if (typeof t === "string")
+                                textToEmbed += t + " ";
+                        }
                     }
                 }
             }

package/dist/extensions/mega-events/context-handler/afterCompact.js

@@ -23,9 +23,12 @@ import { VC6A_ENABLED, VC6C_ENABLED } from "../../../src/config/vector-cortex.js
  * topic model, and dedup — gated on dbMirror. Non-fatal end-to-end.
  */
 export async function persistEpochAndMaintain(runtime, config, ran) {
-    // S27 DB-mirror: write checkpoint_epoch with deterministic nonce.
-    // This makes the cache key stable across identical compactions.
-    if (config.dbMirror) {
+    // PLAN_V2 cache-striping epoch row. buildCacheOptimizedPrompt's stripe
+    // lookup reads the most-recent checkpoint_epochs row, so emit it whenever
+    // PLAN_V2 flags are live. Separate from the legacy dbMirror block below so
+    // PLAN_V2 can run with dbMirror OFF (flag-on is a genuine additive; flag-OFF
+    // = byte-identical to the predecessor, since this block no-ops then).
+    if (config.dbMirror || config.messageSeparation || config.cacheStriping) {
         try {
             const db = openStore(runtime.currentStateDir);
             const cpId = ran.result.checkpointId ?? `epoch-${Date.now()}`;
@@ -40,11 +43,27 @@ export async function persistEpochAndMaintain(runtime, config, ran) {
                 createdAt: Date.now(),
             };
             writeCheckpointEpoch(db, epoch);
+        }
+        catch (e) {
+            runtime.logger.warn("planv2-epoch-fail", { error: String(e) });
+        }
+    }
+    // S27 DB-mirror downstream: stamp turns, rebuild wiki, seed topics, dedup.
+    // Remains on `config.dbMirror` only — these are DB-mirror maintenance and
+    // must NOT run for PLAN_V2-only configurations.
+    if (config.dbMirror) {
+        try {
+            const db = openStore(runtime.currentStateDir);
+            const cpId = ran.result.checkpointId ?? `epoch-${Date.now()}`;
+            // epoch + writeCheckpointEpoch moved to the PLAN_V2 block above (it
+            // gates the wider set of flags); reuse epochIdFor(cpId) here so the
+            // stamps below land in the same epoch row.
+            const epochId = epochIdFor(cpId);
             // S50B: link this session's turns to the epoch that just compacted
             // them (compression-by-conversation-epoch metrics). Isolated-store
             // only; best-effort + non-fatal.
             try {
-                stampTurnsEpochFor(config, runtime.rt.sessionId, epoch.epochId, runtime.currentStateDir);
+                stampTurnsEpochFor(config, runtime.rt.sessionId, epochId, runtime.currentStateDir);
             }
             catch {
                 /* non-fatal: epoch stamping never breaks compaction */

package/dist/extensions/mega-events/context-handler/dbMirrorAppend.js

@@ -3,6 +3,21 @@ import { appendMirrorMessages } from "../mirror-append.js";
 import { appendMessagesToLedger } from "../../mega-runtime/vector-cortex-ledger.js";
 import { epochIdFor } from "../../../src/mirror/epoch.js";
 import { messageContentText } from "./messageText.js";
+/**
+ * Best-effort tool_call_id for the tool_results insert. The toolResult variant
+ * carries a top-level toolCallId (read via an `unknown`-narrowed cast — never
+ * reach into `.content`, which is variant-specific and requires narrowing).
+ * bashExecution has no toolCallId, so fall back to a stable synthetic id keyed
+ * on (turn, index) to satisfy the NOT NULL column. No `any` (PREVENT-011).
+ */
+function toolCallIdOf(m, fallback) {
+    if (m.role === "toolResult") {
+        const id = m.toolCallId;
+        if (typeof id === "string" && id.length > 0)
+            return id;
+    }
+    return fallback;
+}
 /**
  * Append incoming messages to the DB mirror (raw_transcript + thread/tool
  * tables) and the v2 ledger. Gated on config.dbMirror for the mirror; the VC1B
@@ -26,22 +41,35 @@ export function appendMirrorAndLedger(runtime, config, messages) {
             // separation (buildSeparatedPrompt / buildCacheOptimizedPrompt in
             // tailResult) is sufficient for the prompt-construction path;
             // these DB writes persist the split for post-hoc analysis, dashboard
-            // queries, and future readers. Non-fatal — failure here never breaks
-            // the agent loop (PREVENT-PI-004: zero network, local SQLite only).
-            {
+            // queries, and future readers. Gated on (messageSeparation ||
+            // cacheStriping) so flag-OFF remains byte-identical to the
+            // predecessor — when both flags are OFF the live prompt is never
+            // separated, and growing these tables would be dead state.
+            // Non-fatal — failure here never breaks the agent loop
+            // (PREVENT-PI-004: zero network, local SQLite only).
+            if (config.messageSeparation || config.cacheStriping) {
                 const sid = runtime.rt.sessionId;
                 const turn = runtime.currentTurn;
                 const now = Date.now();
                 const threadStmt = db.prepare("INSERT OR IGNORE INTO conversation_thread (conversation_id, role, content, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)");
-                const toolStmt = db.prepare("INSERT OR IGNORE INTO tool_results (conversation_id, role, content, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)");
-                for (const m of messages) {
+                // Schema (plan-v2.ts) is (conversation_id, tool_call_id,
+                // tool_result, turn_index, timestamp) — NOT role/content.
+                const toolStmt = db.prepare("INSERT OR IGNORE INTO tool_results (conversation_id, tool_call_id, tool_result, turn_index, timestamp) VALUES (?, ?, ?, ?, ?)");
+                const toolHas = db.prepare("SELECT 1 FROM tool_results WHERE conversation_id = ? AND turn_index = ? AND tool_call_id = ? AND tool_result = ? LIMIT 1");
+                const threadHas = db.prepare("SELECT 1 FROM conversation_thread WHERE conversation_id = ? AND turn_index = ? AND role = ? AND content = ? LIMIT 1");
+                for (const [idx, m] of messages.entries()) {
                     const role = m.role;
                     const content = messageContentText(m);
                     if (role === "user" || role === "assistant") {
-                        threadStmt.run(sid, role, content, turn, now);
+                        if (threadHas.get(sid, turn, role, content) == null) {
+                            threadStmt.run(sid, role, content, turn, now);
+                        }
                     }
                     else if (role === "toolResult" || role === "bashExecution") {
-                        toolStmt.run(sid, role, content, turn, now);
+                        const toolCallId = toolCallIdOf(m, `bash:${turn}:${idx}`);
+                        if (toolHas.get(sid, turn, toolCallId, content) == null) {
+                            toolStmt.run(sid, toolCallId, content, turn, now);
+                        }
                     }
                 }
             }

package/dist/extensions/mega-events/context-handler/tailResult.js

@@ -1,6 +1,8 @@
 import { stagedForTail, withRecallTail } from "../recall-tail.js";
 import { buildSeparatedPrompt, buildCacheOptimizedPrompt } from "../separated-prompt.js";
 import { messageContentText } from "./messageText.js";
+import { computeContentDigest } from "../../../src/dedup/digest.js";
+const lastTurnPrefix = new WeakMap();
 /**
  * Build the tail injection closure. Returns undefined when nothing is staged
  * (or the flags are OFF) so the caller falls through to its normal return.
@@ -25,20 +27,51 @@ export function buildTailResult(runtime, config, messages) {
         else if (config.messageSeparation) {
             result = buildSeparatedPrompt(result);
         }
-        // P2.5: log prefix stability (fire-and-forget, non-fatal).
-        // tailResult is sync, so use .then().catch() on the dynamic import.
+        // P2.5: log cross-turn stable-prefix length (cache-hit proxy). After the
+        // prompt is built (separated or cache-optimized), fingerprint each leading
+        // message and count how many are byte-identical to the previous turn's
+        // prompt, in order. A high stablePrefix = the provider KV-cache prefix is
+        // re-used (cache hit). Fire-and-forget + non-fatal.
+        //
+        // tailResult may run several times per turn (gate return / replay /
+        // debounce / live-trim), so the sessionId+turn guard measures once per
+        // turn — compare against the PREVIOUS turn's stored footprint, then store
+        // this turn's for the next comparison. Cross-session compares are skipped
+        // via the stored sessionId check (belt-and-suspenders; the WeakMap entry
+        // is scoped to this runtime, which owns the session).
         if (result.length > 1) {
-            import("../../../src/cache-stripe-impl.js").then(({ computeStabilityScore }) => {
-                const stableScore = computeStabilityScore({ content: messageContentText(result[0] ?? result[0]), chunkId: "prefix", accessCount: 0, lastAccessedAt: 0 }, result.slice(0, 2).map((m) => ({ content: messageContentText(m), chunkId: "prefix", accessCount: 0, lastAccessedAt: 0 })));
-                runtime.logger.info("prefix_stability", {
-                    stableScore: Number.isFinite(stableScore) ? stableScore : 0,
-                    prefixMessages: result.length,
-                    separation: config.messageSeparation ? "v2" : "off",
-                    striping: config.cacheStriping ? "v3" : "off",
-                });
-            }).catch(() => {
+            try {
+                const sessionId = runtime.rt.sessionId;
+                const turn = runtime.currentTurn;
+                const prev = lastTurnPrefix.get(runtime);
+                const isNewTurn = !prev || prev.sessionId !== sessionId || prev.turn !== turn;
+                if (isNewTurn) {
+                    const fingerprints = result.map((m) => 
+                    // Role prefix disambiguates identical text across variants
+                    // (roles are a fixed enum — no realistic fingerprint collision).
+                    computeContentDigest(`${m.role}|${messageContentText(m)}`).contentHash);
+                    let stablePrefix = 0;
+                    if (prev && prev.sessionId === sessionId) {
+                        for (let i = 0; i < fingerprints.length; i++) {
+                            if (i >= prev.fingerprints.length ||
+                                prev.fingerprints[i] !== fingerprints[i]) {
+                                break;
+                            }
+                            stablePrefix++;
+                        }
+                    }
+                    lastTurnPrefix.set(runtime, { sessionId, turn, fingerprints });
+                    runtime.logger.info("prefix_stability", {
+                        stablePrefix,
+                        totalMessages: result.length,
+                        separation: config.messageSeparation ? "v2" : "off",
+                        striping: config.cacheStriping ? "v3" : "off",
+                    });
+                }
+            }
+            catch {
                 // Non-fatal: stability logging is best-effort.
-            });
+            }
         }
         return { messages: result };
     };

package/dist/src/cache-stripe-impl.js

@@ -1,240 +1,82 @@
 /**
- * cache-stripe-impl.ts — Vector-Aware Cache Striping implementation.
+ * cache-stripe-impl.ts — Vector-Aware Cache Striping (PLAN_V2 Phase 3).
  *
- * Computes a stability score for each context chunk and assigns it to a
- * cache stripe / prompt-cache layer. Stable chunks (high recency + frequency +
- * semantic density) go to early layers (cached prefix); volatile chunks append
- * at Layer 4 (tail). Runs entirely offline — no network, no LLM (PREVENT-PI-004).
+ * Owns refreshStripeAssignments: the DB-touching write path that scores each
+ * context chunk and UPSERTs its stripe row into cache_stripes. All pure math
+ * and scoring types live in cache-stripe-score.ts (extracted via the
+ * delegate-shell pattern to keep this file under the 300-line src/ soft
+ * limit). cache-stripe.ts re-exports the public surface.
  *
- * The stability score is a weighted composite:
- *   stability = 0.5 * semanticSimilarity + 0.3 * recency + 0.2 * frequency
- *
- * - semanticSimilarity: cosine similarity of the chunk's embedding against the
- *   running session embedding (from TrigramEmbedder). High similarity means the
- *   chunk is topically relevant to current work.
- * - recency: how recently the chunk appeared (normalized to 0.0-1.0 across all
- *   chunks in the epoch). Recent chunks are more likely to benefit from caching.
- * - frequency: how often the chunk's content has been referenced (0.0-1.0,
- *   estimated from a simple access counter stored alongside).
- *
- * Reassignment happens at epoch boundaries via refreshStripeAssignments.
- * All SQL is parameterized (PREVENT-002). No pi runtime types are imported,
- * keeping this module pi-agnostic.
+ * Runs entirely offline — no network, no LLM (PREVENT-PI-004). All SQL is
+ * parameterized (PREVENT-002). No pi runtime types are imported, keeping this
+ * module pi-agnostic.
  */
 import { randomBytes } from "node:crypto";
 import { openStore, withTx } from "./store/sqlite/utils.js";
-// ─── Constants ───────────────────────────────────────────────────────────────
-/** Semantic similarity weight in the composite score. */
-const WEIGHT_SEMANTIC = 0.5;
-/** Recency weight in the composite score. */
-const WEIGHT_RECENCY = 0.3;
-/** Frequency weight in the composite score. */
-const WEIGHT_FREQUENCY = 0.2;
-/** Stripes a chunk lands in based on its stability score. Thresholds define
- *  the boundary between adjacent layers. */
-const STRIPE_THRESHOLDS = [
-    { minStability: 0.90, stripe: 0 },
-    { minStability: 0.70, stripe: 1 },
-    { minStability: 0.50, stripe: 2 },
-    { minStability: 0.30, stripe: 3 },
-    { minStability: -Infinity, stripe: 4 },
-];
-// ─── Embedding helpers (no external dep) ─────────────────────────────────────
-/**
- * FNV-1a 32-bit hash for the content-based embedding fallback. The production
- * path uses TrigramEmbedder from embedder.ts but we keep a self-contained hash
- * for the case where no embedder is passed in.
- */
-function fnv1a(text) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < text.length; i++) {
-        hash ^= text.charCodeAt(i);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0) / 0x100000000;
-}
-/**
- * Produce a crude 128-dim pseudorandom embedding from text using hashed n-gram
- * bins. Matches the approach in TrigramEmbedder._embedRaw conceptually. Used
- * only as a fallback / test path; the caller should prefer TrigramEmbedder.
- */
-function fallbackEmbed(text) {
-    const dim = 128;
-    const vec = new Array(dim).fill(0);
-    const norm = text.toLowerCase().replace(/\s+/g, " ");
-    if (norm.length === 0)
-        return vec;
-    vec[Math.floor(fnv1a(norm) * dim)] += 1;
-    for (const word of norm.split(" ")) {
-        if (word.length === 0)
-            continue;
-        vec[Math.floor(fnv1a(word) * dim)] += 0.5;
-        for (let i = 0; i < Math.max(1, word.length - 1); i++) {
-            const trigram = word.slice(i, i + 3);
-            if (trigram.length === 3) {
-                vec[Math.floor(fnv1a(trigram) * dim)] += 0.25;
-            }
-        }
-    }
-    return l2Normalize(vec);
-}
-function l2Normalize(v) {
-    let sumSq = 0;
-    for (let i = 0; i < v.length; i++)
-        sumSq += v[i] * v[i];
-    if (sumSq === 0)
-        return v;
-    const norm = Math.sqrt(sumSq);
-    for (let i = 0; i < v.length; i++)
-        v[i] /= norm;
-    return v;
-}
-/** Compute cosine similarity between two vectors of equal length. */
-function cosineSimilarity(a, b) {
-    if (a.length !== b.length || a.length === 0)
-        return 0;
-    let dot = 0;
-    let na = 0;
-    let nb = 0;
-    for (let i = 0; i < a.length; i++) {
-        dot += a[i] * b[i];
-        na += a[i] * a[i];
-        nb += b[i] * b[i];
-    }
-    const denom = Math.sqrt(na) * Math.sqrt(nb);
-    return denom === 0 ? 0 : dot / denom;
-}
-// ─── Stability Scoring ───────────────────────────────────────────────────────
-/**
- * Compute a composite stability score for a single chunk.
- *
- * @param chunk         The chunk metadata + content to score.
- * @param allChunks     All chunks in this epoch (used to compute relative recency).
- * @param embedder      Optional embedder instance. If omitted, uses the
- *                      self-contained fallback (128-dim hashed n-gram).
- * @param sessionEmbed  Pre-computed embedding for the current session (the
- *                      "query" vector). If omitted, computed on the fly from
- *                      the chunk content alone, which degrades semantic scoring
- *                      to a self-similarity baseline.
- * @returns             A number in [0.0, 1.0] where 1.0 = most stable.
- */
-export function computeStabilityScore(chunk, allChunks, embedder, sessionEmbed) {
-    // ── Semantic similarity (0.5 weight) ────────────────────────────────────
-    const emb = embedder
-        ? embedder.embed(chunk.content)
-        : fallbackEmbed(chunk.content);
-    // If no session embedding is provided, use the chunk's own embedding as
-    // a self-similarity — this produces a baseline score based on content
-    // density (chunks with more meaningful content get higher internal
-    // similarity). Real deployments should pass the session embedding.
-    const sem = cosineSimilarity(emb, sessionEmbed ?? emb);
-    const semanticScore = isNaN(sem) ? 0 : sem;
-    // ── Recency (0.3 weight) ────────────────────────────────────────────────
-    // Relative recency: lastAccessedAt of this chunk vs. min/max across epoch.
-    // Falls back to 0.5 if there's only one chunk or no timestamp data.
-    let recencyScore = 0.5;
-    const accessed = allChunks
-        .map((c) => c.lastAccessedAt)
-        .filter((t) => t > 0);
-    if (accessed.length > 1) {
-        const minT = Math.min(...accessed);
-        const maxT = Math.max(...accessed);
-        const range = maxT - minT;
-        if (range > 0) {
-            recencyScore = (chunk.lastAccessedAt - minT) / range;
-        }
-        else {
-            recencyScore = 1.0;
-        }
-    }
-    // ── Frequency (0.2 weight) ──────────────────────────────────────────────
-    // Access count relative to the max across the epoch.
-    const counts = allChunks.map((c) => c.accessCount);
-    const maxCount = Math.max(...counts, 1);
-    const freqScore = maxCount > 0 ? chunk.accessCount / maxCount : 0;
-    // ── Composite ───────────────────────────────────────────────────────────
-    const stability = WEIGHT_SEMANTIC * semanticScore +
-        WEIGHT_RECENCY * recencyScore +
-        WEIGHT_FREQUENCY * freqScore;
-    // Clamp to [0.0, 1.0] as a safety net.
-    return Math.max(0, Math.min(1, stability));
-}
-/**
- * Determine the cache stripe (layer) for a given stability score.
- *
- * @param stability  Composite stability score in [0.0, 1.0].
- * @returns          Stripe number 0-4.
- */
-export function stabilityToStripe(stability) {
-    for (const t of STRIPE_THRESHOLDS) {
-        if (stability >= t.minStability)
-            return t.stripe;
-    }
-    return 4;
-}
+import { computeStabilityScore, stabilityToStripe, fallbackEmbed, l2Normalize, } from "./cache-stripe-score.js";
+export { computeStabilityScore, stabilityToStripe, fallbackEmbed, l2Normalize, } from "./cache-stripe-score.js";
 // ─── Stripe Reassignment ─────────────────────────────────────────────────────
 /**
- * Refresh stripe assignments for all chunks in the current epoch.
+ * Refresh stripe assignments for all chunks in an epoch.
  *
  * Steps:
- *  1. Read all context_chunks from the SQLite store that belong to the
- *     current epoch (or all chunks if no epoch filter).
- *  2. For each chunk, compute a stability score via computeStabilityScore.
- *  3. Map stability -> stripe via stabilityToStripe.
- *  4. UPSERT into cache_stripes.
- *  5. (Stale entries for this epoch are implicitly overwritten by the UPSERT.)
- *
- * The optional embedder parameter allows injecting the production
- * TrigramEmbedder. If omitted, the fallback hashed n-gram embedder is used
- * (works offline in all scenarios).
+ *  1. Resolve target epochId: explicit string → use it; '' → no epoch filter
+ *     (assign all chunks); undefined → look up the most recently committed
+ *     checkpoint_epochs row so the stripes we write are visible to the
+ *     buildCacheOptimizedPrompt reader (`ORDER BY created_at DESC LIMIT 1`).
+ *     If no epoch exists yet (pre-first-compaction), fall back to a random id
+ *     — the write succeeds and the rows are simply never read until an epoch
+ *     lands.
+ *  2. Read context_chunks (chunk_id = c.id, NOT rowid — the read path joins
+ *     on the TEXT id).
+ *  3. Score each chunk via computeStabilityScore (mean-pool embeddings for a
+ *     session-level semantic "query" vector).
+ *  4. Atomic UPSERT into cache_stripes.
  *
- * Non-fatal: failures are logged via a provided logger callback and never
- * thrown. Returns the count of chunks reassigned.
- *
- * @param store      An open SQLite DatabaseSync handle (or a stateDir string
- *                   to open lazily). Accepts either to match the caller's
- *                   convenience. When a string is passed, opens the store for
- *                   this call only (does not cache the connection).
- * @param epochId    The epoch to reassign. If omitted, generates a new epoch
- *                   ID (random hex). Pass '' to reassign all chunks without
- *                   filtering by epoch.
- * @param embedder   Optional TrigramEmbedder instance. When provided, uses it
- *                   for semantic similarity; otherwise uses the fallback.
- * @param logFn      Optional logging callback (defaults to no-op).
- * @returns          The number of chunks that were reassigned.
+ * Non-fatal: failures are logged via the provided logger and never thrown.
+ * Returns the count of chunks reassigned (0 on error).
  */
 export function refreshStripeAssignments(store, epochId, embedder, logFn) {
     const db = typeof store === "string" ? openStore(store) : store;
     const log = logFn ?? (() => { });
-    const actualEpochId = epochId ?? nextEpochId();
+    let actualEpochId;
+    if (epochId !== undefined) {
+        actualEpochId = epochId;
+    }
+    else {
+        try {
+            const latest = db
+                .prepare(`SELECT epoch_id FROM checkpoint_epochs ORDER BY created_at DESC LIMIT 1`)
+                .get();
+            actualEpochId = latest?.epoch_id ?? nextEpochId();
+        }
+        catch {
+            actualEpochId = nextEpochId();
+        }
+    }
     const now = Math.floor(Date.now() / 1000);
     try {
-        // 1. Read all relevant context_chunks, using the summary as text content.
-        //    The summary field holds the compressed checkpoint content; for fresh
-        //    chunks that have no summary yet, fall back to normalized_text or
-        //    concatenated key_decisions.
+        // cache_stripes has no access_count / last_accessed_at columns (schema:
+        // chunk_id/stripe/stability/assigned_at/epoch_id) — querying them throws.
+        // Score freshness/frequency to 0 here; stability derives from content +
+        // semantic similarity only until an access-tracking column is added.
         const rows = db
-            .prepare(`SELECT c.rowid AS chunk_id,
-                COALESCE(c.summary, c.normalized_text, c.key_decisions, '') AS content,
-                COALESCE(s.access_count, 0) AS access_count,
-                COALESCE(s.last_accessed_at, 0) AS last_accessed_at
+            .prepare(`SELECT c.id AS chunk_id,
+                COALESCE(c.summary, c.normalized_text, c.key_decisions, '') AS content
          FROM context_chunks c
-         LEFT JOIN cache_stripes s ON s.chunk_id = CAST(c.rowid AS TEXT)
+         LEFT JOIN cache_stripes s ON s.chunk_id = c.id
          WHERE (? = '' OR s.epoch_id = ? OR s.epoch_id IS NULL)`)
             .all(actualEpochId, actualEpochId);
         if (rows.length === 0) {
             log("cache-stripe: no chunks to reassign");
             return 0;
         }
-        // Build the allChunks array for relative scoring.
         const allChunks = rows.map((r) => ({
-            chunkId: String(r.chunk_id),
+            chunkId: r.chunk_id,
             content: r.content,
-            accessCount: r.access_count,
-            lastAccessedAt: r.last_accessed_at,
+            accessCount: 0,
+            lastAccessedAt: 0,
         }));
-        // Compute a session embedding (mean of all chunk embeddings) for semantic
-        // similarity comparison.
         let sessionEmbed;
         try {
             const dim = embedder ? embedder.embed("").length : 128;
@@ -257,14 +99,12 @@ export function refreshStripeAssignments(store, epochId, embedder, logFn) {
         catch {
             log("cache-stripe: session embedding failed, skipping semantic weight");
         }
-        // 2. Compute stability for each chunk.
         const results = [];
         for (const chunk of allChunks) {
             const stability = computeStabilityScore(chunk, allChunks, embedder, sessionEmbed);
             const stripe = stabilityToStripe(stability);
             results.push({ chunkId: chunk.chunkId, stripe, stability });
         }
-        // 3. UPSERT into cache_stripes using a savepoint for atomicity.
         const upsert = db.prepare(`INSERT OR REPLACE INTO cache_stripes(chunk_id, stripe, stability, assigned_at, epoch_id)
        VALUES (?, ?, ?, ?, ?)`);
         withTx(db, () => {
@@ -280,9 +120,7 @@ export function refreshStripeAssignments(store, epochId, embedder, logFn) {
         return 0;
     }
 }
-/**
- * Generate a random epoch ID (16 hex chars) for tokenizing stripe cohorts.
- */
+/** Generate a random epoch id (16 hex chars) for tokenizing stripe cohorts. */
 function nextEpochId() {
     return randomBytes(8).toString("hex");
 }