pi-mega-compact 0.13.4 → 0.13.6

package/dist/src/recall/format.js

@@ -142,8 +142,17 @@ export function scoreAndLogRecallMetrics(query, toInject) {
                 diversity: metrics.breakdown.diversity,
             });
         }
+        return {
+            hitCount: toInject.length,
+            score: metrics.score,
+            pass: metrics.pass,
+            relevance: metrics.breakdown.relevance,
+            coverage: metrics.breakdown.coverage,
+            diversity: metrics.breakdown.diversity,
+            specificity: metrics.breakdown.specificity,
+        };
     }
     catch {
-        /* non-fatal: metrics never break recall */
+        return null; // non-fatal: metrics never break recall
     }
 }

package/dist/src/recall/hydeTelemetry.js

@@ -0,0 +1,22 @@
+export function buildHydeInfo(outcome, hypotheticalDoc, generationMs, rawHitCount, hydeHitCount, fusedHitCount) {
+    const ran = outcome === "ran";
+    const skipped = !ran;
+    // Lift = fusedHitCount / max(1, rawHitCount) — how much HyDE changed recall
+    // breadth. Skipped passes yield 1 (raw hits cascade unchanged) unless there
+    // were no raw hits to compare against.
+    const lift = fusedHitCount / Math.max(1, rawHitCount);
+    return {
+        ran,
+        skipped,
+        reason: outcome,
+        hypotheticalDoc,
+        generationMs: ran ? generationMs : 0,
+        rawHitCount,
+        hydeHitCount: ran ? hydeHitCount : 0,
+        fusedHitCount,
+        lift: Math.round(lift * 100) / 100,
+    };
+}
+export function hydeSkipped(reason, rawHitCount, fusedHitCount) {
+    return buildHydeInfo(reason, "", 0, rawHitCount, 0, fusedHitCount);
+}

package/dist/src/recall/sync.js

