# io.github.dcostenco/prism-coder (npm · prism-mcp-server)

Session memory for coding agents: local-first recall, drift detection, on-device inference.

- Trust score: 79/100 (medium)
- Change this week: −10
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-21

## Components

- npm · `prism-mcp-server`: 79/100 (this document), [markdown](https://verifymcp.io/servers/dcostenco-prism-coder/prism-mcp-server.md), [page](https://verifymcp.io/servers/dcostenco-prism-coder/prism-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `prism-mcp-server`
- Version: `20.21.13`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-21.

- **Supply Chain Security**: 50/100
  - No malware found by supply-chain analysis.
  - Known CVEs could not be checked: the version this server declares is not published in its registry.
  - Install-script check failed: the install command fetches or executes arbitrary code (inline_eval). An install hook runs on every machine, in CI, and on transitive installs, whether or not you ever run the server.
  - Dependency health could not be checked: the version this server declares is not published in its registry.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to dcostenco/prism-coder).
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 79/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 12351 tokens (~247/item across 50 items; 50 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 93/100
  - Stability observed for 28 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "deep_storage_purge" implies "purge" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 51 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.dcostenco/prism-coder MCP server?

io.github.dcostenco/prism-coder runs locally as an npm package, launched with npx -y prism-mcp-server. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add dcostenco-prism-coder -- npx -y prism-mcp-server
```

### Cursor

```json
{
  "mcpServers": {
    "dcostenco-prism-coder": {
      "command": "npx",
      "args": [
        "-y",
        "prism-mcp-server"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "dcostenco-prism-coder": {
      "command": "npx",
      "args": [
        "-y",
        "prism-mcp-server"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add dcostenco-prism-coder -- npx -y prism-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "dcostenco-prism-coder": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "prism-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add dcostenco-prism-coder --command npx --arg -y --arg prism-mcp-server
```

### Hermes

```yaml
mcp_servers:
  dcostenco-prism-coder:
    command: "npx"
    args: ["-y", "prism-mcp-server"]
```

### Netclaw

```json
{
  "McpServers": {
    "dcostenco-prism-coder": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "prism-mcp-server"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add dcostenco-prism-coder -t stdio -c npx -a -y prism-mcp-server
```

### Other

```json
{
  "mcpServers": {
    "dcostenco-prism-coder": {
      "command": "npx",
      "args": [
        "-y",
        "prism-mcp-server"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-21 (score 79, −10)

- [security regression] Stability: 0.90 → unverified
- [security regression] Known CVEs: pass → unverified
- [security regression] Tool safety: pass → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional regression] Dependency health: 0.92 → unverified
- [functional] Package version: 20.21.12 → 20.21.13

### 2026-09-20 (score 89, 0)

- [security regression] Known CVEs: pass → unverified
- [security regression] Stability: 0.87 → unverified
- [security regression] Tool safety: pass → unverified
- [functional regression] Dependency health: 0.92 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 20.21.8 → 20.21.12
- [functional] Package version: 20.21.8 → 20.21.11
- [functional] Package version: 20.21.8 → 20.21.10

### 2026-09-19 (score 89, +1)

- [security regression] Stability: 0.83 → unverified
- [security regression] Tool safety: pass → unverified
- [security regression] Malware scan: pass → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 20.21.6 → 20.21.8
- [functional] Package version: 20.21.6 → 20.21.7

### 2026-09-18 (score 88, +8)

- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → 0.92
- [functional] Stability: pass → 0.83

### 2026-09-17 (score 80, +1)

- [security regression] Stability: 0.97 → unverified
- [security regression] Tool safety: pass → unverified
- [security improvement] Known CVEs: unverified → pass
- [security] Stability: 0.97 → pass
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional improvement] Dependency health: unverified → 0.92
- [functional] Package version: 20.21.0 → 20.21.6
- [functional] Package version: 20.21.0 → 20.21.5
- [functional] Package version: 20.21.0 → 20.21.4
- [functional] Package version: 20.21.0 → 20.21.3
- [functional] Package version: 20.21.0 → 20.21.2

### 2026-09-16 (score 79, +4)

- [security regression] Known CVEs: pass → unverified
- [security regression] Stability: 0.93 → unverified
- [security regression] Tool safety: pass → unverified
- [security improvement] Malware scan: unverified → pass
- [functional regression] Dependency health: 0.92 → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 20.19.0 → 20.21.0
- [functional] Package version: 20.19.0 → 20.20.0

### 2026-09-15 (score 75, −14)

- [security regression] Malware scan: pass → unverified
- [functional] Package version: 20.18.1 → 20.19.0

### 2026-09-14 (score 89, +13)

- [security improvement] Malware scan: unverified → pass
- [functional] Stability: pass → 0.90

## MCP tools (50)

### `brave_web_search` (~126 tokens)

Performs a web search using the Brave Search API, ideal for general queries, news, articles, and online content. Use this for broad information gathering, recent events, or when you need diverse web sources. Supports pagination, content filtering, and freshness controls. Maximum 20 results per request, with offset for pagination.

Input parameters:

- `count` (number): Number of results (1-20, default 10)
- `offset` (number): Pagination offset (max 9, default 0)
- `query` (string, required): Search query (max 400 chars, 50 words)

### `brave_web_search_code_mode` (~232 tokens)

Performs a web search using the Brave Search API, and then runs a custom JavaScript code string against the RAW API RESPONSE in a secure QuickJS sandbox. This drastically reduces context window usage by only returning the output of your script. Use this for broad information gathering, recent events, or when you need diverse web sources and only need specific parts of the result. Your script should read the 'DATA' global variable (a JSON string of the API response), process it, and use console.log() to print the desired output.

Input parameters:

- `code` (string, required): JavaScript code to execute against the 'DATA' variable. E.g. `const r = JSON.parse(DATA); console.log(r.web.results.map(x => x.title).join(', '));`
- `count` (number): Number of results (1-20, default 10)
- `language` (string): Language of the code. Only 'javascript' is supported.
- `offset` (number): Pagination offset (max 9, default 0)
- `query` (string, required): Search query (max 400 chars, 50 words)

### `brave_local_search` (~127 tokens)

Searches for local businesses and places using Brave's Local Search API. Best for queries related to physical locations, businesses, restaurants, services, etc. Returns detailed information including:
\- Business names and addresses
\- Ratings and review counts
\- Phone numbers and opening hours
Use this when the query implies 'near me' or mentions specific locations. Automatically falls back to web search if no local results are found.

Input parameters:

- `count` (number): Number of results (1-20, default 5)
- `query` (string, required): Local search query (e.g. 'pizza near Central Park')

### `brave_local_search_code_mode` (~173 tokens)

Performs a local search using Brave APIs, and then runs a custom JavaScript code string against the RAW API RESPONSE in a secure QuickJS sandbox. This reduces context window usage by only returning the output of your script. Use this for local/business lookups when you only need specific fields from large local payloads. Your script should read the 'DATA' global variable (a JSON string payload) and use console.log() to print the desired output.

Input parameters:

- `code` (string, required): JavaScript code to execute against the 'DATA' variable.
- `count` (number): Number of results (1-20, default 5)
- `language` (string): Language of the code. Only 'javascript' is supported.
- `query` (string, required): Local search query (e.g. 'pizza near Central Park')

### `code_mode_transform` (~362 tokens)

A universal code-mode transformer. Takes RAW TEXT or JSON output from ANY MCP tool (GitHub, Firecrawl, chrome-devtools, camoufox, codegraphcontext, videoMcp, arxiv, etc.) and runs a custom JavaScript code string against it in a secure QuickJS sandbox. Use this as a second step after calling any tool that returns large payloads — pass the raw output as 'data' and a JS extraction script as 'code'. Your script reads the 'DATA' global variable (a string of the tool output) and uses console.log() to print only the fields you need. NEW in v2.1: Pass 'template' instead of 'code' for instant extraction. Available templates: github_issues, github_prs, jira_tickets, dom_links, dom_headings, api_endpoints, slack_messages, csv_summary. Example: { data: '<raw JSON>', template: 'github_issues' } — no custom code needed.

Input parameters:

- `code` (string): JavaScript code to execute. The 'DATA' global variable contains the raw data string. Use console.log() to output your extraction. Optional if using a template.
- `data` (string, required): The raw text or JSON output from another MCP tool to process.
- `language` (string): Language of the code. Only 'javascript' is supported.
- `source_tool` (string): Optional. Name of the MCP tool that produced the data (for logging/metrics only).
- `template` (string): Name of a pre-built extraction template. Use instead of writing custom 'code'. Options: github_issues, github_prs, jira_tickets, dom_links, dom_headings, api_endpoints, slack_messages, csv_summary.

### `brave_answers` (~73 tokens)

Returns direct AI answers grounded in Brave Search using Brave AI Grounding. Uses an OpenAI-compatible chat completions endpoint and is best for concise answer generation with live web grounding.

Input parameters:

- `model` (string): Model name for Brave AI Grounding (default: brave)
- `query` (string, required): Question or prompt to answer

### `gemini_research_paper_analysis` (~140 tokens)

Performs in-depth analysis of research papers using Google's Gemini-2.0-flash model. Ideal for academic research, literature reviews, and deep understanding of scientific papers. Can extract key findings, provide critical evaluation, summarize complex research, and place papers within the broader research landscape. Best for long-form academic content that requires expert analysis.

Input parameters:

- `additionalContext` (string): Optional additional context or specific questions to guide the analysis
- `analysisType` (string): Type of analysis to perform (summary, critique, literature review, key findings, or comprehensive)
- `paperContent` (string, required): The full text of the research paper to analyze

### `prism_infer` (~1247 tokens)

Run an inference on a local prism-coder model (Ollama) to save cloud tokens. Owns model selection across 27B / 9B / 4B / 2B using an explicit `model_ceiling` or the caller's `task_complexity`, then validates loaded memory size, model context, entitlements, installed models, and free RAM at call time. Falls through to the Synalux portal Gemini 3.6 Flash cloud fallback only when local is unviable or refused and the plan allows cloud; `cloud_fallback: false` forbids it. When `project` is provided, loads the dashboard-configured quick/standard/deep handoff and bounded history as untrusted historical context for a memory-aware local worker. Use this for code generation, summarisation, classification, or any synth task you would otherwise hand to the cloud model — it costs $0 when the local hit succeeds. For a FOLLOW-UP to an earlier prism_infer answer, pass the accepted prior turns as `messages` (paid plans): without them the worker answers the follow-up from nothing and fabricates. Every entitlement-resolved result reports `multi_turn` (your plan's caps) and `history_turns` (what was sent); the crisis intercept reports only `history_turns`. A behaviour-plan request also reports `clinical_sections` — how many required sections were found and which were not. That is a structural census, never a clinical endorsement: a section can be present and still be wrong, and a credentialed BCBA decides whether a plan is adequate. History over the plan's caps is refused (history_over_plan_cap), never trimmed; a free plan or a host with no portal is refused (multi_turn_not_in_plan). Hosts that compact large schemas may drop parameter text, so the contract lives here.

Input parameters:

- `allowed_tools` (array): Tool names advertised to the route model; well-formed calls outside this list are suppressed in route mode. Default: Prism's seven trained routing tools.
- `cloud_fallback` (boolean): Synalux portal cascade when local is unviable or refused. Omitted: the plan decides; false forbids it.
- `context_depth` (string): Project-memory depth; defaults to the dashboard setting when `project` is given.
- `conversation_id` (string): Conversation id from session_bootstrap (telemetry, continuity).
- `escalation` (string): 'serve' (default): safety refusals throw, gate-failed output may be served. 'report': every terminal path returns a structured gate_outcome; refused results come back as {status:'refused', output:''}…
- `evidence` (array): Snippets the output must be grounded in. With `verify: true`, every assertive claim (numbers, names, dates, codes, $ amounts) must be ENTAILED by a snippet or the draft is refused.
- `images` (array): Screenshots or frames: absolute file paths or raw base64. Needs a vision-capable tier; tiers without vision are skipped, never shown the prompt without the image.
- `max_tokens` (number): Max output tokens (default 1024, hard cap 8192).
- `messages` (array): Prior turns of THIS conversation, oldest first; `prompt` stays the current turn. Send only accepted turns, as a brief, not a transcript; text only. A paid Synalux plan feature: the plan sets turn and…
- `mode` (string): 'route' (default): MCP tool routing, fast, no thinking. 'chat': conversation, thinking on, cloud escalation on failure. 'code': code generation, thinking on, larger context. chat/code prefer the 27B…
- `model_ceiling` (string): Largest tier the picker may select; '9b' forbids 27B even if RAM allows.
- `project` (string): Prism project whose dashboard-depth handoff and recent session memory go to the local worker as historical data.
- `prompt` (string, required): The user prompt.
- `route_guard` (string): 'auto' (default): local advertised-tool contract plus, on paid plans, the private Synalux deterministic route correction. 'local': skips that correction only.
- `strict_entitlements` (boolean): Fail loud instead of running with ASSUMED free-tier limits: when entitlements fell back to free because the portal was unreachable (source='fallback_free'), throw instead of silently applying free cl…
- `system` (string): System instruction prepended to the prompt.
- `task_complexity` (number): 1-10 workload hint prism_infer (not the task router) uses to pick the initial local tier and thinking mode; explicit model_ceiling/think win.
- `temperature` (number): Sampling temperature; default 0 = deterministic.
- `think` (boolean): <think> reasoning. Default true for chat/code, false for route; better on complex tasks, adds ~2-5s.
- `timeout_ms` (number): Per-call timeout override. Default by tier: 27B 120s, 9B 60s, 4B 20s, 2B 15s.
- `verifier_model` (string): Verifier model override. Default qwen3.5:4b.
- `verifier_timeout_ms` (number): Verifier hard timeout override. Default 2000 ms.
- `verify` (boolean): L3 grounding verifier; default true when `evidence` is given. A second model (qwen3.5:4b by default) checks the draft against `evidence`; NEUTRAL or CONTRADICTED claims are refused.

### `session_bootstrap` (~349 tokens)

IMPORTANT: On the first user turn of every conversation, including a greeting, call this tool exactly once before any user-facing response, passing the user's verbatim first message as {prompt: "<first user message>"}. The prompt is matched against prompt_keywords ON-DEVICE to load symptom-triggered skills on turn one; it is used for routing only and never leaves the machine. Pass {} only when there is no user message. Do not substitute session_load_context when this tool is available. This starts a Prism-backed conversation without host hooks. Prism reads the dashboard's Auto-Load Projects, Context Depth (quick/standard/deep), developer name, and default role, then returns the greeting and correctly scoped prior-session context. Emit no preamble. Print the complete tool result verbatim as the entire first-turn startup display, before any optional answer. Do not summarize, paraphrase, rename headings, reformat, or omit any returned section. Preserve its order and line content. For a greeting-only prompt, stop after the verbatim startup display. Do not guess or pass a project or depth. Prism returns a stable conversation_id on the trailing <prism_session /> line; reuse it for session_save_ledger, session_save_handoff, and session_detect_drift throughout this conversation without adding it to the visible greeting.

Input parameters:

- `conversation_id` (string): Optional stable key for this conversation. When omitted, Prism generates one and returns it on the trailing <prism_session /> line.
- `prompt` (string): The user's verbatim first message. Matched against prompt_keywords ON-DEVICE for symptom-triggered skill routing; it is never transmitted. Omit only when there is no user message.

### `session_route_prompt` (~268 tokens)

Call this at the START of any turn where the user states a NEW task, changes the kind of work, or reports a defect — passing their verbatim message as {prompt: "..."} and the skills you already have as {loaded: [...]}. session_bootstrap routes only the first turn of a conversation; this routes every turn after it, so a long session still picks up the skills its current work requires. The prompt is matched ON-DEVICE against the same table and the same account-scoped frontmatter triggers; it never leaves the machine. Calling it is cheap: when nothing new matches it returns a single line, and anything named in `loaded` is never returned again. When it does return skills, read and follow them before doing the work — they are the rules for the task at hand, not background. Skip it only for follow-ups within work you have already routed.

Input parameters:

- `loaded` (array): Skill names already active in this conversation, including those from the first-turn startup display. Anything listed here is never returned again, which is what keeps repeat calls free.
- `project` (string): Optional project override. Omit to use the session's project.
- `prompt` (string, required): The user's verbatim message for this turn. Matched on-device; never transmitted.

### `skill_save` (~262 tokens)

Save a skill at one of three scopes: local (this machine only, works signed out), user (your account — follows you to every machine), or team (a workspace — delivered to its members; owner/admin only, optionally targeted with assign_to). Default when signed in is USER; team is never a default. Content must be a SKILL.md body with frontmatter (name, description). To make the skill load automatically when a prompt matches, add prompt_triggers to the frontmatter — a list of up to 5 case-insensitive regexes. They stay as private as the skill itself (matching happens on-device; scoped skills cannot use the public routing table):
  prompt_triggers:
    - "\\binvoice\\b.{0,20}\\bsubmit\\b"

Input parameters:

- `assign_to` (array): Team scope only (admin): deliver ONLY to these member user ids; omit for all members
- `content` (string, required): Full SKILL.md content including frontmatter
- `name` (string, required): Skill name (lowercase letters, digits, - and _)
- `scope` (string): Where the skill lives. Omit to default: user when signed in, local otherwise.
- `workspace_id` (string): Required for team scope

### `skill_manage` (~144 tokens)

Manage scoped skills and platform-skill activation. Actions: list (your skills, team skills, releases); delete (remove a user/team/local skill — the final content is archived locally first); release (deactivate a PLATFORM skill you never use, freeing host catalog budget — per user, or per team by admins); restore (re-activate a released platform skill; lossless).

Input parameters:

- `action` (string, required)
- `name` (string): Skill name (all actions except list)
- `scope` (string): delete: where the skill lives; release/restore: user (yourself) or team (admin)
- `workspace_id` (string): Required for team scope

### `session_save_ledger` (~211 tokens)

Save an immutable session log entry to the session ledger. Use this at the END of each work session to record what was accomplished. The ledger is append-only — entries cannot be updated or deleted. This creates a permanent audit trail of all agent work sessions.

Input parameters:

- `conversation_id` (string, required): Unique conversation/session identifier.
- `decisions` (array): Optional list of key decisions made during this session.
- `files_changed` (array): Optional list of files created or modified during this session.
- `project` (string, required): Project identifier (e.g. 'my-app', 'acme-api'). Used to group and filter sessions.
- `role` (string): Optional. Agent role for Hivemind scoping (e.g., 'dev', 'qa', 'pm'). Omit to let the server auto-resolve from dashboard settings.
- `summary` (string, required): Brief summary of what was accomplished in this session.
- `todos` (array): Optional list of open TODO items remaining after this session.

### `session_save_handoff` (~418 tokens)

Upsert the latest project handoff state for the next session to consume on boot. This is the 'live context' that gets loaded when a new session starts. Calling this replaces the previous handoff for the same project (upsert on project).

\**v5.4 CRDT Merge**: On version conflict, a CRDT OR-Map engine automatically merges your changes with concurrent work (Add-Wins OR-Set for arrays, Last-Writer-Wins for scalars). Pass expected_version to enable concurrency control.

\**v0.4.0 OCC**: If you received a version number from session_load_context, /resume_session prompt, or memory resource attachment, you MUST pass it as expected_version to prevent overwriting another session's changes.

Input parameters:

- `active_branch` (string): Git branch or context the next session should resume on.
- `conversation_id` (string): Optional. Session key for this conversation (same id used in session_load_context). When provided, the server verifies that session_load_context was called for this conversation before accepting the…
- `disable_merge` (boolean): Set to true to disable automatic CRDT merging and fail strictly on version conflict (original OCC behavior). Default: false.
- `expected_version` (integer): v0.4.0: The version number you received when loading context. Pass this to enable optimistic concurrency control. If omitted, version check is skipped (backward compatible).
- `key_context` (string): Free-form critical context the next session needs to know.
- `last_summary` (string): Summary of the most recent session — used for quick context recovery.
- `open_todos` (array): Current open TODO items that need attention in the next session.
- `project` (string, required): Project identifier — must match the project used in session_save_ledger.
- `role` (string): Optional. Agent role for Hivemind scoping (e.g., 'dev', 'qa', 'pm'). Omit to let the server auto-resolve from dashboard settings.

### `session_load_context` (~450 tokens)

Load session context for a project using progressive context loading. Use this for an explicit project reload, or as a startup fallback only when session_bootstrap is unavailable. When session_bootstrap is available, do not substitute this tool for the first-turn bootstrap. Three levels available:
\- **quick**: Just the latest project state — keywords and open TODOs (~50 tokens)
\- **standard**: Project state plus recent session summaries and decisions (~200 tokens, recommended)
\- **deep**: Everything — full session history with all files changed, TODOs, and decisions (~1000+ tokens)

Input parameters:

- `conversation_id` (string): Optional. Session key for this conversation (same id used in session_save_ledger). When provided, marks the session as context-loaded server-side so project-scoped tools can verify working context wi…
- `level` (string): How much context to load: 'quick' (just TODOs), 'standard' (recommended — includes recent summaries), or 'deep' (full history). Omit to use the Prism dashboard's Context Depth setting (safe fallback:…
- `max_tokens` (integer): Maximum token budget for context response. Uses 1 token ≈ 4 chars heuristic. When set, the response is truncated to fit within the budget. Default: unlimited.
- `project` (string, required): Project identifier to load context for.
- `prompt` (string): Optional. User prompt text for keyword-triggered skill loading. When provided, the server matches against prompt_keywords in the routing table and loads additional skills. Fires on every call — enabl…
- `role` (string): Optional. Agent role for Hivemind scoping (e.g., 'dev', 'qa', 'pm'). Omit to let the server auto-resolve from dashboard settings. When set, also injects active_team roster.
- `toolAction` (string, required): Brief 2-5 word summary of what this tool is doing. Capitalize like a sentence.
- `toolSummary` (string, required): Brief 2-5 word noun phrase describing what this tool call is about.

### `knowledge_search` (~255 tokens)

Search accumulated knowledge across all sessions by keywords, category, or free text. The knowledge base grows automatically as sessions are saved — keywords are extracted from every ledger and handoff entry. Use this to find related past work, decisions, and context from previous sessions.

Categories available: debugging, architecture, deployment, testing, configuration, api-integration, data-migration, security, performance, documentation, ai-ml, ui-frontend, resume

Input parameters:

- `activation` (object): Configuration for ACT-R inspired Spreading Activation. Use this to find structurally related memories beyond direct semantic/keyword hits.
- `category` (string): Optional category filter (e.g. 'debugging', 'architecture', 'ai-ml'). Filters results to sessions in this category.
- `enable_trace` (boolean): If true, returns a separate MEMORY TRACE content block with search strategy, latency breakdown, and scoring metadata for explainability. Default: false.
- `limit` (integer): Maximum results to return (default: 10, max: 50).
- `project` (string): Optional project filter. If omitted, searches across all projects.
- `query` (string, required): Free-text search query. Searched against session summaries using full-text search.

### `knowledge_forget` (~260 tokens)

Selectively forget (delete) accumulated knowledge entries. Like a brain pruning bad memories — remove outdated, incorrect, or irrelevant session entries to keep the knowledge base clean and relevant.

Forget modes:
\- **By project**: Clear all knowledge for a specific project
\- **By category**: Remove entries matching a category (e.g. 'debugging')
\- **By age**: Forget entries older than N days
\- **Full reset**: Wipe everything (requires confirm_all=true)

⚠️ This permanently deletes ledger entries. Handoff state is preserved unless explicitly cleared.

Input parameters:

- `category` (string): Optional: only forget entries in this category (e.g. 'debugging', 'resume').
- `clear_handoff` (boolean): Also clear the handoff (live state) for this project. Default: false.
- `confirm_all` (boolean): Set to true to confirm wiping ALL entries for the project (safety flag).
- `dry_run` (boolean): If true, only count what would be deleted without actually deleting. Default: false.
- `older_than_days` (integer): Optional: only forget entries older than this many days.
- `project` (string): Project to forget entries for. Required unless using confirm_all.

### `session_compact_ledger` (~186 tokens)

Auto-compact old session ledger entries by rolling them up into AI-generated summaries. This prevents the ledger from growing indefinitely and keeps deep context loading fast.

How it works:
1\. Finds projects with more entries than the threshold
2\. Summarizes old entries using Gemini (keeps recent entries intact)
3\. Inserts a rollup entry and archives the originals (soft-delete)

Use dry_run=true to preview what would be compacted without executing.

Input parameters:

- `dry_run` (boolean): If true, only preview what would be compacted without executing. Default: false.
- `keep_recent` (integer): Number of recent entries to keep intact (default: 10).
- `project` (string): Optional: compact a specific project. If omitted, auto-detects all candidates.
- `threshold` (integer): Minimum entries before compaction triggers (default: 50).

### `session_search_memory` (~273 tokens)

Search session history semantically (by meaning, not just keywords). Uses vector embeddings to find sessions with similar context, even when the exact wording differs. Requires pgvector extension in Supabase.

Complements knowledge_search (keyword-based) — use this when keyword search returns no results or when the query is phrased differently from stored summaries.

Input parameters:

- `activation` (object): Configuration for ACT-R inspired Spreading Activation. Use this to find structurally related memories beyond direct semantic/keyword hits.
- `context_boost` (boolean): If true, appends current project and working context to the search query before embedding generation, naturally biasing results toward contextually relevant memories. Useful when searching within a s…
- `enable_trace` (boolean): If true, returns a separate MEMORY TRACE content block with search strategy, latency breakdown (embedding vs storage), and scoring metadata. Default: false.
- `limit` (integer): Maximum results to return (default: 5, max: 20).
- `project` (string): Optional: limit search to a specific project.
- `query` (string, required): Natural language search query describing what you're looking for.
- `similarity_threshold` (number): Minimum similarity score 0-1 (default: 0.7). Higher = more relevant, fewer results.

### `memory_history` (~83 tokens)

View the timeline of past memory states for this project. Use this BEFORE memory_checkout to find the correct version to revert to. Shows version numbers, timestamps, and summaries of each saved state.

Input parameters:

- `limit` (number): Maximum number of history entries to return (default: 10, max: 50).
- `project` (string, required): Project identifier to view history for.

### `memory_checkout` (~94 tokens)

Time travel! Restores the project's memory to a specific past version. This overwrites the current handoff state with the historical snapshot, like a Git revert — the version number moves forward (no data is lost). Call memory_history first to find the correct target_version.

Input parameters:

- `project` (string, required): Project identifier to revert.
- `target_version` (number, required): The version number to restore from history (get this from memory_history).

### `session_save_image` (~135 tokens)

Save a local image file into the project's permanent visual memory. Use this to remember UI states, diagrams, architecture graphs, or bug screenshots. The image is copied into Prism's media vault and indexed in the handoff metadata. On the next session_load_context, the agent will see a lightweight index of available images.

Input parameters:

- `description` (string, required): What does this image show? Used for indexing and context display.
- `file_path` (string, required): Absolute or relative path to the image file (png, jpg, jpeg, webp, gif, svg).
- `project` (string, required): Project identifier — must match an existing project.

### `session_view_image` (~85 tokens)

Retrieve an image from visual memory using its ID. Returns the image as Base64 inline content for the LLM to analyze. Use session_load_context first to see available image IDs.

Input parameters:

- `image_id` (string, required): The short image ID (e.g., '8f2a1b3c') from the visual memory index.
- `project` (string, required): Project identifier.

### `session_health_check` (~157 tokens)

Run integrity checks on the agent's memory (like fsck for filesystems). Scans for missing embeddings, duplicate entries, orphaned handoffs, and stale rollups.

Checks performed:
1\. **Missing embeddings** — entries that can't be found via semantic search
2\. **Duplicate entries** — near-identical summaries wasting context tokens
3\. **Orphaned handoffs** — handoff state with no backing ledger entries
4\. **Stale rollups** — compaction artifacts with no archived originals

Use auto_fix=true to automatically repair missing embeddings and clean up orphans.

Input parameters:

- `auto_fix` (boolean): If true, automatically repair issues (backfill embeddings, remove orphaned handoffs). Default: false.

### `session_backfill_embeddings` (~162 tokens)

Repair ledger entries that are missing vector embeddings. This can happen if the Gemini API was temporarily unavailable when the entry was saved.

How it works:
1\. Scans for active ledger entries where embedding IS NULL
2\. Generates embeddings via Gemini text-embedding-004
3\. Patches each row with the generated embedding

Run this periodically or after known API outages to ensure full semantic search coverage.

Input parameters:

- `dry_run` (boolean): If true, only count missing embeddings without generating them. Default: false.
- `limit` (integer): Maximum entries to repair in one call (default: 20, max: 50). Keeps API costs predictable.
- `project` (string): Optional: repair only a specific project. If omitted, repairs all projects.

### `session_forget_memory` (~236 tokens)

Forget (delete) a specific memory entry by its ID. Supports two modes:

\- **Soft delete** (default): Tombstones the entry — it stays in the database for audit trails but is excluded from all search results. Reversible.
\- **Hard delete**: Permanently removes the entry from the database. Irreversible. Use only when GDPR Article 17 requires complete erasure.

⚠️ Soft delete is recommended for most use cases. The entry can be restored in the future if needed.

Input parameters:

- `hard_delete` (boolean): If true, permanently removes the entry (irreversible). If false (default), soft-deletes by setting deleted_at timestamp. Soft-deleted entries are excluded from searches but remain in the database.
- `memory_id` (string, required): The UUID of the memory (ledger) entry to forget. You can find this ID in search results returned by session_search_memory or knowledge_search.
- `reason` (string): Optional GDPR Article 17 justification for the deletion. Examples: 'User requested', 'Data retention policy', 'Outdated information'. Stored alongside the tombstone for audit trail purposes.

### `knowledge_set_retention` (~156 tokens)

Set an automatic data retention policy (TTL) for a project's memory. Entries older than ttl_days will be soft-deleted (archived) automatically on every server startup and every 12 hours while running.

\**Use cases:**
\- Set `ttl_days: 90` to auto-expire sessions older than 3 months
\- Set `ttl_days: 0` to disable auto-expiry (default)

\**Note:** Rollup/compaction entries are never expired — only raw sessions.

Input parameters:

- `project` (string, required): Project to set retention policy for.
- `ttl_days` (integer, required): Entries older than this many days are auto-expired. Set to 0 to disable. Minimum: 7 days when enabled.

### `session_save_experience` (~213 tokens)

Record a typed experience event. Unlike session_save_ledger (flat logs), this captures structured behavioral data for pattern detection.

Event Types:
\- **correction**: Agent was corrected by user
\- **success**: Task completed successfully
\- **failure**: Task failed
\- **learning**: New knowledge acquired
\- **validation_result**: Verification sandbox passed or failed

Input parameters:

- `action` (string, required): What action was tried.
- `confidence_score` (integer): Agent's confidence in the outcome (1-100).
- `context` (string, required): What the agent was doing when the event occurred.
- `correction` (string): What should have been done instead (for correction type).
- `event_type` (string, required): Type of behavioral event.
- `outcome` (string, required): What happened as a result.
- `project` (string, required): Project identifier.
- `role` (string): Optional. Agent role for Hivemind scoping. Omit to let the server auto-resolve from dashboard settings.

### `knowledge_upvote` (~57 tokens)

Upvote a memory entry to increase its importance (graduation). Entries with importance >= 7 become 'graduated' insights that always surface in behavioral warnings.

Input parameters:

- `id` (string, required): The UUID of the ledger entry to upvote.

### `knowledge_downvote` (~42 tokens)

Downvote a memory entry to decrease its importance. Importance cannot go below 0.

Input parameters:

- `id` (string, required): The UUID of the ledger entry to downvote.

### `knowledge_sync_rules` (~252 tokens)

Auto-sync graduated insights (importance >= 7) into your project's IDE rules file (.cursorrules or .clauderules). This bridges behavioral memory with static IDE context — turning dynamic agent learnings into always-on rules.

\**How it works:**
1\. Fetches graduated insights from the ledger
2\. Formats them as markdown rules inside sentinel markers
3\. Idempotently writes them into the target file at the project's configured repo_path

\**Requirements:** The project must have a repo_path configured in the dashboard.

\**Idempotency:** Uses `<!-- PRISM:AUTO-RULES:START -->` / `<!-- PRISM:AUTO-RULES:END -->` sentinel markers. Running this tool multiple times produces the same file. User-maintained content outside the sentinels is never touched.

Input parameters:

- `dry_run` (boolean): If true, returns a preview of the rules block without writing to disk. Default: false.
- `project` (string, required): Project identifier. Must have a repo_path configured in the dashboard.
- `target_file` (string): Target rules filename (default: '.cursorrules'). Common values: '.cursorrules', '.clauderules'.

### `deep_storage_purge` (~251 tokens)

v5.1 Deep Storage Mode: Purge high-precision float32 embedding vectors for entries that already have TurboQuant compressed blobs, reclaiming ~90% of vector storage. Only affects entries older than the specified threshold (default: 30 days, minimum: 7). Entries without compressed blobs are NEVER touched. Use dry_run=true to preview the impact before executing.

\**When to use:** After running TurboQuant backfill (session_backfill_embeddings), call this tool to reclaim disk space from legacy float32 vectors that are no longer needed for search.

\**Safety:** Tier-2 search (TurboQuant) maintains 95%+ accuracy with compressed blobs. Tier-3 (FTS5 keyword) search is completely unaffected.

Input parameters:

- `dry_run` (boolean): If true, reports eligible count and estimated byte savings without purging any data. Default: false.
- `older_than_days` (integer): Only purge entries older than this many days. Default: 30. Minimum: 7 (enforced). Entries younger than this threshold keep full float32 precision for Tier-1 native vector search.
- `project` (string): Optional project filter. When omitted, purges across all projects.

### `session_export_memory` (~333 tokens)

Export all of a project's memory to a local file. Fulfills GDPR Article 20 (Right to Data Portability) and the 'local-first' portability promise.

\**What is exported:**
\- All session ledger entries (summaries, decisions, TODOs, file changes)
\- Current handoff state (live project context)
\- System settings (API keys are "**REDACTED**" for security)
\- Visual memory index (descriptions, captions, timestamps; not the raw files)

\**Formats:**
\- `json` — machine-readable, suitable for import into another Prism instance
\- `markdown` — human-readable, ideal for static archiving
\- `vault` — Prism-Port: exports a compressed `.zip` of interrelated Markdown files with proper Obsidian/Logseq YAML frontmatter and `[[Wikilinks]]`

⚠️ Output directory must exist and be writable. Filenames are auto-generated: `prism-export-<project>-<date>.(json|md|zip)`

Input parameters:

- `format` (string): Export format: 'json' (single file), 'markdown' (single human doc), 'vault' / 'obsidian' / 'logseq' (zip with wikilinked .md files + YAML frontmatter — drop into your PKM vault). Default: json.
- `output_dir` (string, required): Absolute path to the directory where the export file(s) will be written. Must exist and be writable. Example: '~/Desktop'.
- `project` (string): Project to export. If omitted, exports ALL projects into separate files.

### `session_backfill_links` (~160 tokens)

Retroactively create graph edges (memory links) for all existing entries in a project. This builds the associative memory graph from your existing session history.

Three strategies are run:
1\. **Temporal Chaining**: Links consecutive entries within the same conversation
2\. **Keyword Overlap**: Links entries sharing ≥3 keywords (bidirectional)
3\. **Provenance**: Links rollup summaries to their archived originals

All strategies use INSERT OR IGNORE — safe to re-run multiple times.

\**When to use:** Run once after upgrading to v6.0 to populate the graph for existing memories. New entries are auto-linked on save (no manual action needed).

Input parameters:

- `project` (string, required): Project to backfill links for. Required.

### `session_synthesize_edges` (~213 tokens)

Step 3A Edge Synthesis: Scans recent project entries with embeddings, finds high-similarity but currently disconnected entries, and creates inferred links as 'synthesized_from'.

\**On-Demand Graph Enrichment**: Use this tool periodically to discover semantic relationships between structurally disconnected memory nodes. It batch processes the newest active entries.

Input parameters:

- `max_entries` (integer): Maximum number of recent entries to scan as sources. Default: 50. Max cap: 50.
- `max_neighbors_per_entry` (integer): Maximum number of links to synthesize per source entry. Default: 3. Max cap: 5.
- `project` (string, required): Project identifier.
- `randomize_selection` (boolean): If true, randomly sample active entries instead of taking the newest (default false). Ideal for wide-coverage background sweeps.
- `similarity_threshold` (number): Minimum cosine similarity score (0.0 to 1.0) to create a link. Default: 0.7.

### `session_cognitive_route` (~181 tokens)

Resolve an HDC compositional state into a nearest semantic concept with policy-gated routing. Returns concept, confidence, distance, ambiguity, convergence steps, and route outcome. Use this for explainable cognitive recall decisions in v6.5.

Input parameters:

- `action` (string, required): Action concept key used for transition binding.
- `clarify_threshold` (number): Optional route clarify threshold override (0 <= fallback < clarify <= 1).
- `explain` (boolean): If true, include expanded explainability details in the response. Default: true.
- `fallback_threshold` (number): Optional route fallback threshold override (0 <= fallback < clarify <= 1).
- `project` (string, required): Project identifier.
- `role` (string, required): Role concept key used for transition binding.
- `state` (string, required): Current state concept key (e.g. 'State:ActiveSession').

### `session_detect_drift` (~585 tokens)

Detect whether the current agent session has semantically drifted from its original goal. Scores recent ledger entries against the goal using synalux's HRR embedding stack (GloVe → Gemini/Voyage → cosine similarity), then runs the rolling-window drift detector algorithm.

\**Triggers:**
\- `goal-drift` — cumulative alignment loss is high and monotonic (not random tangents)
\- `context-collapse` — average output quality has dropped below floor

\**Pre-warning:**
\- `quality-degrading` — quality slope steeply negative before collapse

\**Returns:** drifted, reason, warning, drift_score (0..1), goal_alignment, quality_avg, sample_count, adaptive_threshold, recommendation.

Use alongside GATE 5 (60-minute drift check): call this tool instead of session_cognitive_route for goal-alignment drift detection.

Input parameters:

- `assessment_type` (string): BCBA domain only: assessment instrument name (e.g. 'vb-mapp', 'vineland', 'ablls-r').
- `behavior_functions` (array): BCBA domain only: identified behavior functions for this client (e.g. ['escape-maintained', 'attention-maintained']).
- `client_descriptors` (array): BCBA domain only: client-specific terms to check for specificity (e.g. ['7-year-old', 'aggression at transitions']).
- `contraindications` (array): BCBA domain only: known medical conditions (e.g. ['epilepsy', 'pica']).
- `conversation_id` (string): Optional. Session key (same id used in session_load_context). When provided, resets the server-side drift timer for this conversation.
- `domain` (string): Optional domain for domain-specific drift signals. 'coder' adds file_entropy, summary_vagueness, test_coverage_ratio, trajectory_divergence. 'bcba' adds clinical_specificity, function_aligned, contra…
- `goal` (string, required): The original session goal — the task you started this session to accomplish. Used as the semantic reference vector. Be specific: 'implement drift detection for prism-mcp' is better than 'work on pris…
- `min_directional_ratio` (number): Directional ratio floor for the tremor filter (0..1). Random topic tangents that return to the goal are suppressed below this threshold. Default 0.2. Set to 0 to disable filter.
- `project` (string, required): Project identifier. Must match the project used in session_save_ledger.
- `window_hours` (number): How many hours of ledger history to evaluate. Default 1. Range 0.083–24 (5 min to 24 h).

### `verify_behavior` (~171 tokens)

Call BEFORE editing behavioral source files (API routes, ordering logic, billing, auth, migrations). Returns a domain-specific scenario you must answer to demonstrate understanding of the end-user impact. Example: editing a KDS route returns 'A cook has a 3-item ticket. One item is voided. What should the cook see?' Answer the scenario concretely before proceeding with the edit. If the MCP transport is unavailable, use the packaged `prism verify-behavior` CLI fallback; never fabricate a replacement scenario.

Input parameters:

- `change_summary` (string, required): Brief description of the intended change.
- `file_path` (string, required): Path of the file about to be edited.
- `project` (string): Optional project identifier for workspace-scoped scenarios.
- `workspace_id` (string): Optional workspace ID for custom scenarios.

### `maintenance_vacuum` (~153 tokens)

Reclaim disk space after large purge operations by running VACUUM on the local SQLite database.

Best called after `deep_storage_purge` removes many entries — SQLite reclaims page allocations only when explicitly vacuumed, so the file size stays the same until you call this tool.

For remote (Supabase) backends, returns guidance on triggering maintenance via the dashboard.

\**Note:** On large databases this may take up to 60 seconds. The tool runs synchronously so you will know when it is safe to proceed.

Input parameters:

- `dry_run` (boolean): If true, reports the current database file size without running VACUUM. Use this to preview how large the database is before committing to a full vacuum.

### `onboarding_wizard` (~173 tokens)

Interactive setup wizard for new Prism users. Provides a step-by-step guided experience to get productive in under 3 minutes.

\**Actions:**
\- `start` (default when omitted) — Begin the wizard from step 1
\- `next` — Advance past `step` (pass the step number you are on)
\- `status` — Check current wizard progress
\- `skip` — Skip to completion

Each step returns instructions, code snippets, and progress percentage.

Input parameters:

- `action` (string): Wizard action to perform. Omitted = start.
- `ide_client` (string): IDE client for config generation.
- `project_name` (string): Optional project name to use in setup examples.
- `step` (integer): The step_index from the previous response; used by `next` and `status`.

### `extract_entities` (~134 tokens)

Extract named entities from raw text using rule-based + optional LLM extraction. Automatically identifies technologies, file paths, decisions, TODOs, people, projects, and configuration values without explicit tagging.

\**Entity types:** PERSON, PROJECT, TECH, FILE, DECISION, TODO, CONFIG

Use this to auto-enrich session context with structured metadata from raw conversation text.

Input parameters:

- `project` (string): Optional project to auto-save extracted entities to.
- `text` (string, required): Raw text to extract entities from.
- `use_llm` (boolean): If true, also uses local LLM for higher-quality extraction. Default: false.

### `api_analytics` (~117 tokens)

View API usage analytics per project or system-wide. Shows call counts, success rates, latency, token usage, top tools, and daily trends.

\**Scopes:**
\- `project` — Analytics for a specific project
\- `system` — System-wide aggregate analytics

Input parameters:

- `days` (integer): Number of days to analyze (default: 30).
- `project` (string): Project identifier (required when scope='project').
- `scope` (string, required): Analytics scope: 'project' for per-project, 'system' for global.

### `backup_database` (~168 tokens)

Create, list, or restore SQLite database backups.

\**Actions:**
\- `create` — Create a new backup now
\- `list` — List available backups with sizes and ages
\- `restore` — Restore from a specific backup file
\- `configure` — Set backup schedule (hourly/daily/weekly)

Backups are stored in ~/.prism/backups/ by default. Automatic retention pruning keeps only the configured maximum.

Input parameters:

- `action` (string, required): Backup action to perform.
- `backup_path` (string): Path to backup file (required for 'restore' action).
- `max_backups` (integer): Maximum number of backups to retain (for 'configure' action). Default: 7.
- `schedule` (string): Backup schedule (for 'configure' action).

### `configure_notifications` (~174 tokens)

Configure real-time notifications for memory events via webhook, Slack, or email.

\**Actions:**
\- `status` — Show current notification configuration
\- `add_channel` — Add a notification channel (webhook/slack/email)
\- `remove_channel` — Remove a channel by URL
\- `test` — Send a test notification to all configured channels

\**Events:** health_degradation, compaction_complete, backup_complete, backup_failed, memory_threshold, new_graduated_insight, scheduler_error

Input parameters:

- `action` (string, required): Configuration action to perform.
- `channel_type` (string): Channel type (for add_channel).
- `channel_url` (string): Channel URL (webhook endpoint, Slack webhook, or email relay).
- `min_severity` (string): Minimum severity to notify. Default: 'warning'.

### `query_memory_natural` (~243 tokens)

Query memories using natural language instead of structured tool syntax. Searches Prism memory first. When memory has no useful result, paid tiers automatically run one quick Synalux web search, preserve the raw sources, and synthesize a grounded answer through prism_infer. Reserved or uncertain content is cloud-or-refuse and never sent through the local web-grounded path.

\**Examples:**
\- "What did we decide about authentication?"
\- "What's still open on the billing project?"
\- "What files did we change last week?"
\- "Show me recent work on the API"

Returns the parsed intent, search results, and optionally an LLM-synthesized answer.

Input parameters:

- `conversation_id` (string): Optional session_bootstrap conversation id for inference telemetry and continuity.
- `project` (string): Optional project scope for the query.
- `question` (string, required): Natural language question about your memories.
- `synthesize` (boolean): If true, use prism_infer to synthesize a grounded answer. Default: true.
- `web_fallback` (boolean): If true, use one paid Synalux web search when Prism memory has no useful evidence. Default: true.

### `knowledge_ingest` (~219 tokens)

Ingest source code or documentation into the knowledge graph. Feed your codebase to Prism so knowledge_search can retrieve it at inference time. Accepts raw source code, file paths, or a git repo URL. The content is chunked, Q&A pairs are generated, and stored in the knowledge graph. Use this when the user says 'learn this code', 'index my repo', or 'ingest this file'.

Input parameters:

- `chunk_size` (number): Characters per chunk (default: 4000). Smaller chunks = more granular Q&A.
- `content` (string): Raw source code or documentation text to ingest. Max 50,000 chars.
- `file_path` (string): Local file path to read and ingest. Alternative to providing content directly.
- `project` (string, required): Project identifier for the knowledge namespace (e.g. 'my-backend', 'prism-aac').
- `source_label` (string): Human-readable label for the source (e.g. 'auth-middleware', 'payment-flow'). Used in search results.

### `inference_metrics` (~138 tokens)

Returns local-model inference metrics — call count, local vs cloud split, token totals, per-model breakdown, and average latency. period: 'session' (default) reports this MCP process's prism_infer delegation only. period: 'all' imports the Synalux VS Code panel spool and reports persisted MCP + panel usage across restarts, including the panel local-serve rate. This does not include the host model's (Claude's) own token spend (use /cost for that).

Input parameters:

- `period` (string): Metrics window: 'session' (this MCP process) or 'all' (durable MCP + VS Code panel ledger).

### `local_savings` (~260 tokens)

Reports what prism's local serving displaced, in TOKENS: volume handled by a local model instead of the cloud, calls served locally vs routed, and a per-model breakdown. Reports tokens, never money — prism cannot know your host's current rates, which model a call would otherwise have used, or whether you are on a flat plan, so any dollar figure would be invented. period: 'all' (default, durable ledger), 'month'/'week' (trailing 30/7 days), or 'session' (this MCP process); 'days' sets a custom trailing window. Excludes refused calls and states its known undercounts inline.

Input parameters:

- `days` (number): Custom trailing window in days — overrides period (ledger views only).
- `period` (string): Window: 'all' (default), 'month' (trailing 30 days), 'week' (trailing 7 days), or 'session'.
- `scope` (string): 'machine' (default) reads this machine's ledger. 'team' fetches the portal roll-up of workspace members who opted in to savings sync (paid plans).
- `workspace_id` (string): Workspace for scope 'team'. Omit to use your only/default workspace.

### `sync_pull_handoff` (~102 tokens)

Pulls this account's synced handoff for a project from the E2E relay and opens it with THIS machine's device key. The relay stores ciphertext only; a handoff is readable here only if it was sealed to this device. Requires handoff sync enabled (prism handoff enable), a paid plan, and a signed-in account. Push happens automatically on session_save_handoff.

Input parameters:

- `project` (string, required): Project whose handoff to pull.

### `session_task_route` (~330 tokens)

Analyze a coding task and recommend whether it should be handled by the host cloud model or delegated to Prism's local memory-aware worker (Qwen3). The `claw` target value is retained for API compatibility.

\**How to use:**
1\. Call this tool before delegating a bounded subtask
2\. Read the `target` field in the response
3\. If target is `claw`, call the returned `recommended_tool` (`prism_infer`) with `recommended_args`
4\. If target is `host`, handle the task yourself

Bounded high-complexity inference may still target `claw`; the forwarded 1-10 complexity selects 4B/9B/27B inside `prism_infer`. Architecture, security, host-tool workflows, and other reserved judgment remain on `host`.

\**v7.1.0/v7.2.0:** Uses deterministic keyword/scope heuristics.
When a project is specified, routing is enhanced by analyzing past experience events (success/failure/correction) to adjust confidence scores based on historical outcomes.

Input parameters:

- `estimated_scope` (string): Pre-categorize the task scope to improve routing accuracy. 'minor_edit' for small changes, 'new_feature' for scaffolding, 'refactor' for restructuring, 'bug_fix' for debugging.
- `files_involved` (array): Expected files to be created or modified by this task.
- `project` (string): Optional project identifier for context-aware routing.
- `task_description` (string, required): The raw prompt or task description to analyze for routing.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts. The full working is on the page: https://verifymcp.io/servers/dcostenco-prism-coder/prism-mcp-server#diagnostics

## Score history

- 2026-09-21: 79
- 2026-09-20: 89
- 2026-09-19: 89
- 2026-09-18: 88
- 2026-09-17: 80
- 2026-09-16: 79
- 2026-09-15: 75
- 2026-09-14: 89
- 2026-09-13: 76
- 2026-09-12: 88
- 2026-09-11: 88
- 2026-09-10: 88
- 2026-09-09: 87
- 2026-09-08: 87
- 2026-09-07: 88
- 2026-09-06: 87
- 2026-09-05: 88
- 2026-09-04: 87
- 2026-09-03: 90
- 2026-09-02: 74
- 2026-09-01: 89
- 2026-08-31: 88
- 2026-08-30: 88
- 2026-08-29: 88
- 2026-08-28: 87
- 2026-08-27: 72
- 2026-08-26: 86
- 2026-08-25: 86
- 2026-08-24: 86
- 2026-08-23: 85

## Common questions

### What is the io.github.dcostenco/prism-coder MCP server?

io.github.dcostenco/prism-coder is an MCP server listed in the public MCP registry as io.github.dcostenco/prism-coder. Session memory for coding agents: local-first recall, drift detection, on-device inference. This page covers its npm package (prism-mcp-server).

### Is the io.github.dcostenco/prism-coder MCP server safe to use?

io.github.dcostenco/prism-coder scores 79 out of 100 on VerifyMCP. It declares an install script we flagged as high risk. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.dcostenco/prism-coder MCP server expose?

io.github.dcostenco/prism-coder exposes 50 tools: brave_web_search, brave_web_search_code_mode, brave_local_search, brave_local_search_code_mode, code_mode_transform, and 45 more. Their descriptions and schemas cost roughly 11,333 tokens of context every time the server is loaded.

### Is the io.github.dcostenco/prism-coder MCP server still maintained?

io.github.dcostenco/prism-coder is still listed as active in the MCP registry. We last reached this channel on 21 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.dcostenco/prism-coder MCP server under?

io.github.dcostenco/prism-coder declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/prism-mcp-server
- Socket report: https://socket.dev/npm/package/prism-mcp-server
- Repository: https://github.com/dcostenco/prism-coder
- Changelog RSS feed: https://verifymcp.io/servers/dcostenco-prism-coder/prism-mcp-server.xml
- Changelog JSON feed: https://verifymcp.io/servers/dcostenco-prism-coder/prism-mcp-server.json
- HTML version of this page: https://verifymcp.io/servers/dcostenco-prism-coder/prism-mcp-server