getprismo 0.1.13 → 0.1.15

package/README.md

@@ -22,18 +22,21 @@ prismodev catches it before, during, and after.
 
 ## the loop
 
-prismodev is three commands that cover an entire coding session:
+prismodev covers the full AI coding session:
 
 ```
 before you code     npx getprismo doctor
 while you code      npx getprismo watch
+noisy commands      npx getprismo shield -- npm test
 after you code      npx getprismo cc timeline
+agent-native        npx getprismo mcp
 ```
 
 **doctor** diagnoses the repo, applies safe fixes, and shows the before/after score.
 **watch** monitors context pressure live and warns when things go wrong.
 **cc timeline** reconstructs what happened in the session so you learn from it.
 **shield** runs noisy commands without dumping full output back into the agent context.
+**mcp** exposes PrismoDev as local tools so compatible agents can scan, search shield output, and request scoped context directly.
 
 ---
 
@@ -179,6 +182,15 @@ npx getprismo shield search "auth expected 200"
 npx getprismo shield search "AUTH_FAILURE" --json
 ```
 
+when `watch` detects tool-output floods or repeated command loops, it now recommends this flow directly:
+
+```text
+Shield Plan
+Run: npx getprismo shield -- <noisy command>
+Then: npx getprismo shield search "<error text>"
+MCP: prismo_shield_run -> prismo_shield_search
+```
+
 this is intentionally not magic interception yet. it is a safe local-first primitive you can tell agents to use for noisy commands.
 
 ---
@@ -532,6 +544,7 @@ no install needed. npx runs it directly.
 | `optimize` | generate `.prismo/` context packs |
 | `context` | print paste-ready prompt for agents |
 | `shield` | run noisy commands while keeping full output out of chat |
+| `mcp` | expose PrismoDev tools over local MCP stdio |
 | `setup` | detect tools, logs, proxy readiness |
 | `usage` | show raw session token usage |
 | `init` | add npm scripts and .prismo/README.md |
@@ -583,6 +596,53 @@ npx getprismo shield last
 npx getprismo shield search "auth failure"
 ```
 
+### mcp mode
+
+```bash
+npx getprismo mcp
+npx getprismo mcp /path/to/repo
+```
+
+`mcp` starts a local stdio MCP server for agent clients. It exposes:
+
+- `prismo_scan`
+- `prismo_doctor_dry_run`
+- `prismo_watch_snapshot`
+- `prismo_shield_run`
+- `prismo_shield_search`
+- `prismo_shield_last`
+- `prismo_context_pack`
+- `prismo_firewall`
+- `prismo_cc_timeline`
+
+This lets an MCP-compatible agent search prior shielded test/build output, request scoped context packs, or inspect token-waste signals without pasting giant logs into the conversation.
+
+Generic MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "prismodev": {
+      "command": "npx",
+      "args": ["-y", "getprismo", "mcp", "/path/to/your/repo"]
+    }
+  }
+}
+```
+
+For local development from this repo:
+
+```json
+{
+  "mcpServers": {
+    "prismodev": {
+      "command": "node",
+      "args": ["/path/to/prismodev/bin/prismo.js", "mcp", "/path/to/your/repo"]
+    }
+  }
+}
+```
+
 ---
 
 ## cc modes
@@ -728,8 +788,10 @@ lib/prismo-dev/constants.js      shared defaults, pricing, patterns
 lib/prismo-dev/context-optimize.js  context packs, scoped prompts
 lib/prismo-dev/doctor.js         doctor/dev/init orchestration
 lib/prismo-dev/fixes.js          safe ignore/template generation
+lib/prismo-dev/mcp.js            local MCP server and Prismo tool bindings
 lib/prismo-dev/report.js         terminal, markdown, ci reports
 lib/prismo-dev/scan.js           repo scanning, scoring, readiness
+lib/prismo-dev/shield.js         local command shield and searchable output index
 lib/prismo-dev/usage-watch.js    local logs, watch, cost, timeline
 ```
 