@@ -21,6 +21,7 @@ import { RAG_QUERY_REFORMULATION, RAG_TIERED_ROUTER, RAG_RECALL_METRICS, RAG_HYD
 import { generateHypotheticalDoc, fuseRecallHits } from "../hyde.js";
 import { reformulateRecallQuery, runTieredRecall } from "./reformulate.js";
 import { formatRecallBlock, scoreAndLogRecallMetrics, raptorOverviewBlock } from "./format.js";
+import { buildHydeInfo, hydeSkipped } from "./hydeTelemetry.js";
 /**
  * Recall and inline context from the checkpoint store.
  *
@@ -84,10 +85,17 @@ export function recallAndInline(opts, store) {
     // RRF-fuses with the raw-query results. Non-fatal: any error → raw-only.
     // TrigramEmbedder (kind !== "http") skips this — S57 B1 reformulation above
     // already handles the no-LLM path.
+    // H1 telemetry tracking for the HyDE block below.
     let hydeHits = null;
+    let hydeDoc = "";
+    let hydeGenMs = 0;
+    let hydeRawCount = 0;
     if (RAG_HYDE_ENABLED() && embedder.kind === "http") {
+        const t0 = Date.now();
         const hyde = generateHypotheticalDoc(opts.query, embedder);
+        hydeGenMs = Date.now() - t0;
         if (hyde) {
+            hydeDoc = hyde;
             try {
                 const r2 = searchRecall({ sessionId: opts.sessionId, query: hyde, limit, skipInjected: skip }, store);
                 hydeHits = r2.newHits;
@@ -105,6 +113,8 @@ export function recallAndInline(opts, store) {
         const result = searchRecall({ sessionId: opts.sessionId, query: recallQuery, limit, skipInjected: skip }, store);
         newHits = result.newHits;
     }
+    // H1: the raw-query hit count is taken BEFORE fusion.
+    hydeRawCount = newHits.length;
     // S43 re-plan: fuse the hypothetical-doc hits with the raw-query hits via RRF
     // when HyDE produced results. The downstream inline dedupe + metrics + format
     // operate on this fused set.
@@ -142,8 +152,10 @@ export function recallAndInline(opts, store) {
     // byte-identical). Scores the injected hits against the ORIGINAL query so the
     // metric measures whether the (possibly expanded) search results stay
     // relevant to what the user actually asked.
-    if (RAG_RECALL_METRICS())
-        scoreAndLogRecallMetrics(opts.query, toInject);
+    let recallMetrics = null;
+    if (RAG_RECALL_METRICS()) {
+        recallMetrics = scoreAndLogRecallMetrics(opts.query, toInject);
+    }
     // F3: format once — one preamble, correct [1..n] numbering.
     const recallBlock = toInject.length > 0 ? formatRecallBlock(toInject) : "";
     const report = toInject.map((h) => `  • ${h.checkpoint.checkpointId} (${h.checkpoint.summary.slice(0, 60).replace(/\n/g, " ")}…)`);
@@ -161,10 +173,24 @@ export function recallAndInline(opts, store) {
     const block = overview && recallBlock
         ? overview + "\n" + recallBlock
         : overview || recallBlock;
+    // H1: build the HyDE invocation telemetry for this pass.
+    const fusedCount = toInject.length;
+    let hydeInfo;
+    if (RAG_HYDE_ENABLED() && embedder.kind === "http") {
+        hydeInfo =
+            hydeHits && hydeHits.length > 0
+                ? buildHydeInfo("ran", hydeDoc, hydeGenMs, hydeRawCount, hydeHits.length, fusedCount)
+                : hydeSkipped(hydeDoc ? "generation-failed" : "no-llm", hydeRawCount, fusedCount);
+    }
+    else {
+        hydeInfo = hydeSkipped("disabled", hydeRawCount, fusedCount);
+    }
     return {
         toInject,
         report,
         block,
         empty: block.length === 0,
+        hydeInfo,
+        recallMetrics,
     };
 }

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

@@ -0,0 +1,32 @@
+export function listTelemetryTurns(db, opts = {}) {
+    const limit = Math.max(1, opts.limit ?? 200);
+    return db
+        .prepare(`SELECT id AS turnId, conversation_id AS conversationId,
+			        turn_index AS turnIndex, role, ended_at AS endedAt,
+			        hyde_ran AS hydeRan, hyde_reason AS hydeReason, hyde_doc AS hydeDoc,
+			        hyde_raw_count AS hydeRawCount, hyde_hyde_count AS hydeHydeCount,
+			        hyde_fused_count AS hydeFusedCount, hyde_lift AS hydeLift,
+			        hyde_generation_ms AS hydeGenerationMs,
+			        recall_score AS recallScore, recall_pass AS recallPass,
+			        recall_relevance AS recallRelevance, recall_coverage AS recallCoverage,
+			        recall_diversity AS recallDiversity, recall_specificity AS recallSpecificity
+			 FROM turns
+			 WHERE hyde_ran = 1 OR recall_pass IS NOT NULL
+			 ORDER BY ended_at DESC
+			 LIMIT ?`)
+        .all(limit);
+}
+export function aggregateDailyTelemetry(db, days) {
+    const since = Date.now() - days * 86_400_000;
+    return db
+        .prepare(`SELECT date(ended_at / 1000, 'unixepoch') AS day,
+			        COUNT(*) AS recallCount,
+			        SUM(hyde_ran) AS hydeRanCount,
+			        AVG(recall_score) AS avgScore,
+			        AVG(hyde_lift) AS avgLift,
+			        AVG(hyde_generation_ms) AS avgGenMs
+			 FROM turns
+			 WHERE ended_at >= ? AND (hyde_ran = 1 OR recall_pass IS NOT NULL)
+			 GROUP BY day ORDER BY day ASC`)
+        .all(since);
+}

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

@@ -15,6 +15,7 @@ export { InMemoryTurnStore } from "./memory-store.js";
 export { openTurnDb, openTurnStore, closeTurnDb, closeTurnStore, closeAllTurnDbs, turnDbPath, TURNS_DB_FILE, withTx, } from "./connection.js";
 export { initTurnSchema } from "./schema.js";
 export { migrateTurnTablesIfNeeded } from "./migrations.js";
+export { listTelemetryTurns, aggregateDailyTelemetry } from "./hydeStore.js";
 import { SqliteTurnStore } from "./sqlite-store.js";
 import { InMemoryTurnStore } from "./memory-store.js";
 /**

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

@@ -1,5 +1,5 @@
 /** Schema version stamp (written once into turns_meta). */
-const SCHEMA_VERSION = 2;
+const SCHEMA_VERSION = 3;
 /** Create the unified turn-store schema if absent. Idempotent. */
 export function initTurnSchema(db) {
     // Migration: v1 had a pressure_band CHECK constraint that only allowed
@@ -121,6 +121,107 @@ export function initTurnSchema(db) {
     )
   `);
     db.exec(`CREATE INDEX IF NOT EXISTS idx_memory_topics_topic ON memory_topics(topic_id)`);
+    // H1: additive HyDE + recall-quality telemetry columns. ALTER TABLE ADD
+    // COLUMN (idempotent via PRAGMA guard) — turns stays append-only; these land
+    // in the single INSERT at turn-record time, never via UPDATE.
+    const ensureCol = (name, ddl) => {
+        const has = db.prepare("PRAGMA table_info(turns)").all().some((c) => c.name === name);
+        if (!has)
+            db.exec(`ALTER TABLE turns ADD COLUMN ${ddl}`);
+    };
+    ensureCol("hyde_ran", "hyde_ran INTEGER DEFAULT 0");
+    ensureCol("hyde_doc", "hyde_doc TEXT DEFAULT ''");
+    ensureCol("hyde_raw_count", "hyde_raw_count INTEGER DEFAULT 0");
+    ensureCol("hyde_hyde_count", "hyde_hyde_count INTEGER DEFAULT 0");
+    ensureCol("hyde_fused_count", "hyde_fused_count INTEGER DEFAULT 0");
+    ensureCol("hyde_lift", "hyde_lift REAL DEFAULT 0");
+    ensureCol("hyde_generation_ms", "hyde_generation_ms INTEGER DEFAULT 0");
+    ensureCol("hyde_reason", "hyde_reason TEXT DEFAULT ''");
+    ensureCol("recall_score", "recall_score REAL DEFAULT 0");
+    ensureCol("recall_pass", "recall_pass INTEGER DEFAULT 0");
+    ensureCol("recall_relevance", "recall_relevance REAL DEFAULT 0");
+    ensureCol("recall_coverage", "recall_coverage REAL DEFAULT 0");
+    ensureCol("recall_diversity", "recall_diversity REAL DEFAULT 0");
+    ensureCol("recall_specificity", "recall_specificity REAL DEFAULT 0");
+    // ── Wiki Revival (Spec 3): user curation + topic evolution ────────
+    const sessionCol = db.prepare("PRAGMA table_info(memory_topics)").all().some((c) => c.name === "session_id");
+    if (!sessionCol) {
+        db.exec("ALTER TABLE memory_topics ADD COLUMN session_id TEXT");
+    }
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_memory_topics_session ON memory_topics(session_id)`);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS topic_overrides (
+      topic_id      TEXT NOT NULL,
+      kind          TEXT NOT NULL CHECK(kind IN ('label','merge','split')),
+      custom_label  TEXT,
+      merged_into   TEXT,
+      split_from    TEXT,
+      split_memory_ids TEXT,
+      merged_memory_ids TEXT,
+      overridden_at INTEGER NOT NULL,
+      PRIMARY KEY (topic_id, kind)
+    )
+  `);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_topic_overrides_topic ON topic_overrides(topic_id)`);
+    // W5: add merged_memory_ids column to existing topic_overrides tables (same
+    // additive ensureColumn pattern as the HyDE columns). Stores the member ids
+    // from the source topic at merge time so merge overrides survive a full
+    // replaceTopicModel rebuild (topic_evolution rows are CASCADE-deleted with
+    // their parent topic, but topic_overrides rows persist across rebuilds).
+    const overridesCols = db
+        .prepare("PRAGMA table_info(topic_overrides)")
+        .all();
+    if (overridesCols.length > 0 &&
+        !overridesCols.some((c) => c.name === "merged_memory_ids")) {
+        db.exec("ALTER TABLE topic_overrides ADD COLUMN merged_memory_ids TEXT");
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS topic_evolution (
+      topic_id     TEXT NOT NULL REFERENCES topics(id) ON DELETE CASCADE,
+      memory_id    TEXT NOT NULL,
+      session_id   TEXT,
+      assigned_at  INTEGER NOT NULL,
+      method       TEXT NOT NULL CHECK(method IN ('kmeans+tfidf','merge','split','manual')),
+      PRIMARY KEY (topic_id, memory_id)
+    )
+  `);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_topic_evolution_topic ON topic_evolution(topic_id, assigned_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_topic_evolution_ts   ON topic_evolution(assigned_at)`);
+    // Migration: topic_evolution.topic_id FK lacked ON DELETE CASCADE when the
+    // table was first created (W1). Without it, deleting a topic (merge source or
+    // replaceTopicModel rebuild) throws SQLITE_CONSTRAINT when evolution rows
+    // reference it, rolling back the delete. Recreate the table with CASCADE when
+    // the live FK definition is missing it. Non-fatal: a failure just leaves the
+    // old definition (rebuilds remain best-effort).
+    try {
+        // PRAGMA foreign_key_list exposes the referenced table + on-delete rule.
+        const fkList = db
+            .prepare("PRAGMA foreign_key_list(topic_evolution)")
+            .all();
+        const topicFk = fkList.find((f) => f.from === "topic_id");
+        if (topicFk && topicFk.on_delete !== "CASCADE") {
+            db.exec("DROP TABLE IF EXISTS topic_evolution_mig");
+            db.exec(`
+	        CREATE TABLE topic_evolution_mig (
+	          topic_id     TEXT NOT NULL REFERENCES topics(id) ON DELETE CASCADE,
+	          memory_id    TEXT NOT NULL,
+	          session_id   TEXT,
+	          assigned_at  INTEGER NOT NULL,
+	          method       TEXT NOT NULL CHECK(method IN ('kmeans+tfidf','merge','split','manual')),
+	          PRIMARY KEY (topic_id, memory_id)
+	        )
+	      `);
+            db.exec(`INSERT INTO topic_evolution_mig (topic_id, memory_id, session_id, assigned_at, method)
+	           SELECT topic_id, memory_id, session_id, assigned_at, method FROM topic_evolution`);
+            db.exec("DROP TABLE topic_evolution");
+            db.exec("ALTER TABLE topic_evolution_mig RENAME TO topic_evolution");
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_topic_evolution_topic ON topic_evolution(topic_id, assigned_at)`);
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_topic_evolution_ts   ON topic_evolution(assigned_at)`);
+        }
+    }
+    catch {
+        /* non-fatal: migration never breaks turn-DB open */
+    }
     // Stamp schema version once.
     const existing = db
         .prepare("SELECT value FROM turns_meta WHERE key = 'schema_version'")

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

