linksee-memory 0.14.0 → 0.15.1

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

@@ -95,6 +95,14 @@ export type ResolutionAction = 'fix' | 'supersede' | 'acknowledge' | 'dismiss';
 export interface ResolveInput {
     /** For dismiss: silence only this match term. Omitted → silence the anchor at the gate. */
     hit_term?: string;
+    /**
+     * For dismiss: false = close these drift edges as false positives but leave the gate
+     * watching. The default (true) also stops the gate. Two different verdicts hide behind
+     * "dismiss": "this detection was wrong" and "stop detecting this". Anchor #2 ("no destructive
+     * migrations") had a false positive from migrate.ts — the right answer was to close the edge
+     * and keep the gate, since "ALTER TABLE memories DROP" is exactly what it exists to catch.
+     */
+    gate?: boolean;
     anchor_id: number;
     action: ResolutionAction;
     rationale?: string;

package/dist/lib/truth-engine.js

@@ -543,12 +543,17 @@ export function resolveDrift(db, input) {
     // real detections survive.
     if (input.action === 'dismiss') {
         db.prepare("UPDATE drift_edges SET status = 'dismissed' WHERE anchor_id = ? AND status = 'open'").run(input.anchor_id);
-        try {
-            db.prepare(`INSERT INTO gate_dismissals (anchor_id, hit_term, rationale) VALUES (?, ?, ?)
-         ON CONFLICT(anchor_id, COALESCE(hit_term, '')) DO UPDATE SET rationale = excluded.rationale`).run(input.anchor_id, input.hit_term ? input.hit_term.toLowerCase() : null, input.rationale ?? null);
-            resolution.gate_dismissed = input.hit_term ? input.hit_term.toLowerCase() : 'all matches';
+        if (input.gate === false) {
+            resolution.gate_dismissed = 'none (edges closed; gate still watching)';
+            resolution.gate = false;
         }
-        catch { /* pre-v16 DB → edges-only dismiss, as before */ }
+        else
+            try {
+                db.prepare(`INSERT INTO gate_dismissals (anchor_id, hit_term, rationale) VALUES (?, ?, ?)
+         ON CONFLICT(anchor_id, COALESCE(hit_term, '')) DO UPDATE SET rationale = excluded.rationale`).run(input.anchor_id, input.hit_term ? input.hit_term.toLowerCase() : null, input.rationale ?? null);
+                resolution.gate_dismissed = input.hit_term ? input.hit_term.toLowerCase() : 'all matches';
+            }
+            catch { /* pre-v16 DB → edges-only dismiss, as before */ }
     }
     // If action is 'fix', mark open edges as resolved
     if (input.action === 'fix') {

package/dist/mcp/server.js

@@ -172,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: {
@@ -192,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 },
             },
@@ -219,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.)' },
             },
         },
     },
@@ -252,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' },
@@ -272,12 +280,14 @@ const TOOLS = [
     },
     {
         name: 'resolve_drift',
-        description: 'Record a resolution for a drifting anchor — the human feedback loop.\n\n6 actions:\n• fix — "we fixed the code/reality to match intent" → state becomes aligned\n• supersede — "intent evolved, this is the new direction" → state becomes aligned\n• acknowledge — "we know, parking it for now" → state becomes held (with optional review date)\n• dismiss — "false positive, not actually drifting" → edges dismissed AND the gate stops firing on it (pass hit_term to silence just that word)\n• harden — "re-injected but still violated, enforce it" → card_policy.gate_mode=hard (PreToolUse will BLOCK)\n• soften — "back off to a warning" → gate_mode=soft\n\nWHEN TO CALL:\n• After drift_status shows 🔴 drift or 🟡 review items\n• When the user says "that\'s fixed" / "ignore that" / "we changed direction"\n• When acknowledging a known gap with a review date',
+        description: 'Record a resolution for a drifting anchor — the human feedback loop.\n\n6 actions:\n• fix — "we fixed the code/reality to match intent" → state becomes aligned\n• supersede — "intent evolved, this is the new direction" → state becomes aligned\n• acknowledge — "we know, parking it for now" → state becomes held (with optional review date)\n• dismiss — "false positive, not actually drifting" → edges dismissed AND the gate stops firing on it (hit_term: just that word; gate:false: close the edges but keep the gate watching)\n• harden — "re-injected but still violated, enforce it" → card_policy.gate_mode=hard (PreToolUse will BLOCK)\n• soften — "back off to a warning" → gate_mode=soft\n\nWHEN TO CALL:\n• After drift_status shows 🔴 drift or 🟡 review items\n• When the user says "that\'s fixed" / "ignore that" / "we changed direction"\n• When acknowledging a known gap with a review date',
         inputSchema: {
             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.)' },
+                gate: { type: 'boolean', default: true, description: "For dismiss: false = these detections were false positives, close them, but KEEP the gate watching this anchor (its signals still fire). Use when the anchor's rule is right and only this evidence was wrong — e.g. a lexical hit in a file that is not what the rule is about. Default true also silences the gate (whole anchor, or just hit_term)." },
                 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' },
@@ -1383,7 +1393,78 @@ async function inferDefaultEntity() {
     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({
@@ -1404,17 +1485,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);
@@ -1423,6 +1502,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,
@@ -1575,6 +1656,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,
@@ -1613,6 +1714,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');
     }
@@ -1636,6 +1752,7 @@ function handleResolveDrift(args) {
         review_after: args.review_after,
         superseded_by: args.superseded_by,
         hit_term: args.hit_term,
+        gate: args.gate,
     });
     return JSON.stringify(result);
 }
@@ -1946,7 +2063,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.14.0",
+  "version": "0.15.1",
   "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",