@@ -739,8 +801,16 @@ lib/prismo-dev/usage-watch.js    local logs, watch, cost, timeline
 
 ```bash
 npx getprismo --help
+npx getprismo --version
 npx getprismo doctor --help
 npx getprismo watch --help
+npx getprismo shield --help
+npx getprismo mcp --help
 npx getprismo cc --help
 npx getprismo scan --help
 ```
+
+More docs:
+
+- [MCP setup and tools](docs/mcp.md)
+- [Live demo flow](docs/live-demo.md)

package/docs/live-demo.md

@@ -0,0 +1,115 @@
+# PrismoDev Live Demo
+
+Use this flow to show the full product loop on a real repo.
+
+## 1. Before Session: Doctor
+
+```bash
+npx getprismo doctor
+```
+
+Shows:
+
+- before/after repo score
+- missing `.claudeignore` / `.cursorignore`
+- generated artifacts exposed to AI context
+- compact `.prismo/` context packs
+- recommended next starting context
+
+## 2. During Session: Watch
+
+```bash
+npx getprismo watch --once
+```
+
+Shows:
+
+- context pressure
+- session size
+- recent context growth
+- repeated file reads
+- generated artifact leaks
+- possible loops
+- shield recommendation when command output is flooding context
+
+If watch sees noisy output, the important part is:
+
+```text
+Shield Plan
+Run: npx getprismo shield -- <noisy command>
+Then: npx getprismo shield search "<error text>"
+MCP: prismo_shield_run -> prismo_shield_search
+```
+
+## 3. Noisy Commands: Shield
+
+```bash
+npx getprismo shield -- npm test
+npx getprismo shield search "AUTH_FAILURE"
+npx getprismo shield last
+```
+
+Shows:
+
+- compact command summary
+- useful error lines
+- full output stored locally
+- searchable SQLite FTS index when `sqlite3` is available
+
+Full output stays in:
+
+```text
+.prismo/shield/runs/
+```
+
+## 4. Agent-Native Mode: MCP
+
+```bash
+npx getprismo mcp /path/to/repo
+```
+
+Demo prompt:
+
+```text
+Use Prismo MCP to run the failing test through shield. Search the stored output for the root error. Do not paste the full test log into the chat.
+```
+
+Expected MCP tool flow:
+
+1. `prismo_shield_run`
+2. `prismo_shield_search`
+3. `prismo_context_pack` if the agent needs scoped repo context
+
+## 5. After Session: Timeline
+
+```bash
+npx getprismo cc timeline
+```
+
+Shows:
+
+- generated artifacts that entered context
+- repeated file/path mentions
+- repeated command/tool patterns
+- suggested cleanup action
+
+## Screenshot Commands
+
+For a quick terminal screenshot:
+
+```bash
+npx getprismo doctor
+```
+
+For the proactive story:
+
+```bash
+npx getprismo watch --once
+```
+
+For the MCP/shield story:
+
+```bash
+npx getprismo shield -- npm test
+npx getprismo shield search "error"
+```

package/docs/mcp.md

