linksee-memory 0.18.0 → 0.18.1

package/dist/lib/consolidate.js

@@ -1,56 +1,82 @@
-// Sleep-mode consolidation: cluster stale low-importance memories,
-// summarize into a single `learning`-layer entry, delete originals.
-// Implements Michie's memory principle 4 (sleep consolidation).
+// Sleep-mode consolidation: cluster stale low-importance memories and write one
+// `learning`-layer summary per cluster. Implements Michie's memory principle 4
+// (sleep consolidation).
+//
+// 0.18.1: NOTHING IS DELETED. Up to 0.18.0 this file deleted the original rows of every
+// cluster and then ran a "forget-sweep" that deleted every other cold row — 1,360 rows on
+// 2026-10-29 and 559 (11 decisions among them) on 2026-11-05 on the maintainer's own database,
+// with no notice and no way to opt out. Rows a hand-over needs, gone for a summary that said
+// "N cold observations consolidated during sleep".
 //
 // Strategy (rule-based, no LLM required):
-//   1. Find candidates: layer IN (context, emotion, implementation),
-//      protected=0, cold (heat<30), older than 7 days, cluster size >= 2.
+//   1. Find candidates: layer IN (context, emotion, implementation), protected=0,
+//      JSON content, not already folded, cold (heat<30), older than 7 days, cluster size >= 2.
 //   2. Group by (entity_id, layer).
-//   3. Emit a structured summary into `learning` layer (protected=1),
-//      then delete originals.
-//   4. Per-run forget-sweep drops expired memories that didn't cluster.
+//   3. Emit a structured summary into `learning` layer (protected=1), then MARK the originals
+//      with `consolidated_into: <summary id>` in their content JSON (json_set). The rows stay.
+//      `recall` hides marked rows by default and reports how many (`consolidated_hidden`);
+//      `include_consolidated: true` shows them.
+//   4. There is no forget-sweep any more. Cold rows that did not cluster are counted
+//      (`coldUnclustered`) and left alone.
+//
+// Plain-text rows (content that is not a JSON object) are never folded: the mark can only be
+// written into JSON, and rewriting a user's text to add it is not this module's call. They are
+// counted in `skippedPlainText`.
 import { computeHeat } from './heat-index.js';
 import { decideForgetting } from './forgetting.js';
 import { detectMemoryEdges } from './edge-detection.js';
+import { faultPoint } from './test-faults.js';
 const CLUSTER_LAYERS = ['context', 'emotion', 'implementation'];
 const DEFAULT_MIN_AGE_DAYS = 7;
 const MAX_HEAT = 30;
 const MIN_CLUSTER_SIZE = 2;
