linksee-memory 0.18.0 → 0.18.1

package/dist/lib/test-faults.js

@@ -27,4 +27,20 @@ export function rmGuarded(path, opts) {
     inject('RM');
     rmSync(path, opts);
 }
+/**
+ * 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 function faultPoint(name) {
+    const spec = process.env.LINKSEE_TEST_FAULT;
+    if (!spec)
+        return;
+    if (spec.split(',').map((s) => s.trim()).includes(name)) {
+        const e = new Error(`injected fault at ${name}`);
+        e.code = 'EINJECTED';
+        throw e;
+    }
+}
 //# sourceMappingURL=test-faults.js.map

package/dist/mcp/server.js

@@ -8,9 +8,8 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { openDb, runMigrations, DbRefusedError } from '../db/migrate.js';
 import { computeHeat } from '../lib/heat-index.js';
-import { decideForgetting } from '../lib/forgetting.js';
 import { refreshMomentumForEntity } from '../lib/momentum.js';
-import { consolidate as runConsolidate, autoConsolidateEnabled } from '../lib/consolidate.js';
+import { consolidate as runConsolidate, autoConsolidateEnabled, planConsolidate, CONSOLIDATED_SQL } from '../lib/consolidate.js';
 import { isPastedExternalContent } from '../lib/session-parser.js';
 import { inferAltitude, inferType, inferState } from '../lib/session-extractor.js';
 import { normalizeEntityName } from '../lib/normalize.js';
@@ -67,6 +66,7 @@ const SUBCOMMANDS = {
     'share-draft': 'share-draft.js',
     migrate: 'migrate-legacy.js', // 0.17.2: schema 1–5 → current, without starting the server
     runtime: 'runtime.js', // 0.17.2: runtime list | prune
+    consolidate: 'consolidate.js', // 0.18.1: consolidate --dry-run | --apply (marks, never deletes)
 };
 const subcommand = process.argv[2];
 if (subcommand && Object.prototype.hasOwnProperty.call(SUBCOMMANDS, subcommand)) {
@@ -101,35 +101,46 @@ try {
 catch { /* never block startup */ }
 // Auto-maintenance: consolidate stale memories on startup (non-blocking).
 //