@@ -0,0 +1,76 @@
+# PrismoDev MCP
+
+PrismoDev can run as a local MCP server so compatible coding agents can inspect token waste, run noisy commands through shield, search stored output, and request scoped context without pasting huge logs into chat.
+
+## Start
+
+```bash
+npx getprismo mcp /path/to/your/repo
+```
+
+## Generic MCP Config
+
+```json
+{
+  "mcpServers": {
+    "prismodev": {
+      "command": "npx",
+      "args": ["-y", "getprismo", "mcp", "/path/to/your/repo"]
+    }
+  }
+}
+```
+
+For local development from this repo:
+
+```json
+{
+  "mcpServers": {
+    "prismodev": {
+      "command": "node",
+      "args": ["/path/to/prismodev/bin/prismo.js", "mcp", "/path/to/your/repo"]
+    }
+  }
+}
+```
+
+## Tools
+
+- `prismo_scan`: scan repo context/token waste
+- `prismo_doctor_dry_run`: preview doctor payoff without writing files
+- `prismo_watch_snapshot`: inspect live context pressure
+- `prismo_shield_run`: run a noisy command and store full output locally
+- `prismo_shield_search`: search stored shield output
+- `prismo_shield_last`: list recent shielded command runs
+- `prismo_context_pack`: generate or preview scoped context packs
+- `prismo_firewall`: create a scoped context policy for a task
+- `prismo_cc_timeline`: inspect Claude Code session postmortems
+
+## Best Workflow
+
+Ask your agent:
+
+```text
+Run the failing test command through Prismo shield, then search the stored output for the real error. Do not paste the full log into chat.
+```
+
+The agent should call:
+
+1. `prismo_shield_run`
+2. `prismo_shield_search`
+
+This keeps full stdout/stderr in `.prismo/shield/runs/` and only brings the useful failure snippet back into the model context.
+
+## Watch Integration
+
+When `npx getprismo watch` detects a tool-output flood or repeated command loop, it now prints a Shield Plan:
+
+```text
+Shield Plan
+Tool output is flooding context; shield the command so full logs stay local.
+Run: npx getprismo shield -- <noisy command>
+Then: npx getprismo shield search "<error text>"
+MCP: prismo_shield_run -> prismo_shield_search
+```
+
+That is the intended live-session recovery path.

package/lib/prismo-dev/mcp.js

