Bragproof

← Reports

mindplan-mcp

Starts with no setup0.25.0npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 0 of 5 tools tried
Contacts while installing and starting: huggingface.co, us.aws.cdn.hf.co

42tools listed
2hosts contacted
40files written
0.2 sto start
161dependencies

What it contacted

Hosts it looked up or connected to while installing and starting with no input, watched from outside its sandbox. The npm registry is left out. Says nothing about what its tools contact when called.

Starting it

npx -y mindplan-mcp@0.25.0

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

5 tools that take no input and look read-only were called once with nothing. 0 returned a result.

get_driftNo usable answer tool reported an error: Blocked: Version — This project has no MindPlan graph (mindplan/). Call setup_project to create it, then follow the guide it returns.
get_mindplan_graphNo usable answer tool reported an error: Blocked: Version — This project has no MindPlan graph (mindplan/). Call setup_project to create it, then follow the guide it returns.
find_related_nodesNo usable answer tool reported an error: Blocked: Version — This project has no MindPlan graph (mindplan/). Call setup_project to create it, then follow the guide it returns.
list_areasNo usable answer tool reported an error: Blocked: Version — This project has no MindPlan graph (mindplan/). Call setup_project to create it, then follow the guide it returns.
get_node_implementationNo usable answer tool reported an error: Blocked: Version — This project has no MindPlan graph (mindplan/). Call setup_project to create it, then follow the guide it returns.

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