-// OFF by default since 0.17.1 (L-1-106 / audit F1): consolidate deletes the original rows after
-// writing a summary that keeps only the top 3 × 200 characters, ignores thread_id, and cascades
-// away their edges — reasons and history lost with no action from the user. It now runs only
-// when asked: LINKSEE_AUTO_CONSOLIDATE=1 (or `--auto-consolidate` on the server command line).
-// There is no `consolidate` tool (merged away in 0.7.0). Rows already removed by earlier versions
-// are not restored.
-if (autoConsolidateEnabled(process.env, process.argv.slice(2)))
-    setTimeout(() => {
+// OFF by default (0.17.1 intended this; 0.18.1 makes it hold and takes the delete out):
+// up to 0.18.0 consolidate deleted the original rows after writing a summary that kept only the
+// top 3 × 200 characters, then a forget-sweep deleted every other cold row — reasons and history
+// lost with no action from the user (1,360 rows on 2026-10-29, 559 on 2026-11-05 on the
+// maintainer's DB). Since 0.18.1 nothing is deleted: originals are marked `consolidated_into`
+// and hidden from the default recall. It still runs only when asked: LINKSEE_AUTO_CONSOLIDATE=1
+// (or `--auto-consolidate` on the server command line); by hand: `npx linksee-memory consolidate
+// --dry-run | --apply`. When off, one stderr line says how many rows a run would fold, so a
+// growing database is noticed without anything being touched. There is no `consolidate` MCP tool
+// (merged away in 0.7.0). Rows already removed by earlier versions are not restored.
+const autoConsolidateOn = autoConsolidateEnabled(process.env, process.argv.slice(2));
+setTimeout(() => {
+    try {
+        if (!autoConsolidateOn) {
+            // Read-only: count what a run would fold. Never throws out of here, never writes.
+            const plan = planConsolidate(db, { min_age_days: 7 });
+            process.stderr.write(`[linksee-memory] auto-consolidate is off (set LINKSEE_AUTO_CONSOLIDATE=1 to enable); ${plan.wouldFold} cold memories would be folded` +
+                ` (run: npx linksee-memory consolidate --dry-run)\n`);
+            return;
+        }
+        let shouldRun = true;
         try {
-            let shouldRun = true;
-            try {
-                // Check if consolidations table exists before querying
-                const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='consolidations'").get();
-                if (tableExists) {
-                    const lastRow = db.prepare('SELECT MAX(created_at) as ts FROM consolidations').get();
-                    if (lastRow?.ts && (Date.now() / 1000 - lastRow.ts) / 86400 < 7)
-                        shouldRun = false;
-                }
-            }
-            catch {
-                shouldRun = false; /* genuinely unexpected — skip to be safe */
-            }
-            if (shouldRun) {
-                runConsolidate(db, { scope: 'all', min_age_days: 7 });
-                process.stderr.write('[linksee-memory] auto-consolidate complete\n');
+            // Check if consolidations table exists before querying
+            const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='consolidations'").get();
+            if (tableExists) {
+                const lastRow = db.prepare('SELECT MAX(created_at) as ts FROM consolidations').get();
+                if (lastRow?.ts && (Date.now() / 1000 - lastRow.ts) / 86400 < 7)
+                    shouldRun = false;
             }
         }
-        catch { /* non-fatal */ }
-    }, 3000);
+        catch {
+            shouldRun = false; /* genuinely unexpected — skip to be safe */
+        }
+        if (shouldRun) {
+            const r = runConsolidate(db, { scope: 'all', min_age_days: 7 });
+            process.stderr.write(`[linksee-memory] auto-consolidate complete: ${r.clustersCompressed} summaries, ${r.memoriesFolded} rows marked consolidated_into (0 deleted)\n`);
+        }
+    }
+    catch { /* non-fatal */ }
+}, 3000);
 const server = new Server({ name: 'linksee-memory', version: SERVER_VERSION }, {
     capabilities: {
         tools: {},
@@ -232,6 +243,7 @@ const TOOLS = [
                 max_intents: { type: 'number', description: 'For file mode: max user-intent snippets. Default 10.', default: 10 },
                 scope_to_roots: { type: 'boolean', default: false, description: 'For file mode: filter to client-provided roots.' },
                 include_superseded: { type: 'boolean', default: false, description: 'Also return memories that a newer memory superseded (hidden by default; each carries superseded_by).' },
+                include_consolidated: { type: 'boolean', default: false, description: 'Also return memories that consolidate folded into a summary (hidden by default, still in the DB; each carries consolidated_into = the summary id).' },
                 explain: { type: 'boolean', default: false, description: 'Include ranking internals (composite, heat, band, momentum, match_reasons, score_breakdown). Off by default so more memories fit the token budget.' },
                 where: { description: 'Locate on the Current Truth Map. A topic string, or true to auto-locate from the files you edited recently. Returns your node, journey stage, blast radius, and the decision behind it.', anyOf: [{ type: 'string' }, { type: 'boolean' }] },
                 project: { type: 'string', description: 'With where: the Map project slug, when several maps are imported.' },
@@ -744,6 +756,7 @@ function appendAxisFilters(sql, params, filters) {
 // NULL-safe: plain-text rows and JSON without a state have mem_state NULL, and
 // `NOT (NULL = 'superseded' OR …)` is NULL — which would drop them (Codex review 2 of #21).
 const SUPERSEDED_SQL = `(COALESCE(m.mem_state, '') = 'superseded' OR EXISTS (SELECT 1 FROM memory_edges me WHERE me.to_memory_id = m.id AND me.relation = 'supersedes'))`;
+const SHOW_ALL = { sup: 'include', con: 'include' };
 function appendSupersededFilter(sql, mode) {
     if (mode === 'exclude')
         return sql + ` AND NOT ${SUPERSEDED_SQL}`;
@@ -751,7 +764,17 @@ function appendSupersededFilter(sql, mode) {
         return sql + ` AND ${SUPERSEDED_SQL}`;
     return sql;
 }
-function runFtsQuery(query, layer, limit, axis, sup = 'include') {
+function appendConsolidatedFilter(sql, mode) {
+    if (mode === 'exclude')
+        return sql + ` AND NOT ${CONSOLIDATED_SQL}`;
+    if (mode === 'only')
+        return sql + ` AND ${CONSOLIDATED_SQL}`;
+    return sql;
+}
+function appendHiddenFilters(sql, h) {
+    return appendConsolidatedFilter(appendSupersededFilter(sql, h.sup), h.con);
+}
+function runFtsQuery(query, layer, limit, axis, hidden = SHOW_ALL) {
     let sql = `
     SELECT m.id, m.entity_id, e.name as entity_name, e.kind as entity_kind, e.momentum_score,
            m.layer, m.content, m.importance, m.created_at, m.last_accessed_at, m.access_count,
@@ -769,12 +792,12 @@ function runFtsQuery(query, layer, limit, axis, sup = 'include') {
     }
     if (axis)
         sql = appendAxisFilters(sql, params, axis);
-    sql = appendSupersededFilter(sql, sup);
+    sql = appendHiddenFilters(sql, hidden);
     sql += ' ORDER BY bm25_score ASC LIMIT ?';
     params.push(limit);
     return db.prepare(sql).all(...params);
 }
-function runLikeQuery(query, entityName, layer, limit, axis, sup = 'include') {
+function runLikeQuery(query, entityName, layer, limit, axis, hidden = SHOW_ALL) {
     let sql = `
     SELECT m.id, m.entity_id, e.name as entity_name, e.kind as entity_kind, e.momentum_score,
            m.layer, m.content, m.importance, m.created_at, m.last_accessed_at, m.access_count,
@@ -795,7 +818,7 @@ function runLikeQuery(query, entityName, layer, limit, axis, sup = 'include') {
     }
     if (axis)
         sql = appendAxisFilters(sql, params, axis);
-    sql = appendSupersededFilter(sql, sup);
+    sql = appendHiddenFilters(sql, hidden);
     if (query && !entityName) {
         sql += ' AND (e.name LIKE ? OR m.content LIKE ?)';
         params.push(`%${query}%`, `%${query}%`);
@@ -849,6 +872,13 @@ function contentSignature(raw, entityId) {
         return ''; // too short to dedup safely
     return `${entityId}::${norm}`;
 }
+// The summary id a folded row points at (0.18.1), or undefined for an unfolded / plain-text row.
+function consolidatedIntoOf(parsedContent) {
+    if (!parsedContent || typeof parsedContent !== 'object' || Array.isArray(parsedContent))
+        return undefined;
+    const v = parsedContent.consolidated_into;
+    return typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+}
 function handleRecall(args) {
     // max_tokens is enforced for real at assembly time (greedy fill by measured
     // serialized size), not via a crude fixed per-memory estimate. hardLimit caps COUNT.
@@ -875,26 +905,34 @@ function handleRecall(args) {
     // Superseded rows are left out in SQL by default; asking for them (include_superseded, or
     // mem_state:'superseded') keeps them. The hidden ones are counted with the same filters.
     const showSuperseded = args?.include_superseded === true || axis.mem_state === 'superseded';
+    // Consolidated rows (0.18.1: marked `consolidated_into`, kept in the table) are hidden the
+    // same way; include_consolidated shows them. The two counts do not overlap: a row that is
+    // both superseded and consolidated is counted once, under superseded.
+    const showConsolidated = args?.include_consolidated === true;
     const sup = showSuperseded ? 'include' : 'exclude';
+    const con = showConsolidated ? 'include' : 'exclude';
+    const hidden = { sup, con };
     const HIDDEN_COUNT_CAP = 1000;
-    let supersededHidden = 0;
-    if (!showSuperseded) {
+    const countHidden = (h) => {
         const hiddenIds = new Set();
         if (canUseFts) {
-            for (const r of runFtsQuery(ftsQuery, layer, HIDDEN_COUNT_CAP, axis, 'only'))
+            for (const r of runFtsQuery(ftsQuery, layer, HIDDEN_COUNT_CAP, axis, h))
                 hiddenIds.add(r.id);
-            for (const r of runLikeQuery(args.query, undefined, layer, HIDDEN_COUNT_CAP, axis, 'only'))
+            for (const r of runLikeQuery(args.query, undefined, layer, HIDDEN_COUNT_CAP, axis, h))
                 hiddenIds.add(r.id);
         }
         else {
-            for (const r of runLikeQuery(args.query, args.entity_name, layer, HIDDEN_COUNT_CAP, axis, 'only'))
+            for (const r of runLikeQuery(args.query, args.entity_name, layer, HIDDEN_COUNT_CAP, axis, h))
                 hiddenIds.add(r.id);
         }
-        supersededHidden = hiddenIds.size;
-    }
+        return hiddenIds.size;
+    };
+    const supersededHidden = showSuperseded ? 0 : countHidden({ sup: 'only', con: 'include' });
+    const consolidatedHidden = showConsolidated ? 0 : countHidden({ sup, con: 'only' });
+    const capped = (n) => (n >= HIDDEN_COUNT_CAP ? `${HIDDEN_COUNT_CAP}+` : n);
     if (canUseFts) {
-        const ftsRows = runFtsQuery(ftsQuery, layer, fetchLimit, axis, sup);
-        const likeRows = runLikeQuery(args.query, undefined, layer, fetchLimit, axis, sup);
+        const ftsRows = runFtsQuery(ftsQuery, layer, fetchLimit, axis, hidden);
+        const likeRows = runLikeQuery(args.query, undefined, layer, fetchLimit, axis, hidden);
         const seen = new Map();
         for (const r of ftsRows)
             seen.set(r.id, { ...r, _via: 'fts' });
@@ -915,7 +953,7 @@ function handleRecall(args) {
             searchMethod = 'like';
     }
     else {
-        rows = runLikeQuery(args.query, args.entity_name, layer, fetchLimit, axis, sup).map((r) => ({ ...r, _via: 'like' }));
+        rows = runLikeQuery(args.query, args.entity_name, layer, fetchLimit, axis, hidden).map((r) => ({ ...r, _via: 'like' }));
         searchMethod = 'like';
     }
     const useFts = searchMethod !== 'like';
@@ -1087,6 +1125,7 @@ function handleRecall(args) {
             ...(byFromSource(r._source) ? { by: byFromSource(r._source) } : {}),
             ...(supersedesOf.has(r.id) ? { supersedes: supersedesOf.get(r.id).map((x) => `#${x}`).join(' ') } : {}),
             ...(supersededBy.has(r.id) ? { superseded_by: supersededBy.get(r.id) } : {}),
+            ...(consolidatedIntoOf(parsedContent) !== undefined ? { consolidated_into: consolidatedIntoOf(parsedContent) } : {}),
             // Ranking internals only on request — they roughly double the per-memory cost and an
             // agent acting on the memory needs what/why/state, not the scorer's arithmetic.
             ...(args?.explain ? {
@@ -1131,7 +1170,8 @@ function handleRecall(args) {
             type: axis.mem_type ?? null,
             state: axis.mem_state ?? null,
         },
-        ...(supersededHidden > 0 ? { superseded_hidden: supersededHidden >= HIDDEN_COUNT_CAP ? `${HIDDEN_COUNT_CAP}+` : supersededHidden, superseded_hint: 'include_superseded: true to show them' } : {}),
+        ...(supersededHidden > 0 ? { superseded_hidden: capped(supersededHidden), superseded_hint: 'include_superseded: true to show them' } : {}),
+        ...(consolidatedHidden > 0 ? { consolidated_hidden: capped(consolidatedHidden), consolidated_hint: 'include_consolidated: true to show them (rows folded into a summary; still in the DB)' } : {}),
         memories: memoriesOut,
     });
 }
@@ -1156,82 +1196,28 @@ function handleForget(args) {
         const res = db.prepare('DELETE FROM memories WHERE id = ?').run(args.memory_id);
         return JSON.stringify({ ok: true, deleted: res.changes, memory_id: args.memory_id });
     }
-    // Auto-sweep — also respect pin (importance >= 0.9) as protection
-    const rows = db
-        .prepare(`SELECT id, layer, importance, access_count, last_accessed_at, protected, altitude
-              FROM memories
-              WHERE protected = 0 AND importance < 0.9`)
-        .all();
-    const now = Math.floor(Date.now() / 1000);
-    const actions = [];
-    for (const r of rows) {
-        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,
-            protected: r.protected === 1,
-            layer: r.layer,
-            altitude: r.altitude ?? undefined,
-        });
-        if (action !== 'keep')
-            actions.push({ id: r.id, action });
-    }
-    const toDropIds = actions.filter((a) => a.action === 'drop').map((a) => a.id);
-    if (!args.dry_run) {
-        const del = db.prepare('DELETE FROM memories WHERE id = ?');
-        const tx = db.transaction((ids) => { for (const id of ids)
-            del.run(id); });
-        tx(toDropIds);
-    }
-    return JSON.stringify({
-        ok: true,
-        dry_run: !!args.dry_run,
-        scanned: rows.length,
-        to_drop: toDropIds.length,
-        to_compress: actions.filter((a) => a.action === 'compress').length,
-        sample_ids_to_drop: toDropIds.slice(0, 10),
-    });
+    // 0.18.1: the id-less auto-sweep that used to follow here (DELETE every row whose forgetting
+    // score crossed a threshold) is removed. No caller reached it; it is gone so that the only
+    // memory DELETE in the server is the explicit one above.
+    return JSON.stringify({ ok: false, error: 'memory_id required: forget deletes one memory by id; there is no sweep' });
 }
 function handleConsolidate(args) {
     const dryRun = !!args?.dry_run;
     if (dryRun) {
-        // Preview: simulate by running against a transaction we roll back
-        // We don't have a clean "preview" path in lib/consolidate, so do a best-effort
-        // read-only audit: count candidates using the same rules.
-        const now = Math.floor(Date.now() / 1000);
-        const ageCutoff = now - (args.min_age_days ?? 7) * 86400;
-        const candidates = db.prepare(`
-      SELECT m.entity_id, e.name as entity_name, m.layer, COUNT(*) as c
-      FROM memories m
-      JOIN entities e ON e.id = m.entity_id
-      WHERE m.protected = 0
-        AND m.importance < 0.9
-        AND m.layer IN ('context', 'emotion', 'implementation')
-        AND m.created_at <= ?
-      GROUP BY m.entity_id, m.layer
-      HAVING c >= 2
-      ORDER BY c DESC
-    `).all(ageCutoff);
-        const totalReplaced = candidates.reduce((s, c) => s + c.c, 0);
+        // Read-only preview, the same plan `--apply` would act on (0.18.1).
+        const plan = planConsolidate(db, { min_age_days: typeof args?.min_age_days === 'number' ? args.min_age_days : undefined });
         return JSON.stringify({
             ok: true,
             dry_run: true,
-            clusters: candidates.length,
-            memories_replaced_if_run: totalReplaced,
-            preview: candidates.slice(0, 20).map((c) => ({
+            clusters: plan.clusters.length,
+            memories_folded_if_run: plan.wouldFold,
+            deleted_if_run: 0,
+            preview: plan.clusters.slice(0, 20).map((c) => ({
                 entity: c.entity_name,
                 layer: c.layer,
-                count: c.c,
+                count: c.ids.length,
             })),
-            hint: 'Set dry_run=false to actually consolidate.',
+            hint: 'Set dry_run=false to consolidate (originals are kept and marked consolidated_into).',
         });
     }
     const result = runConsolidate(db, {

package/dist/skill/SKILL.md

@@ -30,9 +30,11 @@ description: |
 
 Claude Code forgets everything when a session ends. The solution the user taught yesterday, the failure you hit today, the decision made three days ago — all of it is normally lost. **linksee-memory is the "memory that doesn't disappear" device.**
 
-Writes are handled automatically by the Stop hook (already running). But **reads require the agent to actively pull**. This skill instills that "go look first" habit in the agent.
+Writes happen automatically only when `linksee-memory setup` installed the Stop hook. The Claude Code plugin alone has no hooks: nothing is saved unless the agent calls `remember`. Either way, **reads require the agent to actively pull**. This skill instills that "go look first" habit in the agent.
 
-*JP: Claude Code は session が終わると全部忘れる。linksee-memory は「消えない記憶」を作る装置。書き込みは Stop hook が自動でやってくれるが、読み出しはエージェントが能動的にやる必要がある。*
+*JP: Claude Code は session が終わると全部忘れる。linksee-memory は「消えない記憶」を作る装置。書き込みの自動保存は `setup` で Stop hook を入れた場合だけ。plugin 単独では hook が無いので、`remember` を呼ばない限り何も保存されない。読み出しはどちらでもエージェントが能動的にやる必要がある。*
+
+**Tool names depend on how linksee-memory was installed.** The examples below use the short tool name (`recall`, `remember`, …). Registered with `npx -y linksee-memory setup` or `claude mcp add`, the full name is `mcp__linksee__<tool>`; installed as the Claude Code plugin, it is `mcp__plugin_linksee-memory_linksee__<tool>` ([why](https://code.claude.com/docs/en/mcp#plugin-provided-mcp-servers)). Use whichever is present in your tool list.
 
 ---
 
@@ -185,7 +187,7 @@ Before starting any new task, inject past context.
 **At the very beginning of a conversation**, use `list_entities` first to understand what you know:
 
 ```
-mcp__linksee__list_entities({ min_memories: 5, limit: 10 })
+list_entities({ min_memories: 5, limit: 10 })
 ```
 
 The returned "high-momentum entities" are the projects likely to be discussed. Each entity's `layer_breakdown` reveals patterns ("this project has many caveats", "goal is unfinished", etc.).
@@ -193,7 +195,7 @@ The returned "high-momentum entities" are the projects likely to be discussed. E
 Then, once a specific task starts, recall:
 
 ```
-mcp__linksee__recall({
+recall({
   query: "<keywords of current task — project name + technology>",
   max_tokens: 2000
 })
@@ -244,7 +246,7 @@ The recall engine uses FTS5 full-text search + heat_score ranking. Your query de
 Before touching a specific file, check its edit history:
 
 ```
-mcp__linksee__recall_file({
+recall_file({
   path_substring: "<file path or substring match>",
   max_intents: 5
 })
@@ -259,7 +261,7 @@ Returns: the file's entire edit history + **the user message that drove each edi
 When you need to read a file, **use `read_smart` instead of the standard `Read` tool**:
 
 ```
-mcp__linksee__read_smart({
+read_smart({
   path: "<absolute path>"
 })
 ```
@@ -290,7 +292,7 @@ update_memory({
 The moment an error, failure, or "doesn't work" happens, record immediately:
 
 ```
-mcp__linksee__remember({
+remember({
   entity_name: "<project name or service name>",
   entity_kind: "project",
   layer: "caveat",
@@ -330,7 +332,7 @@ mcp__linksee__remember({
 When you understand something new, change approaches, or solve a problem:
 
 ```
-mcp__linksee__remember({
+remember({
   entity_name: "<entity>",
   entity_kind: "project | concept | ...",
   layer: "learning",
@@ -372,7 +374,7 @@ Recording `prior_belief` leaves a **belief-update history**. Later, this becomes
 2. ❌ Solve an error on the spot without recording — future you (or another agent) will hit the same failure
 3. ❌ Use `Read` everywhere instead of `read_smart` (wastes tokens)
 4. ❌ Write caveats in a flippant tone — preserve them seriously
-5. ❌ Try to call a `consolidate` tool — there is none; consolidation is a server opt-in that deletes originals (see below)
+5. ❌ Try to call a `consolidate` tool — there is none; consolidation is a CLI subcommand / server opt-in (see below)
 6. ❌ Recall the same entity twice in one session without new context (wastes tokens)
 7. ❌ Write `recall({ query: "what happened last time" })` — use specific keywords
 
@@ -380,9 +382,9 @@ Recording `prior_belief` leaves a **belief-update history**. Later, this becomes
 
 ## 🔁 Consolidation — off unless the user turns it on
 
-There is no `consolidate` tool. Consolidation clusters cold, low-importance memories older than 7 days into one `learning`-layer entry and **deletes the originals**, so since 0.17.1 it never runs on its own. The user can opt in by starting the server with `LINKSEE_AUTO_CONSOLIDATE=1` (then it runs at start-up, at most weekly).
+There is no `consolidate` tool. Consolidation clusters cold, low-importance memories older than 7 days into one `learning`-layer entry. Since 0.18.1 it **keeps the originals**: each gets `consolidated_into: <summary id>` and `recall` hides it by default (`consolidated_hidden` says how many; `include_consolidated: true` shows them). Up to 0.18.0 it deleted them — rows lost that way come back only from a backup. It never runs on its own: the user runs `npx -y linksee-memory consolidate --dry-run` (shows) / `--apply` (folds), or starts the server with `LINKSEE_AUTO_CONSOLIDATE=1` (at start-up, at most weekly).
 
-Do not suggest turning it on as routine housekeeping. If the user asks about a large DB, explain the trade-off (originals are deleted) and suggest backing up `~/.linksee-memory/` first.
+Do not suggest turning it on as routine housekeeping. If the user asks about a large DB, say what it does (summaries + hidden originals, nothing deleted) and point at `--dry-run` first.
 
 **`caveat` memories and active `goal` memories are never consolidated away.**
 
@@ -714,7 +716,7 @@ Now you have both bodies of knowledge before starting
 
 | Moment | recall precision | Why |
 |---|---|---|
-| Day 1 | low (little data) | Stop hook is still collecting |
+| Day 1 | low (little data) | the Stop hook (if `setup` installed it) or your own `remember` calls are still collecting |
 | Week 1 | medium | thousands of memories, FTS5 kicks in |
 | Month 1 | high | heat_score stabilizes, important memories surface |
 | Month 3+ | strongest | learnings crystallized (distilled) |
@@ -724,6 +726,6 @@ Now you have both bodies of knowledge before starting
 ---
 
 *This skill runs on top of linksee-memory MCP v0.4.0+.*
-*Auto-write via Stop hook, explicit read via recall.*
+*Auto-write via the Stop hook when `setup` installed it (the plugin has no hooks), explicit read via recall.*
 *Listed in MCP Official Registry, PulseMCP, mcpservers.org, Glama.*
 *MIT License — Synapse Arrows PTE. LTD.*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linksee-memory",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "mcpName": "io.github.michielinksee/linksee-memory",
   "description": "Hand a project over — to your next session, to Cursor/Codex/Gemini, to your successor — with the reasons attached. Local-first memory MCP for coding agents: decisions re-injected before the agent acts, drift detection across every project you run. One SQLite file, nothing leaves your machine.",
   "type": "module",
@@ -16,7 +16,8 @@
     "linksee-memory-guard": "dist/bin/guard-hook.js",
     "linksee-memory-map": "dist/bin/map-import.js",
     "linksee-memory-export": "dist/bin/export-report.js",
-    "linksee-memory-share-draft": "dist/bin/share-draft.js"
+    "linksee-memory-share-draft": "dist/bin/share-draft.js",
+    "linksee-memory-consolidate": "dist/bin/consolidate.js"
   },
   "main": "./dist/mcp/server.js",
   "files": [
@@ -30,6 +31,7 @@
   "scripts": {
     "build": "tsc && node -e \"require('fs').copyFileSync('src/db/schema.sql','dist/db/schema.sql'); require('fs').mkdirSync('dist/skill',{recursive:true}); require('fs').copyFileSync('src/skill/SKILL.md','dist/skill/SKILL.md')\"",
     "start": "node dist/mcp/server.js",
+    "test": "node test/share-draft.mjs && node test/live-check.mjs && node test/supersede-source.mjs && node test/session-import.mjs && node test/import-cli-append-only.mjs && node test/distill-triage.mjs && node test/consolidate-no-delete.mjs && node test/auto-consolidate.mjs",
     "dev": "tsx src/mcp/server.ts",
     "migrate": "node dist/db/migrate.js",
     "migrate:dev": "tsx src/db/migrate.ts",