Silently save a portable context summary from the current session so it can be resumed later in any tool. This is the effortless 'capture' half of the loop. New captures start as 'captured' (warm tier); they become trusted 'promoted' memories the first time you resume them.

CALL THIS PROACTIVELY (you don't need to be asked) when: a substantive discussion is wrapping up; the user says they're done / switching tasks / "remember this" / "save this"; a key decision, plan, or conclusion was reached; or the user signals they'll continue later. Write the summary so a future session in a DIFFERENT tool could pick up with full context. Skip trivial one-off exchanges.

Args:

• title (string): short topic title

• summary (string): the portable context to inject into a future session (markdown ok)

• key_points (string[]): scannable discussion points (optional)

• tags (string[]): topic tags for filtering (optional)

• source (string): Origin tool, e.g. 'claude-code', 'chatgpt', 'chat', 'cowork', 'claude-desktop'.

• links (string[]): ids of related threads to connect (optional)

• kind ('discussion'|'brainstorm'): mark brainstorm sessions so they can be resumed/clustered as ideas (default 'discussion')

Returns: the created thread id and its formatted record.

Find the best-matching saved context for a topic and return its summary to inject into the current (new) session — so you don't lose context across tools. This is the 'promote-on-reuse' moment: resuming a captured memory promotes it to a trusted (hot) memory and bumps its freshness. After reading, if anything is stale, call mindmap_update to trim it.

CALL THIS PROACTIVELY (you don't need to be asked) at the START of a session when the user references prior work — e.g. "let's continue", "pick up where we left off", "the X project", or any topic that sounds like it may have history. Resuming first means you start with their real context instead of asking them to re-explain.

Args:

• query (string): topic or keywords describing what you were working on

• source (string): only resume memories from this origin tool (optional)

Returns: the matched thread's full context plus a freshness nudge, or near-misses if nothing strong matched.

Start (or continue) a brainstorm on a topic WITH your shared memory. This pulls your prior thinking on the topic — past brainstorms first, then related discussions and your persona — so an idea you explored in one tool continues seamlessly in another. It does NOT replace your own brainstorming ability: use this to load context, then brainstorm with your full capability (and any brainstorming skill you have), then save the result.

CALL THIS PROACTIVELY when the user wants to brainstorm / ideate / "think through" / "explore options" on something that may have history. Reusing a past brainstorm promotes it (promote-on-reuse).

Flow: 1) call this with the topic → get prior context; 2) brainstorm, building on it; 3) save what's worth keeping with mindmap_capture(kind="brainstorm").

Args:

• topic (string): what you're brainstorming about Returns: a brainstorm pack — persona + prior idea-threads to build on.

Search across all saved context (every tier, every tool) to relocate a past discussion. Read-only — does not change freshness or tiers (use mindmap_resume to actually pull a memory forward).

Args:

• query (string): keywords; empty string browses by recency

• source/tag/tier: optional filters

• include_archived (boolean): include forgotten traces (default false)

• limit (number): max results (default 10)

Returns: ranked list of matching memories.

List saved memories with optional filters, newest-used first. Read-only.

Args: source/tag/tier filters, include_archived (default false), limit (default 20). Returns: list of memories.

Fetch the full content of one memory by id. Read-only (does not change freshness).

Args: id (string). Returns: the full thread.

Reconstruct and return the FULL original conversation for a memory (every user + assistant turn), read live from its source transcript. The summary is the distilled gist; this is the complete discussion when you need the detail.

Only available for transcript-backed sources (Claude Code, Cursor, Copilot). Cowork / Claude desktop-app sessions saved no transcript, so this returns a notice instead.

Args: id (string). Returns: the full discussion as turns, or why it's unavailable.

Explicitly bless a memory as trusted: marks it 'promoted' and moves it to the hot tier so it ranks first and decays slower. Use when you know a memory matters even if you haven't resumed it yet.

Args: id (string). Returns: the updated thread.

Edit a memory — the human curation moment. Trim a stale summary, refine key points, retitle, or retag. Any omitted field is left unchanged. Set append=true to append to summary/key_points instead of replacing.

Args: id, title?, summary?, key_points?, tags?, append (default false). Returns: the updated thread.

Connect two memories so related threads (e.g. planning in Chat + code in Claude Code) cross-reference each other. Bidirectional. This is the lightweight 'map' connective tissue.

Args: id (string), target_id (string). Returns: confirmation.

Run the consolidation pass that the background thread runs automatically: recompute every memory's tier by age + usage, cooling unused ones and collapsing cold ones to a one-line trace (still searchable, never deleted). Nothing is destroyed.

Args: dry_run (boolean, default false) — preview changes without writing. Returns: what moved between tiers.

