devsmind-mcp 2.4.0 → 4.0.0

package/dist/cli/integrations/memory-topics.js

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MEMORY_TOPICS = void 0;
+exports.renderTopicFile = renderTopicFile;
+exports.renderIndexLine = renderIndexLine;
+exports.renderCombined = renderCombined;
+exports.renderMemoryPrompt = renderMemoryPrompt;
+const server_1 = require("../../mcp/server");
+exports.MEMORY_TOPICS = [
+    {
+        name: 'devsmind',
+        title: 'DevsMind workflow contract',
+        description: 'The cross-cutting DevsMind workflow — read before any code search, edit, or commit in a project with the DevsMind MCP server.',
+        hook: 'the full contract: session, search, edit, record.',
+        type: 'feedback',
+        body: server_1.DEVSMIND_INSTRUCTIONS,
+    },
+    {
+        name: 'devsmind-edit-node-always',
+        title: 'Always write with edit_node',
+        description: 'Write every file with DevsMind edit_node — never the built-in Edit/Write tools.',
+        hook: 'every file, every extension; never the built-in Edit/Write.',
+        type: 'feedback',
+        body: [
+            '`edit_node` is the write path for **every** file — `.ts`, `.vue`, `.css`, `.json`, `.xml`, `.md`, `.py`, anything. Never reach for your own edit/write tool. Params are the ordinary ones: `file_path` + `old_string` + `new_string`; to create a new file pass `old_string: ""` and the whole file as `new_string`. If the edit creates exactly ONE new function/class, pass `description` in the same call to skip a later round trip ([[devsmind-commit-changes-contract]] would otherwise refuse the batch).',
+            '',
+            "**Why:** it traces where the text landed to the actual function/class changed, stages it, and answers with that node's callers — a plain edit tool records nothing. Writes that land outside any function (markup, config, an import line) get no graph node; that is expected, not a failure, and the whole-file change is still staged for the local activity log.",
+            '',
+            "**How to apply:** `edit_node` is the write path for every file — there is no second write tool to reach for instead.",
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-start-session-first',
+        title: 'start_session first',
+        description: 'Call start_session before your first WRITE — session_id is required on every write, but read-only tools do NOT need one.',
+        hook: 'session_id is required on every DevsMind WRITE; reads (search_nodes, get_node_code, get_activity_log, etc.) do not need one.',
+        type: 'feedback',
+        body: [
+            '`start_session` mints a `session_id` that every WRITE tool (edit_node, commit_changes, and the other mutating calls) REQUIRES. Read-only tools (search_nodes, get_node_code, list_nodes, get_activity_log, and the other getters) do NOT need it — search and read freely from the very first call, before start_session has even run. Never invent a session_id. On a resumed conversation that already called start_session earlier (visible in reloaded history), reuse that same id instead of starting a new one.',
+            '',
+            '**Why:** a session ties a request\'s WRITES together on the local Activity log and makes them revertable as a unit — reads mutate nothing, so gating them buys nothing and only adds friction to the first thing an agent does (usually a search). `get_activity_log` additionally accepts `session_id` as its own OPTIONAL filter ("show me just this session\'s activity") — do not default to passing your own conversation\'s session_id there just because you have it, or you\'ll silently scope an otherwise-broad query (e.g. "what did I do today") down to only this one conversation.',
+            '',
+            '**How to apply:** if a WRITE call errors saying session_id is required, start_session was skipped — call it, then retry. Every response echoes the id back, so it stays visible across a long or compacted conversation. For get_activity_log, omit session_id unless you specifically want to filter to one session.',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-search-nodes-before-grep',
+        title: 'search_nodes before grep',
+        description: 'Find code with search_nodes (query and/or pattern, a real regex) instead of grep or reading files — it covers the graph AND a real file grep.',
+        hook: 'query and/or pattern (a real regex); covers graph + file grep.',
+        type: 'feedback',
+        body: [
+            "`search_nodes` is the one search call: it covers the indexed graph AND the raw filesystem, so an external grep is not needed. Two inputs, pass either or both — a natural-language `query` (a real phrase, drives the semantic/vector layer) and/or `pattern` (a REAL regex, used exactly as you'd give grep — not re-escaped, not split — e.g. an identifier or \"item\\.liked\"). Pattern-only is a precision mode: exact grep + code-body matches, no semantic blur. Your own knowledge of the codebase (identifiers, error strings, config keys) makes a better pattern than tokenizing the query ever will.",
+            '',
+            'Two buckets come back:',
+            '- `nodes` (primary) — functions/classes, each LEADING with `confidence` (high/medium/low), `relevance` and `found_by`, then `uses`/`used_by`/`history_count`; `nodes_total` is the true count before the top-20 cap.',
+            "- `files` (last resort) — a real grep of every repo (or just `path`, if scoped), for what the graph doesn't model: CSS, JSON, `.env`, markup, wiring like \"where is CORS configured\". Sample lines report which function/class they fall inside. `files_total` is the true match count — bigger than what's returned means there's more; pass `offset` for the next page.",
+            '',
+            "**Why:** empty buckets plus a `hint` mean the thing genuinely isn't there — it never pads with guesses. `used_by: 0` carrying a `used_by_note` means \"unverified\", not \"dead code\". A capped page was silently indistinguishable from a complete result before `files_total`/`nodes_total` existed — never assume \"not there\" from a short list alone. Triage on `confidence`, not on which node name reads plausibly: confidence is corroboration across independent search layers, which is evidence you cannot reconstruct by eye, and a name that merely looks right is the easiest way to pick the wrong node.",
+            '',
+            "**How to apply:** search before any grep/glob/file read. Retry once with a different pattern/query before giving up. Drop to a manual grep only if the response says `truncated: true`, or you need full file context after it points at the file. Lockfiles and build artifacts are excluded by default (`.env`, JSON and config are NOT — those are what the files bucket is for); scoping `path` at an excluded file returns nothing and says so in `scope_note`, so read it directly rather than re-querying. A `compacted` field means the response was trimmed to fit and names what was dropped — counts stay exact either way, and `compact:false` demands the full payload. See [[devsmind-get-node-graph]] for blast radius once you have a hit.",
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-get-node-graph',
+        title: 'get_node_code graph params for callers and flows',
+        description: 'Before changing a signature or tracing a feature end to end, pass graph_depth/graph_direction on get_node_code — "in" for the full caller blast radius, "out" + graph_code for a whole call flow.',
+        hook: 'graph_direction:"in" for blast radius, "out"+graph_code for a whole flow, in the SAME get_node_code call.',
+        type: 'feedback',
+        body: [
+            'There is no separate get_node_graph tool anymore — `get_node_code` already includes direct callers/callees by name on every call (`uses_nodes`/`used_by_nodes`). `graph_depth` + `graph_direction` walk the TRANSITIVE graph past those, in that same call, answering the two questions git cannot:',
+            '- `graph_depth: 2-3` + `graph_direction: "in"` — the full caller blast radius, not just direct callers. Use this BEFORE changing any signature or behavior.',
+            '- `graph_depth: 3` + `graph_direction: "out"` + `graph_code: true` — the starting node plus everything it transitively calls, with current source, in ONE call. Use this for tracing a request/endpoint/feature end to end.',
+            '',
+            '**Why:** git shows what changed, never what depends on it. The "out"+`graph_code` combination replaces a long chain of `get_node_code` calls with a single round trip — and depth 1 is already free, since direct neighbors come back on every call regardless of `graph_depth`.',
+            '',
+            '**How to apply:** never chain per-function code fetches when tracing a flow — one `get_node_code` call with the right `graph_depth`/`graph_direction`/`graph_code` does it. When `graph.code_truncated: true`, check WHICH of the two causes applies, because only one is fixable: `graph.code_omitted_node_ids` names the nodes whose code exists but did not fit the budget (call `get_node_code` on exactly those, or re-issue with a bigger `graph_code_budget`), while `graph.nodes_no_code_available` counts nodes whose source genuinely could not be found — raising the budget will never bring those back. If `graph.nodes_truncated: true`, the walk hit its 120-node cap before the queue emptied. Pairs with [[devsmind-search-nodes-before-grep]] (find the node) and [[devsmind-get-node-code-and-history]] (read it, and why it looks that way).',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-get-node-code-and-history',
+        title: 'get_node_code — the one node-read call',
+        description: 'Read one function with get_node_code instead of opening the file — it already returns metadata, imports, named callers/callees, a file outline, and recent reasoning; pass history:"full" for the complete revision trail before refactoring.',
+        hook: 'one call: code + metadata + imports + named callers/callees + file outline + recent reasoning.',
+        type: 'feedback',
+        body: [
+            '`get_node_code` is the ONE node-read call — no separate get_node_graph or get_node_history tool exists anymore, both folded in as params. It reads ONE function/class, live-parsed from disk — cheaper than opening the whole file, and current, so trust it as-is. ALWAYS included, at no extra cost: `name`/`type`/`signature`/`description` (the node\'s own metadata — `description` is the highest-signal field there is), `imports` (the file\'s ES import lines), `uses_nodes`/`used_by_nodes` (up to 20 named callers AND callees per direction, with `uses`/`used_by` always the TRUE count even when capped), `file_outline` (up to 40 OTHER declarations in the same file — consts, types, sibling helpers, whether or not they\'re graph nodes), and `recent_history` (last 3 changes\' reasoning ONLY, no code).',
+            '',
+            'Reach further in the SAME call: `graph_depth`/`graph_direction` (default off) walks the TRANSITIVE graph past the always-included direct neighbors — see [[devsmind-get-node-graph]]. `history:"full"` (default `"recent"`) returns EVERY revision with diffable before/after edits, pageable with `history_limit`/`history_offset` — call it before refactoring anything with a non-trivial `history_count`.',
+            '',
+            '**Why:** git blame gives who and when; the actual decision context exists only in DevsMind history. Nothing else records why a change was made. And a bare function body alone does not say what its identifiers resolve to, who calls it, or what else lives nearby — that used to send agents back to a raw file read for all three; `get_node_code` closes that gap itself now.',
+            '',
+            '**How to apply:** do not re-open the file after `get_node_code` for imports, "what calls this", or "what else is in this file" — `imports`, `uses_nodes`/`used_by_nodes`, and `file_outline` already answer those. Every capped section says so honestly (`*_truncated`, `*_hint`) — a hint means more is reachable in this SAME call (`neighbors_offset`, `graph_depth`, `history_offset`), not a dead end. `snapshot_outdated: true` means the graph disagrees with disk — an `edit_node` on that node re-syncs it as a side effect. `source: "cached"` means the symbol was not found (renamed/moved/deleted) — the `file_outline` still shows what IS in the file, so check there before assuming it vanished — then verify and `rename_node` or `deprecate_node` ([[devsmind-never-delete-nodes]]).',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-get-activity-log',
+        title: 'get_activity_log for "what changed"',
+        description: 'For "what changed recently" or "which files did we touch", call get_activity_log — the only source of the actual file list per commit; falls back to shared graph history when the local log is empty.',
+        hook: 'the one "what changed" tool, and the only source of the FILES touched; source:"auto" falls back to shared history, "both" adds teammates.',
+        type: 'feedback',
+        body: [
+            '`get_activity_log` answers "what changed", one entry per `commit_changes`. It replaced `get_recent_changes` / `get_developer_activity` / `get_changes_by_requirement` — all three are removed. Filters compose (AND): `developer`, `session_id`, `since_hours` or `since`/`until`, `requirement_contains`.',
+            '',
+            'Each entry carries `files` (every file that commit touched), `node_ids`, `developer`, `created_at`, `request`, `summary`, `status`, `source`. The response also has `all_files` (every distinct file across the returned entries) and `total_matched` — the pre-`limit` count, so a capped result is not mistaken for a complete one.',
+            '',
+            'It reads TWO stores. The local activity log is full-fidelity but gitignored, so it is EMPTY on a teammate\'s clone or your second machine; committed graph history is shared but lossier. `source` chooses: `"auto"` (default) reads local and falls back to graph history only when local is empty; `"both"` merges local with every session that did not run on this machine; `"local"` / `"graph"` force one. Graph-backed responses carry a `caveats` array — `status` is always `"applied"` there, and `request` degrades to the reasoning\'s Requirement field.',
+            '',
+            '**Why:** it is the answer to "show me all the files you changed" (e.g. before writing tests against recent work). The graph tools know nodes, not the full file set of a commit. And the fallback is what makes the question answerable at all for someone who just cloned the repo.',
+            '',
+            '**How to apply:** use it for any "what did we change recently", "what did this ticket touch", "which files from this session" question — the default `source:"auto"` is right almost always. Reach for `source:"both"` when you want TEAMMATES\' work too: once you have local activity of your own, `auto` stops at the local store and never consults shared history. `devsmind activity` and `devsmind view` → Activity are the human-facing views of the local log ([[devsmind-cli-commands]]).',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-commit-changes-contract',
+        title: 'commit_changes contract',
+        description: 'commit_changes requires message + reasoning + feedback (all three) and refuses any batch containing an undescribed new node.',
+        hook: 'message + reasoning + feedback all required; new nodes need a description.',
+        type: 'feedback',
+        body: [
+            '`commit_changes` fails unless all THREE are present:',
+            '',
+            "1. `message` — the user's request, verbatim, that led to this commit. Reuse the exact same text on later commits still answering that request; it merges them into one activity-log entry instead of splitting them.",
+            '2. `reasoning` — ONE object (`what_changed`/`why`/`goal`) covering everything staged since the last commit, not one per edit.',
+            '3. `feedback` — 5 string fields (`graph_problems`, `edge_problems`, `tools_used`, `dropped_and_why`, `devsmind_better`). Every field must be answered; `"none"` is allowed, but only after actually checking whether something in THIS task took an extra tool call, a guess, or a wrong turn. Never invent an issue to fill it.',
+            '',
+            'It also REFUSES any batch containing a brand-NEW node with no `description` (1-3 sentences of what it does and its domain concepts, in words a teammate might search by — never a restatement of the name). Nothing staged is lost: describe it via `add_description` and retry the same call.',
+            '',
+            '**Why:** `edit_node` only stages; nothing reaches the graph or the activity log until commit. `feedback` is the only channel that improves DevsMind over time — it routes to a local graph-fix queue and a product log ([[devsmind-graph-feedback-queue]]).',
+            '',
+            '**How to apply:** commit at natural checkpoints during a long task, and always before ending a turn with staged work. Pass `description` inline on [[devsmind-edit-node-always]] when the edit created exactly one new symbol. Noticed something worth reporting but are not committing right now? `add_feedback` takes the same 5 categories ON DEMAND — any one or more, nothing required, no commit needed (see [[devsmind-graph-feedback-queue]]).',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-list-nodes-discovery',
+        title: 'list_nodes for discovery',
+        description: 'To enumerate what exists in a component or directory, call list_nodes rather than search_nodes or walking the file tree.',
+        hook: 'enumerate a component/directory instead of walking the tree.',
+        type: 'feedback',
+        body: [
+            '`list_nodes` is the discovery/enumeration call: all nodes for a component, module, or directory. Use it when the question is "what exists here", not "find the thing that does X" — that one is [[devsmind-search-nodes-before-grep]].',
+            '',
+            '**Why:** search ranks by relevance and stops at the good hits; listing is exhaustive over a scope, which is what an audit or an onboarding sweep needs.',
+            '',
+            '**How to apply:** reach for it before reading a directory tree by hand, then drill in with `get_node_code` (its `graph_depth`/`graph_direction` params reach further from there). It is PAGED — the answer is `{nodes, total, offset}`, where `total` is the true match count and `nodes` is at most `limit` (default 100, max 500). When `total` exceeds what came back, `truncated` and a `hint` name the exact next call; never read a short page as the complete set. Narrow with `type`/`file_path` in preference to paging through a whole repo. If a page is still too large the nodes come back as id/name/type/file_path only, with a `compacted` note — `total` stays exact either way.',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-workflow-tools',
+        title: 'Workflow tools for multi-session work',
+        description: 'A workflow is a named log of how one piece of functionality grew — bind your session to one so commits record onto it, and sync afterwards if you forgot.',
+        hook: 'bind the session; commits auto-log; workflow_sync fixes attribution afterwards.',
+        type: 'feedback',
+        body: [
+            'A workflow is a named, BACKWARD-LOOKING log of how one piece of functionality grew across many nodes and many sessions. You read it to learn how the code got this way. It is not a task list and nothing ever "completes".',
+            '',
+            '`start_session` tells you when there is a recent workflow worth continuing; otherwise `workflow_list` (with `query`, which matches name and description) finds one. Continue it with `workflow_bind`, then `workflow_get_context` to read the story — steps in order, each with the reasoning behind it and the nodes it touched. `last_n` reads the tail, which is what catching up usually means.',
+            '',
+            '**Binding is local to YOUR session.** It never moves, pauses, or steals anyone else\'s, and two sessions can work different workflows — or the same one — at once. There is no project-wide "active workflow" any more; the old one synced through git and let one developer displace everybody else.',
+            '',
+            'The rest: `workflow_create`, `workflow_archive` (retire a thread without deleting it), `workflow_import` (turns existing flow/architecture `.md` docs into workflows).',
+            '',
+            "**Why:** a feature's decision history is invisible to git blame; starting fresh silently loses it. And research is the part nothing else keeps at all — git has the diff, history has the per-node reasoning, but neither records what was evaluated and rejected.",
+            '',
+            "**How to apply:** once bound, `commit_changes` auto-logs a step — you do NOT need `workflow_add_step` for ordinary code work. Call it for what a commit cannot express: a decision or research finding that changed no code, with the docs behind it via `doc_paths` (paths, never copies — a path outside the repo is rejected because it would not exist for a teammate). If you worked while unbound or on the wrong thread, `workflow_sync` attaches it afterwards from your local activity log: it previews first and only writes with `confirm:true`, and re-running is a no-op. See [[devsmind-commit-changes-contract]].",
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-graph-feedback-queue',
+        title: 'Graph feedback queue',
+        description: 'Fixing accumulated graph problems: read_graph_feedback, re-verify, fix, then mark_graph_feedback_processed.',
+        hook: 'read → verify → fix → mark processed, or it never drains.',
+        type: 'feedback',
+        body: [
+            "The graph-problem reports collected by `commit_changes`' `feedback` param — or reported directly, any time, via `add_feedback`'s `graph_problem`/`edge_problem` (no commit needed) — drain through a supervised loop:",
+            '',
+            '1. `read_graph_feedback` — every unprocessed report, clustered by (node_id, category), sorted by frequency. Start any batch graph-fix session here.',
+            '2. Re-verify against current code regardless of source. `confidence` ("confirmed" = evidence given, "suspected" = none) is a PRIORITY signal only — reports go stale. `commit_changes`\' `feedback` is plain text with no evidence field, so anything sourced from it is always `suspected`; `add_feedback`\'s `graph_problem`/`edge_problem` is the only path that can produce `confirmed` — and only because its evidence is VERIFIED FRESH at call time (file must exist, snippet must still be found in it), not self-reported.',
+            '3. Fix — one `record_alias` / `link_nodes` / `merge_nodes` often resolves a whole cluster ([[devsmind-graph-maintenance-tools]]).',
+            "4. `mark_graph_feedback_processed` with those entry ids — whether you fixed it or decided it doesn't apply. Otherwise the queue never drains.",
+            '',
+            "`flag_indexer_rule` records a candidate for a PERMANENT deterministic indexer rule when several reports turn out to be the same recurring pattern (e.g. a framework's generated-binding convention). It doesn't change the graph — it's a note for a human, prioritized by `evidence_count`.",
+            '',
+            '**Why:** without step 4 the same cluster resurfaces forever; without step 2 you act on stale reports.',
+            '',
+            '**How to apply:** `devsmind feedback` (CLI) is the human-facing view of both this queue and the product-feedback log.',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-never-delete-nodes',
+        title: 'Never delete a node',
+        description: 'A renamed function goes through rename_node and a removed one through deprecate_node — never delete a node.',
+        hook: 'rename_node / deprecate_node; deletion loses history forever.',
+        type: 'feedback',
+        body: [
+            'A renamed function/class goes through `rename_node`. A removed one goes through `deprecate_node` — never a delete.',
+            '',
+            "**Why:** deleting the node destroys its recorded history — the reasoning behind every past change — and nothing can recover it. Not git, not a reindex.",
+            '',
+            '**How to apply:** if `get_node_code` comes back with `source: "cached"`, the symbol is gone from disk — verify what actually happened, then `rename_node` or `deprecate_node` rather than leaving the graph stale. See [[devsmind-get-node-code-and-history]].',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-graph-maintenance-tools',
+        title: 'Graph maintenance tools',
+        description: 'Repairing the graph itself — analyze_graph (includes orphan detection), recheck_graph, merge/split/link_nodes, record_alias, create_missing_node.',
+        hook: 'analyze (incl. orphans)/recheck plus merge, split, link, record_alias.',
+        type: 'reference',
+        body: [
+            'Maintenance surface, not day-to-day lookup:',
+            '',
+            '- `analyze_graph` — zero-token local health check (god entities, cycles, dangling edges, renames, AND orphaned nodes — no separate orphan lookup tool exists). `fix: true` applies only the safe automatic fixes. CLI equivalent: `devsmind analyze`.',
+            '- `recheck_graph` — drift and disconnection sweep, pruning spurious nodes.',
+            '- `merge_nodes` / `split_node` — a node that was wrongly split, or wrongly lumped together.',
+            "- `link_nodes` — a real connection the AST couldn't prove (dynamic dispatch, generated bindings).",
+            '- `record_alias` — the same symbol known by another name; often fixes a whole feedback cluster at once.',
+            '- `create_missing_node` — something real the indexer never picked up.',
+            '- `get_visualizer_url` — the local URL for the interactive graph view: one page, Chat + Graph tabs, 2D/3D toggle inside Graph (`devsmind view`).',
+            '',
+            'These are the fixers the [[devsmind-graph-feedback-queue]] loop reaches for.',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-indexing-tools',
+        title: 'Indexing tools',
+        description: 'Indexing a workspace runs through index_start/index_checkpoint/index_continue/index_complete — never an external script.',
+        hook: "index_start/checkpoint/continue/complete natively; don't pause mid-index.",
+        type: 'feedback',
+        body: [
+            'Indexing runs through the MCP tools: `index_start` → `index_checkpoint` → `index_continue` → `index_complete`. No external scripts.',
+            '',
+            '**Why:** the checkpoint/continue pair is what makes progress survive a context reset — a script-driven index loses everything on a restart.',
+            '',
+            '**How to apply:** don\'t pause mid-index for confirmation; keep going until the workspace is indexed or the context limit is hit. `devsmind index` (first run) and `devsmind reindex` (incremental, for manual changes made outside `edit_node`) are the CLI counterparts ([[devsmind-cli-commands]]).',
+        ].join('\n'),
+    },
+    {
+        name: 'devsmind-cli-commands',
+        title: 'devsmind CLI commands',
+        description: 'What the human-facing devsmind CLI offers — setup, graph maintenance, and reviewing recorded work.',
+        hook: 'setup, graph, and review command surface.',
+        type: 'reference',
+        body: [
+            '`devsmind <cmd>`:',
+            '',
+            "**Setup** — `init` (create/update a brain), `start`, `rule` (build + place the AI workspace rule), `mcp` (register the MCP server per tool), `memory` (seed a tool's agent-memory store).",
+            '',
+            '**Graph** — `index` (first-time), `reindex` (incremental, for edits made outside `edit_node`), `sync` (pull committed graph + history from disk into the local brain.db), `analyze` (zero-AI health check), `describe` (backfill descriptions for nodes predating the requirement; safe to re-run), `embed` (local/offline vector embeddings, no LLM credentials; safe to re-run, `--force` for a model upgrade), `prune` (interactive permanent removal).',
+            '',
+            '**Review** — `view` (D3 graph visualizer plus Activity/Chat tabs), `activity` (local session/message timeline), `feedback` (graph problems, product feedback, indexer-rule candidates), `diff <node_id>` (red/green with the recorded reasoning), `revert <node_id>` (undo an entity\'s most recent recorded edit), `workflow` / `workflow-import <path>`.',
+            '',
+            'The activity and feedback logs are LOCAL and gitignored — never pushed. See [[devsmind-get-activity-log]].',
+        ].join('\n'),
+    },
+];
+/** Map of slug → title, for resolving [[links]] when topics get flattened into one document. */
+const TITLES = Object.fromEntries(exports.MEMORY_TOPICS.map(t => [t.name, t.title]));
+/** Resolve `[[slug]]` cross-links to plain titles — meaningful only when each topic is its own file. */
+function flattenLinks(body) {
+    return body.replace(/\[\[([a-z0-9-]+)\]\]/g, (_m, slug) => `"${TITLES[slug] ?? slug}"`);
+}
+/**
+ * One topic as a standalone memory file: YAML frontmatter (name/description/type)
+ * + body. The `description` is the field a file-per-fact store ranks on when
+ * deciding what to load, so it must survive on its own without the body.
+ */
+function renderTopicFile(topic, header) {
+    return [
+        '---',
+        `name: ${topic.name}`,
+        `description: ${topic.description}`,
+        'metadata:',
+        `  type: ${topic.type}`,
+        '---',
+        '',
+        header + topic.body.replace(/\n*$/, '\n'),
+    ].join('\n');
+}
+/** One index line per topic, for the store's always-loaded index file. */
+function renderIndexLine(topic) {
+    return `- [${topic.title}](${topic.name}.md) — ${topic.hook}`;
+}
+/**
+ * Every topic flattened into ONE document — for stores that load a single file
+ * (Antigravity Skills) rather than ranking many. The contract topic leads; the
+ * rest become `##` sections in registry order.
+ */
+function renderCombined(header) {
+    const [contract, ...rest] = exports.MEMORY_TOPICS;
+    return [
+        header + flattenLinks(contract.body),
+        '',
+        '## Tool playbook',
+        '',
+        ...rest.flatMap(t => [`### ${t.title}`, '', flattenLinks(t.body), '']),
+    ].join('\n').replace(/\n*$/, '\n');
+}
+/**
+ * The ONE thing `devsmind memory` prints — a single block meant to be pasted directly into any
+ * AI chat and framed as an explicit "remember this" request, not written to a file on the user's
+ * behalf. Leads with the two rules that matter most (edit_node is the only write path; prefer
+ * search_nodes/get_node_code over grepping or opening files) so they survive even a skim, then
+ * carries the full live contract below — the SAME `DEVSMIND_INSTRUCTIONS` text the MCP handshake
+ * and `devsmind rule` both use, so this can never quietly drift from what the server enforces.
+ */
+function renderMemoryPrompt() {
+    return [
+        "Please remember the following about working in this codebase — it's the DevsMind MCP workflow, and it applies every time we work in a project with a DevsMind server:",
+        '',
+        '1. Always write files with the `edit_node` tool — never your own built-in edit/write tool, whatever the file type.',
+        '2. Prefer `search_nodes` and `get_node_code` over grepping or opening files directly — they already know this codebase\'s structure and history.',
+        '',
+        'The full contract, so nothing gets missed:',
+        '',
+        server_1.DEVSMIND_INSTRUCTIONS,
+    ].join('\n');
+}
+//# sourceMappingURL=memory-topics.js.map

package/dist/cli/integrations/memory-topics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-topics.js","sourceRoot":"","sources":["../../../src/cli/integrations/memory-topics.ts"],"names":[],"mappings":"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"}

package/dist/cli/integrations/memory.d.ts

@@ -1,11 +1,22 @@
 /**
- * `devsmind memory` — seed a tool's own persistent agent-memory/skills store
- * (distinct from `devsmind rule`'s static rule file) with the same workflow
- * contract carried by the MCP `instructions` field, for the handful of tools
- * confirmed to actually read back a file they didn't create themselves. For
- * every other tool this prints honest guidance instead of writing a file that
- * might silently do nothing (or get overwritten by the tool's own background job).
+ * `devsmind memory` — prints ONE natural-language block to paste into any AI chat, framed as an
+ * explicit "remember this" request. DevsMind writes nothing on your behalf.
+ *
+ * Why: research across all 9 tools DevsMind integrates with turned up the same finding stated
+ * independently in several of those tools' own docs — background/automatic memory is
+ * discretionary by design (Windsurf, Codex, and Qwen say so outright; e.g. "auto-memory is
+ * best-effort, QWEN.md is guaranteed"), while an EXPLICIT in-chat request is the one thing that
+ * reliably lands. A silently-written file never crosses that trigger at all. And 5 of the 9 tools
+ * (Cursor, VS Code/Copilot, Windsurf, Kiro, Qwen) have no file DevsMind could safely write to in
+ * the first place — hand-writing into an undocumented or auto-generated store risks corrupting
+ * it. So instead of maintaining 9 different internal file formats, this hands the user one prompt
+ * and lets each tool's own native memory feature do whatever it already does best with it.
+ *
+ * `--tool` only changes the framing line (which feature name to call out, e.g. "Cursor calls
+ * this Memories") — the prompt itself, from `renderMemoryPrompt`, is the same for everyone.
  */
 export declare function handleMemory(opts: {
     path?: string;
+    print?: boolean;
+    tool?: string;
 }): Promise<void>;

package/dist/cli/integrations/memory.js

@@ -1,155 +1,68 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMemory = handleMemory;
-const path = __importStar(require("path"));
-const config_1 = require("../../utils/config");
-const server_1 = require("../../mcp/server");
 const registry_1 = require("./registry");
+const memory_topics_1 = require("./memory-topics");
 const prompt_1 = require("./prompt");
-const MEMORY_FILE_HEADER = '<!-- Seeded by `devsmind memory` — the DevsMind team code-graph MCP server -->\n\n';
 /**
- * `devsmind memory` — seed a tool's own persistent agent-memory/skills store
- * (distinct from `devsmind rule`'s static rule file) with the same workflow
- * contract carried by the MCP `instructions` field, for the handful of tools
- * confirmed to actually read back a file they didn't create themselves. For
- * every other tool this prints honest guidance instead of writing a file that
- * might silently do nothing (or get overwritten by the tool's own background job).
+ * `devsmind memory` — prints ONE natural-language block to paste into any AI chat, framed as an
+ * explicit "remember this" request. DevsMind writes nothing on your behalf.
+ *
+ * Why: research across all 9 tools DevsMind integrates with turned up the same finding stated
+ * independently in several of those tools' own docs — background/automatic memory is
+ * discretionary by design (Windsurf, Codex, and Qwen say so outright; e.g. "auto-memory is
+ * best-effort, QWEN.md is guaranteed"), while an EXPLICIT in-chat request is the one thing that
+ * reliably lands. A silently-written file never crosses that trigger at all. And 5 of the 9 tools
+ * (Cursor, VS Code/Copilot, Windsurf, Kiro, Qwen) have no file DevsMind could safely write to in
+ * the first place — hand-writing into an undocumented or auto-generated store risks corrupting
+ * it. So instead of maintaining 9 different internal file formats, this hands the user one prompt
+ * and lets each tool's own native memory feature do whatever it already does best with it.
+ *
+ * `--tool` only changes the framing line (which feature name to call out, e.g. "Cursor calls
+ * this Memories") — the prompt itself, from `renderMemoryPrompt`, is the same for everyone.
  */
 async function handleMemory(opts) {
-    if (!process.stdin.isTTY || !process.stdout.isTTY) {
-        console.error(`❌ \`devsmind memory\` is interactive and needs a terminal.\n` +
-            `   Run it directly in your shell (not piped/redirected).`);
-        process.exit(1);
-    }
-    const devmindDir = (0, config_1.resolveDevmindDir)(opts.path);
-    const workspaceRoot = devmindDir ? path.dirname(devmindDir) : process.cwd();
-    try {
-        const target = await (0, prompt_1.pickTarget)();
-        const mem = target.memory;
-        if (!mem.supported) {
-            const divider = '─'.repeat(70);
-            console.log(`\n${divider}`);
-            console.log(` ${target.label} — ${mem.featureName}`);
-            console.log(`${divider}\n`);
-            console.log(`⚠️  Nothing written — there's no safe way to pre-seed this.\n`);
-            console.log(mem.note);
-            console.log('');
-            return;
-        }
-        console.log(`\nℹ️  ${target.label} calls this "${mem.featureName}".`);
-        console.log(`   ${mem.note}`);
-        const mode = await (0, prompt_1.pickMode)();
-        const scope = await (0, prompt_1.pickMemoryScope)(target);
-        const content = MEMORY_FILE_HEADER + server_1.DEVSMIND_INSTRUCTIONS;
-        const wrapped = scope.format === 'skill-md' && target.memory.wrap ? target.memory.wrap(content) : content;
-        if (mode === 'manual') {
-            printManual(target.label, scope, workspaceRoot);
-            console.log(`\nContent to place in that file:\n`);
-            console.log(indent(wrapped));
-            if (mem.pointerFile) {
-                console.log(`\n💡 Also add one pointer line into ${mem.pointerFile.file} in the same folder`);
-                console.log(`   (e.g. "See devsmind.md for the DevsMind workflow.") — it loads on demand only.`);
-            }
-            return;
+    const target = await resolveTarget(opts);
+    if (!target)
+        return; // already reported: unknown --tool, or the interactive picker was cancelled
+    console.log(`\nℹ️  ${target.label} calls this "${target.memory.featureName}".`);
+    if (target.memory.note)
+        console.log(`   ${target.memory.note}`);
+    console.log(`\n📋 Paste this into your ${target.label} chat and ask it to remember it:\n`);
+    console.log(indent((0, memory_topics_1.renderMemoryPrompt)()));
+    console.log('');
+}
+/**
+ * `--tool` resolves directly. Otherwise, an interactive TTY offers the same picker `devsmind
+ * rule`/`devsmind mcp` use (purely for the framing line — nothing here depends on the answer
+ * the way file placement used to); a non-interactive/piped run — or an explicit `--print` — falls
+ * back to Claude Code's framing and says so, so scripted use never blocks on a prompt.
+ */
+async function resolveTarget(opts) {
+    if (opts.tool) {
+        const target = (0, registry_1.getTarget)(opts.tool);
+        if (!target) {
+            console.error(`❌ Unknown tool "${opts.tool}". Valid values for --tool: ${registry_1.TARGETS.map(t => t.id).join(', ')}`);
+            process.exit(1);
+            return undefined;
         }
-        // Automatic mode.
-        const targetDir = await resolveMemoryDir(scope, target.label, workspaceRoot);
-        const filePath = path.join(targetDir, scope.file);
-        const merged = (0, prompt_1.mergeRuleFile)(filePath, wrapped, 'standalone');
-        console.log(`\n📝 Target: ${filePath.replace(/\\/g, '/')}  (${merged.existed ? 'overwrite our own file' : 'create new'})`);
-        console.log(`\nContent to be written:\n`);
-        console.log(indent(merged.content));
-        const ok = await (0, prompt_1.confirmPrompt)('Write this?', true);
-        if (!ok) {
-            console.log('\nAborted — nothing written.');
-            return;
+        return target;
+    }
+    if (!opts.print && process.stdin.isTTY && process.stdout.isTTY) {
+        try {
+            return await (0, prompt_1.pickTarget)();
         }
-        (0, prompt_1.writeConfigFile)(filePath, merged.content);
-        console.log(`\n✅ Seeded ${target.label}'s ${mem.featureName} at ${filePath.replace(/\\/g, '/')}`);
-        if (mem.pointerFile) {
-            const pointerConfirm = await (0, prompt_1.confirmPrompt)(`\nAlso append a one-line pointer into ${mem.pointerFile.file} in the same folder, so this gets found ` +
-                `(it only loads "on demand" otherwise)?`, true);
-            if (pointerConfirm) {
-                const pointerPath = path.join(targetDir, mem.pointerFile.file);
-                const pointerBody = `See \`${scope.file}\` in this folder for the DevsMind workflow contract — search before grep, ` +
-                    `\`edit_node\` to change existing TS/JS code, \`stage_change\` to record every other edit, ` +
-                    `\`commit_changes\` before the turn ends.`;
-                const pointerMerged = (0, prompt_1.mergeRuleFile)(pointerPath, pointerBody, 'append-section');
-                if (pointerMerged.error) {
-                    console.error(`❌ ${pointerMerged.error}`);
-                }
-                else {
-                    (0, prompt_1.writeConfigFile)(pointerPath, pointerMerged.content);
-                    console.log(`✅ Pointer added to ${pointerPath.replace(/\\/g, '/')}`);
-                }
+        catch (err) {
+            if (err instanceof prompt_1.CancelledError) {
+                console.log('\nCancelled.');
+                return undefined;
             }
+            throw err;
         }
     }
-    catch (err) {
-        if (err instanceof prompt_1.CancelledError) {
-            console.log('\nCancelled.');
-            return;
-        }
-        throw err;
-    }
-}
-/** Resolve the directory to write into, prompting the user to navigate when the exact path isn't knowable. */
-async function resolveMemoryDir(scope, label, workspaceRoot) {
-    if (scope.needsUserConfirmedDir) {
-        const start = (0, registry_1.resolveOsPath)(scope.dir);
-        return (0, prompt_1.pickDirectory)(start, `Navigate to the correct folder for ${label} (e.g. .../projects/<your-project-hash>/memory)`);
-    }
-    if (scope.scope === 'project') {
-        const base = await (0, prompt_1.pickDirectory)(workspaceRoot, `Where is the project root for ${label}?`);
-        return path.join(base, (0, registry_1.resolveOsPath)(scope.dir));
-    }
-    return (0, registry_1.resolveScopeFile)(scope.dir, 'global', workspaceRoot);
-}
-function printManual(label, scope, workspaceRoot) {
-    const divider = '─'.repeat(70);
-    const dirHint = scope.needsUserConfirmedDir
-        ? `${(0, registry_1.resolveOsPath)(scope.dir)}/<your-project-hash>/...`
-        : scope.scope === 'project'
-            ? path.join(workspaceRoot, (0, registry_1.resolveOsPath)(scope.dir)).replace(/\\/g, '/')
-            : (0, registry_1.resolveOsPath)(scope.dir);
-    console.log(`\n${divider}`);
-    console.log(` Seed DevsMind into ${label}`);
-    console.log(`${divider}`);
-    console.log(`\n1. Create this file:`);
-    console.log(`   ${dirHint.replace(/\\/g, '/')}/${scope.file}`);
+    const fallback = (0, registry_1.getTarget)('claude-code');
+    console.log(`ℹ️  No --tool given — showing generic phrasing (the prompt itself is identical for every tool). Others: ${registry_1.TARGETS.map(t => t.id).join(', ')}`);
+    return fallback;
 }
 function indent(text) {
     return text.split('\n').map(l => '   ' + l).join('\n');

package/dist/cli/integrations/memory.js.map

@@ -1 +1 @@
-{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../src/cli/integrations/memory.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../../src/cli/integrations/memory.ts"],"names":[],"mappings":";;AAqBA,oCASC;AA9BD,yCAA2D;AAC3D,mDAAqD;AACrD,qCAAsD;AAEtD;;;;;;;;;;;;;;;;GAgBG;AACI,KAAK,UAAU,YAAY,CAAC,IAAuD;IACxF,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,CAAC,MAAM;QAAE,OAAO,CAAC,4EAA4E;IAEjG,OAAO,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,KAAK,gBAAgB,MAAM,CAAC,MAAM,CAAC,WAAW,IAAI,CAAC,CAAC;IAChF,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI;QAAE,OAAO,CAAC,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IAChE,OAAO,CAAC,GAAG,CAAC,6BAA6B,MAAM,CAAC,KAAK,oCAAoC,CAAC,CAAC;IAC3F,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAA,kCAAkB,GAAE,CAAC,CAAC,CAAC;IAC1C,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AAClB,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,aAAa,CAAC,IAAwC;IACnE,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QACd,MAAM,MAAM,GAAG,IAAA,oBAAS,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,OAAO,CAAC,KAAK,CAAC,mBAAmB,IAAI,CAAC,IAAI,+BAA+B,kBAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC9G,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAChB,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAC/D,IAAI,CAAC;YACH,OAAO,MAAM,IAAA,mBAAU,GAAE,CAAC;QAC5B,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,GAAG,YAAY,uBAAc,EAAE,CAAC;gBAClC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;gBAC5B,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,MAAM,GAAG,CAAC;QACZ,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,IAAA,oBAAS,EAAC,aAAa,CAAE,CAAC;IAC3C,OAAO,CAAC,GAAG,CAAC,2GAA2G,kBAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5J,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAS,MAAM,CAAC,IAAY;IAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACzD,CAAC"}