linksee-memory 0.18.0 → 0.18.1

package/README.md

@@ -8,11 +8,27 @@ Needs Node.js 20 or later, and Claude Code or Codex to try it (either one is eno
 
 ## Install
 
+Claude Code, from inside a session (plugin: MCP server and skill, no hooks):
+
+```text
+/plugin marketplace add michielinksee/linksee-memory
+/plugin install linksee-memory@linksee-memory
+```
+
+Or from a shell, which also installs the hooks:
+
 ```bash
 npx -y linksee-memory setup                       # Claude Code: MCP server, skill, hooks
 codex mcp add linksee -- npx -y linksee-memory    # Codex: the same memory
 ```
 
+The plugin starts the server with `npx -y linksee-memory@latest` and ships the same skill `setup` installs. It has no hooks: the Stop hook (auto-capture) and the [re-injection guard](docs/guard.md) come only from `setup`. One or the other, not both:
+
+- Already ran `setup`? Do not add the plugin. With both, Claude Code runs the server twice (`linksee` and `plugin:linksee-memory:linksee`).
+- Installed the plugin and want the hooks? Disable it (`/plugin` → Installed → linksee-memory → disable, or `claude plugin disable linksee-memory@linksee-memory`), then run `npx -y linksee-memory setup`. The memory file is the same; nothing is lost.
+- Plugin only: no hooks, so nothing is saved unless the agent calls `remember` (the skill tells it when).
+- Windows: after installing the plugin, run `/mcp` and check that `plugin:linksee-memory:linksee` is connected. If it is not, disable the plugin first (previous bullet), then run `npx -y linksee-memory setup` from the shell block above. `setup` registers the server with `claude mcp add`, the form that is known to work on Windows, and it does not disable the plugin for you.
+
 One command for Claude Code. `setup --dry-run` prints what it would change. It edits `~/.claude/settings.json`, so the hooks apply in every repo, and keeps the old file as `settings.json.bak-<timestamp>` ([what it writes](#what-setup-writes)).
 
 ## First round trip
@@ -233,6 +249,12 @@ We installed them and ran one scenario across all of them. Storing and recalling
 **How do I stop Claude Code from repeating the same mistake it made last week?**  
 Record it as a caveat (`remember({ content, layer: 'caveat' })`). Caveats are protected from forgetting and come back when `recall` touches the same ground again. To have Claude Code stop the repeat before it lands, record it as an anchor with a `violation_signal`, then harden it (`resolve_drift(action: "harden")`); without hardening, a match only warns.
 
+**Does Linksee delete old memories on its own?**
+Not since 0.18.1. Earlier versions had a "sleep" pass (`consolidate`) that folded cold memories into a short summary and deleted the originals — on the maintainer's own database it removed 1,360 rows on 2026-10-29 and 559 on 2026-11-05 without saying so. Now the only thing that removes a memory row is `remember({ memory_id, forget: true })`, by request — the Stop-hook re-import only adds rows (never touches ones it already wrote) and the start-up triage leaves caveats and protected rows alone. (Before importing, the normal schema migration runs; it can raise `protected` from 0 to 1 for rows with importance ≥ 0.9 and fill columns an older schema lacks, but it does not change a memory's text, relations or verdicts.) Consolidation still exists, by hand (`npx -y linksee-memory consolidate --dry-run` to see, `--apply` to fold) or opt-in at start-up (`LINKSEE_AUTO_CONSOLIDATE=1`); it writes one summary per cluster and marks the originals `consolidated_into`, which `recall` hides by default (`consolidated_hidden` says how many; `include_consolidated: true` shows them). Rows that an earlier version deleted come back only from a backup of `~/.linksee-memory/`.
+
+**Linksee は古い記憶を勝手に消しますか？**
+0.18.1 からは消しません。それ以前の版には「睡眠中の整理」（`consolidate`）があり、冷えた記憶を短い要約に畳んで原本を削除していました（開発者自身の DB で 2026-10-29 に 1,360 行、2026-11-05 に 559 行が、知らせも無く消えています）。いまは `remember({ memory_id, forget: true })` で頼んだ 1 行以外、記憶の行を消す処理はありません（Stop フックの再取り込みは追記だけで既存の行に触らず、起動時の整理は caveat と保護行に触りません。取り込みの前に通常の schema 移行が走り、保護フラグの補正（importance 0.9 以上の行の protected を 0→1 にする方向だけ）と旧 schema の列補完が起き得ますが、記憶の本文・関係・判定は変えません）。整理そのものは残っています。手で回す（`npx -y linksee-memory consolidate --dry-run` で中身を見て、`--apply` で畳む）か、起動時に走らせたい時だけ `LINKSEE_AUTO_CONSOLIDATE=1` を付けます。畳んだ原本には `consolidated_into` が付いて残り、`recall` は既定でそれを隠して件数（`consolidated_hidden`）だけ返します（`include_consolidated: true` で出ます）。前の版が消した行は、`~/.linksee-memory/` のバックアップからしか戻りません。
+
 **開発の意思決定履歴をMCPサーバーで残しておく定番のやり方はありますか？**  
 `remember({ content, anchor: {} })` の1回で、記録と決定の登録が同時に入ります（Claude Code では再注入も）。反する編集で警告を出すには `violation_signal` を足し、拒否まで行うにはさらに `resolve_drift(action: "harden")` で hard にします。`drift_status` がその台帳で、各決定が いま守られているか（🔵）・ずれているか（🔴）・誰も確かめていないか（⚫）を示します。
 

package/dist/bin/consolidate.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+interface Args {
+    dryRun: boolean;
+    apply: boolean;
+    minAgeDays?: number;
+    json: boolean;
+    help: boolean;
+    bad?: string;
+}
+export declare function parseArgs(argv: readonly string[]): Args;
+export declare function main(argv?: readonly string[]): number;
+export {};

package/dist/bin/consolidate.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+// linksee-memory consolidate --dry-run | --apply [--min-age-days N] [--json]   (0.18.1)
+//
+// Runs sleep-mode consolidation by hand. Since 0.18.1 it never deletes a row: each cluster of
+// cold, unprotected, JSON-content memories (same entity, same layer, older than N days, 2 or
+// more) gets one `learning`-layer summary, and the originals are marked
+// `consolidated_into: <summary id>` in their content JSON. `recall` hides marked rows by
+// default and says how many (`consolidated_hidden`); `include_consolidated: true` shows them.
+//
+// --dry-run   prints what --apply would fold (counts, then up to 3 example clusters). Opens the
+//             DB read-only and does not run migrations: memory.db is not written. A schema older
+//             than this build → "migrate first", exit 1. Also prints how many rows the
+//             forget-sweep of 0.18.0 and earlier would have deleted.
+// --apply     folds, in one BEGIN IMMEDIATE transaction. Rows marked, 0 deleted. Any failure —
+//             including a row count other than before + summaries, checked inside the
+//             transaction — rolls the whole run back; exit 2.
+// No flag     prints this usage and exits 1 — the DB is not opened.
+//
+// The server's own run at start-up stays off unless LINKSEE_AUTO_CONSOLIDATE=1.
+import { readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Database from 'better-sqlite3';
+import { openDb, runMigrations, getDbPath, DbRefusedError, probeReadonly, migrateCommand } from '../db/migrate.js';
+import { planConsolidate, consolidate, countSweepCandidates } from '../lib/consolidate.js';
+const USAGE = `linksee-memory consolidate — fold cold memories into summaries (nothing is deleted)
+
+  --dry-run            show what --apply would fold; read-only, writes nothing
+  --apply              fold: one learning-layer summary per cluster, originals marked
+                       consolidated_into and kept (recall hides them by default)
+  --min-age-days N     only rows older than N days are candidates (default 7)
+  --json               machine-readable output
+  -h, --help           this message
+
+Exactly one of --dry-run / --apply is required.
+DB: ${getDbPath()}
+`;
+export function parseArgs(argv) {
+    const a = { dryRun: false, apply: false, json: false, help: false };
+    for (let i = 0; i < argv.length; i++) {
+        const v = argv[i];
+        if (v === '--dry-run' || v === '--dry')
+            a.dryRun = true;
+        else if (v === '--apply')
+            a.apply = true;
+        else if (v === '--json')
+            a.json = true;
+        else if (v === '-h' || v === '--help')
+            a.help = true;
+        else if (v === '--min-age-days') {
+            const n = Number(argv[++i]);
+            if (!Number.isFinite(n) || n < 0) {
+                a.bad = `--min-age-days needs a number >= 0, got "${argv[i] ?? ''}"`;
+            }
+            else
+                a.minAgeDays = n;
+        }
+        else
+            a.bad = `unknown argument "${v}"`;
+    }
+    return a;
+}
+/** The schema version this build writes (from schema.sql), or 0 if it cannot be read. */
+function targetSchema() {
+    try {
+        const sql = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'db', 'schema.sql'), 'utf8');
+        const m = sql.match(/VALUES \('schema_version', '(\d+)'\)/);
+        return m ? Number(m[1]) : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * --dry-run: SQLITE_OPEN_READONLY, no runMigrations, so memory.db is not written (0.18.1, Codex
+ * review 1 of #23). The -wal/-shm a read-only open may add are removed again (probeReadonly's
+ * tidy). A schema older than this build → "migrate first", exit 1.
+ */
+function dryRun(args) {
+    const path = getDbPath();
+    const { probe, tidy } = probeReadonly(path);
+    if (probe.kind === 'missing') {
+        process.stdout.write(`consolidate --dry-run: no database at ${path}; nothing to fold\n`);
+        return 0;
+    }
+    if (probe.kind !== 'version') {
+        tidy();
+        process.stderr.write(`consolidate --dry-run: cannot read ${path} read-only (${probe.kind}); nothing was done\n`);
+        return 1;
+    }
+    const want = targetSchema();
+    if (want === 0 || probe.version < want) {
+        tidy();
+        process.stderr.write(`consolidate --dry-run: the database is at schema ${probe.version}, this version expects ${want || '(unknown)'}. ` +
+            `Migrate first (\`${migrateCommand()}\`, or start the server of this version once); nothing was done.\n`);
+        return 1;
+    }
+    const db = new Database(path, { readonly: true, fileMustExist: true });
+    try {
+        const before = db.prepare('SELECT COUNT(*) AS c FROM memories').get().c;
+        const plan = planConsolidate(db, { min_age_days: args.minAgeDays });
+        const sweepWouldHaveDropped = countSweepCandidates(db);
+        if (args.json) {
+            process.stdout.write(JSON.stringify({
+                dry_run: true,
+                memories: before,
+                scanned: plan.scanned,
+                clusters: plan.clusters.length,
+                would_fold: plan.wouldFold,
+                would_delete: 0,
+                cold_unclustered: plan.coldUnclustered,
+                skipped_plain_text: plan.skippedPlainText,
+                sweep_pre_0_18_1_would_have_deleted: sweepWouldHaveDropped,
+                examples: plan.clusters.slice(0, 3).map((c) => ({ entity: c.entity_name, layer: c.layer, ids: c.ids, examples: c.examples })),
+            }, null, 2) + '\n');
+            return 0;
+        }
+        const lines = [
+            `consolidate --dry-run (read-only; nothing written)`,
+            `  memories in DB:            ${before}`,
+            `  scanned (candidates):      ${plan.scanned}`,
+            `  clusters:                  ${plan.clusters.length}`,
+            `  rows --apply would mark:   ${plan.wouldFold}   (consolidated_into; rows stay)`,
+            `  rows --apply would delete: 0`,
+            `  cold but unclustered:      ${plan.coldUnclustered}   (left alone)`,
+            `  plain-text, skipped:       ${plan.skippedPlainText}   (the mark needs JSON content)`,
+            `  the forget-sweep of 0.18.0 and earlier would have deleted: ${sweepWouldHaveDropped}`,
+        ];
+        if (plan.clusters.length > 0) {
+            lines.push('', `  examples (${Math.min(3, plan.clusters.length)} of ${plan.clusters.length} clusters):`);
+            for (const c of plan.clusters.slice(0, 3)) {
+                lines.push(`    ${c.entity_name} / ${c.layer}: ${c.ids.length} rows (ids ${c.ids.slice(0, 5).join(', ')}${c.ids.length > 5 ? ', …' : ''})`);
+                for (const ex of c.examples)
+                    lines.push(`      - ${ex}`);
+            }
+        }
+        lines.push('', `  to fold: npx linksee-memory consolidate --apply`);
+        process.stdout.write(lines.join('\n') + '\n');
+        return 0;
+    }
+    finally {
+        db.close();
+        tidy();
+    }
+}
+export function main(argv = process.argv.slice(2)) {
+    const args = parseArgs(argv);
+    if (args.help) {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    if (args.bad) {
+        process.stderr.write(`${args.bad}\n\n${USAGE}`);
+        return 1;
+    }
+    if (args.dryRun === args.apply) {
+        // neither, or both: refuse before touching the DB
+        process.stderr.write(`consolidate: pass exactly one of --dry-run or --apply (nothing was done)\n\n${USAGE}`);
+        return 1;
+    }
+    if (args.dryRun)
+        return dryRun(args);
+    let db;
+    try {
+        db = openDb();
+        runMigrations(db);
+    }
+    catch (e) {
+        if (e instanceof DbRefusedError) {
+            process.stderr.write(`${e.message}\n`);
+            return 1;
+        }
+        throw e;
+    }
+    try {
+        let r;
+        try {
+            r = consolidate(db, { scope: 'all', min_age_days: args.minAgeDays });
+        }
+        catch (e) {
+            process.stderr.write(`consolidate --apply failed and was rolled back; nothing was written: ${e?.message ?? e}\n`);
+            return 2;
+        }
+        if (args.json) {
+            process.stdout.write(JSON.stringify({ applied: true, ...r }, null, 2) + '\n');
+        }
+        else {
+            process.stdout.write([
+                `consolidate --apply`,
+                `  summaries written:         ${r.clustersCompressed}   (learning layer, ids ${r.learningIdsCreated.slice(0, 5).join(', ')}${r.learningIdsCreated.length > 5 ? ', …' : ''})`,
+                `  rows marked consolidated_into: ${r.memoriesFolded}   (still in the DB; recall({ include_consolidated: true }) shows them)`,
+                `  rows deleted:              ${r.memoriesDropped}`,
+                `  memories before / after:   ${r.memoriesBefore} / ${r.memoriesAfter}`,
+                `  in_progress → stalled:     ${r.stalledTransitions}`,
+                `  decision edges detected:   ${r.memoryEdgesCreated} (superseded marked: ${r.decisionsSuperseded})`,
+            ].join('\n') + '\n');
+        }
+        return 0;
+    }
+    finally {
+        db.close();
+    }
+}
+const isMain = (() => {
+    try {
+        const a = process.argv[1] ? realpathSync(process.argv[1]) : '';
+        const b = realpathSync(fileURLToPath(import.meta.url));
+        return process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+    }
+    catch {
+        return false;
+    }
+})();
+if (isMain)
+    process.exit(main(process.argv.slice(2)));
+//# sourceMappingURL=consolidate.js.map

package/dist/bin/import-sessions.js

@@ -6,7 +6,8 @@
 //   node dist/bin/import-sessions.js --all                   (scans all ~/.claude/projects/*)
 //   node dist/bin/import-sessions.js --session-file <path>   (single jsonl — used by hook)
 //
-// All inserts are IDEMPOTENT: existing data for a given session_id is wiped before re-insert.
+// Re-imports are idempotent and append-only (0.18.1): rows already imported are never touched;
+// new ones are inserted, in one BEGIN IMMEDIATE transaction per session — see lib/session-import.ts.
 import { readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
@@ -14,6 +15,7 @@ import { openDb, runMigrations } from '../db/migrate.js';
 import { parseSessionFile, detectProjectName } from '../lib/session-parser.js';
 import { extractSession } from '../lib/session-extractor.js';
 import { normalizeEntityName } from '../lib/normalize.js';
+import { importSession } from '../lib/session-import.js';
 const CLAUDE_PROJECTS = join(homedir(), '.claude', 'projects');
 function usage() {
     console.log(`Usage:
@@ -40,35 +42,6 @@ function collectJsonlFiles(projectDir) {
         return [];
     }
 }
-// Idempotent wipe: remove all rows tied to a given session_id BEFORE re-inserting.
-// Uses LIKE matching on the JSON-encoded source field for memories/events.
-// DISTILLED memories survive the wipe: a session stays ACTIVE while its raw extractions
-// get distilled (dream → remember(memory_id) rewrite), and the next Stop-hook re-import
-// must not destroy that human/agent-curated rewrite and resurrect the raw utterance.
-function wipeSession(db, sessionId) {
-    const sidNeedle = `%"session_id":"${sessionId}"%`;
-    const editDel = db.prepare('DELETE FROM session_file_edits WHERE session_id = ?').run(sessionId);
-    const memDel = db.prepare(`DELETE FROM memories WHERE source LIKE ?
-       AND (NOT json_valid(content) OR COALESCE(json_extract(content, '$.distilled'), 0) != 1)`).run(sidNeedle);
-    const evtDel = db.prepare('DELETE FROM events WHERE payload LIKE ?').run(sidNeedle);
-    return { memories: memDel.changes, edits: editDel.changes, events: evtDel.changes };
-}
-// A re-extracted memory must NOT be re-inserted if its source turn already has a surviving
-// distilled rewrite (matched by turn_uuid — the stable key shared by raw and rewrite).
-function makeDistilledTurnSet(db, sessionId) {
-    const rows = db.prepare(`SELECT source FROM memories
-      WHERE source LIKE ? AND json_valid(content) AND json_extract(content, '$.distilled') = 1`).all(`%"session_id":"${sessionId}"%`);
-    const set = new Set();
-    for (const r of rows) {
-        try {
-            const uuid = JSON.parse(r.source)?.turn_uuid;
-            if (uuid)
-                set.add(String(uuid));
-        }
-        catch { /* ignore malformed source */ }
-    }
-    return set;
-}
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes('-h') || args.includes('--help')) {
@@ -86,9 +59,8 @@ async function main() {
     const projectArgs = args.filter((a, i) => !a.startsWith('--')
         && (sessionFileIdx < 0 || i !== sessionFileIdx + 1)
         && (viaIdx < 0 || i !== viaIdx + 1));
-    // The session keys are kept as they were: wipeSession and makeDistilledTurnSet find these rows
-    // by the substring `"session_id":"…"` (position does not matter, the exact text does).
-    // Known, not changed here: wipeSession runs outside the re-insert transaction.
+    // The session keys are kept as they were: importSession finds these rows by the substring
+    // `"session_id":"…"` (position does not matter, the exact text does).
     const sourceJson = (src) => JSON.stringify({ ...src, client: 'claude-code', via });
     // Single-file mode (used by the Stop hook)
     if (sessionFile) {
@@ -115,11 +87,6 @@ async function main() {
         }
         if (!db)
             return;
-        // Idempotent: wipe any prior data for THIS session before re-inserting
-        // (distilled rewrites survive — see wipeSession), then skip re-extracting
-        // any turn that already has a distilled rewrite.
-        const wiped = wipeSession(db, result.session_id);
-        const distilledTurns = makeDistilledTurnSet(db, result.session_id);
         // Resolve project entity (canonical_key = project:<name>, so same project across
         // different sessions/cwds collapses to one entity)
         let projectEntityId;
@@ -135,35 +102,18 @@ async function main() {
             const ins = db.prepare('INSERT INTO entities (kind, name, normalized_name, canonical_key) VALUES (?, ?, ?, ?)').run('project', projectName, normalized, canonicalKey);
             projectEntityId = Number(ins.lastInsertRowid);
         }
-        // created_at = the source turn's true timestamp. The Stop hook re-imports the growing
-        // transcript every turn (wipe+reinsert), and DEFAULT unixepoch() restamped days-old
-        // content as "now" — inflating every time-windowed view ("today" showed last week).
-        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 insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
-        let inserted = { memories: 0, edits: 0 };
-        db.transaction(() => {
-            const memContentToId = new Map();
-            for (const m of result.memories) {
-                if (m.source.turn_uuid && distilledTurns.has(m.source.turn_uuid))
-                    continue; // distilled rewrite wins
-                const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, sourceJson(m.source), m.thread_id ?? null, m.occurred_at ?? Math.floor(Date.now() / 1000));
-                memContentToId.set(m.content, Number(res.lastInsertRowid));
-                inserted.memories++;
-            }
-            for (const fe of result.file_edits) {
-                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);
-                inserted.edits++;
-            }
-            insEvt.run(projectEntityId, 'session_imported', JSON.stringify({
-                session_id: result.session_id,
-                memories: result.memories.length,
-                file_edits: result.file_edits.length,
-                stats: result.stats,
-            }), parsed.started_at || Math.floor(Date.now() / 1000));
-        })();
-        console.log(`[ok] ${result.session_id.slice(0, 8)} (${projectName}): wiped ${wiped.memories}m/${wiped.edits}e/${wiped.events}ev → inserted ${inserted.memories}m/${inserted.edits}e`);
+        // created_at = the source turn's true timestamp (a re-import must not restamp old content).
+        let r;
+        try {
+            r = importSession(db, result, { entityId: projectEntityId, sourceJson, startedAt: parsed.started_at || Math.floor(Date.now() / 1000) });
+        }
+        catch (e) {
+            // The transaction rolled back: the session's earlier rows are as they were.
+            console.error(`[error] ${result.session_id.slice(0, 8)} (${projectName}): ${e?.message ?? e} — nothing written`);
+            db.close();
+            process.exit(1);
+        }
+        console.log(`[ok] ${result.session_id.slice(0, 8)} (${projectName}): inserted ${r.inserted}m + ${r.edits}e, kept ${r.kept}m + ${r.editsKept}e untouched, left ${r.leftInPlace}m (append-only, 0 deleted)`);
         db.close();
         return;
     }
@@ -259,43 +209,14 @@ async function main() {
                 const ins = db.prepare('INSERT INTO entities (kind, name, normalized_name, canonical_key) VALUES (?, ?, ?, ?)').run('project', projectName, normalized, canonicalKey);
                 projectEntityId = Number(ins.lastInsertRowid);
             }
-            // Idempotent: wipe any prior data for THIS session before re-inserting (Phase B).
-            // Distilled rewrites survive the wipe and suppress re-insertion of their raw turn.
-            wipeSession(db, result.session_id);
-            const distilledTurns = makeDistilledTurnSet(db, result.session_id);
-            // Insert memories + file_edits in a single transaction per session.
-            // created_at = source-turn timestamp (see single-file mode above for why).
-            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 insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
-            const tx = db.transaction(() => {
-                const memContentToId = new Map();
-                for (const m of result.memories) {
-                    if (m.source.turn_uuid && distilledTurns.has(m.source.turn_uuid))
-                        continue; // distilled rewrite wins
-                    const srcJson = sourceJson(m.source);
-                    const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, srcJson, m.thread_id ?? null, m.occurred_at ?? Math.floor(Date.now() / 1000));
-                    memContentToId.set(m.content, Number(res.lastInsertRowid));
-                    agg.memories_inserted++;
-                }
-                for (const fe of result.file_edits) {
-                    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);
-                    agg.file_edits_inserted++;
-                }
-                insEvt.run(projectEntityId, 'session_imported', JSON.stringify({
-                    session_id: result.session_id,
-                    memories: result.memories.length,
-                    file_edits: result.file_edits.length,
-                    stats: result.stats,
-                }), parsed.started_at || Math.floor(Date.now() / 1000));
-            });
             try {
-                tx();
+                const r = importSession(db, result, { entityId: projectEntityId, sourceJson, startedAt: parsed.started_at || Math.floor(Date.now() / 1000) });
+                agg.memories_inserted += r.inserted;
+                agg.file_edits_inserted += r.edits;
             }
             catch (e) {
                 agg.errors++;
-                console.warn(`  [tx error] ${f}: ${e?.message ?? e}`);
+                console.warn(`  [tx error] ${f}: ${e?.message ?? e} (rolled back; earlier rows kept)`);
             }
         }
     }

package/dist/lib/consolidate.d.ts

@@ -2,23 +2,78 @@ import type Database from 'better-sqlite3';
 export interface ConsolidateResult {
     scanned: number;
     clustersCompressed: number;
-    memoriesReplaced: number;
-    memoriesDropped: number;
+    /** Rows marked `consolidated_into` (kept in the table; hidden from default recall). */
+    memoriesFolded: number;
+    /** Always 0 since 0.18.1 — kept so older readers of the result do not break. */
+    memoriesDropped: 0;
+    /** Cold rows that did not form a cluster. Nothing is done to them. */
+    coldUnclustered: number;
+    /** Cold rows with plain-text content, left out because the mark needs JSON. */
+    skippedPlainText: number;
     learningIdsCreated: number[];
+    /** Row counts read inside the run's transaction (0.18.1). after = before + summaries, or the run rolls back. */
+    memoriesBefore: number;
+    memoriesAfter: number;
     stalledTransitions: number;
     memoryEdgesCreated: number;
     decisionsSuperseded: number;
 }
+interface Candidate {
+    id: number;
+    entity_id: number;
+    entity_name: string;
+    layer: string;
+    content: string;
+    importance: number;
+    last_accessed_at: number;
+    access_count: number;
+    created_at: number;
+    protected: number;
+    altitude: string | null;
+    mem_type: string | null;
+}
+export interface ConsolidatePlanCluster {
+    entity_id: number;
+    entity_name: string;
+    layer: string;
+    ids: number[];
+    members: Candidate[];
+    /** Up to 3 content fragments (first 120 chars), for a dry-run listing. */
+    examples: string[];
+}
+export interface ConsolidatePlan {
+    scanned: number;
+    clusters: ConsolidatePlanCluster[];
+    /** Number of rows that `--apply` would mark. */
+    wouldFold: number;
+    coldUnclustered: number;
+    skippedPlainText: number;
+}
+/** SQL fragment: the row has been folded into a summary (alias `m` for memories). */
+export declare const CONSOLIDATED_SQL = "(json_valid(m.content) AND json_type(m.content) = 'object' AND json_extract(m.content, '$.consolidated_into') IS NOT NULL)";
+/**
+ * What consolidate would do, without writing. Shared by `consolidate` (which applies it),
+ * the `consolidate --dry-run` subcommand, and the start-up notice.
+ */
+export declare function planConsolidate(db: Database.Database, opts?: {
+    min_age_days?: number;
+}, now?: number): ConsolidatePlan;
 export declare function consolidate(db: Database.Database, opts?: {
     scope?: 'all' | 'session';
     min_age_days?: number;
 }): ConsolidateResult;
+/**
+ * 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 declare function countSweepCandidates(db: Database.Database, now?: number): number;
 /**
  * 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 declare function autoConsolidateEnabled(env: Record<string, string | undefined>, argv: readonly string[]): boolean;
+export {};