linksee-memory 0.13.1 → 0.15.0

package/README.md

@@ -513,44 +513,34 @@ Nothing ever leaves your machine, so step 3 fully erases everything Linksee stor
 
 </details>
 
-## 11 Tools
+## 6 Tools
 
-### Memory tools
+Two pillars, one surface. **Memory** and **drift** each get the minimum; nothing else is exposed.
+Eleven tools bled model-dependent behaviour across Claude / GPT / Cursor / Codex / Gemini — six
+is what an agent can hold without a manual.
 
 | Tool | What it does |
 |---|---|
-| `remember` | **Save / update / delete** memories. Auto-classifies into 6 layers. Modes: create (default), update (`memory_id` + fields), delete (`forget: true` + `memory_id`). |
-| `recall` | **Search / file history / overview.** Modes: search (`query`), file history (`path`), entity overview (no params). FTS5 + heat × momentum ranking with `match_reasons`. |
-| `read_smart` | **Token-saving file reader** with AST diff caching. First read = full content. Re-read unchanged = ~50 tokens. Re-read modified = changed chunks only. |
-
-### Drift tools (v0.8.0)
-
-| Tool | What it does |
-|---|---|
-| `drift_status` | **"What's drifting right now?"** Returns the truth map with 4-species classification (hypothesis/constraint/commitment/source_of_truth) and per-node state (🔴 drift / 🟡 review / ⚪ held / 🔵 aligned). |
-| `check_decision` | **Deep-dive into a specific decision.** Returns the full context: what was decided, why, what reality says, pending candidates, and drift edges. |
-| `declare_anchor` | **Record a decision as a truth-map anchor.** The drift detector checks these against committed reality. Supports v9 fields (domain, confidence, lifecycle, review_after). |
-| `resolve_drift` | **Close the loop.** Record a resolution: `fix` (reality now matches), `supersede` (intent evolved), `acknowledge` (parking with review date), or `dismiss` (false positive). |
-| `where_am_i` | **"Where on the Map am I, and what else does this touch?"** Locates the current topic/file on the Current Truth Map and returns its journey stage + blast radius (the `must-stay-consistent-with` / `should-align-with` dependents) + the decision behind it. The per-turn re-anchor that stops you optimizing one node while silently breaking its neighbors. |
-
-### Fork-point tools (v0.10)
-
-| Tool | What it does |
-|---|---|
-| `flag_proposals` | **Record orphaned proposals** — options you presented that the user never addressed. Conversations are tree-shaped but experienced linearly; the branches nobody engaged with become unresolved fork points that both you and the user lose track of. |
-| `dream` | **Consolidate orphaned proposals against the North Star.** Returns the project's direction/goals/ICP alongside unresolved proposals; the evaluating agent decides per candidate: surface (genuinely important fork) or dismiss (outdated / irrelevant / implicitly resolved). |
-| `resolve_proposal` | **Record the verdict** for each dreamed proposal: `surface` (keep visible on the dashboard for human decision) or `dismiss` (remove from the dashboard). |
-
-Previous versions exposed 3 tools — v0.8.0 added 4 drift tools that let agents query and act on product-level intent ↔ reality divergence; v0.10 added the fork-point trio for orphaned-proposal triage; `where_am_i` adds the Current Truth Map's per-turn positional re-anchor. The memory tools are unchanged.
+| `recall` | **Start here.** No arguments → the **session brief**: what needs attention, where you are on the Map, open loops, top entities. `query` → search; `path` → a file's edit history with the user intent behind each edit; `where: "<topic>"` → your position on the Current Truth Map + blast radius; `dream: true` → the triage session (North Star, orphaned proposals, distill queue, friction). |
+| `remember` | **Save / update / delete.** `content` is the only required field — entity and layer default to the project you're in. Add `anchor: {}` to record a decision **and** enforce it in one call (re-injected before Edit/Write/Bash and on session start). |
+| `read_smart` | **Token-saving file reader** with AST diff caching. Re-read unchanged = ~50 tokens; modified = changed chunks only. |
+| `drift_status` | **"What's drifting right now?"** The truth map: 🔴 drift / 🟡 review / ⚪ held / 🔵 verified / ⚫ unverified, with the evidence for each. `anchor_id` → deep-dive into one decision. |
+| `declare_anchor` | **Record a normative claim** — `decision` / `prohibition` / `constraint` the detector checks against reality, or `proposal`: an option you presented that the user never addressed, parked as a review item. |
+| `resolve_drift` | **Close the loop.** `fix` · `supersede` · `acknowledge` · `dismiss` (with `hit_term`, and the gate stops firing on it) · `harden` / `soften`. With `candidate_id`: `surface` or `dismiss` an orphaned proposal. |
+
+The five earlier names — `where_am_i`, `check_decision`, `flag_proposals`, `dream`,
+`resolve_proposal` — are folded into the six above. They are hidden from `tools/list` but **still
+answer if called**, so a skill or agent written against an older version keeps working.
+`LINKSEE_LEGACY_TOOLS=1` lists them.
 
 ### CLI utilities
 
 | Command | Purpose |
 |---|---|
-| `npx -y linksee-memory setup` | One-command setup: MCP server + skill + Stop hook, then offers to wire the re-injection guard into this project. Idempotent — skips what's already done. |
+| `npx -y linksee-memory setup` | One-command setup: MCP server + skill + Stop hook + the re-injection guard for every repo (`--project-guard` for this repo only, `--no-guard` to skip). Idempotent — skips what's already done. |
 | `npx linksee-memory` | MCP server (stdio) |
 | `npx -y linksee-memory sync` | Claude Code Stop-hook entry point |