-export function consolidate(db, opts = {}) {
-    const now = Math.floor(Date.now() / 1000);
+/** SQL fragment: the row has been folded into a summary (alias `m` for memories). */
+export const CONSOLIDATED_SQL = `(json_valid(m.content) AND json_type(m.content) = 'object' AND json_extract(m.content, '$.consolidated_into') IS NOT NULL)`;
+function heatOf(now, r) {
+    const daysSince = (now - r.last_accessed_at) / 86400;
+    return computeHeat({
+        accessesLast30d: daysSince < 30 ? r.access_count : 0,
+        accessesLast90d: daysSince < 90 ? r.access_count : 0,
+        daysSinceLastAccess: daysSince,
+        totalAccesses: r.access_count,
+        baseImportance: r.importance,
+    }).score;
+}
+/**
+ * What consolidate would do, without writing. Shared by `consolidate` (which applies it),
+ * the `consolidate --dry-run` subcommand, and the start-up notice.
+ */
+export function planConsolidate(db, opts = {}, now = Math.floor(Date.now() / 1000)) {
     const minAgeDays = opts.min_age_days ?? DEFAULT_MIN_AGE_DAYS;
     const ageCutoff = now - minAgeDays * 86400;
-    // Fetch candidates with age threshold. 'session' scope → same query currently
-    // (Day 2: session filter needs session_id plumbing; will add when sessions
-    // table is actually populated by the MCP server).
     const layerPlaceholders = CLUSTER_LAYERS.map(() => '?').join(',');
     const rows = db
         .prepare(`
       SELECT m.id, m.entity_id, m.layer, m.content, m.importance,
              m.last_accessed_at, m.access_count, m.created_at, m.protected,
-             m.altitude,
+             m.altitude, m.mem_type,
              e.name as entity_name
       FROM memories m
       JOIN entities e ON e.id = m.entity_id
       WHERE m.protected = 0
         AND m.layer IN (${layerPlaceholders})
         AND m.created_at <= ?
+        AND NOT ${CONSOLIDATED_SQL}
       ORDER BY m.entity_id, m.layer, m.created_at
       `)
         .all(...CLUSTER_LAYERS, ageCutoff);
-    // Filter to cold-heat memories
-    const cold = rows.filter((r) => {
-        const daysSince = (now - r.last_accessed_at) / 86400;
-        const heat = computeHeat({
-            accessesLast30d: daysSince < 30 ? r.access_count : 0,
-            accessesLast90d: daysSince < 90 ? r.access_count : 0,
-            daysSinceLastAccess: daysSince,
-            totalAccesses: r.access_count,
-            baseImportance: r.importance,
-        });
-        return heat.score < MAX_HEAT;
-    });
-    // Group by (entity_id, layer)
+    // Cold-heat rows only; plain-text rows cannot carry the mark and are set aside.
+    const cold = [];
+    let skippedPlainText = 0;
+    for (const r of rows) {
+        if (heatOf(now, r) >= MAX_HEAT)
+            continue;
+        if (!isJsonObject(r.content)) {
+            skippedPlainText++;
+            continue;
+        }
+        cold.push(r);
+    }
     const groups = new Map();
     for (const r of cold) {
         const key = `${r.entity_id}::${r.layer}`;
@@ -58,44 +84,116 @@ export function consolidate(db, opts = {}) {
         arr.push(r);
         groups.set(key, arr);
     }
-    const result = {
+    const clusters = [];
+    let coldUnclustered = 0;
+    for (const members of groups.values()) {
+        if (members.length < MIN_CLUSTER_SIZE) {
+            coldUnclustered += members.length;
+            continue;
+        }
+        clusters.push({
+            entity_id: members[0].entity_id,
+            entity_name: members[0].entity_name,
+            layer: members[0].layer,
+            ids: members.map((c) => c.id),
+            members,
+            examples: members.slice(0, 3).map((c) => fragment(c.content, 120)),
+        });
+    }
+    return {
         scanned: rows.length,
-        clustersCompressed: 0,
-        memoriesReplaced: 0,
-        memoriesDropped: 0,
-        learningIdsCreated: [],
-        stalledTransitions: 0,
-        memoryEdgesCreated: 0,
-        decisionsSuperseded: 0,
+        clusters,
+        wouldFold: clusters.reduce((s, c) => s + c.ids.length, 0),
+        coldUnclustered,
+        skippedPlainText,
     };
+}
+function isJsonObject(content) {
+    try {
+        const v = JSON.parse(content);
+        return !!v && typeof v === 'object' && !Array.isArray(v);
+    }
+    catch {
+        return false;
+    }
+}
+function fragment(content, max) {
+    let text = content;
+    try {
+        const o = JSON.parse(content);
+        const core = o?.what ?? o?.title ?? o?.decision ?? o?.intent ?? o?.learned ?? o?.summary;
+        if (typeof core === 'string')
+            text = core;
+    }
+    catch { /* plain text */ }
+    text = String(text).replace(/\s+/g, ' ').trim();
+    return text.length > max ? text.slice(0, max) + '…' : text;
+}
+export function consolidate(db, opts = {}) {
+    const now = Math.floor(Date.now() / 1000);
     const insertLearning = db.prepare(`INSERT INTO memories (entity_id, layer, content, importance, protected, source)
      VALUES (?, 'learning', ?, ?, 1, ?)`);
-    const deleteMemory = db.prepare('DELETE FROM memories WHERE id = ?');
+    // The mark, not a delete. Guarded so a row that is no longer a JSON object (changed since the
+    // plan) or already folded is left as it is: json_set on non-JSON would throw, and a throw
+    // inside the transaction rolls the whole run back — which is what we want for "unknown".
+    const markFolded = db.prepare(`UPDATE memories
+       SET content = json_set(content, '$.consolidated_into', ?)
+     WHERE id = ?
+       AND json_valid(content) AND json_type(content) = 'object'
+       AND json_extract(content, '$.consolidated_into') IS NULL`);
     const insertAudit = db.prepare(`INSERT INTO consolidations (learning_id, replaced_ids, replaced_count, entity_id, original_layer)
      VALUES (?, ?, ?, ?, ?)`);
     const insertEvent = db.prepare('INSERT INTO events (entity_id, kind, payload) VALUES (?, ?, ?)');
+    const markStalled = db.prepare(`
+    UPDATE memories SET content = json_set(content, '$.state', 'stalled')
+    WHERE json_valid(content)
+      AND json_extract(content, '$.state') = 'in_progress'
+      AND last_accessed_at < ?
+      AND protected = 0
+  `);
+    // ONE BEGIN IMMEDIATE transaction for the whole run (Codex review 1 of #23): the write lock is
+    // taken before the plan is read, so no other connection can change a candidate between the
+    // read and the mark; and the stalled sweep and edge detection are inside it too, so a failure
+    // anywhere rolls the whole run back (no summaries without marks, no folds without the rest).
+    // Order inside: plan → per cluster (summary row, audit row, marks, event) → stalled → edges.
+    // Nothing is deleted at any step.
     const tx = db.transaction(() => {
-        for (const [key, cluster] of groups) {
-            if (cluster.length < MIN_CLUSTER_SIZE)
-                continue;
-            const [entityIdStr, layer] = key.split('::');
-            const entityId = Number(entityIdStr);
-            const entityName = cluster[0].entity_name;
+        // 'session' scope → same query currently (session filter needs session_id plumbing).
+        const countRows = () => db.prepare('SELECT COUNT(*) AS c FROM memories').get().c;
+        const memoriesBefore = countRows();
+        const plan = planConsolidate(db, { min_age_days: opts.min_age_days }, now);
+        const result = {
+            scanned: plan.scanned,
+            clustersCompressed: 0,
+            memoriesFolded: 0,
+            memoriesDropped: 0,
+            coldUnclustered: plan.coldUnclustered,
+            skippedPlainText: plan.skippedPlainText,
+            learningIdsCreated: [],
+            memoriesBefore,
+            memoriesAfter: memoriesBefore,
+            stalledTransitions: 0,
+            memoryEdgesCreated: 0,
+            decisionsSuperseded: 0,
+        };
+        for (const cluster of plan.clusters) {
+            const { entity_id: entityId, entity_name: entityName, layer, members } = cluster;
             // Sort by importance desc, take top 3 as exemplars
-            const byImp = [...cluster].sort((a, b) => b.importance - a.importance);
+            const byImp = [...members].sort((a, b) => b.importance - a.importance);
             const exemplars = byImp.slice(0, 3).map((c) => ({
+                id: c.id,
                 fragment: c.content.length > 200 ? c.content.slice(0, 200) + '…' : c.content,
                 when: new Date(c.created_at * 1000).toISOString().slice(0, 10),
                 importance: c.importance,
             }));
-            const timestamps = cluster.map((c) => c.created_at);
+            const timestamps = members.map((c) => c.created_at);
             const earliest = new Date(Math.min(...timestamps) * 1000).toISOString().slice(0, 10);
             const latest = new Date(Math.max(...timestamps) * 1000).toISOString().slice(0, 10);
-            const avgImp = cluster.reduce((s, c) => s + c.importance, 0) / cluster.length;
-            // Determine dominant altitude from cluster members (most frequent non-null value).
-            // Consolidation summaries inherit the cluster's altitude so decay rates are preserved.
+            const avgImp = members.reduce((s, c) => s + c.importance, 0) / members.length;
+            // Dominant altitude from cluster members (most frequent non-null value), so decay rates
+            // are preserved on the summary.
             const altCounts = new Map();
-            for (const c of cluster) {
+            for (const c of members) {
                 if (c.altitude)
                     altCounts.set(c.altitude, (altCounts.get(c.altitude) ?? 0) + 1);
             }
@@ -113,91 +211,89 @@ export function consolidate(db, opts = {}) {
                 type: 'learning',
                 state: 'done',
                 original_layer: layer,
-                count: cluster.length,
+                count: members.length,
                 period: { from: earliest, to: latest },
-                pattern: `${cluster.length} cold observations on "${entityName}" (${layer}) consolidated during sleep`,
+                pattern: `${members.length} cold observations on "${entityName}" (${layer}) folded into this summary; the originals are kept (recall({ include_consolidated: true }) shows them)`,
                 exemplars,
-                replaced_ids: cluster.map((c) => c.id),
+                // Kept under the old key so readers of pre-0.18.1 summaries still find the ids.
+                replaced_ids: members.map((c) => c.id),
+                folded_ids: members.map((c) => c.id),
             };
             const learningImportance = Math.max(avgImp, 0.55); // summaries are slightly more important than their avg source
-            const sourceMeta = JSON.stringify({ origin: 'consolidate', replaced: cluster.length });
+            const sourceMeta = JSON.stringify({ origin: 'consolidate', folded: members.length });
             const ins = insertLearning.run(entityId, JSON.stringify(summary, null, 2), learningImportance, sourceMeta);
             const learningId = Number(ins.lastInsertRowid);
+            insertAudit.run(learningId, JSON.stringify(members.map((c) => c.id)), members.length, entityId, layer);
+            let marked = 0;
+            for (const c of members)
+                marked += markFolded.run(learningId, c.id).changes;
+            if (marked !== members.length) {
+                // A member changed under us (no longer JSON, or folded by a concurrent run). Unknown
+                // state → stop; the transaction rolls back everything, including the summary row.
+                throw new Error(`consolidate: cluster ${entityName}/${layer} marked ${marked} of ${members.length} rows; rolled back, nothing written`);
+            }
+            insertEvent.run(entityId, 'memory_consolidated', JSON.stringify({ learning_id: learningId, count: members.length, layer, deleted: 0 }));
             result.learningIdsCreated.push(learningId);
-            insertAudit.run(learningId, JSON.stringify(cluster.map((c) => c.id)), cluster.length, entityId, layer);
-            for (const c of cluster)
-                deleteMemory.run(c.id);
-            insertEvent.run(entityId, 'memory_consolidated', JSON.stringify({ learning_id: learningId, count: cluster.length, layer }));
             result.clustersCompressed++;
-            result.memoriesReplaced += cluster.length;
+            result.memoriesFolded += members.length;
+        }
+        faultPoint('consolidate-after-mark');
+        // State transition sweep: in_progress memories untouched for 30+ days → stalled.
+        const STALLED_THRESHOLD_DAYS = 30;
+        result.stalledTransitions = markStalled.run(now - STALLED_THRESHOLD_DAYS * 86400).changes;
+        // Memory→memory edge detection: link superseding/contradicting decisions so the
+        // dashboard can render Pivot Chains and recall can surface superseded decisions.
+        // (Its own db.transaction becomes a savepoint inside this one.)
+        const edgeRes = detectMemoryEdges(db);
+        result.memoryEdgesCreated = edgeRes.edgesCreated;
+        result.decisionsSuperseded = edgeRes.supersededMarked;
+        faultPoint('consolidate-after-edges');
+        // Last line of defence, inside the transaction: the only rows a run may add are its
+        // summaries, and it may remove none. Anything else → throw → the whole run rolls back.
+        result.memoriesAfter = countRows();
+        if (result.memoriesAfter !== memoriesBefore + result.learningIdsCreated.length) {
+            throw new Error(`consolidate: memories ${memoriesBefore} → ${result.memoriesAfter} with ${result.learningIdsCreated.length} summaries; rolled back, nothing written`);
         }
+        // 0.18.1: the forget-sweep that deleted every remaining cold row is gone.
+        return result;
     });
-    tx();
-    // State transition sweep: in_progress memories untouched for 30+ days → stalled.
-    // Uses json_set() to update the state field in content JSON atomically.
-    const STALLED_THRESHOLD_DAYS = 30;
-    const stalledCutoff = now - STALLED_THRESHOLD_DAYS * 86400;
-    const stalledResult = db.prepare(`
-    UPDATE memories SET content = json_set(content, '$.state', 'stalled')
-    WHERE json_valid(content)
-      AND json_extract(content, '$.state') = 'in_progress'
-      AND last_accessed_at < ?
-      AND protected = 0
-  `).run(stalledCutoff);
-    result.stalledTransitions = stalledResult.changes;
-    // Memory→memory edge detection: link superseding/contradicting decisions so the
-    // dashboard can render Pivot Chains and recall can surface superseded decisions.
-    const edgeRes = detectMemoryEdges(db);
-    result.memoryEdgesCreated = edgeRes.edgesCreated;
-    result.decisionsSuperseded = edgeRes.supersededMarked;
-    // Post-consolidate: forget-sweep remaining non-clustered cold memories
+    return tx.immediate();
+}
+/**
+ * How many rows the (removed) forget-sweep would have dropped — reported, never acted on.
+ * Kept for `consolidate --dry-run` so the user can see what earlier versions were deleting.
+ */
+export function countSweepCandidates(db, now = Math.floor(Date.now() / 1000)) {
     const remaining = db
         .prepare('SELECT id, layer, importance, access_count, last_accessed_at, protected, altitude FROM memories WHERE protected = 0')
         .all();
-    const toDrop = [];
+    let n = 0;
     for (const r of remaining) {
         const daysSince = (now - r.last_accessed_at) / 86400;
-        const heat = computeHeat({
-            accessesLast30d: daysSince < 30 ? r.access_count : 0,
-            accessesLast90d: daysSince < 90 ? r.access_count : 0,
-            daysSinceLastAccess: daysSince,
-            totalAccesses: r.access_count,
-            baseImportance: r.importance,
-        });
         const action = decideForgetting({
             daysSinceLastAccess: daysSince,
             importance: r.importance,
-            heatScore: heat.score,
+            heatScore: heatOf(now, r),
             protected: r.protected === 1,
             layer: r.layer,
             altitude: r.altitude ?? undefined,
         });
         if (action === 'drop')
-            toDrop.push(r.id);
-    }
-    if (toDrop.length > 0) {
-        const del = db.prepare('DELETE FROM memories WHERE id = ?');
-        const tx2 = db.transaction((ids) => {
-            for (const id of ids)
-                del.run(id);
-        });
-        tx2(toDrop);
-        result.memoriesDropped = toDrop.length;
+            n++;
     }
-    return result;
+    return n;
 }
 /**
  * Should the MCP server run consolidate on its own at start-up? (0.17.1, L-1-106 / audit F1)
  *
- * No, unless the user asked: consolidate deletes the original rows (keeping a 3 × 200-char
- * summary) and their edges, so it must not run without an explicit opt-in.
- * Opt in with LINKSEE_AUTO_CONSOLIDATE=1|true|on|weekly, or `--auto-consolidate` on the server
- * command line. The weekly gate inside the server still applies once enabled.
+ * No, unless the user asked. Opt in with exactly LINKSEE_AUTO_CONSOLIDATE=1 (0.18.1: true/on/
+ * yes/weekly no longer count), or `--auto-consolidate` on the server command line. The weekly gate inside the server still
+ * applies once enabled. Since 0.18.1 consolidate marks rows instead of deleting them, but it
+ * still rewrites content and hides rows from the default recall, so it stays opt-in.
  */
 export function autoConsolidateEnabled(env, argv) {
     if (argv.includes('--auto-consolidate'))
-        return true;
-    const v = (env.LINKSEE_AUTO_CONSOLIDATE ?? '').trim().toLowerCase();
-    return v === '1' || v === 'true' || v === 'on' || v === 'yes' || v === 'weekly';
+        return true; // kept for compatibility (documented since 0.17.1)
+    return (env.LINKSEE_AUTO_CONSOLIDATE ?? '').trim() === '1';
 }
 //# sourceMappingURL=consolidate.js.map

package/dist/lib/distill-triage.js

@@ -14,8 +14,13 @@
 // Both are archived, never deleted: type → note, state → superseded, distill_verdict records
 // why. needs_distill stays TRUE — anchor #70 says the flag must not be dropped, and it stays
 // truthful: no agent ever rewrote this row. The queue, the pending count and the boot digest
-// exclude rows that carry a verdict. Layer and protection are untouched (a caveat stays a
-// caveat — it just stops being asked about). Reversible: delete distill_verdict from the JSON.
+// exclude rows that carry a verdict. Reversible: delete distill_verdict from the JSON.
+//
+// 0.18.1 (Codex review 1 of #23): protected rows and the caveat layer are NOT triaged. The
+// archive sets state → superseded, and the default recall hides superseded rows, so a short
+// caveat ("never X") was being hidden at every server start. They stay in the queue instead.
+// Rows archived by earlier versions are not un-archived automatically
+// (recall({ include_superseded: true }) shows them).
 //
 // Measured before shipping (2026-09-07, 389 raw): noise 88, stale 51, queue 250 — and the
 // noise sample was read by a human before the rule was trusted.
@@ -51,6 +56,8 @@ export function triageDistillQueue(db, opts = {}) {
         WHERE json_valid(content)
           AND json_extract(content, '$.needs_distill') = 1
           AND json_extract(content, '$.distill_verdict') IS NULL
+          AND protected = 0
+          AND layer != 'caveat'
           AND created_at < ?`)
         .all(now - SETTLE_SECONDS);
     const report = { scanned: rows.length, noise: 0, stale: 0, remaining: 0, dryRun: !!opts.dryRun, samples: { noise: [], stale: [] } };

package/dist/lib/forgetting.js

@@ -1,7 +1,8 @@
 // Ported from linksee-app/setup-learning-box.cjs:62-99 (Ebbinghaus forgetting curve).
 // Implements Michie's memory principle 6: active forgetting.
 // Protected memories (caveat layer) and goal layer bypass decay.
-// Returns true if this memory should be forgotten (compressed to summary or deleted).
+// Risk score for forgetting. Since 0.18.1 nothing in the server acts on 'drop' by deleting:
+// consolidate marks clustered rows and only counts the rest (see consolidate.ts).
 // Higher forgettingRisk → more likely to forget.
 export function forgettingRisk(input) {
     if (input.protected)
@@ -26,9 +27,9 @@ export function forgettingRisk(input) {
     const timeFactor = input.daysSinceLastAccess * (1 + input.daysSinceLastAccess / 30);
     return heatFactor * importanceFactor * timeFactor * altitudeMultiplier;
 }
-// Risk threshold above which memory is compressed (→ learning layer summary) and the original deleted.
+// Risk threshold above which memory is compressed (→ learning layer summary; the original is kept and marked).
 export const COMPRESS_THRESHOLD = 50;
-// Risk threshold above which memory is entirely dropped.
+// Risk threshold that earlier versions used to delete a row outright. Reported only, since 0.18.1.
 export const DROP_THRESHOLD = 200;
 export function decideForgetting(input) {
     const risk = forgettingRisk(input);

package/dist/lib/session-import.d.ts

@@ -0,0 +1,22 @@
+import type Database from 'better-sqlite3';
+import type { ExtractedFileEdit, ExtractedMemory } from './session-extractor.js';
+export interface SessionImportInput {
+    session_id: string;
+    memories: ExtractedMemory[];
+    file_edits: ExtractedFileEdit[];
+    stats: unknown;
+}
+export interface SessionImportResult {
+    inserted: number;
+    /** Extracted memories whose key the DB already had: left exactly as they are. */
+    kept: number;
+    /** Stored undistilled rows whose key the new extraction did not produce. Left in place. */
+    leftInPlace: number;
+    edits: number;
+    editsKept: number;
+}
+export declare function importSession(db: Database.Database, input: SessionImportInput, opts: {
+    entityId: number;
+    sourceJson: (src: object) => string;
+    startedAt: number;
+}): SessionImportResult;

package/dist/lib/session-import.js

@@ -0,0 +1,161 @@
+// session-import — write one extracted Claude Code session into the DB, APPEND-ONLY
+// (0.18.1, Codex reviews 1–2 of #23).
+//
+// Up to 0.18.0 every re-import (the Stop hook runs one per turn) DELETEd the session's
+// undistilled memory rows, its session_file_edits and every event mentioning it, and inserted
+// them again — the memory DELETE outside the insert transaction. A failed insert lost the rows;
+// a successful one renumbered them; deleting session_file_edits cascaded (ON DELETE CASCADE)
+// into drift_edges and erased the user's dismiss/ack verdicts.
+//
+// The first 0.18.1 draft UPDATEd rows in place by a stable key. Review 2 showed that this
+// overwrote what a user had corrected with remember({ memory_id, content }) (the fresh
+// extraction won on same-named fields), and that replacing session_file_edits still dropped
+// drift verdicts. So, by design decision: a re-import only ADDS.
+//
+//   memories            key = source.kind | turn_uuid | layer | file path (file_edit rows, from
+//                       content.affects[0]) or the ordinal among same kind/turn/layer rows.
+//                       A key the DB already has → the row is not touched (no UPDATE, no
+//                       DELETE). A new key → INSERT.
+//   session_file_edits  key = turn_uuid | file_path | operation | occurred_at | ordinal.
+//                       Same rule: existing rows (and the drift_edges that point at them) are
+//                       not touched; new ones are INSERTed.
+//   events              one `session_imported` row per session; its payload (counts) is
+//                       updated in place, or the row is inserted. Other events are not touched.
+//
+// Accepted cost (CHANGELOG, known limits): an improved extraction does not reach rows already
+// imported — e.g. a file_edit row keeps the op count of the turn it was first imported in.
+// Distilled rewrites still suppress the raw turn. Everything is one BEGIN IMMEDIATE transaction.
+import { faultPoint } from './test-faults.js';
+function parseObj(s) {
+    try {
+        const v = JSON.parse(s);
+        return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+function discriminatorOf(kind, content) {
+    if (kind !== 'file_edit')
+        return null;
+    const o = parseObj(content);
+    const a = Array.isArray(o?.affects) ? o.affects[0] : undefined;
+    return typeof a === 'string' ? a : null;
+}
+function memKeyer() {
+    const ordinals = new Map();
+    return (kind, turn, layer, content) => {
+        const base = `${kind}|${turn}|${layer}`;
+        const d = discriminatorOf(kind, content);
+        if (d !== null)
+            return `${base}|p:${d}`;
+        const n = ordinals.get(base) ?? 0;
+        ordinals.set(base, n + 1);
+        return `${base}|#${n}`;
+    };
+}
+function editKeyer() {
+    const ordinals = new Map();
+    return (turn, path, op, at) => {
+        const base = `${turn ?? ''}|${path}|${op}|${at}`;
+        const n = ordinals.get(base) ?? 0;
+        ordinals.set(base, n + 1);
+        return `${base}|#${n}`;
+    };
+}
+export function importSession(db, input, opts) {
+    const sid = input.session_id;
+    const sidNeedle = `%"session_id":"${sid}"%`;
+    const selDistilledTurns = db.prepare(`SELECT source FROM memories
+      WHERE source LIKE ? AND json_valid(content) AND json_extract(content, '$.distilled') = 1`);
+    const selStored = db.prepare(`SELECT id, layer, content, source FROM memories
+      WHERE source LIKE ?
+        AND (NOT json_valid(content) OR COALESCE(json_extract(content, '$.distilled'), 0) != 1)
+      ORDER BY id`);
+    const selEdits = db.prepare('SELECT turn_uuid, file_path, operation, occurred_at FROM session_file_edits WHERE session_id = ? ORDER BY id');
+    const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source, thread_id, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)');
+    const insEdit = db.prepare(`INSERT INTO session_file_edits (session_id, memory_id, file_path, operation, turn_uuid, context_snippet, occurred_at) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+    const selEvt = db.prepare(`SELECT id FROM events WHERE kind = 'session_imported' AND json_valid(payload) AND json_extract(payload, '$.session_id') = ? ORDER BY id LIMIT 1`);
+    const updEvt = db.prepare('UPDATE events SET payload = ? WHERE id = ?');
+    const insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
+    const run = db.transaction(() => {
+        const res = { inserted: 0, kept: 0, leftInPlace: 0, edits: 0, editsKept: 0 };
+        const distilledTurns = new Set();
+        for (const r of selDistilledTurns.all(sidNeedle)) {
+            const u = parseObj(r.source)?.turn_uuid;
+            if (u)
+                distilledTurns.add(String(u));
+        }
+        // Keys of the stored rows. Rows whose source has no kind (a much older version) get no key:
+        // they are never matched and never touched. The key is computed from the stored row as it
+        // is now (a user edit of `affects` changes it; the extraction is then inserted once more,
+        // the edited row is still not touched).
+        const storedByKey = new Map();
+        const storedKey = memKeyer();
+        const stored = selStored.all(sidNeedle);
+        for (const r of stored) {
+            const src = parseObj(r.source);
+            if (!src?.kind || src.session_id !== sid)
+                continue;
+            const k = storedKey(String(src.kind), String(src.turn_uuid ?? ''), r.layer, r.content);
+            if (!storedByKey.has(k))
+                storedByKey.set(k, r);
+        }
+        const freshKey = memKeyer();
+        const matched = new Set();
+        const memContentToId = new Map();
+        const now = Math.floor(Date.now() / 1000);
+        for (const m of input.memories) {
+            if (m.source.turn_uuid && distilledTurns.has(m.source.turn_uuid))
+                continue; // distilled rewrite wins
+            const k = freshKey(m.source.kind, m.source.turn_uuid ?? '', m.layer, m.content);
+            const prev = storedByKey.get(k);
+            if (prev && !matched.has(prev.id)) {
+                matched.add(prev.id); // already imported: not touched
+                memContentToId.set(m.content, prev.id);
+                res.kept++;
+                continue;
+            }
+            const r = insMem.run(opts.entityId, m.layer, m.content, m.importance, opts.sourceJson(m.source), m.thread_id ?? null, m.occurred_at ?? now);
+            memContentToId.set(m.content, Number(r.lastInsertRowid));
+            res.inserted++;
+        }
+        res.leftInPlace = stored.length - matched.size;
+        faultPoint('import-after-memories');
+        // session_file_edits: existing rows (and the drift_edges pointing at them) are not touched.
+        const haveEdits = new Set();
+        const storedEditKey = editKeyer();
+        for (const e of selEdits.all(sid)) {
+            haveEdits.add(storedEditKey(e.turn_uuid, e.file_path, e.operation, e.occurred_at));
+        }
+        const freshEditKey = editKeyer();
+        for (const fe of input.file_edits) {
+            const k = freshEditKey(fe.turn_uuid ?? null, fe.file_path, fe.operation, fe.occurred_at);
+            if (haveEdits.has(k)) {
+                res.editsKept++;
+                continue;
+            }
+            const memId = fe.memory_content ? memContentToId.get(fe.memory_content) ?? null : null;
+            insEdit.run(fe.session_id, memId, fe.file_path, fe.operation, fe.turn_uuid ?? null, fe.context_snippet, fe.occurred_at);
+            res.edits++;
+        }
+        // One session_imported event per session, kept current. No other event is touched.
+        const payload = JSON.stringify({
+            session_id: sid,
+            memories: input.memories.length,
+            file_edits: input.file_edits.length,
+            stats: input.stats,
+        });
+        const evt = selEvt.get(sid);
+        if (evt)
+            updEvt.run(payload, evt.id);
+        else
+            insEvt.run(opts.entityId, 'session_imported', payload, opts.startedAt);
+        faultPoint('import-after-edits');
+        return res;
+    });
+    // IMMEDIATE: take the write lock before reading the stored keys, so another writer cannot
+    // add the same rows between the read and the insert.
+    return run.immediate();
+}
+//# sourceMappingURL=session-import.js.map

package/dist/lib/test-faults.d.ts

@@ -1,3 +1,10 @@
 import { type RmOptions } from 'node:fs';
 export declare function renameGuarded(from: string, to: string): void;
 export declare function rmGuarded(path: string, opts: RmOptions): void;
+/**
+ * Named fault points inside a transaction (0.18.1, Codex review 1 of #23): the rollback tests
+ * need a failure AFTER some rows were written, not one at prepare() time.
+ *   LINKSEE_TEST_FAULT=consolidate-after-mark | consolidate-after-edges | import-after-memories
+ * Unset (the normal case) this is a no-op.
+ */
+export declare function faultPoint(name: string): void;