pi-mega-compact 0.8.24 → 0.8.26

package/dist/src/store/sqlite/mechanical-fix.test.js

@@ -0,0 +1,146 @@
+/**
+ * mechanical-fix.test.ts — focused unit tests for the SQLite-side mechanical-fix
+ * batch: safeJson (utils.ts), storeStats numeric MAX + dedup_status filter
+ * (stats.ts), addTokensSaved CAST AS REAL (meta.ts), evictMemoryLru named
+ * @param bindings (memories.ts). Pi-agnostic; uses isolated state dirs (G7).
+ */
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { mkdtempSync, rmSync } from "node:fs";
+import { safeJson, closeStore } from "./utils.js";
+import { storeStats } from "./stats.js";
+import { upsertCheckpoint, setDedupStatus } from "./checkpoints.js";
+import { addTokensSaved, getTokensSaved } from "./meta.js";
+import { addMemory, listMemories } from "./memories.js";
+function makeCp(id, sessionId) {
+    return {
+        checkpointId: id,
+        sessionId,
+        summary: `summary-${id}`,
+        keyDecisions: [],
+        nextSteps: [],
+        filesModified: [],
+        tokenEstimate: 100,
+        regionHash: `hash-${id}`,
+        embedding: [],
+        timestamp: Date.now(),
+    };
+}
+// ---------------------------------------------------------------------------
+// safeJson (utils.ts)
+// ---------------------------------------------------------------------------
+describe("mechanical-fix: safeJson (utils.ts)", () => {
+    it("returns fallback on null, undefined, empty, and corrupt JSON", () => {
+        assert.deepEqual(safeJson(null, []), []);
+        assert.deepEqual(safeJson(undefined, []), []);
+        assert.deepEqual(safeJson("", []), []);
+        assert.deepEqual(safeJson("not json", ["fb"]), ["fb"]);
+        assert.deepEqual(safeJson('["a","b"]', []), ["a", "b"]);
+        assert.equal(safeJson(null, 42), 42);
+        assert.deepEqual(safeJson('{"k":1}', {}), { k: 1 });
+    });
+});
+// ---------------------------------------------------------------------------
+// storeStats (stats.ts) — numeric MAX(id) + dedup_status filter
+// ---------------------------------------------------------------------------
+describe("mechanical-fix: storeStats (stats.ts)", () => {
+    let dir;
+    before(() => {
+        dir = mkdtempSync(join(tmpdir(), "mc-mech-stats-"));
+        process.env.MEGACOMPACT_STATE_DIR = dir;
+    });
+    after(() => {
+        closeStore(dir);
+        delete process.env.MEGACOMPACT_STATE_DIR;
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("returns numerically-max checkpoint id (not lexicographic) for 100+ checkpoints", () => {
+        const sid = "sess_stats";
+        // Insert chkpt_001..chkpt_100 (100 checkpoints) + chkpt_999 + chkpt_1000.
+        // Numeric max = 1000 → "chkpt_1000"; lexicographic max would be "chkpt_999"
+        // (because '9' > '1' at position 6 when comparing 8 vs 9-char strings).
+        for (let i = 1; i <= 100; i++) {
+            upsertCheckpoint(makeCp(`chkpt_${String(i).padStart(3, "0")}`, sid), dir);
+        }
+        upsertCheckpoint(makeCp("chkpt_999", sid), dir);
+        upsertCheckpoint(makeCp("chkpt_1000", sid), dir);
+        const s = storeStats(sid, dir);
+        assert.equal(s.checkpointCount, 102);
+        assert.equal(s.lastCheckpointId, "chkpt_1000");
+        assert.equal(s.lastSummary, "summary-chkpt_1000");
+    });
+    it("excludes dedup_status='removed' rows from counts", () => {
+        const sid = "sess_dedup";
+        upsertCheckpoint(makeCp("chkpt_001", sid), dir);
+        upsertCheckpoint(makeCp("chkpt_002", sid), dir);
+        setDedupStatus("chkpt_001", sid, "removed", dir);
+        const s = storeStats(sid, dir);
+        assert.equal(s.checkpointCount, 1);
+        assert.equal(s.lastCheckpointId, "chkpt_002");
+    });
+});
+// ---------------------------------------------------------------------------
+// addTokensSaved (meta.ts) — CAST AS REAL preserves fractional values
+// ---------------------------------------------------------------------------
+describe("mechanical-fix: addTokensSaved (meta.ts)", () => {
+    let dir;
+    before(() => {
+        dir = mkdtempSync(join(tmpdir(), "mc-mech-meta-"));
+        process.env.MEGACOMPACT_STATE_DIR = dir;
+    });
+    after(() => {
+        closeStore(dir);
+        delete process.env.MEGACOMPACT_STATE_DIR;
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("preserves fractional values (CAST AS REAL, not INTEGER)", () => {
+        addTokensSaved(10.5, dir);
+        assert.equal(getTokensSaved(dir), 10.5);
+        addTokensSaved(10.5, dir);
+        // With INTEGER: CAST("10.5" AS INTEGER)=10, 10+10.5=20.5.
+        // With REAL: CAST("10.5" AS REAL)=10.5, 10.5+10.5=21.
+        assert.equal(getTokensSaved(dir), 21);
+    });
+});
+// ---------------------------------------------------------------------------
+// evictMemoryLru (memories.ts) — named @param bindings
+// ---------------------------------------------------------------------------
+describe("mechanical-fix: evictMemoryLru (memories.ts)", () => {
+    let dir;
+    before(() => {
+        dir = mkdtempSync(join(tmpdir(), "mc-mech-mem-"));
+        process.env.MEGACOMPACT_STATE_DIR = dir;
+        process.env.MEGACOMPACT_MEMORY_MAX_ROWS = "3";
+    });
+    after(() => {
+        closeStore(dir);
+        delete process.env.MEGACOMPACT_STATE_DIR;
+        delete process.env.MEGACOMPACT_MEMORY_MAX_ROWS;
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it("evicts oldest rows past cap (repo-scoped, @repo named binding)", () => {
+        const repo = "test-repo";
+        for (let i = 0; i < 5; i++) {
+            addMemory({ content: `memory-${i}` }, repo, dir);
+        }
+        const memories = listMemories(repo, 100, dir);
+        assert.equal(memories.length, 3);
+        // Oldest two (memory-0, memory-1) evicted; memory-2, 3, 4 survive.
+        const contents = memories.map((m) => m.content).sort();
+        assert.deepEqual(contents, ["memory-2", "memory-3", "memory-4"]);
+    });
+    it("handles null-repo scope (repo IS NULL branch, @over only)", () => {
+        for (let i = 0; i < 4; i++) {
+            addMemory({ content: `nullmem-${i}` }, null, dir);
+        }
+        // listMemories(null, ...) returns ALL rows (no repo filter); narrow to
+        // null-repo rows to verify the IS NULL eviction branch in isolation.
+        const nullMemories = listMemories(null, 100, dir).filter((m) => m.repo === null);
+        assert.equal(nullMemories.length, 3);
+        // Oldest (nullmem-0) evicted.
+        const contents = nullMemories.map((m) => m.content).sort();
+        assert.deepEqual(contents, ["nullmem-1", "nullmem-2", "nullmem-3"]);
+    });
+});

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

@@ -49,10 +49,10 @@ function evictMemoryLru(repo, stateDir) {
     const maxRows = memoryMaxRows();
     // SQLite `= NULL` is never true, so the null-repo scope (memories are
     // stateDir-scoped when repo is null — the applyMemoryOps path) needs `IS NULL`.
-    const where = repo == null ? "repo IS NULL" : "repo = ?";
+    const where = repo == null ? "repo IS NULL" : "repo = @repo";
     const countRow = repo == null
         ? db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get()
-        : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get(repo);
+        : db.prepare(`SELECT COUNT(*) AS n FROM memories WHERE ${where}`).get({ "@repo": repo });
     const count = countRow.n;
     const over = count - maxRows;
     if (over <= 0)
@@ -63,12 +63,12 @@ function evictMemoryLru(repo, stateDir) {
     const sql = `DELETE FROM memories WHERE ${where} AND id IN (
        SELECT id FROM memories WHERE ${where}
        ORDER BY COALESCE(last_referenced, last_recalled_at, created_at) ASC, id ASC
-       LIMIT ?
+       LIMIT @over
      )`;
     if (repo == null)
-        db.prepare(sql).run(over);
+        db.prepare(sql).run({ "@over": over });
     else
-        db.prepare(sql).run(repo, repo, over);
+        db.prepare(sql).run({ "@over": over, "@repo": repo });
 }
 /** Save a memory to the current repo's store. Returns the new row id.
  *  S24 hardening: content is truncated to MEMORY_MAX_CHARS and, once the per-repo

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

@@ -28,7 +28,7 @@ export function addTokensSaved(delta, stateDir = getStateDir()) {
         return;
     const db = openStore(stateDir);
     db.prepare(`INSERT INTO meta(key, value) VALUES('tokens_saved', ?)
-     ON CONFLICT(key) DO UPDATE SET value = CAST(CAST(value AS INTEGER) + ? AS TEXT)`).run(String(delta), delta);
+     ON CONFLICT(key) DO UPDATE SET value = CAST(CAST(value AS REAL) + ? AS TEXT)`).run(String(delta), delta);
 }
 /** Read a store-wide integer counter from the meta table (0 if absent). */
 export function getMetaNumber(key, stateDir = getStateDir()) {

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

@@ -2,33 +2,60 @@
  * raptor.ts — Sprint 13 RAPTOR node persistence.
  */
 import { getStateDir, normalizeSessionId } from "../../store.js";
-import { openStore, jsonText, encodeEmbedding, decodeEmbedding } from "./utils.js";
+import { openStore, withTx, jsonText, encodeEmbedding, decodeEmbedding, } from "./utils.js";
 /** Persist a single RAPTOR node (upsert by (session_id, id)). */
 export function upsertRaptorNode(node, stateDir = getStateDir()) {
     const db = openStore(stateDir);
     db.prepare(`INSERT INTO raptor_nodes(id, session_id, level, parent_id, children, summary, embedding_blob, quality_marker, token_estimate, built_at)
-     VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     VALUES(@id, @session_id, @level, @parent_id, @children, @summary, @embedding_blob, @quality_marker, @token_estimate, @built_at)
      ON CONFLICT(session_id, id) DO UPDATE SET
        level=excluded.level, parent_id=excluded.parent_id, children=excluded.children,
        summary=excluded.summary, embedding_blob=excluded.embedding_blob,
        quality_marker=excluded.quality_marker, token_estimate=excluded.token_estimate,
-       built_at=excluded.built_at`).run(node.id, node.sessionId, node.level, node.parentId, jsonText(node.children), node.summary, encodeEmbedding(node.embedding), node.qualityMarker, node.tokenEstimate, node.builtAt);
+       built_at=excluded.built_at`).run({
+        id: node.id,
+        session_id: node.sessionId,
+        level: node.level,
+        parent_id: node.parentId,
+        children: jsonText(node.children),
+        summary: node.summary,
+        embedding_blob: encodeEmbedding(node.embedding),
+        quality_marker: node.qualityMarker,
+        token_estimate: node.tokenEstimate,
+        built_at: node.builtAt,
+    });
 }
 /** Persist an entire built RAPTOR tree for a session (shadow or live). */
 export function saveRaptorTree(sessionId, tree, builtAt, stateDir = getStateDir()) {
-    for (const node of tree.nodes.values()) {
-        upsertRaptorNode({
-            id: node.id,
-            sessionId,
-            level: node.level,
-            parentId: node.parentId,
-            children: node.children,
-            summary: node.summary,
-            embedding: node.embedding,
-            qualityMarker: node.qualityMarker,
-            tokenEstimate: node.tokenEstimate,
-            builtAt,
-        }, stateDir);
+    const nsid = normalizeSessionId(sessionId);
+    const db = openStore(stateDir);
+    withTx(db, () => {
+        db.prepare("DELETE FROM raptor_nodes WHERE session_id = ?").run(nsid);
+        for (const node of tree.nodes.values()) {
+            upsertRaptorNode({
+                id: node.id,
+                sessionId: nsid,
+                level: node.level,
+                parentId: node.parentId,
+                children: node.children,
+                summary: node.summary,
+                embedding: node.embedding,
+                qualityMarker: node.qualityMarker,
+                tokenEstimate: node.tokenEstimate,
+                builtAt,
+            }, stateDir);
+        }
+    });
+}
+/** Safe JSON array parse — returns [] on corrupt input. */
+function safeJsonArray(raw) {
+    if (typeof raw !== "string" || !raw)
+        return [];
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
     }
 }
 /** Load all RAPTOR nodes for a session. */
@@ -42,7 +69,7 @@ export function listRaptorNodes(sessionId, stateDir = getStateDir()) {
         sessionId: row.session_id,
         level: row.level,
         parentId: row.parent_id ?? null,
-        children: row.children ? JSON.parse(row.children) : [],
+        children: safeJsonArray(row.children),
         summary: row.summary ?? "",
         embedding: decodeEmbedding(row.embedding_blob),
         qualityMarker: row.quality_marker ?? "low",
@@ -55,3 +82,15 @@ export function clearRaptorNodes(sessionId, stateDir = getStateDir()) {
     const db = openStore(stateDir);
     db.prepare("DELETE FROM raptor_nodes WHERE session_id = ?").run(normalizeSessionId(sessionId));
 }
+/**
+ * S25: newest built_at for a session's RAPTOR tree (0 if no nodes exist).
+ * Cheap indexed MAX query used by raptorSearchHits to validate cache freshness
+ * without rehydrating the full node Map.
+ */
+export function maxRaptorNodeBuiltAt(sessionId, stateDir = getStateDir()) {
+    const db = openStore(stateDir);
+    const row = db
+        .prepare(`SELECT MAX(built_at) AS max_built FROM raptor_nodes WHERE session_id = ?`)
+        .get(normalizeSessionId(sessionId));
+    return row?.max_built ?? 0;
+}

package/dist/src/store/sqlite/raptor.test.js

@@ -0,0 +1,106 @@
+/**
+ * raptor.test.ts — regression tests for RAPTOR node persistence.
+ *
+ * Covers:
+ *   1. saveRaptorTree atomicity (withTx + openStore nesting safety): rebuilding
+ *      a DIFFERENT tree for the same session leaves no stale nodes from the
+ *      first tree.
+ *   2. listRaptorNodes robustness: corrupt `children` JSON in a row does not
+ *      throw and that row's children come back as [].
+ *
+ * No network. Uses node:sqlite directly via openStore.
+ */
+import { test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { openStore, closeStore } from "./utils.js";
+import { saveRaptorTree, listRaptorNodes } from "./raptor.js";
+let tmpDir;
+beforeEach(() => {
+    tmpDir = mkdtempSync(join(tmpdir(), "mc-raptor-persist-"));
+});
+afterEach(() => {
+    closeStore(tmpDir);
+    rmSync(tmpDir, { recursive: true, force: true });
+});
+/** Build a simple tree map with the minimal shape saveRaptorTree expects. */
+function makeTree(nodeSpecs) {
+    const nodes = new Map();
+    for (const spec of nodeSpecs) {
+        nodes.set(spec.id, {
+            id: spec.id,
+            level: spec.level,
+            parentId: spec.level === 0 ? null : "root",
+            children: spec.children,
+            summary: `summary for ${spec.id}`,
+            embedding: [1, 0, 0],
+            qualityMarker: "low",
+            tokenEstimate: 10,
+        });
+    }
+    return { nodes };
+}
+// ── Test 1: rebuild + save a different tree → no stale nodes ──────────────────
+test("saveRaptorTree: rebuilding a different tree for the same session leaves no stale nodes", () => {
+    const sid = "sess_replace";
+    const builtAt1 = 1000;
+    const builtAt2 = 2000;
+    // Tree A: nodes alpha, beta, root.
+    const treeA = makeTree([
+        { id: "alpha", level: 1, children: ["leaf_0", "leaf_1"] },
+        { id: "beta", level: 1, children: ["leaf_2", "leaf_3"] },
+        { id: "root", level: 2, children: ["leaf_0", "leaf_1", "leaf_2", "leaf_3"] },
+    ]);
+    saveRaptorTree(sid, treeA, builtAt1, tmpDir);
+    const afterA = listRaptorNodes(sid, tmpDir);
+    assert.equal(afterA.length, 3, "tree A has 3 nodes");
+    assert.deepEqual(afterA.map((n) => n.id).sort(), ["alpha", "beta", "root"], "tree A node ids match");
+    // Tree B: completely different nodes gamma, delta, root.
+    const treeB = makeTree([
+        { id: "gamma", level: 1, children: ["leaf_4", "leaf_5"] },
+        { id: "delta", level: 1, children: ["leaf_6", "leaf_7"] },
+        { id: "root", level: 2, children: ["leaf_4", "leaf_5", "leaf_6", "leaf_7"] },
+    ]);
+    saveRaptorTree(sid, treeB, builtAt2, tmpDir);
+    const afterB = listRaptorNodes(sid, tmpDir);
+    assert.equal(afterB.length, 3, "tree B has 3 nodes (stale A nodes gone)");
+    // No stale node ids from tree A survive.
+    const idsAfterB = new Set(afterB.map((n) => n.id));
+    assert.ok(!idsAfterB.has("alpha"), "stale node alpha is gone");
+    assert.ok(!idsAfterB.has("beta"), "stale node beta is gone");
+    assert.ok(idsAfterB.has("gamma"), "new node gamma present");
+    assert.ok(idsAfterB.has("delta"), "new node delta present");
+    assert.ok(idsAfterB.has("root"), "root present (upserted, not duplicated)");
+    // builtAt was updated to the new timestamp.
+    for (const n of afterB) {
+        assert.equal(n.builtAt, builtAt2, `node ${n.id} builtAt updated to tree B timestamp`);
+    }
+});
+// ── Test 2: corrupt children JSON → no throw, children = [] ──────────────────
+test("listRaptorNodes: corrupt children JSON does not throw and returns []", () => {
+    const sid = "sess_corrupt";
+    const builtAt = 5000;
+    const tree = makeTree([
+        { id: "good", level: 1, children: ["leaf_0", "leaf_1"] },
+        { id: "bad", level: 1, children: ["leaf_2", "leaf_3"] },
+        { id: "root", level: 2, children: ["leaf_0", "leaf_1", "leaf_2", "leaf_3"] },
+    ]);
+    saveRaptorTree(sid, tree, builtAt, tmpDir);
+    // Corrupt the `children` JSON for the "bad" row directly in SQLite.
+    const db = openStore(tmpDir);
+    db.prepare("UPDATE raptor_nodes SET children = ? WHERE session_id = ? AND id = ?").run("{not valid json", sid, "bad");
+    // listRaptorNodes must not throw.
+    let nodes;
+    assert.doesNotThrow(() => {
+        nodes = listRaptorNodes(sid, tmpDir);
+    }, "listRaptorNodes must not throw on corrupt children JSON");
+    const badNode = nodes.find((n) => n.id === "bad");
+    assert.ok(badNode, "bad node still present");
+    assert.deepEqual(badNode.children, [], "corrupt children parsed to []");
+    // The good node is unaffected.
+    const goodNode = nodes.find((n) => n.id === "good");
+    assert.ok(goodNode, "good node present");
+    assert.deepEqual(goodNode.children, ["leaf_0", "leaf_1"], "good node children intact");
+});

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

@@ -42,6 +42,11 @@ export function initSchema(db) {
     CREATE UNIQUE INDEX IF NOT EXISTS idx_chunks_pk
       ON context_chunks(session_id, id);
     CREATE INDEX IF NOT EXISTS idx_chunks_session ON context_chunks(session_id);
+    -- S42D/QA perf: session-scoped timestamp ordering so the S25 RAPTOR
+    -- freshness guard's MAX(timestamp) (run on every RAPTOR search) is
+    -- index-satisfied rather than a full partition scan as checkpoints grow.
+    CREATE INDEX IF NOT EXISTS idx_chunks_session_ts
+      ON context_chunks(session_id, timestamp DESC);
     CREATE INDEX IF NOT EXISTS idx_chunks_region ON context_chunks(region_hash);
     CREATE INDEX IF NOT EXISTS idx_chunks_content ON context_chunks(content_hash);
     -- Partial UNIQUE (QA #1): null content_hash rows never violate the constraint;
@@ -71,7 +76,9 @@ export function initSchema(db) {
     CREATE TABLE IF NOT EXISTS session_state (
       session_id               TEXT PRIMARY KEY,
       injected_checkpoint_ids TEXT,      -- JSON array
-      stored_region_hashes    TEXT       -- JSON array
+      stored_region_hashes    TEXT,      -- JSON array
+      conversation_id         TEXT,       -- S43: groups turns across resumes (/clear → new root)
+      last_turn_id            INTEGER     -- S43: most recent turn id (stable fork refs)
     );
 
     CREATE TABLE IF NOT EXISTS meta (
@@ -98,6 +105,28 @@ export function initSchema(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_raptor_session ON raptor_nodes(session_id);
     CREATE INDEX IF NOT EXISTS idx_raptor_parent ON raptor_nodes(parent_id);
+    -- S42D/QA perf: session-scoped built_at ordering so the per-search cache
+    -- invalidation MAX(built_at) is index-satisfied.
+    CREATE INDEX IF NOT EXISTS idx_raptor_session_built
+      ON raptor_nodes(session_id, built_at DESC);
+
+    -- S42D: structured RAPTOR build history. One row per tree build; the
+    -- freshness check (buildHistory.ts) uses completed_at + leaf_count to skip
+    -- unnecessary rebuilds when the tree is recent and the chunk count is stable.
+    CREATE TABLE IF NOT EXISTS raptor_build_history (
+      build_id        TEXT PRIMARY KEY,
+      session_id      TEXT NOT NULL,
+      state_dir       TEXT NOT NULL,
+      started_at      INTEGER NOT NULL,
+      completed_at    INTEGER NOT NULL,
+      node_count      INTEGER NOT NULL,
+      leaf_count      INTEGER NOT NULL,
+      depth           INTEGER NOT NULL,
+      config_json     TEXT NOT NULL,    -- serialized BuildOptions
+      coherence_score REAL,            -- avg intra-cluster cosine (post-build)
+      timed_out       INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_raptor_build_session ON raptor_build_history(session_id);
 
     -- Foundation for future features (resume sessions, daily log, lessons
     -- learned). Scaffolded now so all store data lives in SQLite from day one;
@@ -216,6 +245,59 @@ export function initSchema(db) {
     );
     CREATE INDEX IF NOT EXISTS idx_epoch_session ON checkpoint_epochs(session_id, created_at DESC);
 
+    -- S43 (per-turn vector tracking): the relational spine for per-turn +
+    -- per-conversation memories. One row per turn_end; links turns to the
+    -- epoch that compacted them (epoch_id) and to the checkpoints/cluster
+    -- summaries that were RECALLED during that turn (turn_recall).
+    -- conversation_id groups turns across pi session resumes (/clear starts a
+    -- new conversation root; a fork carries parent_conversation_id).
+    CREATE TABLE IF NOT EXISTS turns (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT, -- global turn id
+      conversation_id TEXT NOT NULL,
+      session_id      TEXT NOT NULL,
+      turn_index      INTEGER NOT NULL,                   -- per-session turn (event.turnIndex)
+      role            TEXT,                                -- 'user' | 'assistant' | 'tool' (turn's last role)
+      started_at      INTEGER NOT NULL,
+      ended_at        INTEGER,                             -- set at turn_end
+      ctx_tokens      INTEGER,                             -- runtime.lastCtxTokens snapshot
+      ctx_percent     REAL,                                -- runtime.lastCtxPercent
+      pressure_band   TEXT,                                -- 'low'|'mid'|'high'|'critical'
+      model_id        TEXT,
+      epoch_id        TEXT,                                -- FK checkpoint_epochs (set when a compact closes this turn's epoch)
+      UNIQUE(session_id, turn_index)
+    );
+    CREATE INDEX IF NOT EXISTS idx_turns_conv ON turns(conversation_id, turn_index);
+    CREATE INDEX IF NOT EXISTS idx_turns_session ON turns(session_id, turn_index);
+    CREATE INDEX IF NOT EXISTS idx_turns_epoch ON turns(epoch_id) WHERE epoch_id IS NOT NULL;
+
+    -- S43: recall provenance — which checkpoints/cluster summaries were
+    -- injected at which turn, their score, and the path that sourced them.
+    -- This is the per-turn vector data that makes memory quality measurable
+    -- per turn and enables recall-to-point (replay these checkpoint_ids into a
+    -- forked session). source: 'flat' | 'raptor' | 'cross-repo' | 'memory'.
+    CREATE TABLE IF NOT EXISTS turn_recall (
+      id            INTEGER PRIMARY KEY AUTOINCREMENT,
+      turn_id       INTEGER NOT NULL,
+      checkpoint_id TEXT NOT NULL,
+      score         REAL NOT NULL,
+      source        TEXT NOT NULL,
+      raptor_level  INTEGER,                              -- set for RAPTOR cluster hits
+      UNIQUE(turn_id, checkpoint_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_turn_recall_turn ON turn_recall(turn_id);
+    CREATE INDEX IF NOT EXISTS idx_turn_recall_cp ON turn_recall(checkpoint_id);
+
+    -- S43: conversation branch/fork registry. A row per fork: the child
+    -- conversation inherits the parent's recall state at fork_turn_id as its
+    -- starting injected-set. The root conversation has no row here.
+    CREATE TABLE IF NOT EXISTS conversation_branches (
+      conversation_id        TEXT PRIMARY KEY,
+      parent_conversation_id TEXT NOT NULL,
+      fork_turn_id           INTEGER NOT NULL,             -- FK turns.id at the branch point
+      created_at             INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_conv_branch_parent ON conversation_branches(parent_conversation_id);
+
     -- S27 Task 6: dedup_mirror for space-efficient deduplicated storage.
     -- Each unique content_hash stores its bytes ONCE; raw_transcript rows
     -- reference this table via content_ref instead of storing duplicate content_bytes inline.
@@ -293,6 +375,13 @@ export function initSchema(db) {
     // S25: RAPTOR freshness-guard timestamp. Additive; old DBs have NULL → 0 →
     // treated as stale → flat fallback (safe).
     ensureColumn(db, "raptor_nodes", "built_at", "INTEGER");
+    // S43: turn_index on raw_transcript so a message points directly at its
+    // conversation turn (otherwise it must be inferred from seq ordering). NULL
+    // for legacy rows — turns written before S43 have no turn link.
+    ensureColumn(db, "raw_transcript", "turn_index", "INTEGER");
+    // 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");
     // 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/sqlite/session-state.js

@@ -8,6 +8,8 @@ function loadSessionStateRow(sid, db) {
     return {
         injectedCheckpointIds: row.injected_checkpoint_ids ? JSON.parse(row.injected_checkpoint_ids) : [],
         storedRegionHashes: row.stored_region_hashes ? JSON.parse(row.stored_region_hashes) : [],
+        conversationId: row.conversation_id ?? undefined,
+        lastTurnId: row.last_turn_id ?? undefined,
     };
 }
 export function loadSessionState(sessionId, stateDir = getStateDir()) {
@@ -16,13 +18,17 @@ export function loadSessionState(sessionId, stateDir = getStateDir()) {
 export function saveSessionState(sessionId, state, stateDir = getStateDir()) {
     const db = openStore(stateDir);
     const sid = normalizeSessionId(sessionId);
-    db.prepare(`INSERT INTO session_state(session_id, injected_checkpoint_ids, stored_region_hashes)
-     VALUES(@sid, @inj, @reg)
+    db.prepare(`INSERT INTO session_state(session_id, injected_checkpoint_ids, stored_region_hashes, conversation_id, last_turn_id)
+     VALUES(@sid, @inj, @reg, @conv, @tid)
      ON CONFLICT(session_id) DO UPDATE SET
        injected_checkpoint_ids=excluded.injected_checkpoint_ids,
-       stored_region_hashes=excluded.stored_region_hashes`).run({
+       stored_region_hashes=excluded.stored_region_hashes,
+       conversation_id=excluded.conversation_id,
+       last_turn_id=excluded.last_turn_id`).run({
         sid,
         inj: jsonText(state.injectedCheckpointIds),
         reg: jsonText(state.storedRegionHashes),
+        conv: state.conversationId ?? null,
+        tid: state.lastTurnId ?? null,
     });
 }

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

@@ -9,18 +9,22 @@ export function storeStats(sessionId, stateDir = getStateDir()) {
     const sid = normalizeSessionId(sessionId);
     const row = db
         .prepare(`SELECT COUNT(*) AS c, COALESCE(SUM(token_estimate),0) AS tok,
-              MAX(id) AS lastId
-       FROM context_chunks WHERE session_id = ?`)
+              MAX(CAST(SUBSTR(id, 7) AS INTEGER)) AS lastNum
+       FROM context_chunks WHERE session_id = ? AND dedup_status != 'removed'`)
         .get(sid);
+    let lastCheckpointId;
     let lastSummary;
-    if (row.lastId) {
-        const s = db.prepare("SELECT summary FROM context_chunks WHERE id = ?").get(row.lastId);
+    if (row.lastNum != null) {
+        lastCheckpointId = `chkpt_${String(row.lastNum).padStart(3, "0")}`;
+        const s = db
+            .prepare("SELECT summary FROM context_chunks WHERE session_id = ? AND id = ?")
+            .get(sid, lastCheckpointId);
         lastSummary = s?.summary;
     }
     return {
         checkpointCount: row.c,
         totalTokenEstimate: row.tok,
-        lastCheckpointId: row.lastId ?? undefined,
+        lastCheckpointId,
         lastSummary,
     };
 }