run_check base, change, merge, after_merge, compact, nodes, run_tests, root
Call before in-review, before ship, and before telling the user the work is done. Runs the same check as `mindplan-mcp check` (graph load, exclusivity, coverage, presence, leftovers, import matrix); warnings never fail it. Compact by default: { ok, counts, failures, warnings: [{ id, text }], info, acknowledged, unchanged }, listing only warnings not shown earlier in this session or acknowledged (acknowledge_warning); nodes lists those nodes' warnings again; compact: false returns the CLI output. A graph that needs setup_project or upgrade_project fails with Blocked: Version. An unclaimed source file is Blocked: Coverage with its probable owner and the claim call, or leads with create_node when no node has a file in its folder. Pass change to also run the in-review gate on every member of that change. Pass merge before telling the user a PR is ready to merge: it Blocks nodes still in review, and shipped nodes with no open revision whose claimed files changed against base while their territory did not (open_next + ship, or patch_node_territory in place); "strict" also Blocks in-progress nodes whose claimed files changed. Pass after_merge after merging a branch that changed the graph. Pass run_tests (with change or nodes) to run their linked tests; passing tests close each node's verify item. Details: get_spec({ topic: "run_check" }).
get_drift root
Call when a reply's drift count says source files drift and you need every path, or before handing off. Returns { count, paths: [{ path, class, owner_id?, state?, next_state? }], expected, reminder }: every uncommitted source file whose owner has no open update (owner_idle), that a node claims but is missing (claimed_missing), or that no node claims (unowned). Other replies carry only drift: { count, new_since_last_reply }. Details: get_spec({ topic: "get_drift" }).
acknowledge_warning id, ids, root
Call when a run_check warning is known and accepted, so compact checks stop listing it. Stores the w- ids a compact run_check lists in .mindplan-cache/acks.json of this root (no graph write); returns { acknowledged: [ids] }. A warning whose text changes gets a new id and shows again. Details: get_spec({ topic: "acknowledge_warning" }).
get_mindplan_graph offset, limit, state, type, change, fields, edges, root
Call when you need the graph's nodes and edges, or a slice of them; prefer orient_for_work for one piece of work. Returns one page: nodes sorted by id, the edges whose source is in the page, totals, and next_offset while nodes remain (up to 200 nodes per page). Filter with state / type / change (AND across, OR within an array), project with fields, and drop or narrow edges with edges: e.g. state: ["draft", "ready"], fields: ["id", "type", "title", "change"], edges: false lists what is planned but not built. Details: get_spec({ topic: "get_mindplan_graph" }).
export_mindplan_view format, focus, include_retired, decisions, output, root
Call when a human wants a map for a PR or a doc (agents orient with find_related_nodes). Exports the typed DAG as Mermaid or DOT: the full filtered map, or with focus that node and its 1-hop neighborhood; retired nodes and closed bugs are hidden by default. A diagram over 80000 characters is Blocked unless you pass focus or output (a repo-relative file path, outside mindplan/). Details: get_spec({ topic: "export_mindplan_view" }).
37 more tools
find_related_nodes query, node_id, type, limit, area, root
Call before creating a node, to reuse one that already exists. Ranks nodes for a text query (keyword plus semantic; an exact id ranks first) and returns the focus node plus its 1-hop neighborhood as summaries. Pass query and/or node_id; get_node_context reads full territory. Details: get_spec({ topic: "find_related_nodes" }).
list_areas root
Call when you are unsure where work lands. Returns every Capability as one compact table row (id, title, short description, interaction / interface / foundation counts, open_bugs); pass a row's id as area to orient_for_work or find_related_nodes. Details: get_spec({ topic: "list_areas" }).
get_node_implementation node_id, path, root
Call before editing a file, to see which node owns it, or to list a node's claimed files. Pass node_id for its implements files ({ path, exists }, next_files?), or path for the owner of that path. Details: get_spec({ topic: "get_node_implementation" }).
get_node_context node_id, include_superseded, include_inherited_decisions, include_inherited_rules, slot, section, change, resend_rules, root
Call when you are about to read or edit one node's territory. Returns its record, body (without ## Rules / ## Decisions), own rules, active decisions, resolved_rules (sources past distance 1 as one line unless include_inherited_rules; text this session already received as { node_id, version, unchanged: true }), and attachments, plus the next slot while a revision is open; it counts as orienting on the node. With several open revisions pass change to read one (otherwise only live comes back). slot or section returns only that body part, the minimal record (id, type, state, title), the rules, and decisions not yet sent; include_superseded and include_inherited_decisions widen the decisions. To find exact text for a replace edit use find_in_node. Details: get_spec({ topic: "get_node_context" }).
find_in_node node_id, text, slot, change, regex, case_sensitive, limit, root
Call when you need the exact text of a node for patch_node_territory's replace edit. Searches the node's body as replace.find sees it (live without ## Rules / ## Decisions, plus the open revision) and returns each matching line with its slot, line, section, and a snippet of whole lines that occurs exactly once in that slot: pass it as replace.find (with the match's slot and change). Details: get_spec({ topic: "find_in_node" }).
search_graph text, regex, case_sensitive, type, limit, root
Call when you need to know which nodes' text mentions something (a path, a term, a phrase) instead of grepping mindplan/. Searches the body of every non-retired node (live and each open revision) and returns matching lines { node_id, type, slot, change?, line, section, match }. find_in_node then gives a replace-ready snippet. Details: get_spec({ topic: "search_graph" }).
orient_for_work query, node_id, node_ids, change, type, limit, depth, include_superseded, include_inherited_decisions, include_inherited_rules, known_rules_versions, area, slot, section, resend_rules, sections, root
Call before working on a node: a write on a node is Blocked: Orientation until that node had a full reply in this session, and again after the rules reaching it changed (create_node never is). With query alone it returns ranked rows (a clear winner comes back in full with auto_focus: true); with node_id, the node: record, active-slot body, owned files, shape, its mandatory node rules (its own and those at distance 1 in full, further sources as one line), and its decisions; depth full adds the neighborhood, blast radius, and stability. change alone orients on every member of a change and clears the gate for all of them; with node_id it reads that node's revision. node_ids orients on several nodes (up to 50) in one lean reply. Rule text this session already received comes back as { node_id, version, unchanged: true } (resend_rules returns it again); known_rules_versions also leaves out text you hold; a reply without the rules section does not clear the gate. slot or section returns only that body part plus the minimal record. Replies that orient carry project_rules when the project rules have not reached the session or changed. Details: get_spec({ topic: "orient_for_work" }).
next_page cursor, root
Call when a reply carries truncated: [{ path, shown, total, cursor }] and you need more of that list. Returns { path, from, items, total, next_cursor? }: the next items that fit the reply budget; pass next_cursor for more. Cursors live for this session. Details: get_spec({ topic: "next_page" }).
get_project root
Call before the first answer or code change in a session, and again after the product description or rules change. Returns the MindPlan playbook and this product's description and rules ({ path, description, rules, rules_version, playbook, check, version?, restart? }). version appears only when the graph needs setup_project, upgrade_project, or a newer server; until then other graph tools are Blocked. restart means a different mindplan-mcp was installed under this server: have the user restart it, then call again. Details: get_spec({ topic: "get_project" }).
doctor root
Call when the server seems slow, attached to the wrong folder, or a graph tool fails in a way the message does not explain. Returns the server and Node versions, the project root it serves, the graph's state (setup, upgrade, server-behind, current), graph-load time through the cache (load_error says why it did not load), and which derived caches exist. Answers in every graph state. Details: get_spec({ topic: "doctor" }).
get_spec topic, root
Call when you need a specific MindPlan rule (lifecycle, required sections, change ids, decisions, orientation) instead of guessing or retrying. Returns one part of the running server's SPEC.md ({ topic, version, text }) by topic id, or a tool's entry by tool name; without topic it lists them. Details: get_spec({ topic: "get_spec" }).
get_skill name, file, root
Call when the playbook or the server instructions name a skill, before acting on it. Returns { name, text, files } (text is SKILL.md without frontmatter); pass file to read one supporting file; without name it lists the skills. Details: get_spec({ topic: "get_skill" }).
get_rules known_version, root
Call to re-read the project rules explicitly: after a context summary, or when a rules push was missed. Returns the mandatory project rules ({ path, rules, rules_version }) from mindplan/project.md and records them as served to this session. Pass known_version only while you still hold that text; unchanged: true means it still applies. Node rules arrive through orient_for_work. Details: get_spec({ topic: "get_rules" }).
patch_node_territory verbose, node_id, aliases, title, description, role, body, section, text, replace, toggle_checkboxes, add_checklist_items, change, change_ref, reason, slot, split_into, root
Call when a node's title, description, or body should match the work, before the feature code. The writer for territory prose (never edit mindplan/ with host file tools): body (whole), section + text (one ## section), replace { find, with }, toggle_checkboxes, add_checklist_items, title / description / role. On a shipped node it writes the open revision (change picks one when several are open); with none open, body edits go to live in place and change is Blocked. A wording fix on a shipped node is one call: reason: "text" writes title, description, body, section, or replace to live in place, with no open_next, decision, or ship; it must leave the ## sections and checklist items as they are. Before first ship, change sets the node's change id. aliases replaces search aliases on any node, live. A contract write to a slot in state ready (territory text, added checklist items, claims, links) moves that slot back to draft and returns readiness_reset; self-ready it again after review. Ticking or unticking an existing item (toggle_checkboxes) never does. Details: get_spec({ topic: "patch_node_territory" }).
confirm_territory node_id, files, note, root
Call when the merge gate Blocks a shipped node whose claimed files changed but whose territory did not, and its text still describes the code (a removed script, a bumped constant): records who confirmed it, why, and each file's content hash in the node's confirmed.json, so the gate passes it without a made-up prose edit. Editing a confirmed file again Blocks again. A changed contract needs open_next and ship instead; stale text needs patch_node_territory. Only a shipped node with no open revision. Details: get_spec({ topic: "confirm_territory" }).
patch_node_rules node_id, rules, root
Call when a rule applies to one node and the work that inherits from it, not everywhere (patch_project_rules covers that). Replaces the node's ## Rules section (empty string clears it), shipped nodes included, without open_next. Returns rules_impact: the nodes the rules reach. Details: get_spec({ topic: "patch_node_rules" }).
record_decision verbose, node_id, decision, alternatives, why, consequences, keep_whole, supersedes, change, id, nodes, root
Call when you choose between viable designs (a data shape, an ordering guarantee, which system owns a fact), on the node the choice shapes. Writes decisions/<id>.md in the node's open revision of change (or its only one), else beside live; list every other node it shapes in nodes. Never rewritten: to change one, record a new decision with supersedes. A decision-worthy revision is Blocked at in-review until a decision is recorded under its change. Never resets readiness. Details: get_spec({ topic: "record_decision" }).
list_decisions node_id, change, include_superseded, root
Call before reshaping a design someone else chose, or to read the reasoning trail of a node or change. Returns { decisions, count } for one node, one change, or the whole graph, each with its node, status, and superseded_by; superseded entries only with include_superseded. Details: get_spec({ topic: "list_decisions" }).
patch_project_description description, root
Call when the product summary changes. The next session start calls get_project again. Writes the ## Description section of mindplan/project.md via the territory store. Leaves ## Rules unchanged. Do not hand-edit project.md.
patch_project_rules rules, add, remove, root
Call when a standing rule for all work changes; a rule about one node's work belongs in patch_node_rules instead. Writes the ## Rules section of mindplan/project.md (## Description unchanged; do not hand-edit it): add / remove change single rules, rules replaces the whole text. Rules reach a session once, through get_project, get_rules, or the project_rules push in orient replies; write tools are Blocked: Rules until they have. Returns a confirmation ({ rules_version, count, added, removed, skipped? }), not the rules; get_rules returns the text. Details: get_spec({ topic: "patch_project_rules" }).
patch_config sources, exclude, decisions, hotspots, fan_out, fan_in, search, replies, tests, rule_checks, root
Call when source roots, exclude paths, decision-gate settings, hotspot thresholds, the fan-out threshold, search, reply size, the test command, or when rules' command checks run change. Writes mindplan/config.json sources, exclude, decisions, hotspots, fan_out, fan_in, search, replies, tests, and/or rule_checks via the territory store. Do not hand-edit config.json.
put_attachment verbose, node_id, filename, content_base64, slot, change, root
Call when a supporting file should sit beside a node. Writes content_base64 under its attachments/ (the open revision's while one is open; change picks among several). Details: get_spec({ topic: "put_attachment" }).
remove_attachment verbose, node_id, filename, slot, change, root
Call when a supporting file should leave a node. Deletes it from its attachments/ (the open revision's while one is open; change picks among several). Details: get_spec({ topic: "remove_attachment" }).
set_implementation_files verbose, node_id, add, remove, files, replace, attributed, slot, change, root
Call before writing a file the node does not yet claim. Changes the server-owned implements list of a Foundation, Interaction, or Interface: add (default) and remove entries; files replaces the whole list only with replace: true. Entries are files, directories ending in /, or globs (* ** ?). Pre-ship writes current; with an open revision it writes a delta (change picks the revision when several are open). A shipped node with no open revision may only add exact files in a folder it already dominates (listed in added_in_place: name each in the body with patch_node_territory); removing, globbing, claiming elsewhere, or claiming a migration or schema file is Blocked → open_next. Ownership conflicts are rejected. attributed lists files this revision adds in another node's claimed folder: that node keeps ownership, the decision gate and blast radius count them here. A contract write to a slot in state ready (territory text, added checklist items, claims, links) moves that slot back to draft and returns readiness_reset; self-ready it again after review. Ticking or unticking an existing item (toggle_checkboxes) never does. Details: get_spec({ topic: "set_implementation_files" }).
set_test_files verbose, node_id, add, remove, files, replace, change, root
Call when tests that verify a node exist, before moving it to in-review. Changes a Foundation, Interaction, or Interface's linked tests: add (default) and remove entries (files, directories ending in /, or globs); files replaces the whole list only with replace: true. Test links are evidence, not ownership: several nodes may list one file, and readiness is never reset. Without change the live list is written in place (no open_next needed); with change on a shipped node, that revision takes it as a delta applied on ship. run_check Blocks an entry missing on disk once the node is in review or shipped. Details: get_spec({ topic: "set_test_files" }).
create_node verbose, id, type, title, description, role, change, change_ref, aliases, root
Call when reuse found no node, before any new-feature code. Creates a Capability, Interaction, Interface, Foundation (role required), or Bug with its <id>.mdx scaffold; claim files later with set_implementation_files. Returns shape: the sections its first transition checks, each present, missing, or stub. Details: get_spec({ topic: "create_node" }).
link_nodes verbose, source_id, target_id, edge_type, change, root
Call when two existing nodes should be connected. Adds a DAG edge. Legal: Interaction -belongs_to-> Capability; Interaction|Interface -depends_on-> Foundation; Foundation -depends_on-> Foundation; Interface -exposes-> Interaction; Foundation -mounts-> Interface; Interaction -leads_to-> Interaction; Bug -affects-> Interaction|Interface|Foundation. On a shipped node with an open revision the edge goes to it as a delta (change picks the revision when several are open); with change and no open revision of it, the edge is planned under that change (live graph unchanged; applied when open_next opens the node with that change). A contract write to a slot in state ready (territory text, added checklist items, claims, links) moves that slot back to draft and returns readiness_reset; self-ready it again after review. Ticking or unticking an existing item (toggle_checkboxes) never does. Details: get_spec({ topic: "link_nodes" }).
open_next verbose, node_id, title, description, change, change_ref, reason, root
Call when a shipped node's contract changes, before editing that contract. Opens a draft revision under change (required) while the live node keeps serving; a node may hold several, one per change. Optional title/description overrides. Ship it with update_node_status (pass change when several are open) or abandon it with discard_next; shipping one rebases its siblings (conflicts go to resolve_conflict). Blocked when the node is not shipped or already has that change open. reason (required) says why: behavior, wiring, fix, platform, text, or refactor; only behavior and wiring count toward the node's hotspot rate. On a hotspot the result carries the diagnosis (invert or split) and a decision_prompt: do that refactor (a revision with reason refactor), or record why not. On a node with more dependents than decisions.blast_radius it carries additive_question: answer whether a new node that depends_on it would do, before editing. Details: get_spec({ topic: "open_next" }).
discard_next verbose, node_id, change, root
Call when an open revision should be abandoned. Deletes the revision with its attachments and decisions; live and other revisions stay. Pass change when several are open. Details: get_spec({ topic: "discard_next" }).
resolve_conflict verbose, node_id, change, section, field, claim, take, text, root
Call when a revision holds a conflict after a sibling revision shipped (in-review is Blocked until none remain). Name one conflict: section (e.g. "## Spec"), field (title, description, role), or claim (a path); take "revision", "live", or "text" (with text; sections and fields only). Pass change when several revisions are open. Returns the conflicts left. Details: get_spec({ topic: "resolve_conflict" }).
rebase_revision verbose, node_id, change, root
Call when run_check({ after_merge: true }) reports a revision whose base no longer matches live. Carries the open revision onto current live as a ship rebases siblings: untouched text takes live's, text both edited becomes a conflict (resolve_conflict), and a ready / in-review revision whose text changed returns to draft (readiness_reset). Pass change when several are open; a revision already on live returns rebased: false. Details: get_spec({ topic: "rebase_revision" }).
get_blast_radius node_id, change, include_retired, include_dependent_decisions, detail, root
Call before changing a shipped node. Returns a summary by default: counts of its transitive dependents by type and of affected files, capabilities_at_risk, the 10 dependents with the highest fan-in, tests (the suites to run), and decision ids; detail "full" returns every dependent with hop distance, affected_files grouped by owner, rules_impact, and the decision rows, paged by the reply budget (next_page). Pass change instead of node_id for the merged radius of a change and its additivity (whether it only adds nodes or reopens shipped ones); change with node_id judges that node's open revision. include_retired and include_dependent_decisions widen the reply. Details: get_spec({ topic: "get_blast_radius" }).
unlink_nodes verbose, source_id, target_id, change, root
Call when an existing edge should go away. Removes the edge(s) from source to target; with an open revision it is a delta (change picks the revision), with change and no revision of it only that change's planned edges go. A contract write to a slot in state ready (territory text, added checklist items, claims, links) moves that slot back to draft and returns readiness_reset; self-ready it again after review. Ticking or unticking an existing item (toggle_checkboxes) never does. Details: get_spec({ topic: "unlink_nodes" }).
update_node_status verbose, node_id, new_status, scope, change, nodes, skip_review, skip_blocked, dry_run, revisions, root
Call when a node should move along the build or bug pipeline, including ship or resolved at handoff. Build: draft -> ready -> in-progress -> in-review -> ship (stable/unstable computed). Bug: open -> triaged -> fixing -> in-review -> resolved | wontfix. Three forms: node_id + new_status (one node; on a shipped node it moves one open revision, pass change when it has several); revisions: [...] (a batch, each item tried in order; when only some moved the result has partial: true and blocked_count, so check it); scope + new_status (all_open_updates, node_and_dependents, or change; validated before the first write; dry_run previews). To ship a change in one call: update_node_status({ scope: "change", change, new_status: "ship" }); nodes: [...] limits it to those members. A scoped walk is all-or-nothing unless skip_blocked: true; walking to ship past a node's in-review stop needs skip_review: true. Other scopes leave a node with several open revisions in needs_change_walk. Ship writes the revision over live and rebases its siblings; a revision with conflicts is Blocked at in-review and ship until resolve_conflict clears them. Moves to in-review and ship run the check's import and ownership rules; a decision-worthy revision with no decision recorded is Blocked: Decision (record_decision). Details: get_spec({ topic: "update_node_status" }).
force_unship verbose, node_id, confirm, new_status, root
Call only after the user confirms a mistaken ship; recovery only. Returns a shipped Foundation/Interaction/Interface to a pre-ship state (default ready). Requires confirm exactly "unship:<node_id>"; do not invent it. Blocked while the node has an open revision or shipped dependents. Details: get_spec({ topic: "force_unship" }).
setup_project ci, install_hook, root
Call when get_project's version or a Blocked: Version names setup_project, or the user asks to set up MindPlan. Creates the mindplan/ graph and writes no other file unless asked; returns { created, changed_files, ci?, hook?, pointer, guide }: the MINDPLAN.md text and the follow-up steps (an existing graph is left as is). Pass ci: "github" for the merge-gate workflow, install_hook: true for the Claude Code hook that keeps host file writes off mindplan/ (hook.offer says when it is missing). Blocked on a graph that needs upgrade_project. Details: get_spec({ topic: "setup_project" }).
upgrade_project install_hook, root
Call when get_project's version, a Blocked: Version, or the check names upgrade_project. Runs every idempotent migration and stamps mindplan/version.json; returns { from_level, to_level, changed_files, hook?, migrations, leftovers, pointer_outdated, pointer, guide }: delete the leftovers and follow the guide. Commit the upgrade on its own. Pass install_hook: true for the Claude Code hook that keeps host file writes off mindplan/ (hook.offer says when it is missing). Blocked without a graph (call setup_project) or when the graph is newer than this server. Details: get_spec({ topic: "upgrade_project" }).

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Files it wrote

Paths inside its sandbox, where its home folder is /tmp and its own folder cannot be written to.

Install facts

LicenseMIT
Needsnode >=22.13
Sourcegithub.com/nbiro/mindplan
Install scriptsonnxruntime-node, protobufjs declare them. This runner does not run them.
Tarballsha512-O/eHaZP6PLt+V5g6W05xe6M7NnZek6lqh/If90PXnpEAaOm1qQzVX6dCagHBBPvEoM06DAudyOjAoaNTRtrM7g==

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/mindplan-mcp.svg)](https://bragproof.smaverk.com/r/mindplan-mcp)

New version out? Ask for a fresh report.