Forget a memory. By default this is a soft forget: status→archived, kept only as a searchable one-line trace (recall never hard-fails). Set hard=true to permanently delete the file.

Args: id (string), hard (boolean, default false). Returns: confirmation.

The opt-in gamified curation surface. Reports a cleanliness score — the share of memory that is still live (hot+warm) vs stale — which rewards pruning, not hoarding. Also lists stale candidates worth a tidy pass.

Args: none. Returns: health report.

Return a small batch of the stalest memories for a quick keep / trim / forget review — the opt-in curation game. Read-only: it only suggests. Act on items with mindmap_promote (keep), mindmap_update (trim), or mindmap_forget.

Args: limit (number, default 5). Returns: stalest cold memories.

View or change Mind Map settings: decay windows, the promoted longevity factor, and the gamification toggle. Omit all args to just view current settings.

Args (all optional): hot_window_days, warm_window_days, promoted_longevity_factor, gamification. Returns: the effective config.

Return the user's persona — a distilled profile of how they work (stack, style, communication, constraints), so you can make aligned defaults and AVOID re-asking things they've already established.

CALL THIS PROACTIVELY at the start of a session before asking the user setup-style questions (their stack, preferences, conventions). Apply high-confidence facts silently; only ask when something needed isn't covered.

Args:

• project (string, optional): include preferences scoped to this project on top of global ones. Returns: an "About this user" block + fact count.

Save a durable preference about how the user works, so future sessions don't re-ask. Use this when the user states a lasting preference — "I prefer X", "always Y", "never Z", "I'm on macOS", "we use Postgres". (For saving a discussion, use mindmap_capture instead — this is for standing preferences.)

Args:

• text (string): the preference, e.g. "Prefers concise, code-first answers"

• category: identity | stack | style | communication | constraints | workflow | goals

• polarity ('prefer'|'avoid'|'fact'): default 'prefer'

• project (string, optional): scope to one project instead of global Returns: the saved fact.

Remove or mute a persona fact (e.g. it's wrong or out of date). Get ids from mindmap_persona. Default mutes (recoverable); hard=true deletes.

Args: id (string), hard (boolean, default false). Returns: confirmation.

Derive persona facts from your existing memories. If you've configured an LLM (mindmap_llm), it extracts richer facts — style, constraints, workflow; otherwise it runs a no-LLM keyword heuristic over your stack/tools. Either way, inferred facts get lower confidence than declared ones and never override what you've explicitly set.

Args: none. Returns: how many facts were added/updated and which path ran.

Mind Map runs fully WITHOUT an LLM. This is opt-in: plug in your OWN provider to unlock smarter features (LLM-assisted persona inference, richer summaries).

Security: Mind Map stores only the provider + model name. It NEVER stores your API key — the key is read from your environment (ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY; ollama needs none). Set the env var yourself.

Args (all optional — omit all to just see status):

• provider: none | anthropic | openai | google | ollama

• model: override the default model

• baseUrl: for ollama / self-hosted (default http://localhost:11434) Returns: current provider/model, whether it's ready, and a rough cost note.

Show a transparent ledger of everything Mind Map knows — each memory's provenance (where it came from), trust (promote-on-reuse count), tier, last use, and when it will fade to a one-line trace. Use when the user asks "what do you know about me?", "what's stored?", or wants to review/clean their memory.

Args: limit (number, optional, default 30). Returns: the ledger rows.

Export all memories + persona to a single portable JSON file you own — to back up, move to another machine, or hand to a fork. This is your context, extractable.

Args: path (string, optional) — output file (default ~/mindmap-passport-.json). Returns: the file path and counts.

Bring context IN. Either a Mind Map passport file (from another machine), or pull your conversations OUT of a walled garden by pointing at its exported data file:

• kind 'passport' (default): a Mind Map passport JSON

• kind 'chatgpt': ChatGPT's exported conversations.json

• kind 'claude': Claude.ai's exported conversations.json The cloud chats themselves can't be reached live, but their EXPORT FILES are yours — this imports them as distilled memories.

Args: file (string, required), kind ('passport'|'chatgpt'|'claude', default 'passport'). Returns: import counts.

Project the user's persona into the native instruction files of their AI tools (Claude CLAUDE.md, Cursor rules, Copilot instructions, Windsurf rules), so even non-MCP tools know how they work — from one source. Writes only inside a managed block; never clobbers the user's own content. By default writes the global Claude config + any detected project tools.

Args:

• targets (string[], optional): specific target ids (claude-global, claude-project, cursor, copilot, windsurf)

• force (boolean, optional): write even if a tool isn't detected Returns: per-target outcomes.