@@ -21,6 +21,29 @@ export function rowToEntry(r) {
         pressureBand: r.pressure_band ?? undefined,
         model: r.model ?? undefined,
         epochId: r.epoch_id ?? undefined,
+        // H1: telemetry columns (only populated when the row has them non-default).
+        hyde: r.hyde_ran == null
+            ? undefined
+            : {
+                ran: r.hyde_ran === 1,
+                reason: r.hyde_reason ?? "",
+                hypotheticalDoc: r.hyde_doc ?? "",
+                rawHitCount: r.hyde_raw_count ?? 0,
+                hydeHitCount: r.hyde_hyde_count ?? 0,
+                fusedHitCount: r.hyde_fused_count ?? 0,
+                lift: r.hyde_lift ?? 0,
+                generationMs: r.hyde_generation_ms ?? 0,
+            },
+        recallMetrics: r.recall_score == null
+            ? undefined
+            : {
+                score: r.recall_score ?? 0,
+                pass: r.recall_pass === 1,
+                relevance: r.recall_relevance ?? 0,
+                coverage: r.recall_coverage ?? 0,
+                diversity: r.recall_diversity ?? 0,
+                specificity: r.recall_specificity ?? 0,
+            },
     };
 }
 export function rowToRecall(r) {

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

@@ -7,9 +7,13 @@ export function appendTurn(ctx, entry) {
     try {
         db
             .prepare(`INSERT INTO turns (conversation_id, session_id, turn_index, role, ended_at,
-	                           ctx_tokens, ctx_percent, pressure_band, model, epoch_id)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(entry.conversationId, sid, entry.turnIndex, entry.role, entry.endedAt, entry.ctxTokens ?? null, entry.ctxPercent ?? null, entry.pressureBand ?? null, entry.model ?? null, entry.epochId ?? null);
+	                           ctx_tokens, ctx_percent, pressure_band, model, epoch_id,
+	                           hyde_ran, hyde_doc, hyde_raw_count, hyde_hyde_count,
+	                           hyde_fused_count, hyde_lift, hyde_generation_ms, hyde_reason,
+	                           recall_score, recall_pass, recall_relevance, recall_coverage,
+	                           recall_diversity, recall_specificity)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(entry.conversationId, sid, entry.turnIndex, entry.role, entry.endedAt, entry.ctxTokens ?? null, entry.ctxPercent ?? null, entry.pressureBand ?? null, entry.model ?? null, entry.epochId ?? null, entry.hyde?.ran == null ? null : entry.hyde.ran ? 1 : 0, entry.hyde?.hypotheticalDoc ?? null, entry.hyde?.rawHitCount ?? null, entry.hyde?.hydeHitCount ?? null, entry.hyde?.fusedHitCount ?? null, entry.hyde?.lift ?? null, entry.hyde?.generationMs ?? null, entry.hyde?.reason ?? null, entry.recallMetrics?.score ?? null, entry.recallMetrics?.pass == null ? null : entry.recallMetrics.pass ? 1 : 0, entry.recallMetrics?.relevance ?? null, entry.recallMetrics?.coverage ?? null, entry.recallMetrics?.diversity ?? null, entry.recallMetrics?.specificity ?? null);
     }
     catch (e) {
         if (e instanceof Error &&

package/dist/src/topics/durability.js

@@ -0,0 +1,187 @@
+import { withTx } from "../store/turns/connection.js";
+import { moveMemory, recordEvolution, } from "../wiki/curation-helpers.js";
+/** Read all overrides in chronological order (oldest first). */
+function loadOverrides(db) {
+    return db
+        .prepare(`SELECT topic_id, kind, custom_label, merged_into, split_from, split_memory_ids, merged_memory_ids
+			 FROM topic_overrides ORDER BY overridden_at ASC`)
+        .all();
+}
+/** Does a topic row with this id exist? */
+function topicExists(db, topicId) {
+    return !!db.prepare("SELECT 1 FROM topics WHERE id = ?").get(topicId);
+}
+/** All existing topic ids (for nearest-by-label-overlap fallback). */
+function allTopicIds(db) {
+    const rows = db
+        .prepare("SELECT id FROM topics")
+        .all();
+    return rows.map((r) => r.id);
+}
+/**
+ * When a curated target topic dissolved in a rebuild, fall back to whichever
+ * surviving topic shares the most label tokens, so merged memories still land
+ * somewhere sensible. Returns "" when no overlap candidate exists.
+ */
+function nearestByLabelOverlap(db, label) {
+    const tokens = new Set(label.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0));
+    if (tokens.size === 0)
+        return "";
+    let bestId = "";
+    let bestOverlap = 0;
+    for (const id of allTopicIds(db)) {
+        const r = db
+            .prepare("SELECT label FROM topics WHERE id = ?")
+            .get(id);
+        if (!r)
+            continue;
+        const labelTokens = new Set(r.label.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length > 0));
+        let overlap = 0;
+        for (const t of tokens)
+            if (labelTokens.has(t))
+                overlap++;
+        if (overlap > bestOverlap) {
+            bestOverlap = overlap;
+            bestId = id;
+        }
+    }
+    return bestOverlap > 0 ? bestId : "";
+}
+/**
+ * Replay a single merge override: force the source topic's merged members back
+ * into the target topic (or its nearest-by-label-overlap survivor if the target
+ * dissolved). Member ids are read from `merged_memory_ids` on the override row
+ * (W5 — survives `replaceTopicModel` because `topic_overrides` is never wiped).
+ * Falls back to `topic_evolution` for pre-W5 merges (only works when evolution
+ * rows are intact, i.e. the incremental path or no rebuild has fired since).
+ */
+function replayMerge(db, row) {
+    const target = row.merged_into;
+    if (!target)
+        return;
+    // Primary source: merged_memory_ids on the override row itself.
+    let memoryIds = [];
+    if (row.merged_memory_ids) {
+        try {
+            const parsed = JSON.parse(row.merged_memory_ids);
+            if (Array.isArray(parsed)) {
+                memoryIds = parsed.filter((m) => typeof m === "string");
+            }
+        }
+        catch {
+            /* non-fatal: malformed member list falls through to evolution */
+        }
+    }
+    // Fallback: topic_evolution rows (only intact when no rebuild has fired).
+    let members = [];
+    if (memoryIds.length === 0) {
+        members = db
+            .prepare(`SELECT memory_id, session_id FROM topic_evolution
+				 WHERE topic_id = ? AND method = 'merge' ORDER BY memory_id ASC`)
+            .all(target);
+        if (members.length === 0)
+            return;
+    }
+    else {
+        // Resolve session_id for each member from its current assignment (if any).
+        for (const mid of memoryIds) {
+            const r = db
+                .prepare("SELECT session_id FROM memory_topics WHERE memory_id = ? LIMIT 1")
+                .get(mid);
+            members.push({
+                memory_id: mid,
+                session_id: r?.session_id ?? null,
+            });
+        }
+    }
+    let dest = target;
+    if (!topicExists(db, target)) {
+        dest = nearestByLabelOverlap(db, target);
+        if (!dest)
+            return;
+    }
+    withTx(db, () => {
+        const t = Date.now();
+        for (const m of members) {
+            moveMemory(db, m.memory_id, dest);
+            recordEvolution(db, dest, m.memory_id, m.session_id, t, "merge");
+        }
+    });
+}
+/**
+ * Replay a single split override: recreate the split topic (if the source
+ * still exists or the memories are somewhere in the model) and move the listed
+ * memory ids into it.
+ */
+function replaySplit(db, row) {
+    let memoryIds = [];
+    if (row.split_memory_ids) {
+        try {
+            const parsed = JSON.parse(row.split_memory_ids);
+            if (Array.isArray(parsed)) {
+                memoryIds = parsed.filter((m) => typeof m === "string");
+            }
+        }
+        catch {
+            /* non-fatal: malformed member list is skipped */
+        }
+    }
+    if (memoryIds.length === 0 || topicExists(db, row.topic_id))
+        return;
+    // Recreate the split topic reusing its original id + source label.
+    const sourceLabel = row.split_from && topicExists(db, row.split_from)
+        ? db.prepare("SELECT label FROM topics WHERE id = ?")
+            .get(row.split_from).label
+        : row.topic_id;
+    withTx(db, () => {
+        db.prepare(`INSERT INTO topics (id, label, term_scores, memory_count, last_updated, cluster_model_built_at)
+			 VALUES (?, ?, NULL, 0, ?, NULL)`).run(row.topic_id, `${sourceLabel} (split)`, Date.now());
+        const t = Date.now();
+        // Only memories that still exist in the model move; drop the rest.
+        for (const memoryId of memoryIds) {
+            const src = db
+                .prepare("SELECT session_id FROM memory_topics WHERE memory_id = ? LIMIT 1")
+                .get(memoryId);
+            if (!src)
+                continue;
+            moveMemory(db, memoryId, row.topic_id);
+            recordEvolution(db, row.topic_id, memoryId, src.session_id, t, "split");
+        }
+    });
+}
+/**
+ * Apply all user overrides (label / merge / split) after a topic-model rebuild,
+ * in `overridden_at` order. Non-fatal end-to-end: each override is isolated so a
+ * single corruption never aborts the replay. This is the W5 high-fidelity replay (feature A).
+ */
+export function applyFullOverridesAfterRebuild(db) {
+    if (!db)
+        return;
+    let rows;
+    try {
+        rows = loadOverrides(db);
+    }
+    catch {
+        return; // non-fatal: no overrides table / unreadable → nothing to replay
+    }
+    for (const row of rows) {
+        try {
+            if (row.kind === "label") {
+                // Same fast path as store.applyOverridesAfterRebuild, inline here
+                // so the full replay owns label + merge + split in one pass.
+                if (row.custom_label && row.custom_label.trim() !== "") {
+                    db.prepare("UPDATE topics SET label = ? WHERE id = ?").run(row.custom_label, row.topic_id);
+                }
+            }
+            else if (row.kind === "merge") {
+                replayMerge(db, row);
+            }
+            else if (row.kind === "split") {
+                replaySplit(db, row);
+            }
+        }
+        catch {
+            /* non-fatal: skip this override, keep replaying the rest */
+        }
+    }
+}

package/dist/src/topics/index.js

@@ -2,5 +2,6 @@
  * index.ts — S51 topics barrel. Re-export only; no logic.
  */
 export { loadEmbeddings, buildTopicModel, DEFAULT_CLUSTER_CONFIG, } from "./cluster.js";
-export { createTopicStore, getWikiCompactCounter, bumpWikiCompactCounter } from "./store.js";
+export { createTopicStore, getWikiCompactCounter, bumpWikiCompactCounter, applyOverridesAfterRebuild, } from "./store.js";
+export { applyFullOverridesAfterRebuild } from "./durability.js";
 export { tokenize, tfidfScores, labelFromScores, membershipConfidence } from "./labels.js";

package/dist/src/topics/store.js

@@ -35,10 +35,7 @@ function rowToTopic(r) {
 function rowToAssignment(r) {
     return {
         memoryId: r.memory_id,
-        // memory_topics has no session_id column; the chunk id is globally unique
-        // enough for the wiki view (context_chunks PK is (session_id, id)).
-        // sessionId omitted — memory_topics has no session_id column;
-        // the TopicAssignment type marks it optional for this reason.
+        sessionId: r.session_id ?? "",
         topicId: r.topic_id,
         confidence: r.confidence ?? 0,
         assignedAt: r.assigned_at ?? 0,
@@ -57,10 +54,10 @@ export function createTopicStore(stateDir) {
             for (const t of model.topics) {
                 insTopic.run(t.id, t.label, JSON.stringify(t.termScores), t.memoryCount, t.lastUpdated, model.builtAt);
             }
-            const insAssign = db.prepare(`INSERT OR REPLACE INTO memory_topics (memory_id, topic_id, confidence, assigned_at, method)
-         VALUES (?, ?, ?, ?, 'kmeans+tfidf')`);
+            const insAssign = db.prepare(`INSERT OR REPLACE INTO memory_topics (memory_id, topic_id, confidence, assigned_at, method, session_id)
+         VALUES (?, ?, ?, ?, 'kmeans+tfidf', ?)`);
             for (const a of model.assignments) {
-                insAssign.run(a.memoryId, a.topicId, a.confidence, a.assignedAt);
+                insAssign.run(a.memoryId, a.topicId, a.confidence, a.assignedAt, a.sessionId ?? null);
             }
         });
     }
@@ -74,7 +71,7 @@ export function createTopicStore(stateDir) {
         },
         getMemoriesForTopic(topicId, limit = 50, offset = 0) {
             const rows = db
-                .prepare(`SELECT memory_id, topic_id, confidence, assigned_at, method
+                .prepare(`SELECT memory_id, topic_id, confidence, assigned_at, method, session_id
            FROM memory_topics WHERE topic_id = ?
            ORDER BY confidence DESC, memory_id ASC LIMIT ? OFFSET ?`)
                 .all(topicId, limit, offset);
@@ -82,7 +79,7 @@ export function createTopicStore(stateDir) {
         },
         getTopicForMemory(memoryId) {
             const r = db
-                .prepare(`SELECT memory_id, topic_id, confidence, assigned_at, method
+                .prepare(`SELECT memory_id, topic_id, confidence, assigned_at, method, session_id
            FROM memory_topics WHERE memory_id = ? LIMIT 1`)
                 .get(memoryId);
             return r ? rowToAssignment(r) : null;
@@ -101,6 +98,28 @@ export function createTopicStore(stateDir) {
         },
     };
 }
+/**
+ * Re-apply user label overrides after a topic-model rebuild. `replaceTopicModel`
+ * deletes + recreates `topics`, so any `label` override rows that resolved to a
+ * custom label would otherwise be lost — this copies them back onto the fresh
+ * rows. Non-fatal: a failure never breaks a rebuild.
+ */
+export function applyOverridesAfterRebuild(db) {
+    try {
+        const rows = db
+            .prepare("SELECT topic_id, custom_label FROM topic_overrides WHERE kind = 'label'")
+            .all();
+        const upd = db.prepare("UPDATE topics SET label = ? WHERE id = ?");
+        for (const r of rows) {
+            if (r.custom_label && r.custom_label.trim() !== "") {
+                upd.run(r.custom_label, r.topic_id);
+            }
+        }
+    }
+    catch {
+        /* non-fatal: override re-apply never breaks a rebuild */
+    }
+}
 /** Turns-meta counter key for the every-Nth-compaction rebuild trigger. */
 const WIKI_COUNTER_KEY = "wiki_compact_counter";
 /** Read the rebuild counter (0 when unset). */

package/dist/src/wiki/curation-helpers.js

@@ -0,0 +1,71 @@
+/** Read a topic's current label, or null when the topic does not exist. */
+export function getTopicLabel(db, topicId) {
+    const r = db
+        .prepare("SELECT label FROM topics WHERE id = ?")
+        .get(topicId);
+    return r?.label ?? null;
+}
+/** Recompute memory_count for a topic from its live member rows. */
+export function recountTopic(db, topicId) {
+    const c = db
+        .prepare("SELECT COUNT(*) AS c FROM memory_topics WHERE topic_id = ?")
+        .get(topicId);
+    db.prepare("UPDATE topics SET memory_count = ? WHERE id = ?").run(c.c, topicId);
+}
+/** Look up a custom label override; empty/blank means "no override". */
+export function customLabelOverride(db, topicId) {
+    const r = db
+        .prepare(`SELECT custom_label FROM topic_overrides
+			 WHERE topic_id = ? AND kind = 'label'`)
+        .get(topicId);
+    const label = r?.custom_label;
+    return label && label.trim() !== "" ? label : null;
+}
+/** Write (or clear) a label override for a topic. */
+export function writeLabelOverride(db, topicId, label, now) {
+    if (label.trim() === "") {
+        db.prepare("DELETE FROM topic_overrides WHERE topic_id = ? AND kind = 'label'").run(topicId);
+        return;
+    }
+    db.prepare(`INSERT OR REPLACE INTO topic_overrides
+		   (topic_id, kind, custom_label, overridden_at)
+		 VALUES (?, 'label', ?, ?)`).run(topicId, label, now);
+    // Keep the live topics.label in sync with the override so reads resolve directly.
+    db.prepare("UPDATE topics SET label = ? WHERE id = ?").run(label, topicId);
+}
+/** Copy a source assignment into the target topic (idempotent, atomic caller). */
+export function moveMemory(db, memoryId, toTopicId) {
+    const src = db
+        .prepare(`SELECT topic_id, confidence, assigned_at, session_id FROM memory_topics
+			 WHERE memory_id = ? LIMIT 1`)
+        .get(memoryId);
+    // Delete the source row first so a memory already present in the target just stays.
+    db.prepare("DELETE FROM memory_topics WHERE memory_id = ?").run(memoryId);
+    if (!src)
+        return;
+    db.prepare(`INSERT OR REPLACE INTO memory_topics
+		   (memory_id, topic_id, confidence, assigned_at, method, session_id)
+		 VALUES (?, ?, ?, ?, 'kmeans+tfidf', ?)`).run(memoryId, toTopicId, src.confidence ?? 0, src.assigned_at ?? 0, src.session_id ?? null);
+}
+/** Record a member's provenance evolution row (best-effort, non-fatal). */
+export function recordEvolution(db, topicId, memoryId, sessionId, assignedAt, method) {
+    db.prepare(`INSERT OR REPLACE INTO topic_evolution
+		   (topic_id, memory_id, session_id, assigned_at, method)
+		 VALUES (?, ?, ?, ?, ?)`).run(topicId, memoryId, sessionId, assignedAt, method);
+}
+/** Create a new split topic, returning its id. */
+export function createSplitTopic(db, sourceId, sourceLabel, now) {
+    // Two splits in the same millisecond collide on the base id; append a
+    // numeric suffix until the id is unused.
+    let newId = `topic_${sourceId}_split_${now}`;
+    let suffix = 2;
+    let exists = db.prepare("SELECT 1 FROM topics WHERE id = ?").get(newId);
+    while (exists) {
+        newId = `topic_${sourceId}_split_${now}_${suffix}`;
+        exists = db.prepare("SELECT 1 FROM topics WHERE id = ?").get(newId);
+        suffix++;
+    }
+    db.prepare(`INSERT INTO topics (id, label, term_scores, memory_count, last_updated, cluster_model_built_at)
+		 VALUES (?, ?, NULL, 0, ?, NULL)`).run(newId, `${sourceLabel} (split)`, now);
+    return newId;
+}