@@ -0,0 +1,264 @@
+function createTextResult(payload) {
+  const text = typeof payload === "string" ? payload : JSON.stringify(payload, null, 2);
+  return {
+    content: [{ type: "text", text }],
+  };
+}
+
+function normalizeArgs(args) {
+  return args && typeof args === "object" ? args : {};
+}
+
+function makeTool(name, description, properties = {}, required = []) {
+  return {
+    name,
+    description,
+    inputSchema: {
+      type: "object",
+      properties,
+      required,
+      additionalProperties: false,
+    },
+  };
+}
+
+function createMcpTools(deps) {
+  const {
+    rootDir,
+    scanRepo,
+    toJsonPayload,
+    runDoctor,
+    toDoctorJsonPayload,
+    getUsageSummary,
+    getClaudeCodeCostSummary,
+    runOptimize,
+    createOptimizeContext,
+    renderStarterPrompt,
+    runFirewall,
+    runShield,
+    runShieldLast,
+    runShieldSearch,
+  } = deps;
+
+  const pathProperty = {
+    type: "string",
+    description: "Repository path. Defaults to the repo used when the MCP server started.",
+  };
+  const limitProperty = {
+    type: "number",
+    description: "Maximum number of recent sessions or runs to inspect.",
+  };
+  const scopeProperty = {
+    type: "string",
+    description: "Optional scope such as frontend, backend, auth, tests, billing, or routing.",
+  };
+
+  const tools = [
+    makeTool("prismo_scan", "Scan a repo for AI coding token/context waste.", {
+      path: pathProperty,
+      includeUsage: { type: "boolean", description: "Include local Claude/Codex usage logs when available." },
+      limit: limitProperty,
+    }),
+    makeTool("prismo_doctor_dry_run", "Preview PrismoDev doctor fixes and before/after payoff without writing files.", {
+      path: pathProperty,
+      scope: scopeProperty,
+      limit: limitProperty,
+    }),
+    makeTool("prismo_watch_snapshot", "Return a one-shot local session/context pressure snapshot.", {
+      path: pathProperty,
+      tool: { type: "string", enum: ["all", "codex", "claude"], description: "Which local session logs to inspect." },
+      limit: limitProperty,
+    }),
+    makeTool("prismo_shield_run", "Run a noisy command through Prismo shield and store full output locally.", {
+      path: pathProperty,
+      command: {
+        type: "array",
+        items: { type: "string" },
+        description: "Command argv array, for example [\"npm\", \"test\"].",
+      },
+    }, ["command"]),
+    makeTool("prismo_shield_search", "Search stored shield stdout/stderr without loading full logs into context.", {
+      path: pathProperty,
+      query: { type: "string", description: "Text to search for in stored shield output." },
+      limit: limitProperty,
+    }, ["query"]),
+    makeTool("prismo_shield_last", "List recent shielded command runs.", {
+      path: pathProperty,
+      limit: limitProperty,
+    }),
+    makeTool("prismo_context_pack", "Generate or preview a scoped Prismo context pack/starter prompt.", {
+      path: pathProperty,
+      scope: scopeProperty,
+      dryRun: { type: "boolean", description: "When true, do not write .prismo files." },
+    }),
+    makeTool("prismo_firewall", "Generate a scoped context firewall policy for a task.", {
+      path: pathProperty,
+      task: { type: "string", description: "Task description such as auth-bug or frontend-test-failure." },
+      scope: scopeProperty,
+      dryRun: { type: "boolean", description: "When true, preview allowed/blocked context without writing files." },
+    }),
+    makeTool("prismo_cc_timeline", "Return the latest Claude Code session timeline/postmortem data.", {
+      path: pathProperty,
+      limit: limitProperty,
+    }),
+  ];
+
+  function resolveRoot(args) {
+    return args.path || rootDir || process.cwd();
+  }
+
+  async function callTool(name, rawArgs) {
+    const args = normalizeArgs(rawArgs);
+    const target = resolveRoot(args);
+
+    if (name === "prismo_scan") {
+      return createTextResult(toJsonPayload(scanRepo(target, {
+        includeUsage: Boolean(args.includeUsage),
+        usageLimit: Number(args.limit) || 5,
+      })));
+    }
+
+    if (name === "prismo_doctor_dry_run") {
+      const result = runDoctor(target, {
+        dryRun: true,
+        scope: args.scope || null,
+        limit: Number(args.limit) || 3,
+      });
+      return createTextResult(toDoctorJsonPayload(result));
+    }
+
+    if (name === "prismo_watch_snapshot") {
+      const summary = getUsageSummary({
+        cwd: target,
+        limit: Number(args.limit) || 3,
+        usageTool: args.tool || "all",
+      });
+      return createTextResult(summary);
+    }
+
+    if (name === "prismo_shield_run") {
+      return createTextResult(runShield(target, args.command));
+    }
+
+    if (name === "prismo_shield_search") {
+      return createTextResult(runShieldSearch(target, args.query, { limit: Number(args.limit) || 5 }));
+    }
+
+    if (name === "prismo_shield_last") {
+      return createTextResult(runShieldLast(target, { limit: Number(args.limit) || 5 }));
+    }
+
+    if (name === "prismo_context_pack") {
+      const scope = args.scope || null;
+      const result = runOptimize(target, { scope, dryRun: args.dryRun !== false });
+      const context = createOptimizeContext(target, scope);
+      return createTextResult({
+        ...result,
+        starterPrompt: renderStarterPrompt(context, scope),
+      });
+    }
+
+    if (name === "prismo_firewall") {
+      return createTextResult(runFirewall(target, {
+        task: args.task || args.scope || "general",
+        scope: args.scope || null,
+        dryRun: args.dryRun !== false,
+      }));
+    }
+
+    if (name === "prismo_cc_timeline") {
+      return createTextResult(getClaudeCodeCostSummary({
+        cwd: target,
+        limit: Number(args.limit) || 1,
+        mode: "timeline",
+      }));
+    }
+
+    throw new Error(`Unknown MCP tool: ${name}`);
+  }
+
+  return { tools, callTool };
+}
+
+function runMcpServer(deps) {
+  const readline = require("readline");
+  const { packageVersion = "0.0.0" } = deps;
+  const { tools, callTool } = createMcpTools(deps);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+  });
+
+  function send(message) {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+  }
+
+  async function handle(message) {
+    if (!message || !message.method) return;
+    if (!Object.prototype.hasOwnProperty.call(message, "id")) return;
+
+    try {
+      if (message.method === "initialize") {
+        send({
+          jsonrpc: "2.0",
+          id: message.id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "prismodev", version: packageVersion },
+          },
+        });
+        return;
+      }
+
+      if (message.method === "tools/list") {
+        send({ jsonrpc: "2.0", id: message.id, result: { tools } });
+        return;
+      }
+
+      if (message.method === "tools/call") {
+        const params = normalizeArgs(message.params);
+        const result = await callTool(params.name, params.arguments);
+        send({ jsonrpc: "2.0", id: message.id, result });
+        return;
+      }
+
+      send({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code: -32601, message: `Method not found: ${message.method}` },
+      });
+    } catch (error) {
+      send({
+        jsonrpc: "2.0",
+        id: message.id,
+        error: {
+          code: -32000,
+          message: error && error.message ? error.message : String(error),
+        },
+      });
+    }
+  }
+
+  rl.on("line", (line) => {
+    if (!line.trim()) return;
+    try {
+      handle(JSON.parse(line));
+    } catch (error) {
+      send({
+        jsonrpc: "2.0",
+        id: null,
+        error: {
+          code: -32700,
+          message: error && error.message ? error.message : String(error),
+        },
+      });
+    }
+  });
+}
+
+module.exports = {
+  createMcpTools,
+  runMcpServer,
+};