-| `npx -y linksee-memory guard` | Re-injection guard hook: `PreToolUse` gate (`Edit`/`Write`/`Bash`) + `SessionStart` boot digest. Wired per-project (see [Re-injection Guard](#reinjection-guard)); fail-open. |
+| `npx -y linksee-memory guard` | Re-injection guard hook: `PreToolUse` gate (`Edit`/`Write`/`Bash`) + `SessionStart` boot digest. Wired by `setup` for every repo (see [Re-injection Guard](#reinjection-guard)); fail-open. |
 | `npx -y linksee-memory import` | Batch-import Claude Code session JSONL history |
 | `npx -y linksee-memory install-skill` | Install the Claude Code Skill that teaches the agent when to call recall/remember/read_smart |
 | `npx -y linksee-memory stats` | Summary of the local DB (entity count / layer breakdown / top entities / top edited files). Add `--json` for machine-readable output. |

package/dist/lib/truth-engine.d.ts

@@ -1,5 +1,5 @@
 import type Database from 'better-sqlite3';
-export type DriftState = 'drift' | 'review' | 'held' | 'aligned';
+export type DriftState = 'drift' | 'review' | 'held' | 'aligned' | 'unverified';
 export type Species = 'hypothesis' | 'constraint' | 'commitment' | 'source_of_truth';
 export interface TruthNode {
     id: number;
@@ -39,6 +39,11 @@ export interface TruthCounts {
 }
 export interface TruthView {
     attention: TruthNode[];
+    /** Active anchors the detector has no evidence about — neither aligned nor drifting. */
+    unverifiedByDomain: Array<{
+        domain: string;
+        nodes: TruthNode[];
+    }>;
     alignedByDomain: Array<{
         domain: string;
         nodes: TruthNode[];

package/dist/lib/truth-engine.js

@@ -18,7 +18,7 @@ const DOMAIN_ORDER = [
     'growth', 'operations', 'security', 'roadmap', 'memory', 'other',
 ];
 const STATE_RANK = {
-    drift: 0, review: 1, held: 2, aligned: 3,
+    drift: 0, review: 1, held: 2, aligned: 3, unverified: 4,
 };
 // ── Helpers ──────────────────────────────────────────────────────────────────
 function safeJsonParse(s, fallback) {
@@ -70,6 +70,9 @@ function summarizeEdges(verdict, edges) {
     const file = ev.file_path ? String(ev.file_path).replace(/\\/g, '/').split('/').slice(-2).join('/') : null;
     const hit = ev.hit_term ? ` hit "${ev.hit_term}"` : '';
     const when = new Date(latest.detected_at * 1000).toISOString().slice(0, 10);
+    if (verdict === 'implements') {
+        return `Observed in reality${file ? ` — ${file}` : ''} (${when}).`;
+    }
     const head = verdict === 'contradicts'
         ? `${edges.length} open contradiction${edges.length > 1 ? 's' : ''}`
         : `declared but not found in reality (${edges.length} absent signal${edges.length > 1 ? 's' : ''})`;
@@ -203,6 +206,7 @@ export function getTruthView(db, opts = {}) {
         const edges = openEdges.get(r.id) ?? [];
         const contradicts = edges.filter((e) => e.verdict === 'contradicts');
         const absent = edges.filter((e) => e.verdict === 'absent');
+        const implemented = edges.filter((e) => e.verdict === 'implements');
         // ── State derivation (the make-or-break logic) ──
         let state;
         let accounted;
@@ -251,10 +255,16 @@ export function getTruthView(db, opts = {}) {
             accounted = false;
             accountedBy = null;
         }
-        else {
-            // 🔵 convergent — reality matches intent (or no signal)
+        else if (implemented.length > 0) {
+            // 🔵 the detector saw reality match — this is the only way to be aligned without a verdict
             state = 'aligned';
             accounted = true;
+            accountedBy = 'observed (implements)';
+        }
+        else {
+            // ⚫ nothing checked, nothing decided. Not a problem — but not "fine" either.
+            state = 'unverified';
+            accounted = false;
             accountedBy = null;
         }
         // Say what was observed. Never claim convergence when nothing was checked — an agent
@@ -263,9 +273,9 @@ export function getTruthView(db, opts = {}) {
             ?? pending?.rationale
             ?? (contradicts.length > 0 ? summarizeEdges('contradicts', contradicts) : null)
             ?? (absent.length > 0 ? summarizeEdges('absent', absent) : null)
-            ?? (state === 'aligned'
-                ? (accountedBy ? 'Accounted for by recorded resolution' : 'No signal observed (not verified against reality)')
-                : null);
+            ?? (state === 'aligned' && implemented.length > 0 ? summarizeEdges('implements', implemented) : null)
+            ?? (state === 'aligned' ? 'Accounted for by recorded resolution' : null)
+            ?? (state === 'unverified' ? 'No signal observed (not verified against reality)' : null);
         return {
             id: r.id,
             node_type: r.node_type,
@@ -288,8 +298,18 @@ export function getTruthView(db, opts = {}) {
     });
     // ── Partition: attention (loud) vs aligned (quiet) ──
     const attention = nodes
-        .filter((n) => n.state !== 'aligned')
+        .filter((n) => n.state !== 'aligned' && n.state !== 'unverified')
         .sort((a, b) => STATE_RANK[a.state] - STATE_RANK[b.state] || b.confidence - a.confidence);
+    const unverifiedGroups = new Map();
+    for (const n of nodes.filter((n) => n.state === 'unverified')) {
+        const d = n.domain ?? 'other';
+        if (!unverifiedGroups.has(d))
+            unverifiedGroups.set(d, []);
+        unverifiedGroups.get(d).push(n);
+    }
+    const unverifiedByDomain = [...unverifiedGroups.entries()]
+        .sort((a, b) => DOMAIN_ORDER.indexOf(a[0]) - DOMAIN_ORDER.indexOf(b[0]))
+        .map(([domain, ns]) => ({ domain, nodes: ns }));
     const alignedGroups = new Map();
     for (const n of nodes.filter((n) => n.state === 'aligned')) {
         const d = n.domain ?? 'other';
@@ -311,7 +331,7 @@ export function getTruthView(db, opts = {}) {
     };
     for (const n of nodes)
         by_species[n.species]++;
-    const by_state = { drift: 0, review: 0, held: 0, aligned: 0 };
+    const by_state = { drift: 0, review: 0, held: 0, aligned: 0, unverified: 0 };
     for (const n of nodes)
         by_state[n.state]++;
     const reopenDates = nodes
@@ -335,6 +355,7 @@ export function getTruthView(db, opts = {}) {
     return {
         attention,
         alignedByDomain,
+        unverifiedByDomain,
         candidates: { auto, suppressed },
         counts: {
             nodes: nodes.length,
@@ -366,7 +387,14 @@ export function getDecisionDetail(db, anchorId) {
     catch { /* */ }
     const res = resolutionFor(row.id);
     const overdue = row.review_after != null && row.review_after * 1000 < now;
-    // State derivation (same logic)
+    // State derivation — MUST mirror getTruthView. It had drifted: this branch never looked at
+    // drift_edges, so check_decision could say "aligned" on the anchor drift_status flagged 🔴.
+    const openEdgesHere = db
+        .prepare(`SELECT verdict, confidence, evidence, detected_at FROM drift_edges WHERE anchor_id = ? AND status = 'open' ORDER BY detected_at DESC`)
+        .all(anchorId);
+    const contradictsHere = openEdgesHere.filter((e) => e.verdict === 'contradicts');
+    const absentHere = openEdgesHere.filter((e) => e.verdict === 'absent');
+    const implementedHere = openEdgesHere.filter((e) => e.verdict === 'implements');
     let state, accounted, accountedBy;
     const pendingCand = db
         .prepare(`SELECT id, candidate_type, target_node_id, rationale, confidence, status
@@ -395,7 +423,17 @@ export function getDecisionDetail(db, anchorId) {
         accounted = true;
         accountedBy = 'supersede (intentional evolution)';
     }
-    else if (hasPending) {
+    else if (res?.action === 'dismiss') {
+        state = 'aligned';
+        accounted = true;
+        accountedBy = 'dismiss (false positive)';
+    }
+    else if (contradictsHere.length > 0) {
+        state = 'drift';
+        accounted = false;
+        accountedBy = null;
+    }
+    else if (hasPending || absentHere.length > 0) {
         state = 'review';
         accounted = false;
         accountedBy = null;
@@ -405,13 +443,22 @@ export function getDecisionDetail(db, anchorId) {
         accounted = false;
         accountedBy = null;
     }
-    else {
+    else if (implementedHere.length > 0) {
         state = 'aligned';
         accounted = true;
+        accountedBy = 'observed (implements)';
+    }
+    else {
+        state = 'unverified';
+        accounted = false;
         accountedBy = null;
     }
     const reality = cardCand?.rationale ?? (hasPending ? pendingCand[0].rationale : null)
-        ?? (state === 'aligned' ? 'Committed reality matches intent (convergent)' : null);
+        ?? (contradictsHere.length > 0 ? summarizeEdges('contradicts', contradictsHere) : null)
+        ?? (absentHere.length > 0 ? summarizeEdges('absent', absentHere) : null)
+        ?? (state === 'aligned' && implementedHere.length > 0 ? summarizeEdges('implements', implementedHere) : null)
+        ?? (state === 'aligned' ? 'Accounted for by recorded resolution' : null)
+        ?? (state === 'unverified' ? 'No signal observed (not verified against reality)' : null);
     // Drift edges for this anchor
     const edges = db
         .prepare(`SELECT id AS edge_id, verdict, confidence, status, detected_at

package/dist/mcp/roots.js

@@ -5,7 +5,7 @@
 //
 // MCP semantics: client owns the root list, server is informed. We refresh on demand
 // (lazily on first use) and on roots/list_changed notification.
-import { ListRootsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { ListRootsResultSchema } from '@modelcontextprotocol/sdk/types.js';
 let cachedRoots = null;
 let lastFetched = 0;
 const STALE_MS = 60_000; // re-fetch at most once a minute
@@ -14,7 +14,11 @@ export async function fetchRoots(server) {
     if (cachedRoots && now - lastFetched < STALE_MS)
         return cachedRoots;
     try {
-        const res = await server.request({ method: 'roots/list', params: {} }, ListRootsRequestSchema);
+        // Protocol.request(request, RESULT schema). This passed the REQUEST schema, so every client's
+        // reply — `{ roots: [...] }` — failed validation against a shape expecting `{ method: 'roots/list' }`,
+        // was swallowed by the catch below, and cached as "no roots" for a minute. Roots had been empty
+        // for every client since this was written; where_am_i's root inference never once fired.
+        const res = await server.request({ method: 'roots/list', params: {} }, ListRootsResultSchema);
         cachedRoots = Array.isArray(res?.roots) ? res.roots : [];
         lastFetched = now;
     }

package/dist/mcp/server.js

@@ -136,15 +136,32 @@ const LAYER_ENUM = ['goal', 'context', 'emotion', 'implementation', 'caveat', 'l
 const TOOLS = [
     {
         name: 'remember',
-        description: 'Persist knowledge across sessions and AI tools (Claude, GPT, Cursor, Codex, Gemini). The only cross-agent memory that survives session boundaries.\n\nWHEN TO CALL:\n• The moment an error or failure occurs → layer: "caveat" (auto-protected, never forgotten)\n• When a decision is made or approved → layer: "learning"\n• When a goal is set or updated → layer: "goal"\n• When something new is learned → layer: "learning"\n• When the user says "remember this" / "覚えておいて"\n• After completing a task or receiving user approval\n\nREQUIRED PARAMS BY MODE:\n• Create (default): entity_name + entity_kind + layer + content\n• Update: memory_id (+ optional content, layer, importance)\n• Delete: memory_id + forget: true\n\nImportance ≥ 0.9 pins the memory (protected from auto-forgetting). Supports Japanese (日本語) and English.',
+        description: 'Persist knowledge across sessions and AI tools (Claude, GPT, Cursor, Codex, Gemini). The only cross-agent memory that survives session boundaries.\n\nWHEN TO CALL:\n• The moment an error or failure occurs → layer: "caveat" (auto-protected, never forgotten)\n• When a decision is made or approved → content + anchor: {} (remembered AND enforced in one call)\n• When a goal is set or updated → layer: "goal"\n• When something new is learned → layer: "learning"\n• When the user says "remember this" / "覚えておいて"\n• After completing a task or receiving user approval\n\nMODES:\n• Create (default): content is the only required field. entity defaults to the project you are in; layer defaults to "context" (or "learning" when anchor is set).\n• Create + enforce: add anchor: {} — the memory also becomes a decision the guard re-injects before Edit/Write/Bash and on session start. Give anchor.violation_signal (forbidden strings) to make contradictions detectable; anchor.affects (path globs) to scope it.\n• Update: memory_id (+ optional content, layer, importance)\n• Delete: memory_id + forget: true\n\nImportance ≥ 0.9 pins the memory (protected from auto-forgetting). Supports Japanese (日本語) and English.',
         inputSchema: {
             type: 'object',
             properties: {
-                entity_name: { type: 'string', description: 'Name of the entity this memory is about (required for create)' },
-                entity_kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'Required for create' },
+                entity_name: { type: 'string', description: 'What this memory is about. Optional — defaults to the project you are working in (from workspace roots, else the files edited recently).' },
+                entity_kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'Optional — defaults to "project".' },
+                anchor: {
+                    description: 'Also declare this as an enforceable decision. Pass {} for defaults, or an object: { kind?: "decision"|"prohibition"|"constraint", violation_signal?: string[] (forbidden strings — needed for the gate to detect a contradiction), affects?: string[] (path globs that scope it), detect_terms?: string[], domain?: string, rationale?: string }. Without violation_signal the anchor is a constraint: re-injected on session start and when its scope is touched, but no contradiction can be detected.',
+                    anyOf: [
+                        { type: 'boolean' },
+                        {
+                            type: 'object',
+                            properties: {
+                                kind: { type: 'string', enum: ['decision', 'prohibition', 'constraint'] },
+                                violation_signal: { type: 'array', items: { type: 'string' } },
+                                affects: { type: 'array', items: { type: 'string' } },
+                                detect_terms: { type: 'array', items: { type: 'string' } },
+                                domain: { type: 'string' },
+                                rationale: { type: 'string' },
+                            },
+                        },
+                    ],
+                },
                 entity_key: { type: 'string', description: 'Optional canonical key (email, domain, file path)' },
-                layer: { type: 'string', description: 'One of: goal / context / emotion / implementation / caveat / learning. Aliases accepted (why→goal, warnings→caveat, decisions→learning, how→implementation).' },
-                content: { type: 'string', description: 'The memory content (plain text or structured JSON with altitude/type/state/what/why)' },
+                layer: { type: 'string', description: 'One of: goal / context / emotion / implementation / caveat / learning. Aliases accepted (why→goal, warnings→caveat, decisions→learning, how→implementation). Optional — defaults to "context", or "learning" when anchor is set.' },
+                content: { type: 'string', description: 'The memory content (plain text or structured JSON with altitude/type/state/what/why). The only required field for create.' },
                 importance: { type: 'number', minimum: 0, maximum: 1, description: '0.0-1.0. Set ≥0.9 to pin (protects from forgetting).' },
                 thread_id: { type: 'string', description: 'Optional thread ID to group related memories (decision chains, session groups).' },
                 force: { type: 'boolean', default: false, description: 'Bypass paste-back quality check.' },
@@ -155,7 +172,7 @@ const TOOLS = [
     },
     {
         name: 'recall',
-        description: 'Your persistent memory across all AI tools. CALL THIS BEFORE STARTING ANY TASK to check for past caveats (pain records), decisions, and learnings — prevents repeating mistakes across sessions.\n\nTypical usage: recall({ query: "keywords" }) for search, recall({ path: "file.ts" }) for file history, recall() for overview.\n\nWHEN TO CALL:\n• Before starting any new task or touching a file\n• When the user mentions "before" / "前に" / "last time" / "remember when"\n• When an error occurs — check if you\'ve seen it before\n• When making a decision — check for prior decisions on the same topic\n\nTHREE MODES (auto-detected):\n• Search (default): provide query → returns memories ranked by relevance + heat\n• File history: provide path → returns complete edit history with user-intent context\n• Overview: omit all params → returns entity list sorted by momentum\n\nWorks across Claude, GPT, Cursor, Codex, Gemini — one local SQLite file, nothing leaves your machine.',
+        description: 'Your persistent memory across all AI tools. CALL THIS BEFORE STARTING ANY TASK to check for past caveats (pain records), decisions, and learnings — prevents repeating mistakes across sessions.\n\nTypical usage: recall({ query: "keywords" }) for search, recall({ path: "file.ts" }) for file history, recall() for overview.\n\nWHEN TO CALL:\n• Before starting any new task or touching a file\n• When the user mentions "before" / "前に" / "last time" / "remember when"\n• When an error occurs — check if you\'ve seen it before\n• When making a decision — check for prior decisions on the same topic\n\nTHREE MODES (auto-detected):\n• Search (default): provide query → returns memories ranked by relevance + heat\n• File history: provide path → returns complete edit history with user-intent context\n• Session brief: omit all params → what needs attention (🔴/🟡), where you are on the Map, open loops (proposals / distill queue / friction), top entities. CALL THIS FIRST in a new session.\n• Locate: where: "<topic>" → your position on the Current Truth Map + blast radius (what else moves if you touch this). where: true → auto-locate from recent edits\n• Dream: dream: true → North Star + orphaned proposals to triage + distill_queue + friction (the full triage session; the brief carries only the counts)\n• Entity list: overview: true (the old no-arg behaviour)\n\nWorks across Claude, GPT, Cursor, Codex, Gemini — one local SQLite file, nothing leaves your machine.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -175,6 +192,10 @@ 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.' },
                 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.' },
+                dream: { type: 'boolean', default: false, description: 'Return the full triage set: North Star, orphaned proposals (each with candidate_id), distill_queue, friction. Resolve proposals with resolve_drift({ candidate_id, action }); rewrite distill items with remember({ memory_id, content }).' },
+                overview: { type: 'boolean', default: false, description: 'Return the entity list instead of the session brief when no query is given.' },
                 kind: { type: 'string', enum: ['person', 'company', 'project', 'concept', 'file', 'other'], description: 'For overview mode: filter by entity kind.' },
                 min_memories: { type: 'number', description: 'For overview mode: minimum memory count. Default 1.', default: 1 },
             },
@@ -202,6 +223,7 @@ const TOOLS = [
                 domain: { type: 'string', description: 'Filter by domain (strategy, product, engineering, growth, etc.)' },
                 decision_mode: { type: 'string', description: 'Filter by decision_mode (hypothesis, constraint, commitment, source_of_truth)' },
                 verbose: { type: 'boolean', default: false, description: 'Return full aligned nodes and all candidates. Default is compact: attention items in full, aligned as id+statement per domain, candidates as counts.' },
+                anchor_id: { type: 'number', description: 'Deep-dive into ONE decision instead of the map: its state, premises, drift edges, pending candidates. (Absorbs check_decision.)' },
             },
         },
     },
@@ -235,7 +257,10 @@ const TOOLS = [
         inputSchema: {
             type: 'object',
             properties: {
-                kind: { type: 'string', enum: ['prohibition', 'decision', 'constraint'], description: 'Anchor type' },
+                kind: { type: 'string', enum: ['prohibition', 'decision', 'constraint', 'proposal'], description: "Anchor type. 'proposal' = an option you presented that the user never addressed (an orphaned fork) — it lands as a review item and can be triaged later via recall({ dream: true }). (Absorbs flag_proposals.)" },
+                decided: { type: 'string', description: "For kind 'proposal': what the user chose or engaged with instead." },
+                siblings: { type: 'array', items: { type: 'string' }, description: "For kind 'proposal': the other options from the same set, for context." },
+                session_context: { type: 'string', description: "For kind 'proposal': one line on the conversation it came from." },
                 statement: { type: 'string', description: 'The normative claim (>= 8 chars)' },
                 rationale: { type: 'string', description: 'Why this was decided' },
                 affects: { type: 'array', items: { type: 'string' }, description: 'Path globs that scope this anchor' },
@@ -260,7 +285,8 @@ const TOOLS = [
             type: 'object',
             properties: {
                 anchor_id: { type: 'number', description: 'The drift_anchor ID to resolve' },
-                action: { type: 'string', enum: ['fix', 'supersede', 'acknowledge', 'dismiss', 'harden', 'soften'], description: 'Resolution action' },
+                action: { type: 'string', enum: ['fix', 'supersede', 'acknowledge', 'dismiss', 'harden', 'soften', 'surface'], description: "Resolution action. With candidate_id (an orphaned proposal): 'surface' keeps it visible for the human, 'dismiss' retires it." },
+                candidate_id: { type: 'number', description: 'Resolve an orphaned proposal (from recall({ dream: true })) instead of an anchor: pass its candidate_id with action surface | dismiss and a rationale that references the North Star. (Absorbs resolve_proposal.)' },
                 rationale: { type: 'string', description: 'Why this resolution (recorded for audit trail)' },
                 review_after: { type: 'string', description: 'For acknowledge: ISO date to re-check (e.g. "2026-07-04")' },
                 superseded_by: { type: 'number', description: 'For supersede: the new anchor ID that replaces this one' },
@@ -436,14 +462,74 @@ function handleRemember(args) {
         .run(entityId, layer, rawContent, importance, importance >= 0.9 ? 1 : 0, args.thread_id ?? null);
     db.prepare('INSERT INTO events (entity_id, kind, payload) VALUES (?, ?, ?)').run(entityId, 'memory_stored', JSON.stringify({ layer, memory_id: result.lastInsertRowid }));
     const mom = refreshMomentumForEntity(db, entityId);
-    return JSON.stringify({
+    const memoryId = Number(result.lastInsertRowid);
+    const out = {
         ok: true,
-        memory_id: Number(result.lastInsertRowid),
+        memory_id: memoryId,
         entity_id: entityId,
         layer,
         pinned: importance >= 0.9,
         momentum: { score: mom.score, band: mom.band },
-    });
+    };
+    // "Remember" and "enforce" used to be two tools with two schemas, and an agent had to pick.
+    // Picking remember meant the decision was stored but never re-injected — the exact failure
+    // the product exists to prevent. One call now does both when the caller asks for it.
+    if (args.anchor) {
+        const spec = typeof args.anchor === 'object' && args.anchor !== null ? args.anchor : {};
+        let what = rawContent, why = spec.rationale;
+        try {
+            const c = JSON.parse(rawContent);
+            if (c && typeof c === 'object') {
+                what = String(c.what ?? c.title ?? rawContent);
+                why = why ?? (c.why ? String(c.why) : undefined);
+            }
+        }
+        catch { /* plain text */ }
+        const signals = Array.isArray(spec.violation_signal) ? spec.violation_signal : [];
+        // A decision/prohibition needs forbidden strings for a contradiction to be detectable; without
+        // them the honest shape is a constraint (still re-injected on boot and when its scope is touched).
+        const kind = spec.kind ?? (signals.length > 0 ? 'decision' : 'constraint');
+        try {
+            const anchor = declareAnchor(db, {
+                kind,
+                statement: what.length >= 8 ? what : `${what} (decision)`,
+                rationale: why,
+                affects: Array.isArray(spec.affects) ? spec.affects : undefined,
+                detect_terms: Array.isArray(spec.detect_terms) ? spec.detect_terms : undefined,
+                violation_signal: signals.length > 0 ? signals : undefined,
+                tier: 'human',
+                source_memory_id: memoryId,
+            });
+            const nodeFields = {};
+            if (spec.domain)
+                nodeFields.domain = spec.domain;
+            if (spec.confidence !== undefined)
+                nodeFields.confidence = spec.confidence;
+            if (Object.keys(nodeFields).length > 0)
+                setNodeFields(db, anchor.id, nodeFields);
+            // Link both ways so recall can show "this memory is enforced as #N" and the anchor can
+            // point back at the moment it was decided.
+            try {
+                const c = JSON.parse(rawContent);
+                if (c && typeof c === 'object') {
+                    c.anchor_id = anchor.id;
+                    db.prepare('UPDATE memories SET content = ? WHERE id = ?').run(JSON.stringify(c), memoryId);
+                }
+            }
+            catch { /* leave content as-is */ }
+            logAnchorTouch(db, { anchorId: anchor.id, tool: 'remember', interaction: 'create' });
+            out.anchor_id = anchor.id;
+            out.anchor_kind = kind;
+            out.enforced = signals.length > 0
+                ? 'contradictions are detected at the gate; re-injected on boot and in scope'
+                : 'no violation_signal given — re-injected on boot and when its scope is touched, but contradictions cannot be detected';
+        }
+        catch (e) {
+            out.anchor_error = String(e?.message ?? e);
+            out.hint = 'The memory was saved. Fix the anchor spec and call declare_anchor, or remember again with a corrected anchor.';
+        }
+    }
+    return JSON.stringify(out);
 }
 // Sanitize query for FTS5 MATCH (strip chars that break the grammar, quote it).
 // Note: with trigram tokenizer, tokens shorter than 3 chars cannot match anything.
@@ -1234,16 +1320,150 @@ async function handleRememberUnified(args) {
     if (args.memory_id) {
         return handleUpdateMemory(args);
     }
-    // Create mode (default) — validate required fields
-    if (!args.entity_name || !args.entity_kind || !args.layer || !args.content) {
+    // Create mode (default). Only content is required; everything an agent used to have to
+    // invent is defaulted. Inventing an entity name and picking a layer were the two places a
+    // "remember this" call stalled — the taxonomy is for the dashboard, not for the agent.
+    if (!args.content || !String(args.content).trim()) {
         return JSON.stringify({
             ok: false,
-            error: 'Create mode requires: entity_name, entity_kind, layer, content. To update, provide memory_id. To delete, set forget: true + memory_id.',
+            error: 'content is required. (entity/layer are optional now.) To update, provide memory_id. To delete, set forget: true + memory_id.',
         });
     }
-    return handleRemember(args);
+    const a = { ...args };
+    let entityInferred;
+    if (!a.entity_name) {
+        const inferred = await inferDefaultEntity();
+        a.entity_name = inferred.name;
+        a.entity_kind = a.entity_kind ?? inferred.kind;
+        entityInferred = inferred.from;
+    }
+    if (!a.entity_kind)
+        a.entity_kind = 'project';
+    if (!a.layer)
+        a.layer = a.anchor ? 'learning' : 'context';
+    const out = handleRemember(a);
+    if (!entityInferred)
+        return out;
+    try {
+        const parsed = JSON.parse(out);
+        if (parsed.ok)
+            parsed.entity_inferred_from = entityInferred;
+        return JSON.stringify(parsed);
+    }
+    catch {
+        return out;
+    }
+}
+/**
+ * The entity a memory is about when the caller did not say: the project they are in.
+ * Same evidence chain as where_am_i — workspace roots first, then the files edited recently.
+ */
+async function inferDefaultEntity() {
+    try {
+        const roots = await fetchRoots(server);
+        if (roots.length === 1) {
+            const base = rootPathFromUri(roots[0].uri).replace(/\\/g, '/').replace(/\/+$/, '').split('/').pop();
+            if (base)
+                return { name: base, kind: 'project', from: 'workspace_root' };
+        }
+    }
+    catch { /* roots unsupported by this host */ }
+    try {
+        const rows = db
+            .prepare(`SELECT file_path FROM session_file_edits WHERE occurred_at > unixepoch() - 86400 ORDER BY occurred_at DESC LIMIT 40`)
+            .all();
+        const paths = rows.map((r) => r.file_path.replace(/\\/g, '/').split('/').filter(Boolean));
+        if (paths.length > 0) {
+            // longest common directory prefix of what was touched → its basename is the project
+            let prefix = paths[0].slice(0, -1);
+            for (const p of paths.slice(1)) {
+                let i = 0;
+                while (i < prefix.length && i < p.length - 1 && prefix[i].toLowerCase() === p[i].toLowerCase())
+                    i++;
+                prefix = prefix.slice(0, i);
+                if (prefix.length === 0)
+                    break;
+            }
+            const base = prefix[prefix.length - 1];
+            if (base && !/^(c:|users|home|[a-z])$/i.test(base))
+                return { name: base, kind: 'project', from: 'recent_edits' };
+        }
+    }
+    catch { /* fall through */ }
+    return { name: 'workspace', kind: 'project', from: 'fallback' };
+}
+/**
+ * The session brief: what an agent needs in the first call of a session, in one call.
+ *
+ * On 2026-09-05 this took four calls (recall / drift_status / dream / where_am_i), ~20k tokens,
+ * and one of them failed. The brief carries the attention items in full and everything else as
+ * counts plus a hint for the drill-down — small enough to call freely, complete enough that the
+ * agent does not have to know which of five tools holds which fact.
+ */
+async function handleSessionBrief() {
+    const view = getTruthView(db, {});
+    const bs = view.counts.by_state;
+    const triage = `${view.counts.nodes} anchors: ` + [
+        bs.drift > 0 ? `🔴 ${bs.drift} drifting` : null,
+        bs.review > 0 ? `🟡 ${bs.review} needs review` : null,
+        bs.held > 0 ? `⚪ ${bs.held} held` : null,
+        `🔵 ${bs.aligned} verified`,
+        bs.unverified > 0 ? `⚫ ${bs.unverified} unverified` : null,
+    ].filter(Boolean).join(' · ');
+    const attention = view.attention.slice(0, 8).map((n) => ({
+        id: n.id, state: n.state, statement: n.statement.slice(0, 160), reality: (n.reality ?? '').slice(0, 160),
+    }));
+    let where = null;
+    try {
+        const w = JSON.parse(await handleWhereAmI({}));
+        where = w.located
+            ? { project: w.project, you_are_here: w.you_are_here }
+            : w.reason
+                ? { reason: w.reason, available_projects: w.available_projects }
+                : null;
+    }
+    catch { /* no map, or roots unavailable — the brief still stands */ }
+    let open_loops = null;
+    try {
+        const d = JSON.parse(handleDream({}));
+        open_loops = {
+            north_star: d.north_star ? { id: d.north_star.id, statement: String(d.north_star.statement).slice(0, 160) } : null,
+            proposals: d.total ?? 0,
+            proposals_top: (d.candidates ?? []).slice(0, 3).map((c) => ({ candidate_id: c.candidate_id ?? c.id, statement: String(c.statement ?? c.target_statement ?? '').slice(0, 120) })),
+            distill_queue: d.distill_total ?? 0,
+            friction: d.friction_total ?? 0,
+        };
+    }
+    catch { /* fine */ }
+    let entities = [];
+    try {
+        entities = (JSON.parse(handleListEntities({ limit: 8 })).entities ?? []).map((e) => ({ name: e.name, kind: e.kind, memories: e.memory_count }));
+    }
+    catch { /* fine */ }
+    return JSON.stringify({
+        ok: true,
+        brief: true,
+        triage,
+        attention,
+        where,
+        open_loops,
+        entities,
+        next: [
+            'recall({ query }) to search; recall({ path }) for a file\'s history',
+            'drift_status() for the full truth map; drift_status({ anchor_id }) for one decision',
+            'recall({ dream: true }) to triage proposals and drain the distill queue',
+            'remember({ content, anchor: {} }) to record a decision and enforce it',
+        ],
+    });
 }
 async function handleRecallUnified(args) {
+    // Folded surfaces (roadmap 5): locating yourself and the triage session are ways of
+    // recalling, not separate tools.
+    if (args?.dream)
+        return handleDream({ domain: args.domain });
+    if (args?.where !== undefined && args?.where !== false) {
+        return handleWhereAmI({ query: args.where === true ? undefined : String(args.where), project: args.project, limit: args.limit });
+    }
     // File history mode (path takes priority; if query also provided, include it as context)
     if (args.path) {
         const fileResult = await handleRecallFileWithRoots({
@@ -1264,17 +1484,15 @@ async function handleRecallUnified(args) {
         }
         return fileResult;
     }
-    // Detect overview request (no search criteria at all)
+    // No search criteria at all → the session brief (or the entity list on request).
     const hasQuery = args.query && String(args.query).trim().length > 0;
     const hasFilters = args.entity_name || args.layer || args.altitude ||
         args.mem_type || args.mem_state || args.thread_id || args.band;
     if (!hasQuery && !hasFilters) {
-        return handleListEntities({
-            kind: args.kind,
-            min_memories: args.min_memories,
-            limit: args.limit,
-            offset: args.offset,
-        });
+        if (args.overview || args.kind || args.min_memories !== undefined || args.offset) {
+            return handleListEntities({ kind: args.kind, min_memories: args.min_memories, limit: args.limit, offset: args.offset });
+        }
+        return handleSessionBrief();
     }
     // Search mode (default)
     return handleRecall(args);
@@ -1283,6 +1501,8 @@ async function handleRecallUnified(args) {
 // Drift tool handlers (v0.8.0)
 // ============================================================
 function handleDriftStatus(args) {
+    if (args?.anchor_id)
+        return handleCheckDecision({ anchor_id: args.anchor_id });
     const view = getTruthView(db, {
         domain: args?.domain,
         decision_mode: args?.decision_mode,
@@ -1294,7 +1514,8 @@ function handleDriftStatus(args) {
         by_state.drift > 0 ? `🔴 ${by_state.drift} drifting` : null,
         by_state.review > 0 ? `🟡 ${by_state.review} needs review` : null,
         by_state.held > 0 ? `⚪ ${by_state.held} held` : null,
-        `🔵 ${by_state.aligned} aligned`,
+        `🔵 ${by_state.aligned} verified`,
+        by_state.unverified > 0 ? `⚫ ${by_state.unverified} unverified` : null,
     ].filter(Boolean).join(' · ');
     if (args?.verbose) {
         return JSON.stringify({
@@ -1315,6 +1536,13 @@ function handleDriftStatus(args) {
         count: g.nodes.length,
         nodes: g.nodes.map((n) => ({ id: n.id, statement: n.statement, reality: n.reality })),
     }));
+    // Unverified is the quiet majority on most machines. One line each, grouped by domain —
+    // enough to see where the detector has no eyes, not enough to bury the six that matter.
+    const unverified = view.unverifiedByDomain.map((g) => ({
+        domain: g.domain,
+        count: g.nodes.length,
+        nodes: g.nodes.map((n) => ({ id: n.id, statement: n.statement })),
+    }));
     const cand = view.candidates;
     return JSON.stringify({
         ok: true,
@@ -1322,9 +1550,10 @@ function handleDriftStatus(args) {
         nextReopen: view.nextReopen,
         attention: view.attention,
         aligned,
+        unverified,
         candidates: { auto: cand?.auto?.length ?? 0, suppressed: cand?.suppressed?.length ?? 0 },
         counts: view.counts,
-        hint: 'verbose:true for full aligned nodes and candidate details; check_decision(anchor_id) for one node.',
+        hint: 'verbose:true for full nodes and candidate details; check_decision(anchor_id) for one node. ⚫ unverified = declared, never checked against reality: give it affects/violation_signal so the detector can see it, or leave it as a note.',
     });
 }
 // Fix ① (2026-06-17): infer the Map project from the client's workspace roots when the
@@ -1426,6 +1655,26 @@ function handleDeclareAnchor(args) {
     if (!args?.kind || !args?.statement) {
         throw new Error('kind and statement are required');
     }
+    // An orphaned proposal is a fork the user never took. Same tool as any other declaration —
+    // the agent should not need a separate verb for "I noticed something went unaddressed".
+    if (args.kind === 'proposal') {
+        const r = JSON.parse(handleFlagProposals({
+            session_context: args.session_context,
+            proposals: [{
+                    statement: args.statement, rationale: args.rationale, domain: args.domain ?? 'general',
+                    confidence: args.confidence, decided: args.decided, siblings: args.siblings,
+                }],
+        }));
+        const anchorId = r.proposals?.[0]?.anchor_id;
+        if (!r.ok || !anchorId) {
+            return JSON.stringify({ ok: false, error: r.error ?? 'proposal was not recorded (statement must be >= 10 chars)' });
+        }
+        const cand = db.prepare(`SELECT id FROM memory_write_candidates WHERE target_node_id = ? AND scope = 'orphaned_proposal' ORDER BY id DESC LIMIT 1`).get(anchorId);
+        return JSON.stringify({
+            ok: true, anchor_id: anchorId, candidate_id: cand?.id ?? null, kind: 'proposal', statement: args.statement,
+            message: `Proposal recorded as review item #${anchorId}. Triage later: recall({ dream: true }) → resolve_drift({ candidate_id: ${cand?.id ?? '<id>'}, action: 'surface' | 'dismiss', rationale }).`,
+        });
+    }
     // Create the base anchor
     const anchor = declareAnchor(db, {
         kind: args.kind,
@@ -1464,6 +1713,21 @@ function handleDeclareAnchor(args) {
     });
 }
 function handleResolveDrift(args) {
+    // A proposal verdict is a resolution like any other; it just targets a candidate row.
+    if (args?.candidate_id) {
+        if (!['surface', 'dismiss'].includes(args.action)) {
+            return JSON.stringify({ ok: false, error: `candidate_id takes action 'surface' or 'dismiss' (got '${args.action}')` });
+        }
+        if (!args.rationale) {
+            return JSON.stringify({ ok: false, error: 'rationale is required for a proposal verdict — say what in the North Star decided it' });
+        }
+        try {
+            return handleResolveProposal({ candidate_id: args.candidate_id, verdict: args.action, rationale: args.rationale });
+        }
+        catch (e) {
+            return JSON.stringify({ ok: false, error: String(e?.message ?? e) });
+        }
+    }
     if (!args?.anchor_id || !args?.action) {
         throw new Error('anchor_id and action are required');
     }
@@ -1797,7 +2061,27 @@ function handleResolveProposal(args) {
 // ============================================================
 // MCP wiring
 // ============================================================
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+// Six tools on the surface (2026-09-07, roadmap 5). Anchor #1's reason for "3 tools, never a
+// 4th" was real — eight tools bled model-dependent behaviour across Claude/GPT/Cursor/Codex/
+// Gemini — and the surface had crept to eleven. The five below are folded into the six
+// (see LEGACY_TOOLS) and hidden from tools/list, but a call to any of them still works: an
+// agent or a SKILL.md written against 0.14 does not break. LINKSEE_LEGACY_TOOLS=1 lists them.
+const LEGACY_TOOLS = {
+    where_am_i: 'recall({ where: "<topic>" }) — or recall() with no arguments for the session brief',
+    check_decision: 'drift_status({ anchor_id })',
+    flag_proposals: "declare_anchor({ kind: 'proposal', statement, rationale, domain, decided?, siblings? })",
+    dream: 'recall({ dream: true }) — recall() with no arguments already includes the counts',
+    resolve_proposal: "resolve_drift({ candidate_id, action: 'surface' | 'dismiss', rationale })",
+};
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const showLegacy = process.env.LINKSEE_LEGACY_TOOLS === '1';
+    const tools = TOOLS
+        .filter((t) => showLegacy || !(t.name in LEGACY_TOOLS))
+        .map((t) => (t.name in LEGACY_TOOLS
+        ? { ...t, description: `(legacy — folded into ${LEGACY_TOOLS[t.name]}. Still works.)\n\n${t.description}` }
+        : t));
+    return { tools };
+});
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
     const { name, arguments: args } = req.params;
     try {

package/dist/skill/SKILL.md

@@ -175,6 +175,11 @@ open → decided → in_progress → done
 
 ### ① Task Start — Always recall before starting work
 
+**First call of a session: `recall()` with no arguments.** It returns the session brief — what
+needs attention (🔴/🟡 anchors), where you are on the Map, open loops (proposals to triage,
+raw memories to distill, friction at the gate), and the top entities. One call, small, complete.
+Then search with `recall({ query })` for the task at hand.
+
 Before starting any new task, inject past context.
 
 **At the very beginning of a conversation**, use `list_entities` first to understand what you know:
@@ -534,20 +539,18 @@ User: "That's it for today"
 
 ```
 1. Review the session: which proposals did you make that the user never addressed?
-2. flag_proposals({
-     session_context: "GTM channel strategy discussion",
-     proposals: [
-       {
-         statement: "[未解決] LinkedIn B2B: SaaS企業のCTO/VPE向けDMアウトリーチ",
-         rationale: "3つのGTMチャネルを提示したがX/Twitterのみ採用。LinkedIn経由の検討が未着手",
-         domain: "growth",
-         confidence: 0.5,
-         decided: "X/Twitter data-driven growth",
-         siblings: ["X/Twitter", "LinkedIn B2B", "Dev Community"]
-       },
-       ...
-     ]
+2. For each one:
+   declare_anchor({
+     kind: "proposal",
+     statement: "[未解決] LinkedIn B2B: SaaS企業のCTO/VPE向けDMアウトリーチ",
+     rationale: "3つのGTMチャネルを提示したがX/Twitterのみ採用。LinkedIn経由の検討が未着手",
+     domain: "growth",
+     confidence: 0.5,
+     decided: "X/Twitter data-driven growth",
+     siblings: ["X/Twitter", "LinkedIn B2B", "Dev Community"],
+     session_context: "GTM channel strategy discussion"
    })
+   → { anchor_id, candidate_id }
 3. Report: "Flagged N unresolved proposals for dashboard review."
 ```
 
@@ -555,27 +558,27 @@ Each proposal becomes a review-state anchor on the Linksee Dashboard — visible
 
 ### Case F3 — Dream: triage orphaned proposals against the North Star
 
-**Not all orphaned proposals are worth surfacing.** Many are outdated, already implicitly resolved, or irrelevant to the current direction. The `dream` tool returns the project's **North Star** (direction/goals/ICP/phase) alongside accumulated proposals so you can evaluate each one.
+**Not all orphaned proposals are worth surfacing.** Many are outdated, already implicitly resolved, or irrelevant to the current direction. `recall({ dream: true })` returns the project's **North Star** (direction/goals/ICP/phase) alongside accumulated proposals so you can evaluate each one.
 
 Think like a General Doctor doing triage: the North Star is the patient's chart, each proposal is a symptom. Not every symptom needs treatment.
 
-**When to dream:**
+**When to run the triage (`recall({ dream: true })`):**
 - At session start, if there are accumulated proposals
 - When the user asks "何か見落としてない？" or "what should we revisit?"
 - Periodically (weekly) to prevent proposal backlog from growing stale
 
 ```
-1. dream()
-   → Returns: north_star + candidates[]
+1. recall({ dream: true })
+   → Returns: north_star + candidates[] (each with candidate_id)
 
 2. For each candidate, evaluate against North Star:
    - Does this affect the current phase/goals? → surface
    - Is this for a different ICP or future phase? → dismiss
    - Already implicitly resolved by later decisions? → dismiss
 
-3. resolve_proposal({
+3. resolve_drift({
      candidate_id: <id>,
-     verdict: "surface" | "dismiss",
+     action: "surface" | "dismiss",
      rationale: "North Star says ICP = solo devs; this is enterprise-only → dismiss"
    })
 ```
@@ -596,14 +599,14 @@ Candidate C: "kintone enterprise integration"
 
 The North Star is declared via `declare_anchor(node_type: "north_star")` and should be updated when the project enters a new phase (e.g., post-HN → growth phase). This keeps the Doctor's judgment frame current.
 
-### Case F4 — Distill: rewrite raw auto-captured memories (every dream call)
+### Case F4 — Distill: rewrite raw auto-captured memories (every `recall({ dream: true })` call)
 
-The session hook captures decisions/caveats as **RAW user utterances** (no LLM runs in the hook path — heuristic extraction is the best it can do). `dream` returns them as `distill_queue`. **You are the distiller.**
+The session hook captures decisions/caveats as **RAW user utterances** (no LLM runs in the hook path — heuristic extraction is the best it can do). `recall({ dream: true })` returns them as `distill_queue`. **You are the distiller.**
 
-**When:** every `dream()` call — drain up to 8 items while triaging proposals. The SessionStart boot digest reminds you while the queue is non-empty.
+**When:** every `recall({ dream: true })` call — drain up to 8 items while triaging proposals. The SessionStart boot digest reminds you while the queue is non-empty.
 
 ```
-1. dream() → distill_queue: [{memory_id, layer, raw_what, context_hint, affects, created}]
+1. recall({ dream: true }) → distill_queue: [{memory_id, layer, raw_what, context_hint, affects, created}]
 
 2. For each item, rewrite into ONE clean record:
    - what = the actual decision/warning in one line — RESOLVE references

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "linksee-memory",
-  "version": "0.13.1",
+  "version": "0.15.0",
   "mcpName": "io.github.michielinksee/linksee-memory",
   "description": "Local-first agent memory MCP — cross-agent brain with drift detection, 6-layer structured memory + token-saving file diff cache",
   "type": "module",