package/lib/prismo-dev/usage-watch.js

@@ -947,7 +947,7 @@ function getTokenBudgetStatus(activeSession, tokenBudget) {
 
 function getRecommendedWatchAction(activeSession, warnings) {
   if (!activeSession) return `${NPX_COMMAND} setup`;
-  if (activeSession.loopSuspicion) return "Pause the loop, summarize the failure once, then start a fresh scoped session.";
+  if (activeSession.estimatedToolTokens >= 150000 || activeSession.loopSuspicion) return `${NPX_COMMAND} shield -- <noisy command>`;
   if ((activeSession.generatedArtifacts || []).length || getActionableRepeatedPaths(activeSession, 1).length) return `${NPX_COMMAND} doctor`;
   if (activeSession.recentContextGrowth >= 250000) return "Start a fresh coding-agent session with a scoped Prismo context prompt.";
   if (warnings.some((warning) => warning.includes("Tool/output"))) return `${NPX_COMMAND} context`;
@@ -956,6 +956,41 @@ function getRecommendedWatchAction(activeSession, warnings) {
   return `${NPX_COMMAND} scan --usage`;
 }
 
+function buildShieldPlan(activeSession, liveAction) {
+  if (!activeSession || !liveAction) return null;
+  const shieldCauses = new Set(["tool-output-flood", "possible-loop"]);
+  const hasRepeatedCommand = Boolean(activeSession.repeatedCommands?.[0]);
+  const highToolOutput = activeSession.estimatedToolTokens >= 150000;
+  if (!shieldCauses.has(liveAction.cause) && !hasRepeatedCommand && !highToolOutput) return null;
+
+  const repeatedCommand = activeSession.repeatedCommands?.[0]?.value || null;
+  const cliCommand = repeatedCommand
+    ? `${NPX_COMMAND} shield -- ${repeatedCommand}`
+    : `${NPX_COMMAND} shield -- <noisy command>`;
+  const searchHint = liveAction.cause === "possible-loop"
+    ? "Search the stored output for the stable error text before rerunning the command."
+    : "Search the stored output for the failure token, filename, or exception instead of loading the full log.";
+
+  return {
+    reason: liveAction.cause === "possible-loop"
+      ? "Repeated command/output loop detected; shield the command and search stored output before reruns."
+      : "Tool output is flooding context; shield the command so full logs stay local.",
+    command: cliCommand,
+    commandTemplate: `${NPX_COMMAND} shield -- <command>`,
+    searchCommand: `${NPX_COMMAND} shield search "<error text>"`,
+    mcp: {
+      runTool: "prismo_shield_run",
+      searchTool: "prismo_shield_search",
+      workflow: "Call prismo_shield_run with the noisy command, then prismo_shield_search for the relevant error text.",
+    },
+    next: [
+      repeatedCommand ? `Run the command through shield: ${cliCommand}` : `Run the noisy command through shield: ${cliCommand}`,
+      searchHint,
+      "Give the agent the compact shield summary first; inspect full stdout/stderr only if needed.",
+    ],
+  };
+}
+
 function buildLiveAction(activeSession, warnings, budgetStatus = null) {
   if (!activeSession) {
     return {
@@ -1103,6 +1138,7 @@ function buildLiveSessionView(summary) {
   const actionableRepeatedPaths = activeSession ? getActionableRepeatedPaths(activeSession, 5) : [];
   const generatedArtifactGroups = activeSession ? summarizeGeneratedArtifacts(activeSession.generatedArtifacts || [], 5) : [];
   const liveAction = buildLiveAction(activeSession, warnings, budgetStatus);
+  const shieldPlan = buildShieldPlan(activeSession, liveAction);
   return {
     activeSession: activeSession
       ? {
@@ -1137,7 +1173,10 @@ function buildLiveSessionView(summary) {
     highestRisk: summary.sessions.reduce((risk, session) => (getRiskRank(session.contextRisk) > getRiskRank(risk) ? session.contextRisk : risk), "Low"),
     budget: budgetStatus,
     warnings,
-    liveAction,
+    liveAction: {
+      ...liveAction,
+      shieldPlan,
+    },
     recommendedAction: getRecommendedWatchAction(activeSession, warnings),
     nextCommands: Array.from(new Set([
       `${NPX_COMMAND} doctor`,
@@ -1316,6 +1355,14 @@ function renderWatchTerminal(summary) {
   lines.push(live.liveAction.summary);
   live.liveAction.now.slice(0, 4).forEach((step, index) => lines.push(`${index + 1}. ${step}`));
   if (live.liveAction.rescueAvailable) lines.push(`Rescue: ${live.liveAction.rescueCommand}`);
+  if (live.liveAction.shieldPlan) {
+    lines.push("");
+    lines.push("Shield Plan");
+    lines.push(live.liveAction.shieldPlan.reason);
+    lines.push(`Run: ${live.liveAction.shieldPlan.command}`);
+    lines.push(`Then: ${live.liveAction.shieldPlan.searchCommand}`);
+    lines.push(`MCP: ${live.liveAction.shieldPlan.mcp.runTool} -> ${live.liveAction.shieldPlan.mcp.searchTool}`);
+  }
   lines.push("");
   if (active.actionableRepeatedPaths?.length || active.generatedArtifactGroups?.length || active.repeatedCommands.length) {
     lines.push("Signals");
@@ -1366,6 +1413,13 @@ function renderRescuePrompt(summary) {
   lines.push("");
   lines.push("Do this now:");
   live.liveAction.now.forEach((step, index) => lines.push(`${index + 1}. ${step}`));
+  if (live.liveAction.shieldPlan) {
+    lines.push("");
+    lines.push("For noisy commands, use Prismo shield instead of loading full output into this chat:");
+    lines.push(`- CLI: ${live.liveAction.shieldPlan.command}`);
+    lines.push(`- Search stored output: ${live.liveAction.shieldPlan.searchCommand}`);
+    lines.push(`- MCP workflow: ${live.liveAction.shieldPlan.mcp.workflow}`);
+  }
   lines.push("");
   lines.push("Before reading or editing anything else, summarize:");
   lines.push("- files changed so far");
@@ -1405,6 +1459,11 @@ function renderLiveGuardrails(summary) {
   lines.push("## Effective Immediately");
   lines.push("");
   live.liveAction.now.forEach((step) => lines.push(`- ${step}`));
+  if (live.liveAction.shieldPlan) {
+    lines.push(`- Run noisy commands through Prismo shield: \`${live.liveAction.shieldPlan.command}\`.`);
+    lines.push(`- Search stored command output with: \`${live.liveAction.shieldPlan.searchCommand}\`.`);
+    lines.push(`- If MCP tools are available, use \`${live.liveAction.shieldPlan.mcp.runTool}\` then \`${live.liveAction.shieldPlan.mcp.searchTool}\`.`);
+  }
   lines.push("- Keep command output short; prefer filtered errors, small ranges, and summaries over full logs.");
   lines.push("- Do not read generated artifacts, lockfiles, caches, build output, coverage, or logs unless explicitly required.");
   lines.push("- Before broad exploration, summarize the current task, changed files, current failure, and next smallest useful file/test.");
@@ -1477,6 +1536,10 @@ function renderContextThrottle(summary) {
     live.liveAction.now.slice(0, 4).forEach((step) => lines.push(`- ${step}`));
     lines.push("- Keep the next tool call narrow enough to summarize in one screen.");
   }
+  if (live.liveAction.shieldPlan) {
+    lines.push(`- Run noisy commands through shield: \`${live.liveAction.shieldPlan.command}\`.`);
+    lines.push(`- Search shield output instead of reloading full logs: \`${live.liveAction.shieldPlan.searchCommand}\`.`);
+  }
   if (active?.actionableRepeatedPaths?.length) {
     lines.push("");
     lines.push("## Blocked Re-Reads");
@@ -1547,6 +1610,7 @@ function buildWatchEvent(summary) {
     toolOutputTokens: active.estimatedToolTokens || 0,
     budget,
     warnings: live.warnings || [],
+    shieldPlan: live.liveAction.shieldPlan || null,
     repeatedFiles: repeated.slice(0, 5),
     artifactGroups: artifacts.slice(0, 5),
     signature: signatureParts.join("::"),
@@ -1621,6 +1685,11 @@ function renderWatchReport(summary) {
   lines.push(`- Cause: ${live.liveAction.cause} (${live.liveAction.confidence} confidence)`);
   lines.push(`- ${live.liveAction.summary}`);
   live.liveAction.now.forEach((step) => lines.push(`- ${step}`));
+  if (live.liveAction.shieldPlan) {
+    lines.push(`- Shield noisy command output: \`${live.liveAction.shieldPlan.command}\``);
+    lines.push(`- Search shielded output: \`${live.liveAction.shieldPlan.searchCommand}\``);
+    lines.push(`- MCP workflow: \`${live.liveAction.shieldPlan.mcp.runTool}\` -> \`${live.liveAction.shieldPlan.mcp.searchTool}\``);
+  }
   if (summary.guardrailsPath) {
     lines.push(`- Guardrails: ${summary.guardrailsPath}`);
     lines.push(`- Rescue prompt: ${summary.rescuePath}`);

package/lib/prismo-dev-scan.js

@@ -3,6 +3,7 @@ const http = require("http");
 const https = require("https");
 const os = require("os");
 const path = require("path");
+const { version: PACKAGE_VERSION } = require("../package.json");
 
 const {
   HIGH_RISK_DIRS,
@@ -282,10 +283,13 @@ const {
   color,
 });
 
+const { runMcpServer } = require("./prismo-dev/mcp");
+
 function printHelp() {
   console.log(`Prismo CLI
 
 Usage:
+  prismo --version
   prismo dev [path]
   prismo init [--json] [--dry-run] [path]
   prismo doctor [--json] [--dry-run] [--apply-ignores-only] [--no-context-packs] [--limit N] [path]
@@ -293,6 +297,7 @@ Usage:
   prismo shield [--json] [path] -- <command ...>
   prismo shield last [--json] [--limit N] [path]
   prismo shield search <query> [--json] [--limit N] [path]
+  prismo mcp [path]
   prismo setup [--json] [--proxy-url URL] [path]
   prismo scan [--fix] [--ci] [--json] [--usage] [--simple] [--no-report] [path]
   prismo optimize [scope] [--json] [path]
@@ -308,6 +313,7 @@ Commands:
   doctor      Diagnose, safely optimize, re-scan, and show before/after payoff.
   firewall    Generate allowed/blocked context policy files for an AI coding task.
   shield      Run a noisy command, store full output locally, and return a compact summary.
+  mcp         Start a local MCP server exposing Prismo tools over stdio.
   scan        Run PrismoDev for Claude Code, Codex, Cursor, and AI coding workflows.
   optimize    Generate lightweight AI-readable project context files in .prismo/.
   context     Print a copy-pasteable compact context prompt for AI coding tools.
@@ -511,6 +517,28 @@ Examples:
 Output:
   Runs the command locally, stores full stdout/stderr under .prismo/shield/runs/, indexes output in SQLite FTS5 when available, and prints only a compact summary plus useful error lines.
   Search and last retrieve prior shield runs without re-feeding full output into agent context.`,
+    mcp: `Prismo MCP Server
+
+Usage:
+  prismo mcp [path]
+
+Examples:
+  prismo mcp
+  prismo mcp /path/to/repo
+
+Tools exposed:
+  prismo_scan
+  prismo_doctor_dry_run
+  prismo_watch_snapshot
+  prismo_shield_run
+  prismo_shield_search
+  prismo_shield_last
+  prismo_context_pack
+  prismo_firewall
+  prismo_cc_timeline
+
+Output:
+  Starts a local JSON-RPC MCP server over stdio. Use it from MCP-compatible clients so agents can scan context waste, search shielded command output, and request scoped context without loading huge logs into chat.`,
     ci: `Prismo CI
 
 Usage:
@@ -549,6 +577,10 @@ Good first command for people who want to see the value before scanning a repo.`
 
 async function runCli(argv) {
   const [command, ...rest] = argv;
+  if (command === "--version" || command === "-v" || command === "version") {
+    console.log(PACKAGE_VERSION);
+    return;
+  }
   if (!command || command === "--help" || command === "-h") {
     printHelp();
     return;
@@ -557,8 +589,8 @@ async function runCli(argv) {
     printCommandHelp(command);
     return;
   }
-  if (!["dev", "init", "doctor", "firewall", "shield", "setup", "scan", "optimize", "context", "cc", "usage", "watch", "demo"].includes(command)) {
-    throw new Error(`Unknown command: ${command}. Try: prismo doctor, prismo watch, prismo shield, prismo firewall, prismo init, prismo scan, prismo optimize, prismo context, prismo cc, or prismo usage`);
+  if (!["dev", "init", "doctor", "firewall", "shield", "mcp", "setup", "scan", "optimize", "context", "cc", "usage", "watch", "demo"].includes(command)) {
+    throw new Error(`Unknown command: ${command}. Try: prismo doctor, prismo watch, prismo shield, prismo mcp, prismo firewall, prismo init, prismo scan, prismo optimize, prismo context, prismo cc, or prismo usage`);
   }
 
   if (command === "demo") {
@@ -674,6 +706,28 @@ async function runCli(argv) {
     return;
   }
 
+  if (command === "mcp") {
+    const target = getPositionals(rest)[0] || process.cwd();
+    runMcpServer({
+      rootDir: path.resolve(target),
+      packageVersion: PACKAGE_VERSION,
+      scanRepo,
+      toJsonPayload,
+      runDoctor,
+      toDoctorJsonPayload,
+      getUsageSummary,
+      getClaudeCodeCostSummary,
+      runOptimize,
+      createOptimizeContext,
+      renderStarterPrompt,
+      runFirewall,
+      runShield,
+      runShieldLast,
+      runShieldSearch,
+    });
+    return;
+  }
+
   if (command === "setup") {
     const json = rest.includes("--json");
     const limitIndex = rest.indexOf("--limit");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getprismo",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Local AI coding workflow scanner for Codex, Claude Code, Cursor, and token-waste diagnostics.",
   "license": "MIT",
   "homepage": "https://github.com/shanirsh/prismodev#readme",
@@ -29,7 +29,7 @@
   "files": [
     "bin/",
     "lib/",
-    "docs/prismodev-user-testing.md",
+    "docs/",
     "README.md",
     "LICENSE",
     "NOTICE"