@mushi-mushi/mcp 0.21.0 → 0.22.0

package/dist/server.js

@@ -1,128 +1,1886 @@
 import {
   CODEBASE_TOOL_CATALOG,
+  MUSHI_SERVER_INSTRUCTIONS,
   TDD_TOOL_CATALOG,
   TOOL_CATALOG,
-  USE_MUSHI_INTENTS
-} from "./chunk-FNDGCFSJ.js";
+  routeUseMushiIntent
+} from "./chunk-RPSPV4FC.js";
 import {
   MUSHI_SERVER_METADATA
-} from "./chunk-EANW5YTI.js";
+} from "./chunk-FJRPC4VR.js";
 import {
   DEPRECATED_TOOL_ALIASES,
+  TOOL_FEATURE_MAP,
   toolMatchesFeatures
-} from "./chunk-XSL2FPLV.js";
+} from "./chunk-LFSAKI6Z.js";
 
 // src/server.ts
+import { AsyncLocalStorage } from "async_hooks";
 import { McpServer } from "@modelcontextprotocol/server";
 import { z } from "zod";
 import { createLogger } from "@mushi-mushi/core";
 
 // src/docs-index.ts
-var BASE = "https://kensaur.us/mushi-mushi/docs";
+var MUSHI_DOCS_BASE = "https://kensaur.us/mushi-mushi/docs";
+function docUrl(route) {
+  return route === "/" ? MUSHI_DOCS_BASE : MUSHI_DOCS_BASE + route;
+}
 var MUSHI_DOCS_INDEX = [
   {
-    title: "Architecture overview",
-    path: `${BASE}/concepts/architecture`,
-    keywords: ["architecture", "evolution loop", "pdca", "overview"],
-    excerpt: "How Mushi captures user-felt bugs, triages, dispatches fixes, and learns."
+    title: "Mushi Mushi \u2014 know why your AI-built app broke, with the fix ready",
+    url: docUrl("/"),
+    route: "/",
+    markdown: "index.md",
+    keywords: ["know", "ai-built", "app", "broke", "fix", "ready"],
+    headings: ["See it in action", "What this is (and is not)", "Get started with the SDK", "Install in your framework", "One queue. Sentry flows in, fixes flow out."],
+    excerpt: "Your AI shipped it. Mushi tells you why it broke: a plain-English diagnosis and a ready fix in your editor. Open source, Sentry optional."
+  },
+  {
+    title: "Admin console",
+    url: docUrl("/admin"),
+    route: "/admin",
+    markdown: "admin/index.md",
+    keywords: ["admin", "console"],
+    headings: ["Day-to-day", "Deeper surfaces"],
+    excerpt: "Guide to the Mushi admin console \u2014 the reports inbox, fix drafts and PRs, plain-English queries, and a link to every deeper page of the console."
+  },
+  {
+    title: "Activity",
+    url: docUrl("/admin/activity"),
+    route: "/admin/activity",
+    markdown: "admin/activity.md",
+    keywords: ["admin", "activity"],
+    headings: ["What you see", "Data source", "Related"],
+    excerpt: "The Activity page in the Mushi console shows end-user sessions, top routes, and identified versus anonymous users for a project over the last 30 days."
+  },
+  {
+    title: "Anomaly detection",
+    url: docUrl("/admin/anomalies"),
+    route: "/admin/anomalies",
+    markdown: "admin/anomalies.md",
+    keywords: ["admin", "anomalies", "anomaly", "detection"],
+    headings: ["Tabs", "Anomalies", "Metrics", "Detect", "Detection methods", "Auto-reporting", "API", "Related pages"],
+    excerpt: "The Anomaly detection page runs statistical detectors over the metrics you send and can file a report in your queue when one behaves unexpectedly."
+  },
+  {
+    title: "Anti-gaming",
+    url: docUrl("/admin/anti-gaming"),
+    route: "/admin/anti-gaming",
+    markdown: "admin/anti-gaming.md",
+    keywords: ["admin", "anti-gaming", "anti", "gaming"],
+    headings: ["How detection works", "Actions", "Velocity rules", "False positive rate", "Related pages"],
+    excerpt: "The Anti-gaming page flags reporters whose patterns look abusive \u2014 near-duplicate spam, reward farming or synthetic sessions \u2014 for you to review."
+  },
+  {
+    title: "Audit log",
+    url: docUrl("/admin/audit"),
+    route: "/admin/audit",
+    markdown: "admin/audit.md",
+    keywords: ["admin", "audit", "log"],
+    headings: ["What's logged", "Columns", "Hero metrics", "Filtering", "Expanding a row", "Export", "Common tasks", "Tracing an unexpected fix-worker action"],
+    excerpt: "The Audit log records every admin action and agent run in Mushi \u2014 who minted API keys, who dispatched a fix, and what triggered a pull request."
+  },
+  {
+    title: "Billing",
+    url: docUrl("/admin/billing"),
+    route: "/admin/billing",
+    markdown: "admin/billing.md",
+    keywords: ["admin", "billing"],
+    headings: ["Reading your usage card", "Usage breakdown", "Predictability controls", "Upgrading your plan", "Managing payment and invoices", "CLI parity", "Related docs"],
+    excerpt: "The Billing page shows your diagnosis quota, usage alerts at 50% and 80%, your projected bill, and spend caps for your Mushi plan."
+  },
+  {
+    title: "CLI device auth",
+    url: docUrl("/admin/cli-auth"),
+    route: "/admin/cli-auth",
+    markdown: "admin/cli-auth.md",
+    keywords: ["admin", "cli-auth", "cli", "auth", "device"],
+    headings: ["Related pages"],
+    excerpt: "The page that mushi login opens so you can approve a CLI device code while signed in to the console, and how the device authorization flow works."
+  },
+  {
+    title: "Code health",
+    url: docUrl("/admin/code-health"),
+    route: "/admin/code-health",
+    markdown: "admin/code-health.md",
+    keywords: ["admin", "code-health", "code", "health"],
+    headings: ["What you see", "Wiring CI ingest", "API", "Related pages"],
+    excerpt: "The Code health page charts bundle size and oversized files from your CI over time, so you notice an app getting heavier before your users do."
+  },
+  {
+    title: "Compliance",
+    url: docUrl("/admin/compliance"),
+    route: "/admin/compliance",
+    markdown: "admin/compliance.md",
+    keywords: ["admin", "compliance"],
+    headings: ["Navigating the page", "SOC 2 control evidence", "Data residency", "Retention policies", "Data Subject Access Requests (DSAR)", "Filing a DSAR", "DSAR workflow", "Common tasks"],
+    excerpt: "The Compliance page shows SOC 2 control status, retention policies and DSAR requests, and exports an evidence PDF for procurement reviews."
+  },
+  {
+    title: "Connect & Update",
+    url: docUrl("/admin/connect"),
+    route: "/admin/connect",
+    markdown: "admin/connect.md",
+    keywords: ["admin", "connect", "update"],
+    headings: ["ConnectStudio hero (3 lanes)", "Sections", "Native app CI secrets", "SDK upgrade PR", "Quick path (5 minutes)", "Connect GitHub", "Install SDK", "Wire MCP"],
+    excerpt: "Connect & Update wires GitHub, the SDK, MCP, the CLI and your editor to a Mushi project, and shows when your installed SDK is out of date."
+  },
+  {
+    title: "Content quality",
+    url: docUrl("/admin/content"),
+    route: "/admin/content",
+    markdown: "admin/content.md",
+    keywords: ["admin", "content", "quality"],
+    headings: ["Related pages"],
+    excerpt: "The Content quality page queues AI-generated copy, release notes and knowledge snippets that scored poorly or were flagged, so you can fix them."
+  },
+  {
+    title: "Cost & usage",
+    url: docUrl("/admin/cost"),
+    route: "/admin/cost",
+    markdown: "admin/cost.md",
+    keywords: ["admin", "cost", "usage"],
+    headings: ["What's tracked", "Charts", "Controlling costs", "Export", "Related pages"],
+    excerpt: "The Cost page shows LLM token use and estimated spend per model and pipeline for a Mushi project, so you can see what each diagnosis costs."
+  },
+  {
+    title: "Dashboard",
+    url: docUrl("/admin/dashboard"),
+    route: "/admin/dashboard",
+    markdown: "admin/dashboard.md",
+    keywords: ["admin", "dashboard"],
+    headings: ["What to look for first", "Flow canvas", "KPI tiles (14-day window)", "Charts row (14 days)", "Triage queue", "Insights row", "Common tasks", "Morning check (2 minutes)"],
+    excerpt: "The Mushi dashboard answers whether anything broke since your last release \u2014 new reports, overnight fix runs and pipeline health on one screen."
+  },
+  {
+    title: "Docs bridge",
+    url: docUrl("/admin/docs-bridge"),
+    route: "/admin/docs-bridge",
+    markdown: "admin/docs-bridge.md",
+    keywords: ["admin", "docs-bridge", "bridge"],
+    headings: ["How it works", "Status messages", "Security", "Related pages"],
+    excerpt: "The docs bridge is the console's silent sign-in relay that lets the Mushi docs site fill live snippets with your project details when you are signed in."
+  },
+  {
+    title: "Drift scanner",
+    url: docUrl("/admin/drift"),
+    route: "/admin/drift",
+    markdown: "admin/drift.md",
+    keywords: ["admin", "drift", "scanner"],
+    headings: ["When to run it", "Tab: Scanner", "If the scan fails", "Tab: Findings", "What to do with a critical finding", "Tab: Snapshots", "Common tasks", "Post-deploy check (the fast path)"],
+    excerpt: "The Drift scanner compares your live routes and components against the last snapshot to find the pages that a refactor silently broke."
+  },
+  {
+    title: "Experiments",
+    url: docUrl("/admin/experiments"),
+    route: "/admin/experiments",
+    markdown: "admin/experiments.md",
+    keywords: ["admin", "experiments"],
+    headings: ["Tabs", "Experiments", "New", "Experiment detail drawer", "Analysis results", "Bandit mode (Thompson Sampling)", "API", "Related pages"],
+    excerpt: "The Experiments page defines and runs A/B tests in Mushi and analyses them with CUPED variance reduction and sequential testing."
+  },
+  {
+    title: "Codebase Atlas",
+    url: docUrl("/admin/explore"),
+    route: "/admin/explore",
+    markdown: "admin/explore.md",
+    keywords: ["admin", "explore", "codebase", "atlas"],
+    headings: ["Tab groups", "Map views", "Graph", "Layers", "Search", "The detail panel", "Layer filter chips", "Stats bar"],
+    excerpt: "Visual, searchable map of every indexed source file \u2014 explore architectural layers, import dependencies, and find code by meaning."
+  },
+  {
+    title: "Feature board",
+    url: docUrl("/admin/feature-board"),
+    route: "/admin/feature-board",
+    markdown: "admin/feature-board.md",
+    keywords: ["admin", "feature-board", "feature", "board"],
+    headings: ["Related pages"],
+    excerpt: "The Feature board collects feature requests from support tickets so members can upvote them and you can mark them as shipped."
+  },
+  {
+    title: "Feedback hub",
+    url: docUrl("/admin/feedback"),
+    route: "/admin/feedback",
+    markdown: "admin/feedback.md",
+    keywords: ["admin", "feedback", "hub"],
+    headings: ["Related pages"],
+    excerpt: "The Feedback hub lists the support tickets filed from the console \u2014 active, shipped and all \u2014 with unread replies in one place."
+  },
+  {
+    title: "Fine-tuning",
+    url: docUrl("/admin/fine-tuning"),
+    route: "/admin/fine-tuning",
+    markdown: "admin/fine-tuning.md",
+    keywords: ["admin", "fine-tuning", "fine", "tuning"],
+    headings: ["Pipeline", "Stage details", "exporting \u2192 exported", "training \u2192 trained", "validating \u2192 validated / rejected", "promoted", "History tab", "Cost projection"],
+    excerpt: "The Fine-tuning page exports your best-scored classifications, trains a fine-tuned model, benchmarks it offline and promotes it to production."
+  },
+  {
+    title: "Fix drafts & PRs",
+    url: docUrl("/admin/fixes"),
+    route: "/admin/fixes",
+    markdown: "admin/fixes.md",
+    keywords: ["admin", "fixes", "fix", "drafts", "prs"],
+    headings: ["The fixes list", "Streaming view", "Spec-validation warnings", "Cursor Cloud Agent runs", "Dispatching a fix", "Webhooks", "CI feedback on open PRs", "Merging from the console"],
+    excerpt: "The Fixes page tracks every draft pull request Mushi opened from a bug report, from the moment a fix run starts until the PR is ready or the run fails."
+  },
+  {
+    title: "Full-stack audit",
+    url: docUrl("/admin/fullstack-audit"),
+    route: "/admin/fullstack-audit",
+    markdown: "admin/fullstack-audit.md",
+    keywords: ["admin", "fullstack-audit", "fullstack", "audit", "full-stack"],
+    headings: ["Scorecard sections", "Prerequisites", "CLI", "Related pages"],
+    excerpt: "The Full-stack audit runs one health check across RLS gaps, recent backend errors and API contract drift, and returns a readable scorecard."
+  },
+  {
+    title: "Knowledge graph",
+    url: docUrl("/admin/graph"),
+    route: "/admin/graph",
+    markdown: "admin/graph.md",
+    keywords: ["admin", "graph", "knowledge"],
+    headings: ["Node types", "Blast radius", "Surface mode", "Cypher console", "Keyboard shortcuts", "See also"],
+    excerpt: "The Knowledge graph page draws your project's bugs, components and fixes as an interactive graph, so you can see which areas cluster problems."
+  },
+  {
+    title: "Integration health",
+    url: docUrl("/admin/health"),
+    route: "/admin/health",
+    markdown: "admin/health.md",
+    keywords: ["admin", "health", "integration"],
+    headings: ["Time window", "LLM health summary", "Provider probes", "Cron job health", "Recent LLM calls log", "Recommended actions", "Related pages"],
+    excerpt: "The Integration health page monitors Mushi's LLM pipelines, cron jobs and provider connections so you catch a degraded integration early."
+  },
+  {
+    title: "Action inbox",
+    url: docUrl("/admin/inbox"),
+    route: "/admin/inbox",
+    markdown: "admin/inbox.md",
+    keywords: ["admin", "inbox", "action"],
+    headings: ["How it works", "Reading an action card", "Cleared stages strip", "Filtering by PDCA phase", "Common tasks", "Morning triage (the fast path)", "Understanding a stage chip colour", "When the Inbox seems wrong"],
+    excerpt: "The Action inbox gathers everything in Mushi that needs a human decision \u2014 reports, queue failures, health and drift alerts \u2014 in one list."
+  },
+  {
+    title: "Integrations",
+    url: docUrl("/admin/integrations"),
+    route: "/admin/integrations",
+    markdown: "admin/integrations.md",
+    keywords: ["admin", "integrations"],
+    headings: ["Hero", "Core platform integrations", "Sentry", "Langfuse", "GitHub", "Cursor Cloud", "Routing destinations", "Common tasks"],
+    excerpt: "Set up Mushi integrations from one page \u2014 send new bugs to Linear, bring in Sentry feedback, and open fix pull requests on your GitHub repo."
+  },
+  {
+    title: "Intelligence reports",
+    url: docUrl("/admin/intelligence"),
+    route: "/admin/intelligence",
+    markdown: "admin/intelligence.md",
+    keywords: ["admin", "intelligence", "reports"],
+    headings: ["What's in a report", "Schedule and delivery", "Regenerating on demand", "Cross-customer benchmarks", "PDF format", "See also"],
+    excerpt: "Intelligence reports are Mushi's weekly plain-English bug digest for each project \u2014 what broke, what got fixed and what to watch, sent to your inbox."
+  },
+  {
+    title: "User stories \xB7 Inventory",
+    url: docUrl("/admin/inventory"),
+    route: "/admin/inventory",
+    markdown: "admin/inventory.md",
+    keywords: ["admin", "inventory", "user", "stories"],
+    headings: ["What you see", "Run gates / Run crawler from a row", "SDK-driven discovery", "Surface mode in the graph", "Five gates", "Synthetic monitor", "Spec traceability \u2014 every fix carries the originating Action", "See also"],
+    excerpt: "The User stories page manages your inventory.yaml \u2014 every page, action and story your app should have \u2014 and shows which of them the gates cover."
+  },
+  {
+    title: "Iterate",
+    url: docUrl("/admin/iterate"),
+    route: "/admin/iterate",
+    markdown: "admin/iterate.md",
+    keywords: ["admin", "iterate"],
+    headings: ["Understanding the score", "Runs table", "Run detail drawer", "Score timeline", "Iterations list", "Succeeded run", "Creating a run", "Common tasks"],
+    excerpt: "The Iterate page queues improvement runs on a user flow \u2014 an agent tests the screens, finds friction and proposes changes for you to review."
+  },
+  {
+    title: "Judge dashboard",
+    url: docUrl("/admin/judge"),
+    route: "/admin/judge",
+    markdown: "admin/judge.md",
+    keywords: ["admin", "judge", "dashboard"],
+    headings: ["Trailing score panel", "Per-component breakdown", "Prompt A/B status", "Drift alerts", "See also"],
+    excerpt: "The Judge page scores how well Mushi's plain-English reads match reality over time, so you see quality slipping or a better prompt ready to promote."
+  },
+  {
+    title: "Lessons",
+    url: docUrl("/admin/lessons"),
+    route: "/admin/lessons",
+    markdown: "admin/lessons.md",
+    keywords: ["admin", "lessons"],
+    headings: ["The lifecycle: how a report becomes a rule", "Tab: Lessons", "When to retire a lesson", "Tab: Clusters", "Tab: Query Sim", "Common tasks", "Reviewing new candidates (weekly)", "After fixing a recurring bug"],
+    excerpt: "The Lessons page turns repeat fixes into rules \u2014 when the same root cause keeps returning, Mushi records it so your editor sees it on the next PR."
+  },
+  {
+    title: "Plugin marketplace",
+    url: docUrl("/admin/marketplace"),
+    route: "/admin/marketplace",
+    markdown: "admin/marketplace.md",
+    keywords: ["admin", "marketplace", "plugin"],
+    headings: ["Sections", "Available plugins", "Installed", "Recent deliveries", "Installing a plugin", "Managing installed plugins", "Signing verification", "First-party plugins"],
+    excerpt: "The Plugin marketplace installs outbound plugins such as PagerDuty, Linear and Zapier that receive Mushi webhook events for your project."
+  },
+  {
+    title: "MCP",
+    url: docUrl("/admin/mcp"),
+    route: "/admin/mcp",
+    markdown: "admin/mcp.md",
+    keywords: ["admin", "mcp"],
+    headings: ["Quickstart", "1. Generate an MCP-scoped API key", "2. Install the MCP server", "3. Use it", "Install snippets", ".cursor/mcp.json (stdio \u2014 recommended)", "Hosted HTTP (no local subprocess)", "Key status"],
+    excerpt: "The MCP page connects Cursor, Claude Code, Windsurf and other MCP clients to Mushi and lists the tools your agent can call from the editor."
+  },
+  {
+    title: "MCP OAuth consent",
+    url: docUrl("/admin/mcp-auth"),
+    route: "/admin/mcp-auth",
+    markdown: "admin/mcp-auth.md",
+    keywords: ["admin", "mcp-auth", "mcp", "auth", "oauth", "consent"],
+    headings: ["Related pages"],
+    excerpt: "The consent page the hosted Mushi MCP server opens when your editor signs in over OAuth \u2014 what you approve and how the authorization flow works."
+  },
+  {
+    title: "Notifications",
+    url: docUrl("/admin/notifications"),
+    route: "/admin/notifications",
+    markdown: "admin/notifications.md",
+    keywords: ["admin", "notifications"],
+    headings: ["What appears here", "Columns", "Marking as read", "Debugging delivery failures", "Configuring notification rules", "Related pages"],
+    excerpt: "The Notifications page lists every alert Mushi sent to reporters and team members for a project, so you can debug delivery or audit messages."
+  },
+  {
+    title: "Onboarding",
+    url: docUrl("/admin/onboarding"),
+    route: "/admin/onboarding",
+    markdown: "admin/onboarding.md",
+    keywords: ["admin", "onboarding"],
+    headings: ["Setup checklist", "Create a project", "Generate an API key", "Test the connection", "Install the SDK", "Go to dashboard", "CLI setup mode (?setup=cli)", "CliSetupGuide strip"],
+    excerpt: "Get your first real bug report into Mushi in about 10 minutes with the console onboarding checklist, from new project to classified report."
+  },
+  {
+    title: "Overview (portfolio)",
+    url: docUrl("/admin/overview"),
+    route: "/admin/overview",
+    markdown: "admin/overview.md",
+    keywords: ["admin", "overview", "portfolio"],
+    headings: ["What you see", "Data source", "Related"],
+    excerpt: "The Overview page is the organization-wide portfolio view \u2014 seven-day activity and open tickets for every connected project at a glance."
+  },
+  {
+    title: "Projects",
+    url: docUrl("/admin/projects"),
+    route: "/admin/projects",
+    markdown: "admin/projects.md",
+    keywords: ["admin", "projects"],
+    headings: ["Project card", "Creating a project", "API keys", "SDK install configurator", "Send test report", "Deleting a project", "Common tasks", "Connecting a new app (5 minutes)"],
+    excerpt: "Create a Mushi project, mint an API key, copy the install snippet for your framework and send a test report, all from the Projects page."
+  },
+  {
+    title: "Prompt lab",
+    url: docUrl("/admin/prompt-lab"),
+    route: "/admin/prompt-lab",
+    markdown: "admin/prompt-lab.md",
+    keywords: ["admin", "prompt-lab", "prompt", "lab"],
+    headings: ["The 4-step workflow", "KPI tiles", "Stage tabs", "Prompt table columns explained", "Actions per row", "Common tasks", "Fixing wrong component classification", "Investigating a bad judge score"],
+    excerpt: "The Prompt lab lets you edit, test and A/B compare the classification prompts behind Mushi's diagnoses before you promote a new version."
+  },
+  {
+    title: "QA Coverage",
+    url: docUrl("/admin/qa-coverage"),
+    route: "/admin/qa-coverage",
+    markdown: "admin/qa-coverage.md",
+    keywords: ["admin", "qa-coverage", "coverage", "qa"],
+    headings: ["Story lifecycle", "Execution providers", "Creating a story", "Story cards", "Story drawer", "Manual run", "Coverage report", "Related pages"],
+    excerpt: "QA Coverage turns user flows written in plain English into scheduled browser tests, so you find out when login or checkout breaks."
+  },
+  {
+    title: "Natural-language query",
+    url: docUrl("/admin/query"),
+    route: "/admin/query",
+    markdown: "admin/query.md",
+    keywords: ["admin", "query", "natural-language"],
+    headings: ["How it works", "Allow-listed tables", "Example questions", "Audit log", "Chart types", "Saved queries", "See also"],
+    excerpt: "Ask questions about your Mushi project's bug data in plain English \u2014 the Query page writes the SQL and draws the chart for you."
+  },
+  {
+    title: "Processing queue",
+    url: docUrl("/admin/queue"),
+    route: "/admin/queue",
+    markdown: "admin/queue.md",
+    keywords: ["admin", "queue", "processing"],
+    headings: ['What "dead-letter" means', "KPI tiles (14-day sparklines)", "Throughput chart", "Stage breakdown", "Item cards", "Bulk actions", "Common tasks", "Monday morning: 14 dead-letter items"],
+    excerpt: "The Processing queue shows reports waiting for classification, retries and dead-letter items, and lets you requeue the ones that failed."
+  },
+  {
+    title: "Real-time collaboration",
+    url: docUrl("/admin/realtime"),
+    route: "/admin/realtime",
+    markdown: "admin/realtime.md",
+    keywords: ["admin", "realtime", "real-time", "collaboration"],
+    headings: ["Presence", "Comments", "Writing a comment", "Editing and deleting", "Timestamps", "Notifications", "Audit log", "See also"],
+    excerpt: "How Mushi report pages support real-time collaboration \u2014 see who else is viewing a report and watch new comments arrive without a refresh."
+  },
+  {
+    title: "Releases",
+    url: docUrl("/admin/releases"),
+    route: "/admin/releases",
+    markdown: "admin/releases.md",
+    keywords: ["admin", "releases"],
+    headings: ["What it generates", "Creating a release", "Release entry fields", "SDK surface", "Related pages"],
+    excerpt: "The Releases page drafts a changelog for each version from the fixes that shipped, crediting the users whose reports led to each fix."
+  },
+  {
+    title: "Repo graph",
+    url: docUrl("/admin/repo"),
+    route: "/admin/repo",
+    markdown: "admin/repo.md",
+    keywords: ["admin", "repo", "graph"],
+    headings: ["Repo header", "Branch list", "Repo activity log", "Managing the GitHub connection", "API", "Related pages"],
+    excerpt: "The Repo page shows every fix branch in your connected GitHub repository \u2014 open PRs, CI status, and what the fix worker did on each branch."
+  },
+  {
+    title: "Reports & triage",
+    url: docUrl("/admin/reports"),
+    route: "/admin/reports",
+    markdown: "admin/reports.md",
+    keywords: ["admin", "reports", "triage"],
+    headings: ["Diagnosis + Fix hero", "Compact diagnosis preview", "Merging a fix from report detail"],
+    excerpt: "The Reports list is Mushi's bug inbox \u2014 filter by status, severity, category and component, and start with the recommended action at the top."
+  },
+  {
+    title: "Research",
+    url: docUrl("/admin/research"),
+    route: "/admin/research",
+    markdown: "admin/research.md",
+    keywords: ["admin", "research"],
+    headings: ["What it's for", "Running a search", "Saving results", "Prerequisites", "Related pages"],
+    excerpt: "The Research page runs a Firecrawl web search scoped to your tech stack and returns summarised answers with links to their sources."
+  },
+  {
+    title: "Rewards program",
+    url: docUrl("/admin/rewards"),
+    route: "/admin/rewards",
+    markdown: "admin/rewards.md",
+    keywords: ["admin", "rewards", "program"],
+    headings: ["How the pipeline works", "Overview tab", "One-click recommended defaults", "Activity Rules tab", "Custom rules", "Tier Ladder tab", "Contributors tab", "Quests tab"],
+    excerpt: "Set up the Mushi rewards program from the console \u2014 points for reporter activity, the tier ladder, and the perks your app grants at each tier."
+  },
+  {
+    title: "SDK health",
+    url: docUrl("/admin/sdk-health"),
+    route: "/admin/sdk-health",
+    markdown: "admin/sdk-health.md",
+    keywords: ["admin", "sdk-health", "sdk", "health"],
+    headings: ["What it shows", "Out-of-date detection", "Setup checklist integration", "Where it lives", "Related"],
+    excerpt: "The SDK health card shows the live heartbeat of every Mushi SDK that reported in the last 24 hours, so an SDK that never shipped is obvious."
+  },
+  {
+    title: "Settings",
+    url: docUrl("/admin/settings"),
+    route: "/admin/settings",
+    markdown: "admin/settings.md",
+    keywords: ["admin", "settings"],
+    headings: ["Tabs", "General", "BYOK (API keys)", "Firecrawl", "Browserbase", "Health", "Dev tools", "Changing a key"],
+    excerpt: "The Settings page holds every project option \u2014 notifications, your own LLM keys, widget copy, Slack alerts and developer settings."
+  },
+  {
+    title: "Setup Copilot",
+    url: docUrl("/admin/setup-copilot"),
+    route: "/admin/setup-copilot",
+    markdown: "admin/setup-copilot.md",
+    keywords: ["admin", "setup-copilot", "setup", "copilot"],
+    headings: ["Related pages"],
+    excerpt: "Setup Copilot is a guided checklist that verifies SDK ingest and fix dispatch for a project, with copy-paste CLI commands for each step."
+  },
+  {
+    title: "Skill Pipelines",
+    url: docUrl("/admin/skill-pipelines"),
+    route: "/admin/skill-pipelines",
+    markdown: "admin/skill-pipelines.md",
+    keywords: ["admin", "skill-pipelines", "skill", "pipelines"],
+    headings: ["How it works", "The three tabs", "Catalog", "Pipelines", "Sources", "Execution modes", "Triage links (?skill=)", "CLI quick reference"],
+    excerpt: "Skill Pipelines recommend agent skills from the cursor-kenji and skills.sh ecosystem for each classified bug and run them during review in Mushi."
+  },
+  {
+    title: "SSO",
+    url: docUrl("/admin/sso"),
+    route: "/admin/sso",
+    markdown: "admin/sso.md",
+    keywords: ["admin", "sso"],
+    headings: ["Supported protocols", "Registering an identity provider", "Providers table", "Disconnecting a provider", "End-user login flow", "API", "Related pages"],
+    excerpt: "Set up SAML 2.0 or OIDC single sign-on for your Mushi organization so teammates log in with your company's identity provider."
+  },
+  {
+    title: "Storage",
+    url: docUrl("/admin/storage"),
+    route: "/admin/storage",
+    markdown: "admin/storage.md",
+    keywords: ["admin", "storage"],
+    headings: ["Providers", "Configuring a custom bucket", "Required IAM permissions (S3)", "Required R2 permissions", "Required GCS permissions", "Data residency", "Related pages"],
+    excerpt: "The Storage page chooses where Mushi keeps report attachments and recordings \u2014 managed storage, or your own bucket for residency or cost."
+  },
+  {
+    title: "Teams and Members",
+    url: docUrl("/admin/teams"),
+    route: "/admin/teams",
+    markdown: "admin/teams.md",
+    keywords: ["admin", "teams", "members"],
+    headings: ["Plans", "Roles", "Invitation Flow"],
+    excerpt: "How teams work in Mushi \u2014 organizations own projects, billing, invitations and the member roster, and project access comes from membership."
+  },
+  {
+    title: "Users",
+    url: docUrl("/admin/users"),
+    route: "/admin/users",
+    markdown: "admin/users.md",
+    keywords: ["admin", "users"],
+    headings: ["Metrics row", "User directory", "User detail drawer", "API", "Related pages"],
+    excerpt: "The Users page is an operator-only directory of every Mushi account with plan, MRR and churn; other visitors see a not-found page instead."
+  },
+  {
+    title: "Voice intake",
+    url: docUrl("/admin/voice"),
+    route: "/admin/voice",
+    markdown: "admin/voice.md",
+    keywords: ["admin", "voice", "intake"],
+    headings: ["Turning it on", "The four ways in", "The confirmation gate", "Getting the answer back", "Telegram", "Recent voice requests", "Limits", "Self-hosting"],
+    excerpt: "Report a bug by voice from the Mushi console \u2014 say what is wrong, confirm the transcript, and a draft pull request is started for you."
+  },
+  {
+    title: "Blog",
+    url: docUrl("/blog"),
+    route: "/blog",
+    markdown: "blog/index.md",
+    keywords: ["blog"],
+    headings: [],
+    excerpt: "Notes from building Mushi Mushi \u2014 the real numbers behind the funnel, open-source licensing, launches, and how AI-built apps get debugged in practice."
+  },
+  {
+    title: "Mushi goes AGPLv3 \u2014 the honest open source story",
+    url: docUrl("/blog/agplv3-relicense"),
+    route: "/blog/agplv3-relicense",
+    markdown: "blog/agplv3-relicense.md",
+    keywords: ["blog", "agplv3-relicense", "agplv3", "relicense", "goes", "honest", "open", "source", "story"],
+    headings: ["What we actually want", "The decision", "What this changes", 'The honest "open source" claim'],
+    excerpt: "Why Mushi Mushi relicensed its server to AGPLv3 while keeping every SDK MIT \u2014 the open-core reasoning, what changes for self-hosters, and what stays free."
+  },
+  {
+    title: '60 seconds from "this is broken" to a draft PR \u2014 building Mushi Mushi',
+    url: docUrl("/blog/auto-fix-loop"),
+    route: "/blog/auto-fix-loop",
+    markdown: "blog/auto-fix-loop.md",
+    keywords: ["blog", "auto-fix-loop", "auto", "fix", "loop", "60", "seconds", "this", "broken", "draft", "pr", "building"],
+    headings: ["The 60-second loop", "Why we kept the human in the loop", "1. The judge is good. The judge is not infallible.", "2. The user's trust is the moat.", "What's actually open source", "Try it"],
+    excerpt: "How Mushi Mushi turns a one-sentence user complaint into a classified, deduped, AI-judged draft PR, and why the human stays in the loop the whole way."
+  },
+  {
+    title: "Launch Week 1 \u2014 five features, five days",
+    url: docUrl("/blog/launch-week-1"),
+    route: "/blog/launch-week-1",
+    markdown: "blog/launch-week-1.md",
+    keywords: ["blog", "launch-week-1", "launch", "week", "five", "features", "days"],
+    headings: ["The five", "Why now", "Numbers on Friday"],
+    excerpt: "Everything Mushi Mushi shipped in Launch Week 1 \u2014 one feature a day, from bug-report capture to editor-ready fixes, with demos and setup commands."
+  },
+  {
+    title: "I shipped a bug tool for 5 months and got 9 signups. Here's what the data said.",
+    url: docUrl("/blog/nine-signups-what-the-data-said"),
+    route: "/blog/nine-signups-what-the-data-said",
+    markdown: "blog/nine-signups-what-the-data-said.md",
+    keywords: ["blog", "nine-signups-what-the-data-said", "nine", "signups", "data", "said", "shipped", "bug", "tool", "months", "got", "here"],
+    headings: ["The numbers", "Three things I found when I looked", "What the data said", "What changed", "What happens next"],
+    excerpt: "Five months after launch, Mushi Mushi had 30 npm packages, an MCP server in every registry and nine signups. What the data said, and what changed."
+  },
+  {
+    title: "Changelog",
+    url: docUrl("/changelog"),
+    route: "/changelog",
+    markdown: "changelog.md",
+    keywords: ["changelog"],
+    headings: [],
+    excerpt: "What shipped in Mushi Mushi \u2014 new SDK releases, console features, MCP tools, and fixes, in plain English with dates."
+  },
+  {
+    title: "Mushi Cloud",
+    url: docUrl("/cloud"),
+    route: "/cloud",
+    markdown: "cloud.md",
+    keywords: ["cloud"],
+    headings: ["Plans", "Sign-up flow", "Why metered on diagnoses", "Spend controls", "Self-hosting"],
+    excerpt: "Hosted Mushi Mushi \u2014 bug reports, plain-English diagnoses, and fix dispatch without running servers. Free tier includes 50 diagnoses a month."
+  },
+  {
+    title: "Compare",
+    url: docUrl("/compare"),
+    route: "/compare",
+    markdown: "compare/index.md",
+    keywords: ["compare", "sentry", "jam", "posthog"],
+    headings: ["How these pages are written"],
+    excerpt: "Honest, dated comparisons of Mushi Mushi with Sentry, Jam and PostHog, plus Sentry alternatives for solo founders. Every number links to its source."
+  },
+  {
+    title: "Jam vs Mushi Mushi",
+    url: docUrl("/compare/jam-vs-mushi"),
+    route: "/compare/jam-vs-mushi",
+    markdown: "compare/jam-vs-mushi.md",
+    keywords: ["compare", "jam-vs-mushi", "jam"],
+    headings: ["What each one is", "Side by side", "Where they overlap", "Where they do not", "Using both", "Pick Jam if", "Pick Mushi if", "Frequently asked questions"],
+    excerpt: "Jam.dev vs Mushi Mushi in 2026 \u2014 a teammate recording a bug in the Jam extension versus a user reporting from your app, MCP handoff and free tiers."
+  },
+  {
+    title: "PostHog session replay vs Mushi Mushi",
+    url: docUrl("/compare/posthog-session-replay-vs-mushi"),
+    route: "/compare/posthog-session-replay-vs-mushi",
+    markdown: "compare/posthog-session-replay-vs-mushi.md",
+    keywords: ["compare", "posthog-session-replay-vs-mushi", "posthog", "session", "replay"],
+    headings: ["What each one is", "Side by side", "They work alongside each other", "Pick PostHog if", "Pick Mushi if", "Frequently asked questions"],
+    excerpt: "PostHog session replay vs Mushi Mushi in 2026 \u2014 every session recorded versus the one a user flagged as broken, free tiers, and why teams run both."
+  },
+  {
+    title: "Sentry alternatives for solo founders",
+    url: docUrl("/compare/sentry-alternatives-for-solo-founders"),
+    route: "/compare/sentry-alternatives-for-solo-founders",
+    markdown: "compare/sentry-alternatives-for-solo-founders.md",
+    keywords: ["compare", "sentry-alternatives-for-solo-founders", "sentry", "alternatives", "solo", "founders"],
+    headings: ["The table", "How to read it", "What this page does not claim", "Frequently asked questions"],
+    excerpt: "Sentry alternatives for solo founders in 2026 \u2014 Bugsnag, Rollbar, highlight.io, PostHog and Mushi compared on free tiers, self-hosting and AI fixes."
+  },
+  {
+    title: "Sentry vs Mushi Mushi",
+    url: docUrl("/compare/sentry-vs-mushi"),
+    route: "/compare/sentry-vs-mushi",
+    markdown: "compare/sentry-vs-mushi.md",
+    keywords: ["compare", "sentry-vs-mushi", "sentry"],
+    headings: ["What each one is", "Side by side", "Where they overlap, and where they do not", "Running Mushi alongside Sentry", "Pick Sentry if", "Pick Mushi if", "Frequently asked questions"],
+    excerpt: "Sentry vs Mushi Mushi in 2026 \u2014 what each captures, Sentry's free tier and Seer pricing next to Mushi's 50 free diagnoses a month, and running both."
+  },
+  {
+    title: "Concepts",
+    url: docUrl("/concepts"),
+    route: "/concepts",
+    markdown: "concepts/index.md",
+    keywords: ["concepts"],
+    headings: ["Primary paths", "Everything else"],
+    excerpt: "Mushi's core ideas in one place \u2014 capture, plain-English diagnosis, dedupe into one row, optional agent fixes, verification, and lessons it remembers."
+  },
+  {
+    title: "Agent contract",
+    url: docUrl("/concepts/agent-contract"),
+    route: "/concepts/agent-contract",
+    markdown: "concepts/agent-contract.md",
+    keywords: ["concepts", "agent-contract", "agent", "contract"],
+    headings: ["The evolution loop (what you're plugging into)", "What the agent reads before opening a PR", "What the agent does after merging the PR", "What Mushi commits to in return", "Self-bootstrap (Claude Code and similar)", "Privacy contract", "Scopes"],
+    excerpt: "What Mushi expects an agent to read before opening a PR, and what it promises in return."
+  },
+  {
+    title: "Anti-gaming & reputation",
+    url: docUrl("/concepts/anti-gaming"),
+    route: "/concepts/anti-gaming",
+    markdown: "concepts/anti-gaming.md",
+    keywords: ["concepts", "anti-gaming", "anti", "gaming", "reputation"],
+    headings: ["Reporter reputation", "Anti-gaming detection", "Report fatigue prevention"],
+    excerpt: "How Mushi keeps bug reports honest \u2014 reporter reputation against spam and point farming, and prompt-fatigue limits so real users are not nagged."
+  },
+  {
+    title: "Architecture",
+    url: docUrl("/concepts/architecture"),
+    route: "/concepts/architecture",
+    markdown: "concepts/architecture.md",
+    keywords: ["concepts", "architecture"],
+    headings: ["Wire-level flow", "Component summary", "MCP surface (2026)", "Connect & Update (console)", "Knowledge graph", "A2A Agent Card", "Data residency", "Storage"],
+    excerpt: "How Mushi is built \u2014 a Hono gateway in front of Supabase, the edge functions behind it, and the relational, vector and graph stores that hold each report."
+  },
+  {
+    title: "Mushi Bounties \u2014 crowd-testing marketplace",
+    url: docUrl("/concepts/bounty-marketplace"),
+    route: "/concepts/bounty-marketplace",
+    markdown: "concepts/bounty-marketplace.md",
+    keywords: ["concepts", "bounty-marketplace", "bounty", "marketplace", "bounties", "crowd-testing"],
+    headings: ["How it works", "Publish your app", "Testers find your app", "Testers submit bugs", "You review and grade", "Testers redeem", "Reward model and legal posture", "Anti-gaming and reputation"],
+    excerpt: "Mushi Bounties is a crowd-testing marketplace \u2014 publish your app, and real testers file bug reports and earn points they can redeem for rewards."
+  },
+  {
+    title: "How Mushi reads a bug report",
+    url: docUrl("/concepts/classification"),
+    route: "/concepts/classification",
+    markdown: "concepts/classification.md",
+    keywords: ["concepts", "classification", "reads", "bug", "report"],
+    headings: ["Outputs", "Vision air-gap", "BYOK"],
+    excerpt: "How Mushi turns a raw bug report and screenshot into a plain-English diagnosis \u2014 the fast filter, the text and vision stages, and what gets stored."
+  },
+  {
+    title: "Closed-loop evolution \u2014 the thesis",
+    url: docUrl("/concepts/closed-loop"),
+    route: "/concepts/closed-loop",
+    markdown: "concepts/closed-loop.md",
+    keywords: ["concepts", "closed-loop", "closed", "loop", "evolution", "thesis"],
+    headings: ["The NTSB moment software is missing", "Why the linear SDLC is the wrong unit", "Cumulative selection: why it works", "What the loop looks like in practice", "What this means for the roadmap"],
+    excerpt: "The thesis behind Mushi \u2014 why AI-built apps need a closed loop from what users feel to a verified fix, and how capture, diagnosis and fixes connect."
+  },
+  {
+    title: "Project ID & API keys",
+    url: docUrl("/concepts/credentials"),
+    route: "/concepts/credentials",
+    markdown: "concepts/credentials.md",
+    keywords: ["concepts", "credentials", "project", "id", "api", "keys"],
+    headings: ["API key scopes", "Project ID", "API key", "API endpoint", "Environment variable names"],
+    excerpt: "Where to find your Mushi project ID and API key, what the report:write and mcp scopes allow, the one mushi_ key format, and env var names per framework."
+  },
+  {
+    title: "API error catalog",
+    url: docUrl("/concepts/error-catalog"),
+    route: "/concepts/error-catalog",
+    markdown: "concepts/error-catalog.md",
+    keywords: ["concepts", "error-catalog", "error", "catalog", "api"],
+    headings: ["Why codes exist", "Codes you will see often", "Console feedback", "SDK reporters", "Drift gate"],
+    excerpt: "Stable error codes returned by the Mushi API envelope, how to read them in the console, and how they correlate with Sentry and Langfuse."
+  },
+  {
+    title: "The evolution loop \u2014 how Mushi closes the cycle",
+    url: docUrl("/concepts/evolution-loop"),
+    route: "/concepts/evolution-loop",
+    markdown: "concepts/evolution-loop.md",
+    keywords: ["concepts", "evolution-loop", "evolution", "loop", "closes", "cycle"],
+    headings: ["Why vibe coding needs a closing loop", "The five stages", "\u2460 Capture", "\u2461 Classify", "\u2462 Fix", "\u2463 Verify", "\u2464 Remember", "How to see the loop close"],
+    excerpt: "The five stages that turn a user-felt bug into a merged fix and a lesson rule \u2014 the loop that improves your app without Jira, QA teams or PM bottlenecks."
+  },
+  {
+    title: "Fix drafts & PRs",
+    url: docUrl("/concepts/fix-orchestrator"),
+    route: "/concepts/fix-orchestrator",
+    markdown: "concepts/fix-orchestrator.md",
+    keywords: ["concepts", "fix-orchestrator", "fix", "orchestrator", "drafts", "prs"],
+    headings: ["Flow", "Sandbox providers", "Agent contract", "Credential scoping", "Spec traceability \u2014 inventoryAction end-to-end", "What the worker now does", "expectedoutcome shape", "Carrying the anchor through external surfaces"],
+    excerpt: "What happens when you dispatch a fix \u2014 Mushi runs a coding agent in a sandbox and opens a draft pull request with a rationale and CI status to review."
+  },
+  {
+    title: "Inventory and gates (v2)",
+    url: docUrl("/concepts/inventory-and-gates"),
+    route: "/concepts/inventory-and-gates",
+    markdown: "concepts/inventory-and-gates.md",
+    keywords: ["concepts", "inventory-and-gates", "inventory", "gates", "v2"],
+    headings: ["The model", "Five gates", "Discovery \u2014 the SDK proposes the inventory", "Synthetic monitor", "Surface mode in the graph", "Spec traceability \u2014 read AND write side", "Where each link lives", "Related packages"],
+    excerpt: "Mushi v2's inventory.yaml lists every page, story and action in your app, and five composite gates fail the build when a change breaks that contract."
+  },
+  {
+    title: "Judge & self-improvement",
+    url: docUrl("/concepts/judge-loop"),
+    route: "/concepts/judge-loop",
+    markdown: "concepts/judge-loop.md",
+    keywords: ["concepts", "judge-loop", "judge", "loop", "self-improvement"],
+    headings: ["1. Judge", "2. Prompt A/B testing", "3. Fine-tune export", "4. Drift detection", "See also"],
+    excerpt: "How Mushi's classifier improves itself \u2014 a nightly judge scores yesterday's reads, prompts are A/B tested, and drift is caught before it reaches you."
+  },
+  {
+    title: "Knowledge graph",
+    url: docUrl("/concepts/knowledge-graph"),
+    route: "/concepts/knowledge-graph",
+    markdown: "concepts/knowledge-graph.md",
+    keywords: ["concepts", "knowledge-graph", "knowledge", "graph"],
+    headings: ["Storage", "Why both pgvector and AGE?", "Indexing", "Bug Ontology"],
+    excerpt: "How Mushi links reports, components, fixes and developers in a per-project knowledge graph, with pgvector for similarity and Apache AGE for traversal."
+  },
+  {
+    title: "Multi-repo coordinated fixes",
+    url: docUrl("/concepts/multi-repo-fixes"),
+    route: "/concepts/multi-repo-fixes",
+    markdown: "concepts/multi-repo-fixes.md",
+    keywords: ["concepts", "multi-repo-fixes", "multi", "repo", "fixes", "multi-repo", "coordinated"],
+    headings: ["Setup", "How a coordination flows", "Cross-linking PRs", "Inventory traceability", "See also"],
+    excerpt: "When one bug spans a frontend and a backend repo, Mushi plans the fix across both and opens one cross-linked pull request per repository."
+  },
+  {
+    title: "Open source & licensing",
+    url: docUrl("/concepts/open-source"),
+    route: "/concepts/open-source",
+    markdown: "concepts/open-source.md",
+    keywords: ["concepts", "open-source", "open", "source", "licensing"],
+    headings: ["Open-core, one repo", "Why MIT for the SDK?", "Why AGPLv3 for the server?", "No lock-in", "What's paid and what's free", "Run it yourself", "Trademarks"],
+    excerpt: "What is open source in Mushi \u2014 MIT SDKs you can embed anywhere, an AGPLv3 server you can self-host, and the small commercial enterprise edition."
+  },
+  {
+    title: "Connecting your orchestrator (MCP / A2A / REST / AG-UI)",
+    url: docUrl("/concepts/orchestrator-interop"),
+    route: "/concepts/orchestrator-interop",
+    markdown: "concepts/orchestrator-interop.md",
+    keywords: ["concepts", "orchestrator-interop", "orchestrator", "interop", "connecting", "mcp", "a2a", "rest", "ag-ui"],
+    headings: ["Discovery", "Inbound surfaces", "MCP \u2014 stdio (local) AND Streamable HTTP (hosted)", "A2A v1.0.0 \u2014 Tasks resource", "Push notifications (A2A v1.0.0 PushNotificationConfig)", "REST + OpenAPI 3.1", "AG-UI v0.4 \u2014 fix dispatch SSE", "JSON Schemas"],
+    excerpt: "Connect any agent orchestrator to Mushi \u2014 MCP, A2A, REST and AG-UI surfaces for Cursor, Claude, OpenAI Agents, LangGraph, CrewAI and your own agents."
+  },
+  {
+    title: "Rewards & contributor identity",
+    url: docUrl("/concepts/rewards"),
+    route: "/concepts/rewards",
+    markdown: "concepts/rewards.md",
+    keywords: ["concepts", "rewards", "contributor", "identity"],
+    headings: ["Design principles", "Data model", "Server-side award flow", "SDK-side flow", "Identity verification (P2 \u2014 monetary awards)", "Tier multipliers", "Anti-gaming integration", "Webhooks reference"],
+    excerpt: "How Mushi's rewards program works \u2014 reporters earn points for reports and triage, climb project-defined tiers, and get perks from your app via webhooks."
+  },
+  {
+    title: "Runtime config",
+    url: docUrl("/concepts/runtime-config"),
+    route: "/concepts/runtime-config",
+    markdown: "concepts/runtime-config.md",
+    keywords: ["concepts", "runtime-config", "runtime", "config"],
+    headings: ["Setup default", "When host init wins", "Console tuning without rebuild", "Widget draft persistence", "Troubleshooting", "Related"],
+    excerpt: "How the Mushi SDK fetches widget and capture settings from the console at startup, how they merge with your init options, and when to turn it off."
+  },
+  {
+    title: "Where the report button lives",
+    url: docUrl("/concepts/trigger-modes"),
+    route: "/concepts/trigger-modes",
+    markdown: "concepts/trigger-modes.md",
+    keywords: ["concepts", "trigger-modes", "trigger", "modes", "where", "report", "button", "lives"],
+    headings: ["Choosing a Mode", "Bring Your Own Button", "Smart Hide", "Native SDKs"],
+    excerpt: "Choose where Mushi's bug-report button lives \u2014 corner stamp, edge tab, banner, your own button via attach, or fully manual \u2014 on web and mobile."
+  },
+  {
+    title: "Cursor integration",
+    url: docUrl("/integrations/cursor"),
+    route: "/integrations/cursor",
+    markdown: "integrations/cursor.md",
+    keywords: ["integrations", "cursor", "integration"],
+    headings: ["Step-by-step", "Log in", "Wire Cursor", "(Optional) Add the evolution-loop coding rules", "Restart Cursor", "Verify", "Available tools in Cursor", "Keep lessons current"],
+    excerpt: "Wire Mushi's evolution loop into Cursor with one command \u2014 get fix context, lessons, and dispatch right from the editor."
+  },
+  {
+    title: "Voice intake",
+    url: docUrl("/integrations/voice-intake"),
+    route: "/integrations/voice-intake",
+    markdown: "integrations/voice-intake.md",
+    keywords: ["integrations", "voice-intake", "voice", "intake"],
+    headings: ["Enable it", "Turn it on", "Mint a voice:write key", "Make sure Autofix is on", "iOS Shortcut", "Telegram (the Android inbox)", "Create a bot", "Connect it"],
+    excerpt: "Say the bug on your phone, get a draft PR back. iOS Shortcut, Telegram, Slack, or the installed console \u2014 one pipeline, one confirmation gate, no audio kept."
+  },
+  {
+    title: "Launch Week",
+    url: docUrl("/launch-week"),
+    route: "/launch-week",
+    markdown: "launch-week.md",
+    keywords: ["launch-week", "launch", "week"],
+    headings: ["What shipped in June 2026", "How we launch now: one post per release", "The gate before R1", "What we will not do", "Want to be notified?", "Run your own"],
+    excerpt: "How Mushi Mushi launches now \u2014 one public post per release (Show HN, then Product Hunt), the gate each release must pass, and what we publish after."
+  },
+  {
+    title: "Legal",
+    url: docUrl("/legal"),
+    route: "/legal",
+    markdown: "legal/index.md",
+    keywords: ["legal"],
+    headings: [],
+    excerpt: "Privacy policy and terms of service for Mushi Mushi Cloud, the SDKs, and the tester program."
+  },
+  {
+    title: "Privacy Policy",
+    url: docUrl("/legal/privacy"),
+    route: "/legal/privacy",
+    markdown: "legal/privacy.md",
+    keywords: ["legal", "privacy", "policy"],
+    headings: ["1. Who is responsible", "2. What data we handle, in one table", "3. Data where Mushi is the controller", "4. Data where Mushi is the processor", "5. Sub-processors", "6. International transfers and residency", "7. Retention", "8. Your rights and how to use them"],
+    excerpt: "What Mushi Mushi collects, why, who processes it, how long it is kept, and how to exercise your rights under GDPR and Japan's APPI."
+  },
+  {
+    title: "Terms of Service",
+    url: docUrl("/legal/terms"),
+    route: "/legal/terms",
+    markdown: "legal/terms.md",
+    keywords: ["legal", "terms", "service"],
+    headings: ["1. Acceptance", "2. The Service", "3. Software licenses", "4. Accounts", "5. Acceptable use", "6. Your data and the license you give us", "7. Free tier", "8. Paid plans and billing"],
+    excerpt: "The terms for Mushi Cloud, the admin console, the SDKs and the Bounties tester marketplace \u2014 plans, limits, AI-output disclaimer, licenses and liability."
+  },
+  {
+    title: "Migration guides",
+    url: docUrl("/migrations"),
+    route: "/migrations",
+    markdown: "migrations/index.md",
+    keywords: ["migrations", "migration", "guides"],
+    headings: ["Don't see your migration?"],
+    excerpt: "Step-by-step guides for moving an app onto Mushi from Sentry, Instabug, Shake, LogRocket, BugHerd or Pendo, or between React, Vue and mobile runtimes."
+  },
+  {
+    title: "BugHerd \u2192 Mushi",
+    url: docUrl("/migrations/bugherd-to-mushi"),
+    route: "/migrations/bugherd-to-mushi",
+    markdown: "migrations/bugherd-to-mushi.md",
+    keywords: ["migrations", "bugherd-to-mushi", "bugherd"],
+    headings: ["Why switch", "API mapping", "Before / After", "Migration checklist", "Feature parity", "References"],
+    excerpt: "Move from BugHerd to Mushi \u2014 map pin-to-element feedback onto Mushi's element selector, screenshot and metadata capture, with an interactive checklist."
+  },
+  {
+    title: "Migration: Capacitor \u2192 React Native",
+    url: docUrl("/migrations/capacitor-to-react-native"),
+    route: "/migrations/capacitor-to-react-native",
+    markdown: "migrations/capacitor-to-react-native.md",
+    keywords: ["migrations", "capacitor-to-react-native", "capacitor", "react", "native", "migration"],
+    headings: ["TL;DR", "Web strategy", "Mushi Mushi during the migration", "API mapping at a glance", "Before / after", "Get the snippet from the admin console", "Or use the CLI", "What's covered in the full guide"],
+    excerpt: "Port an Ionic or Capacitor app to React Native \u2014 a full plan with a Mushi API map and CI/CD recipes for Expo EAS or React Native CLI with Fastlane."
+  },
+  {
+    title: "Cordova \u2192 Capacitor",
+    url: docUrl("/migrations/cordova-to-capacitor"),
+    route: "/migrations/cordova-to-capacitor",
+    markdown: "migrations/cordova-to-capacitor.md",
+    keywords: ["migrations", "cordova-to-capacitor", "cordova", "capacitor"],
+    headings: ["Why migrate", "Prerequisites", "API mapping (Cordova plugins \u2192 Capacitor)", "Migration checklist", "Common gotchas", "Rollback", "Related guides", "References"],
+    excerpt: "Migrate a Cordova app to Capacitor in place \u2014 same web code, a new native shell \u2014 and re-mount Mushi bug reporting with @mushi-mushi/capacitor."
+  },
+  {
+    title: "Cordova \u2192 React Native",
+    url: docUrl("/migrations/cordova-to-react-native"),
+    route: "/migrations/cordova-to-react-native",
+    markdown: "migrations/cordova-to-react-native.md",
+    keywords: ["migrations", "cordova-to-react-native", "cordova", "react", "native"],
+    headings: ["Why migrate", "Two paths", "Path A: Cordova \u2192 Capacitor \u2192 React Native (recommended)", "Path B: Direct Cordova \u2192 React Native", "Mushi during the migration", "Migration checklist (Path A)", "Migration checklist (Path B \u2014 direct)", "Verification"],
+    excerpt: "Move a Cordova app to React Native in two hops \u2014 stabilise on Capacitor first, then port screen by screen \u2014 without losing Mushi bug reporting."
+  },
+  {
+    title: "Create React App \u2192 Vite",
+    url: docUrl("/migrations/cra-to-vite"),
+    route: "/migrations/cra-to-vite",
+    markdown: "migrations/cra-to-vite.md",
+    keywords: ["migrations", "cra-to-vite", "cra", "vite", "create", "react", "app"],
+    headings: ["Prerequisites", "Migration checklist", "Common gotchas", "Rollback", "Mushi compatibility", "References"],
+    excerpt: "Migrate a Create React App project to Vite \u2014 run the codemod, rename REACT_APP_ env vars to VITE_, and keep your Mushi React setup working."
+  },
+  {
+    title: "Instabug (Luciq) \u2192 Mushi",
+    url: docUrl("/migrations/instabug-to-mushi"),
+    route: "/migrations/instabug-to-mushi",
+    markdown: "migrations/instabug-to-mushi.md",
+    keywords: ["migrations", "instabug-to-mushi", "instabug", "luciq"],
+    headings: ["Why switch", "API mapping", "Before / After", "Web", "React Native", "Migration checklist", "Feature parity at a glance", "Rollback"],
+    excerpt: "Replace Instabug (Luciq) with Mushi for in-app bug reporting \u2014 config mapping, shake-to-report parity, a beta validation pass, and a checklist."
+  },
+  {
+    title: "LogRocket Feedback \u2192 Mushi",
+    url: docUrl("/migrations/logrocket-feedback-to-mushi"),
+    route: "/migrations/logrocket-feedback-to-mushi",
+    markdown: "migrations/logrocket-feedback-to-mushi.md",
+    keywords: ["migrations", "logrocket-feedback-to-mushi", "logrocket", "feedback"],
+    headings: ["Why switch (the feedback piece)", "API mapping", "Linking LogRocket session URLs into Mushi reports", "Migration checklist", "Feature parity (feedback only \u2014 replay is its own product)", "References"],
+    excerpt: "Move LogRocket's feedback widget to Mushi while keeping LogRocket for session replay \u2014 both SDKs run side by side, with a step-by-step checklist."
+  },
+  {
+    title: "@mushi-mushi/* upgrades",
+    url: docUrl("/migrations/mushi-sdk-upgrade"),
+    route: "/migrations/mushi-sdk-upgrade",
+    markdown: "migrations/mushi-sdk-upgrade.md",
+    keywords: ["migrations", "mushi-sdk-upgrade", "sdk", "upgrade", "@mushi-mushi", "upgrades"],
+    headings: ["What stays stable", "Migration checklist", "Current package tracks (workspace snapshot)"],
+    excerpt: "Upgrade @mushi-mushi packages to the current 1.x releases \u2014 breaking changes by package, the codemod, and how to check which versions you run."
+  },
+  {
+    title: "Native iOS / Android \u2192 Hybrid",
+    url: docUrl("/migrations/native-to-hybrid"),
+    route: "/migrations/native-to-hybrid",
+    markdown: "migrations/native-to-hybrid.md",
+    keywords: ["migrations", "native-to-hybrid", "native", "hybrid", "ios", "android"],
+    headings: ["Should you migrate?", "Pick a target shell", "Migration checklist", "Mushi during the migration", "Verification", "References"],
+    excerpt: "Should you wrap a native iOS or Android app in Capacitor or React Native? When it pays off, how to do it, and where Mushi's SDKs fit either way."
+  },
+  {
+    title: "Next.js Pages \u2192 App Router",
+    url: docUrl("/migrations/nextjs-pages-to-app-router"),
+    route: "/migrations/nextjs-pages-to-app-router",
+    markdown: "migrations/nextjs-pages-to-app-router.md",
+    keywords: ["migrations", "nextjs-pages-to-app-router", "nextjs", "pages", "app", "router", "next.js"],
+    headings: ["API mapping (Pages \u2192 App)", "Migration checklist", "Where to put (the most asked question)", "Server Components and useMushi()", "Common gotchas", "References"],
+    excerpt: "Move a Next.js app from the Pages Router to the App Router step by step \u2014 where to mount Mushi, CSP for static export, and client component boundaries."
+  },
+  {
+    title: "Pendo Feedback \u2192 Mushi",
+    url: docUrl("/migrations/pendo-feedback-to-mushi"),
+    route: "/migrations/pendo-feedback-to-mushi",
+    markdown: "migrations/pendo-feedback-to-mushi.md",
+    keywords: ["migrations", "pendo-feedback-to-mushi", "pendo", "feedback"],
+    headings: ["Why switch (the feedback piece)", "API mapping", "Recipe: keep Pendo for analytics + guides; use Mushi for feedback", "Migration checklist", "Feature parity", "References"],
+    excerpt: "Swap Pendo's feedback module for Mushi while keeping Pendo for analytics, guides and NPS \u2014 both share user identity through one identify call."
+  },
+  {
+    title: "React Native CLI \u2194 Expo",
+    url: docUrl("/migrations/react-native-cli-to-expo"),
+    route: "/migrations/react-native-cli-to-expo",
+    markdown: "migrations/react-native-cli-to-expo.md",
+    keywords: ["migrations", "react-native-cli-to-expo", "react", "native", "cli", "expo"],
+    headings: ["Direction A: React Native CLI \u2192 Expo (managed-with-dev-client)", "Why", "Migration checklist", "Direction B: Expo \u2192 bare React Native CLI (expo prebuild)", "Hybrid (the third option, often the right one)", "Verification", "References"],
+    excerpt: "Move between React Native CLI and Expo in either direction \u2014 EAS Build and OTA updates, or expo prebuild for full native control \u2014 with Mushi intact."
+  },
+  {
+    title: "Sentry + Mushi (enrich or standalone)",
+    url: docUrl("/migrations/sentry-to-mushi"),
+    route: "/migrations/sentry-to-mushi",
+    markdown: "migrations/sentry-to-mushi.md",
+    keywords: ["migrations", "sentry-to-mushi", "sentry", "enrich", "standalone"],
+    headings: ["What each tool is for", "Option 1 \u2014 Enrich: run both, link events", "Option 2 \u2014 Standalone", "API mapping (for code you already have)", "Migration checklist", "When would you actually drop Sentry?", "References"],
+    excerpt: "Add Mushi alongside Sentry or run it on its own \u2014 three setups, the Sentry webhook for errors, and user bug reports with plain-English diagnoses."
+  },
+  {
+    title: "Shake \u2192 Mushi",
+    url: docUrl("/migrations/shake-to-mushi"),
+    route: "/migrations/shake-to-mushi",
+    markdown: "migrations/shake-to-mushi.md",
+    keywords: ["migrations", "shake-to-mushi", "shake"],
+    headings: ["Why switch", "API mapping", "Before / After", "React Native", "Web", "Migration checklist", "Feature parity", "References"],
+    excerpt: "Replace the Shake bug-reporting SDK with Mushi and keep the same shake-to-report experience \u2014 config mapping, identity, and a cut-over checklist."
+  },
+  {
+    title: "SPA \u2192 SSR (Next.js / Nuxt / SvelteKit)",
+    url: docUrl("/migrations/spa-to-ssr"),
+    route: "/migrations/spa-to-ssr",
+    markdown: "migrations/spa-to-ssr.md",
+    keywords: ["migrations", "spa-to-ssr", "spa", "ssr", "next.js", "nuxt", "sveltekit"],
+    headings: ["Env-var prefix mapping", "Migration checklist (generic, picks the right framework as you go)", "Where the Mushi widget lives across SSR vs CSR", "Common gotchas", "References"],
+    excerpt: "Move a Vite SPA to Next.js, Nuxt or SvelteKit \u2014 env var prefix changes, where to mount Mushi so it survives navigation, and hydration gotchas."
+  },
+  {
+    title: "Vue 2 \u2192 Vue 3",
+    url: docUrl("/migrations/vue-2-to-vue-3"),
+    route: "/migrations/vue-2-to-vue-3",
+    markdown: "migrations/vue-2-to-vue-3.md",
+    keywords: ["migrations", "vue-2-to-vue-3", "vue"],
+    headings: ["What changes (high level)", "API mapping (Mushi-specific)", "Migration checklist", "Common gotchas", "Mushi behaviour during the migration", "References"],
+    excerpt: "Upgrade a Vue 2 app to Vue 3 and move from the vanilla Mushi web SDK to the @mushi-mushi/vue plugin, with an interactive migration checklist."
+  },
+  {
+    title: "Operating (maintainers)",
+    url: docUrl("/operating"),
+    route: "/operating",
+    markdown: "operating/index.md",
+    keywords: ["operating", "maintainers"],
+    headings: ["What lives here", "The four independent deploy paths"],
+    excerpt: "Runbooks for maintainers running Mushi Cloud or publishing the open-source packages \u2014 deployment, releases and status. Not needed to use the SDK."
+  },
+  {
+    title: "Deployment & releases",
+    url: docUrl("/operating/deployment"),
+    route: "/operating/deployment",
+    markdown: "operating/deployment.md",
+    keywords: ["operating", "deployment", "releases"],
+    headings: ["Four independent pipelines", "npm SDK release (Changesets + OIDC)", "Add a changeset on your PR", "Merge to master", "Merge the version PR", "Dispatch the release if it does not auto-start", "Edge Functions, admin & docs", "Database migrations"],
+    excerpt: "How Mushi's maintainers ship the SDKs, edge functions and docs \u2014 a public summary of the release process. App developers never need to run any of it."
+  },
+  {
+    title: "Status & Uptime",
+    url: docUrl("/operating/status"),
+    route: "/operating/status",
+    markdown: "operating/status.md",
+    keywords: ["operating", "status", "uptime"],
+    headings: ["What we monitor", "Uptime commitment", "Incident communication", "Reporting availability issues"],
+    excerpt: "Mushi Cloud status and uptime \u2014 the live status page for the API, hosted MCP, console and docs, what is monitored, and the uptime commitment per plan."
+  },
+  {
+    title: "Plugin marketplace",
+    url: docUrl("/plugins"),
+    route: "/plugins",
+    markdown: "plugins/index.md",
+    keywords: ["plugins", "plugin", "marketplace"],
+    headings: ["Available plugins", "Webhook delivery contract", "Build your own"],
+    excerpt: "Send Mushi events to the tools you already use through HMAC-signed Standard Webhooks \u2014 12 first-party plugins and an SDK to build your own."
+  },
+  {
+    title: "Bugsnag",
+    url: docUrl("/plugins/bugsnag"),
+    route: "/plugins/bugsnag",
+    markdown: "plugins/bugsnag.md",
+    keywords: ["plugins", "bugsnag"],
+    headings: ["Setup", "Package", "Events"],
+    excerpt: "Mirror Mushi bug reports into Bugsnag and close the Bugsnag error when the fix PR merges \u2014 install from the marketplace and map release stages."
+  },
+  {
+    title: "Building a plugin",
+    url: docUrl("/plugins/building"),
+    route: "/plugins/building",
+    markdown: "plugins/building.md",
+    keywords: ["plugins", "building", "plugin"],
+    headings: ["Minimal receiver", "Typed event shapes", "Signature verification", "Publishing to the marketplace", "Local testing"],
+    excerpt: "Build your own Mushi plugin \u2014 an HTTP endpoint that receives HMAC-signed webhook events, verified with @mushi-mushi/plugin-sdk in a few lines."
+  },
+  {
+    title: "Crashlytics",
+    url: docUrl("/plugins/crashlytics"),
+    route: "/plugins/crashlytics",
+    markdown: "plugins/crashlytics.md",
+    keywords: ["plugins", "crashlytics"],
+    headings: ["Setup", "Package", "Events"],
+    excerpt: "Push Mushi mobile bug reports into Firebase Crashlytics issues and close them when fixes merge \u2014 service account setup and app ID mapping."
+  },
+  {
+    title: "Cursor Cloud Agent",
+    url: docUrl("/plugins/cursor-cloud"),
+    route: "/plugins/cursor-cloud",
+    markdown: "plugins/cursor-cloud.md",
+    keywords: ["plugins", "cursor-cloud", "cursor", "cloud", "agent"],
+    headings: ["Prerequisites", "Setup", "Behaviour", "Fixes view integration", "Common tasks", "Limiting dispatch to critical reports only", "Triggering manually", "Reviewing what the agent did"],
+    excerpt: "Dispatch a Cursor Cloud Agent automatically when a Mushi report qualifies \u2014 it investigates, drafts a fix and opens a PR that links back to Mushi."
+  },
+  {
+    title: "Discord",
+    url: docUrl("/plugins/discord"),
+    route: "/plugins/discord",
+    markdown: "plugins/discord.md",
+    keywords: ["plugins", "discord"],
+    headings: ["Setup", "Package", "Events"],
+    excerpt: "Post Mushi report and fix events to a Discord channel through a webhook \u2014 create the webhook, install the plugin, and choose which events to send."
+  },
+  {
+    title: "Webhook events",
+    url: docUrl("/plugins/events"),
+    route: "/plugins/events",
+    markdown: "plugins/events.md",
+    keywords: ["plugins", "events", "webhook"],
+    headings: ["Event reference", "Subscribing to a subset", "Cursor Cloud Agent events"],
+    excerpt: "Reference for every webhook event Mushi plugins receive \u2014 the shared envelope, each event's payload, and how to subscribe to only the events you need."
+  },
+  {
+    title: "GitHub Issues",
+    url: docUrl("/plugins/github-issues"),
+    route: "/plugins/github-issues",
+    markdown: "plugins/github-issues.md",
+    keywords: ["plugins", "github-issues", "github", "issues"],
+    headings: ["Setup", "Package", "Events"],
+    excerpt: "Open a labelled GitHub issue for every classified Mushi report, with a link back to the report \u2014 target repo, default labels and assignee settings."
+  },
+  {
+    title: "Jira Cloud",
+    url: docUrl("/plugins/jira"),
+    route: "/plugins/jira",
+    markdown: "plugins/jira.md",
+    keywords: ["plugins", "jira", "cloud"],
+    headings: ["Setup", "Package", "Events"],
+    excerpt: "Two-way sync between Mushi reports and Jira Cloud issues \u2014 create issues on classification, sync status, and comment fix summaries when fixes land."
+  },
+  {
+    title: "Linear",
+    url: docUrl("/plugins/linear"),
+    route: "/plugins/linear",
+    markdown: "plugins/linear.md",
+    keywords: ["plugins", "linear"],
+    headings: ["Setup", "Behaviour", "Label mapping example", "Troubleshooting"],
+    excerpt: "File a Linear issue automatically when Mushi classifies a bug report \u2014 create a Linear API key, install the plugin, and choose the team and filters."
+  },
+  {
+    title: "Microsoft Teams",
+    url: docUrl("/plugins/msteams"),
+    route: "/plugins/msteams",
+    markdown: "plugins/msteams.md",
+    keywords: ["plugins", "msteams", "microsoft", "teams"],
+    headings: ["Setup", "Package", "Events"],
+    excerpt: "Send Adaptive Cards to a Microsoft Teams channel when Mushi classifies a report or a fix lands \u2014 incoming webhook setup and severity filters."
+  },
+  {
+    title: "PagerDuty",
+    url: docUrl("/plugins/pagerduty"),
+    route: "/plugins/pagerduty",
+    markdown: "plugins/pagerduty.md",
+    keywords: ["plugins", "pagerduty"],
+    headings: ["Setup", "Behaviour", "Troubleshooting"],
+    excerpt: "Page your on-call rotation through PagerDuty when a P0 or P1 bug report lands in Mushi \u2014 Events API v2 integration key setup and filters."
+  },
+  {
+    title: "Rollbar",
+    url: docUrl("/plugins/rollbar"),
+    route: "/plugins/rollbar",
+    markdown: "plugins/rollbar.md",
+    keywords: ["plugins", "rollbar"],
+    headings: ["Setup", "Package", "Events"],
+    excerpt: "Mirror Mushi bug reports into Rollbar items and resolve them when fixes ship \u2014 access token, environment name, and dedup key mapping."
+  },
+  {
+    title: "Sentry",
+    url: docUrl("/plugins/sentry"),
+    route: "/plugins/sentry",
+    markdown: "plugins/sentry.md",
+    keywords: ["plugins", "sentry"],
+    headings: ["Route Sentry errors into Mushi (inbound)", "Setup (outbound plugin)", "Package", "Events"],
+    excerpt: "Two-way Sentry integration \u2014 Sentry errors flow into Mushi's queue, merging a Mushi fix resolves the Sentry issue, and critical reports mirror back."
+  },
+  {
+    title: "Slack app",
+    url: docUrl("/plugins/slack"),
+    route: "/plugins/slack",
+    markdown: "plugins/slack.md",
+    keywords: ["plugins", "slack", "app"],
+    headings: ["Setup", "What's on the card", "Acting from the channel", "Package", "Events", "Troubleshooting"],
+    excerpt: "Triage Mushi bug reports from Slack \u2014 each classified report posts as a card with its root cause and buttons to dispatch a fix, resolve or dismiss."
+  },
+  {
+    title: "Zapier",
+    url: docUrl("/plugins/zapier"),
+    route: "/plugins/zapier",
+    markdown: "plugins/zapier.md",
+    keywords: ["plugins", "zapier"],
+    headings: ["Setup", "Signature verification in Zapier", "Common Zaps", "Troubleshooting"],
+    excerpt: "Send every Mushi event to Zapier and on to thousands of apps such as Notion, Google Sheets and HubSpot \u2014 Catch Hook setup and event filters."
+  },
+  {
+    title: "Pricing \u2014 free tier, Pro, and self-host",
+    url: docUrl("/pricing"),
+    route: "/pricing",
+    markdown: "pricing.md",
+    keywords: ["pricing", "free", "tier", "pro", "self-host"],
+    headings: ["Plans", "What counts as a diagnosis", "Pricing estimator", "Example bills", "Why diagnoses, not events", "BYOK and the self-host path", "Compared to Sentry + Seer", "Frequently asked questions"],
+    excerpt: "Mushi Mushi pricing \u2014 50 AI bug diagnoses a month free, no card. Open-source Sentry alternative you can self-host for free, or upgrade for teams."
+  },
+  {
+    title: "Quickstart \u2014 fix your first bug in 60 seconds",
+    url: docUrl("/quickstart"),
+    route: "/quickstart",
+    markdown: "quickstart/index.md",
+    keywords: ["quickstart", "fix", "first", "bug", "60", "seconds", "choose", "stack"],
+    headings: ["Start here (MCP)", "Pick your stack", "How do I install the SDK?", "Troubleshooting"],
+    excerpt: "Install Mushi with npx mushi-mushi, connect Cursor or Claude Code over MCP, and turn user bug reports into plain-English diagnoses with ready fixes."
+  },
+  {
+    title: "Android (Kotlin) quickstart",
+    url: docUrl("/quickstart/android"),
+    route: "/quickstart/android",
+    markdown: "quickstart/android.md",
+    keywords: ["quickstart", "android", "kotlin"],
+    headings: ["Build from source", "Initialize", "Open the widget or submit a report", "Sentry bridge (optional)"],
+    excerpt: "Try Mushi's native Kotlin SDK on Android \u2014 shake-to-report, a bottom-sheet widget and an offline queue. A preview built from source, not on Maven Central yet."
+  },
+  {
+    title: "Angular quickstart",
+    url: docUrl("/quickstart/angular"),
+    route: "/quickstart/angular",
+    markdown: "quickstart/angular.md",
+    keywords: ["quickstart", "angular"],
+    headings: [],
+    excerpt: "Add Mushi to an Angular 17+ app \u2014 register the Mushi service and error handler as factory providers so uncaught errors and user bug reports reach your queue."
+  },
+  {
+    title: "Capacitor quickstart",
+    url: docUrl("/quickstart/capacitor"),
+    route: "/quickstart/capacitor",
+    markdown: "quickstart/capacitor.md",
+    keywords: ["quickstart", "capacitor"],
+    headings: ["1. Install", "2. Configure", "3. Submit a report"],
+    excerpt: "Add Mushi to an Ionic or Capacitor app \u2014 install @mushi-mushi/capacitor, configure shake-to-report and screenshots, and file your first bug report."
+  },
+  {
+    title: "CLI \u2194 console setup loop",
+    url: docUrl("/quickstart/cli-console-loop"),
+    route: "/quickstart/cli-console-loop",
+    markdown: "quickstart/cli-console-loop.md",
+    keywords: ["quickstart", "cli-console-loop", "cli", "console", "loop", "setup"],
+    headings: ["Which CLI command?", "Browser sign-in flow (recommended)", "What happens in the terminal", "What happens in the browser", "How sign-in reliability works", "1. Run the wizard", "2. Approve in the browser", "3. Pick or create a project"],
+    excerpt: "How npx mushi-mushi creates a project, mints an SDK key and installs the SDK through browser sign-in, and how to recover when the setup loop fails."
+  },
+  {
+    title: "Flutter quickstart",
+    url: docUrl("/quickstart/flutter"),
+    route: "/quickstart/flutter",
+    markdown: "quickstart/flutter.md",
+    keywords: ["quickstart", "flutter"],
+    headings: ["Install", "Initialize", "Open the widget or submit a report"],
+    excerpt: "Add Mushi's Flutter SDK as a git dependency \u2014 shake-to-report, a Material bottom sheet and an offline queue for iOS and Android. Preview, not on pub.dev yet."
+  },
+  {
+    title: "Incident loop \u2014 bug to fix prompt",
+    url: docUrl("/quickstart/incident-loop"),
+    route: "/quickstart/incident-loop",
+    markdown: "quickstart/incident-loop.md",
+    keywords: ["quickstart", "incident-loop", "incident", "loop", "bug", "fix", "prompt"],
+    headings: ["Prerequisites", "Step 1 \u2014 Capture or pick a report", "Step 2 \u2014 Pull fix context", "Step 3 \u2014 Generate the fix prompt", "Step 4 \u2014 Paste and ship", "Troubleshooting", "See also"],
+    excerpt: "Run npx mushi-mushi, ship, and turn your first user-reported bug into a plain-English diagnosis and a paste-ready fix for Cursor or Claude Code."
+  },
+  {
+    title: "iOS (Swift) quickstart",
+    url: docUrl("/quickstart/ios"),
+    route: "/quickstart/ios",
+    markdown: "quickstart/ios.md",
+    keywords: ["quickstart", "ios", "swift"],
+    headings: ["Install (Swift Package Manager)", "Initialize", "Open the widget or submit a report", "Sentry"],
+    excerpt: "Add Mushi's native Swift SDK to an iOS app with Swift Package Manager \u2014 shake-to-report, offline queue and device context. Preview build, not on CocoaPods yet."
+  },
+  {
+    title: "MCP server for bug fixing in Cursor & Claude Code",
+    url: docUrl("/quickstart/mcp"),
+    route: "/quickstart/mcp",
+    markdown: "quickstart/mcp.md",
+    keywords: ["quickstart", "mcp", "server", "bug", "fixing", "cursor", "claude", "code"],
+    headings: ["OAuth login (recommended \u2014 no keys to copy)", "One-liner setup (recommended)", "Claude Code plugin", "Smithery (hosted MCP)", "Manual setup: Cursor", "Manual setup: Claude Desktop", "Hosted Streamable HTTP transport (no subprocess)", "Available tools"],
+    excerpt: "Set up the Mushi MCP server with npx mushi-mushi setup \u2014 read bug reports, get fix context, and dispatch fixes from Cursor, Claude Code, or Codex."
+  },
+  {
+    title: "Mobile (overview)",
+    url: docUrl("/quickstart/mobile"),
+    route: "/quickstart/mobile",
+    markdown: "quickstart/mobile.md",
+    keywords: ["quickstart", "mobile", "overview"],
+    headings: [],
+    excerpt: "Shake-to-report bug capture for mobile apps \u2014 React Native and Capacitor from npm with npx mushi-mushi, plus preview native SDKs for iOS, Android and Flutter."
+  },
+  {
+    title: "React quickstart",
+    url: docUrl("/quickstart/react"),
+    route: "/quickstart/react",
+    markdown: "quickstart/react.md",
+    keywords: ["quickstart", "react"],
+    headings: ["Try it live", "1. Install", "2. Wrap your app", "Next.js App Router", "3. Trigger reports", "4. Verify", "Next steps"],
+    excerpt: "Add the Mushi React SDK in one command \u2014 npx mushi-mushi installs the bug-reporting widget, writes env vars, and files your first test report."
+  },
+  {
+    title: "React Native quickstart",
+    url: docUrl("/quickstart/react-native"),
+    route: "/quickstart/react-native",
+    markdown: "quickstart/react-native.md",
+    keywords: ["quickstart", "react-native", "react", "native"],
+    headings: ["1. Install", "2. Mount the provider", "3. Verify"],
+    excerpt: "Add shake-to-report bug capture to a React Native or Expo app with @mushi-mushi/react-native \u2014 install, mount the provider, and verify the first report."
+  },
+  {
+    title: "Svelte quickstart",
+    url: docUrl("/quickstart/svelte"),
+    route: "/quickstart/svelte",
+    markdown: "quickstart/svelte.md",
+    keywords: ["quickstart", "svelte"],
+    headings: [],
+    excerpt: "Add Mushi bug reporting to a Svelte or SvelteKit app \u2014 install @mushi-mushi/svelte and call initMushi from hooks.client.ts or a root layout's onMount."
+  },
+  {
+    title: "Vue 3 quickstart",
+    url: docUrl("/quickstart/vue"),
+    route: "/quickstart/vue",
+    markdown: "quickstart/vue.md",
+    keywords: ["quickstart", "vue"],
+    headings: [],
+    excerpt: "Add Mushi bug reporting to a Vue 3 app \u2014 install @mushi-mushi/vue and register MushiPlugin with your project ID and public API key in main.ts."
+  },
+  {
+    title: "Vanilla JS quickstart",
+    url: docUrl("/quickstart/web"),
+    route: "/quickstart/web",
+    markdown: "quickstart/web.md",
+    keywords: ["quickstart", "web", "vanilla", "js"],
+    headings: ["Try it live", "1. Install", "2. Initialize", "3. Submit", "No bundler: script tag"],
+    excerpt: "Add Mushi's browser SDK to any site without a framework \u2014 install @mushi-mushi/web, call Mushi.init, and file bug reports from your buttons or the widget."
+  },
+  {
+    title: "Roadmap",
+    url: docUrl("/roadmap"),
+    route: "/roadmap",
+    markdown: "roadmap.md",
+    keywords: ["roadmap"],
+    headings: ["Live boards", "Release waves", "Wave E details (in-flight)", "Wave D highlights (shipped)", "Completed highlights (Wave C, v0.8.0)"],
+    excerpt: "Where Mushi Mushi is headed \u2014 upcoming SDK platforms, diagnosis speed targets, and console features, updated as work lands."
+  },
+  {
+    title: "SDK reference",
+    url: docUrl("/sdks"),
+    route: "/sdks",
+    markdown: "sdks/index.md",
+    keywords: ["sdks", "sdk", "reference", "index"],
+    headings: ["Maturity, honestly", "Web & frameworks", "Server", "Mobile & native", "Tooling & automation", "Infrastructure & advanced", "Recipes & presets", "Installation"],
+    excerpt: "Bug-reporting SDKs for React, Vue, Svelte, Angular, React Native, Capacitor and Node, installed by npx mushi-mushi, plus preview iOS, Android and Flutter SDKs."
+  },
+  {
+    title: "@mushi-mushi/adapters",
+    url: docUrl("/sdks/adapters"),
+    route: "/sdks/adapters",
+    markdown: "sdks/adapters.md",
+    keywords: ["sdks", "adapters", "@mushi-mushi/adapters"],
+    headings: ["Install", "Eleven supported sources", "Quick start \u2014 Datadog \u2192 Hono", "Severity mapping", "Authentication"],
+    excerpt: "Turn Sentry, Datadog, Bugsnag and other monitoring webhooks into Mushi reports with @mushi-mushi/adapters, deduped against the same queue as user reports."
+  },
+  {
+    title: "Product analytics (track)",
+    url: docUrl("/sdks/analytics"),
+    route: "/sdks/analytics",
+    markdown: "sdks/analytics.md",
+    keywords: ["sdks", "analytics", "product", "track"],
+    headings: ["Quick start", "API", "Configuration: analytics", "Event names and properties", "Consent and privacy", "Batching and delivery", "The console: Users & Funnels", "MCP tools"],
+    excerpt: "Mushi.track() reference \u2014 named events, consent, sampling and batching, useMushiTrack() for React, Users & Funnels, and the /v1/sdk/events wire format."
+  },
+  {
+    title: "dev.mushimushi:mushi-android (Android)",
+    url: docUrl("/sdks/android"),
+    route: "/sdks/android",
+    markdown: "sdks/android.md",
+    keywords: ["sdks", "android", "dev.mushimushi", "mushi-android"],
+    headings: ["API surface", "Setup", "Identifying users", "Offline queue", "Sentry bridge"],
+    excerpt: "API reference for Mushi's native Kotlin SDK \u2014 init, report, captureError, showWidget, breadcrumbs and the Sentry bridge. A preview built from source."
+  },
+  {
+    title: "@mushi-mushi/angular",
+    url: docUrl("/sdks/angular"),
+    route: "/sdks/angular",
+    markdown: "sdks/angular.md",
+    keywords: ["sdks", "angular", "@mushi-mushi/angular"],
+    headings: ["API surface", "Setup (standalone bootstrap)", "Submitting a report", "Identifying users"],
+    excerpt: "API reference for @mushi-mushi/angular \u2014 MushiService, MushiErrorHandler and the MUSHI_CONFIG token, wired with factory providers in an Angular 17+ app."
+  },
+  {
+    title: "In-SDK Ask assistant",
+    url: docUrl("/sdks/assistant"),
+    route: "/sdks/assistant",
+    markdown: "sdks/assistant.md",
+    keywords: ["sdks", "assistant", "in-sdk", "ask"],
+    headings: ["What it does", "Enable it", "SDK surface (host app)", "Security (short)"],
+    excerpt: "The Mushi widget's Ask tab answers end users' questions from the current page and your knowledge corpus, using your own LLM key, with every turn logged."
+  },
+  {
+    title: "@mushi-mushi/capacitor",
+    url: docUrl("/sdks/capacitor"),
+    route: "/sdks/capacitor",
+    markdown: "sdks/capacitor.md",
+    keywords: ["sdks", "capacitor", "@mushi-mushi/capacitor"],
+    headings: ["Install", "Configure", "Submit a report", "Programmatic widget + listeners", "Position the trigger above your tab bar / dock"],
+    excerpt: "API reference for @mushi-mushi/capacitor \u2014 configure, report, listeners, setUser and widget options for Ionic and Capacitor apps on iOS, Android and web."
+  },
+  {
+    title: "Capacitor bottom dock",
+    url: docUrl("/sdks/capacitor-bottom-dock"),
+    route: "/sdks/capacitor-bottom-dock",
+    markdown: "sdks/capacitor-bottom-dock.md",
+    keywords: ["sdks", "capacitor-bottom-dock", "capacitor", "bottom", "dock"],
+    headings: [],
+    excerpt: "Keep the Mushi bug-report button clear of tab bars and bottom docks in Capacitor apps with triggerInsetPreset, explicit insets, or widget.anchor."
+  },
+  {
+    title: "@mushi-mushi/cli",
+    url: docUrl("/sdks/cli"),
+    route: "/sdks/cli",
+    markdown: "sdks/cli.md",
+    keywords: ["sdks", "cli", "@mushi-mushi/cli"],
+    headings: ["Console \u2194 CLI setup loop", "Setup & health", "mushi doctor", "mushi nudge", "Reports & lessons", "Agentic fixes", "mushi fix", "mushi fixes"],
+    excerpt: "Reference for @mushi-mushi/cli \u2014 log in, connect a project, run doctor, list reports, dispatch agent fixes and merge their pull requests from the terminal."
+  },
+  {
+    title: "@mushi-mushi/core",
+    url: docUrl("/sdks/core"),
+    route: "/sdks/core",
+    markdown: "sdks/core.md",
+    keywords: ["sdks", "core", "@mushi-mushi/core"],
+    headings: ["Install", "API", "Mushi.init(config) (web) / MushiProvider (React Native)", "MushiWidgetConfig (selected keys)", "submitReport(input)", "flushOfflineQueueNow()", "PII scrubbing utilities (1.27+)", "Region resolution"],
+    excerpt: "Reference for @mushi-mushi/core \u2014 the MushiConfig shape, widget options, PII scrubbing helpers and region resolution shared by every Mushi JavaScript SDK."
+  },
+  {
+    title: "eslint-plugin-mushi-mushi",
+    url: docUrl("/sdks/eslint-plugin"),
+    route: "/sdks/eslint-plugin",
+    markdown: "sdks/eslint-plugin.md",
+    keywords: ["sdks", "eslint-plugin", "eslint", "plugin", "eslint-plugin-mushi-mushi"],
+    headings: ["Install", "Recommended preset", "Rules", "mushi-mushi/no-dead-handler", "mushi-mushi/no-mock-leak", "Combining with the gates action"],
+    excerpt: "eslint-plugin-mushi-mushi flags empty event handlers and leftover mock data in production code \u2014 the no-dead-handler and no-mock-leak rules and preset."
+  },
+  {
+    title: "mushi_mushi (Flutter)",
+    url: docUrl("/sdks/flutter"),
+    route: "/sdks/flutter",
+    markdown: "sdks/flutter.md",
+    keywords: ["sdks", "flutter"],
+    headings: ["API surface", "Configuration", "Submitting a report", "Screenshot capture", "Offline queue"],
+    excerpt: "API reference for mushi_mushi, Mushi's Flutter SDK \u2014 configure, report, captureError, showWidget, screenshots and the offline queue. Preview, not on pub.dev."
+  },
+  {
+    title: "Framework wrappers (Vue / Svelte / Angular)",
+    url: docUrl("/sdks/framework-wrappers"),
+    route: "/sdks/framework-wrappers",
+    markdown: "sdks/framework-wrappers.md",
+    keywords: ["sdks", "framework-wrappers", "framework", "wrappers", "vue", "svelte", "angular"],
+    headings: [],
+    excerpt: "How the Vue, Svelte and Angular Mushi packages wrap @mushi-mushi/web \u2014 how each one boots the SDK once, and where to find capture and widget options."
+  },
+  {
+    title: "@mushi-mushi/inventory-auth-runner",
+    url: docUrl("/sdks/inventory-auth-runner"),
+    route: "/sdks/inventory-auth-runner",
+    markdown: "sdks/inventory-auth-runner.md",
+    keywords: ["sdks", "inventory-auth-runner", "inventory", "auth", "runner", "@mushi-mushi/inventory-auth-runner"],
+    headings: ["When you need it", "Install", "Usage", "In CI"],
+    excerpt: "@mushi-mushi/inventory-auth-runner logs in with Playwright from your inventory.yaml auth script so Mushi's crawler can reach pages behind a login."
+  },
+  {
+    title: "@mushi-mushi/inventory-schema",
+    url: docUrl("/sdks/inventory-schema"),
+    route: "/sdks/inventory-schema",
+    markdown: "sdks/inventory-schema.md",
+    keywords: ["sdks", "inventory-schema", "inventory", "schema", "@mushi-mushi/inventory-schema"],
+    headings: ["Install", "What inventory.yaml looks like", "Programmatic use", "JSON Schema"],
+    excerpt: "The Zod schema, JSON Schema and TypeScript types for inventory.yaml \u2014 the contract that Mushi's gates, crawler, ESLint plugin and CLI all read."
+  },
+  {
+    title: "MushiMushi (iOS)",
+    url: docUrl("/sdks/ios"),
+    route: "/sdks/ios",
+    markdown: "sdks/ios.md",
+    keywords: ["sdks", "ios", "mushimushi"],
+    headings: ["API surface", "Setup", "Identifying users", "Offline queue", "Screenshot capture", "Sentry"],
+    excerpt: "API reference for MushiMushi, Mushi's native Swift SDK \u2014 configure, report, captureError, breadcrumbs and PII scrubbing. Preview, via SwiftPM from master."
+  },
+  {
+    title: "mushi-mushi (launcher)",
+    url: docUrl("/sdks/launcher"),
+    route: "/sdks/launcher",
+    markdown: "sdks/launcher.md",
+    keywords: ["sdks", "launcher", "mushi-mushi"],
+    headings: ["Try it", "What it detects", "Idempotent", "When to use the launcher vs the CLI directly"],
+    excerpt: "npx mushi-mushi detects your framework, installs the matching @mushi-mushi SDK, writes your project ID and API key to .env.local, and prints the snippet."
+  },
+  {
+    title: "Bug report MCP server for Cursor & Claude Code",
+    url: docUrl("/sdks/mcp"),
+    route: "/sdks/mcp",
+    markdown: "sdks/mcp.md",
+    keywords: ["sdks", "mcp", "bug", "report", "server", "cursor", "claude", "code", "@mushi-mushi/mcp"],
+    headings: ["Two transports", "Spec traceability for dispatchfix"],
+    excerpt: "Reference for @mushi-mushi/mcp, the Mushi MCP server for Cursor, Claude Code, VS Code and Windsurf \u2014 stdio and hosted HTTP transports, scopes and setup."
+  },
+  {
+    title: "@mushi-mushi/mcp-ci",
+    url: docUrl("/sdks/mcp-ci"),
+    route: "/sdks/mcp-ci",
+    markdown: "sdks/mcp-ci.md",
+    keywords: ["sdks", "mcp-ci", "mcp", "@mushi-mushi/mcp-ci"],
+    headings: ["Quick start", "Commands", "In your IDE", "Inputs"],
+    excerpt: "@mushi-mushi/mcp-ci is Mushi's GitHub Action \u2014 run the five-gate composite check on pull requests, draft inventory entries, and bootstrap crawler auth."
+  },
+  {
+    title: "MCP tools reference",
+    url: docUrl("/sdks/mcp-tools"),
+    route: "/sdks/mcp-tools",
+    markdown: "sdks/mcp-tools.md",
+    keywords: ["sdks", "mcp-tools", "mcp", "tools", "reference"],
+    headings: ["Read tools (mcp:read)", "Write tools (mcp:write)", "Resources", "Prompts"],
+    excerpt: "Every tool, resource and prompt the Mushi MCP server exposes to Cursor, Claude Code and other editors, with its read or write scope, from the catalog."
+  },
+  {
+    title: "Next.js App Router + CSP",
+    url: docUrl("/sdks/nextjs-app-router-csp"),
+    route: "/sdks/nextjs-app-router-csp",
+    markdown: "sdks/nextjs-app-router-csp.md",
+    keywords: ["sdks", "nextjs-app-router-csp", "nextjs", "app", "router", "csp", "next.js"],
+    headings: [],
+    excerpt: "Mount Mushi in a Next.js App Router client component and allow its endpoints in your Content-Security-Policy, with a copy-paste CSP allowlist."
+  },
+  {
+    title: "Next.js static export",
+    url: docUrl("/sdks/nextjs-static-export"),
+    route: "/sdks/nextjs-static-export",
+    markdown: "sdks/nextjs-static-export.md",
+    keywords: ["sdks", "nextjs-static-export", "nextjs", "static", "export", "next.js"],
+    headings: [],
+    excerpt: "Use Mushi in a Next.js static export \u2014 keep the public env vars in NEXT_PUBLIC_* or set runtimeConfig to false, and initialise on the client only."
+  },
+  {
+    title: "Node.js server error reporting SDK",
+    url: docUrl("/sdks/node"),
+    route: "/sdks/node",
+    markdown: "sdks/node.md",
+    keywords: ["sdks", "node", "node.js", "server", "error", "reporting", "sdk", "@mushi-mushi/node"],
+    headings: ["Install", "Express", "Fastify", "Hono", "Process-level fallbacks", "Programmatic submit", "PII and credential scrubbing"],
+    excerpt: "Report server errors from Node with @mushi-mushi/node \u2014 Express, Fastify and Hono error handlers that tag each report with route, request ID and user."
+  },
+  {
+    title: "@mushi-mushi/plugin-sdk",
+    url: docUrl("/sdks/plugin-sdk"),
+    route: "/sdks/plugin-sdk",
+    markdown: "sdks/plugin-sdk.md",
+    keywords: ["sdks", "plugin-sdk", "plugin", "sdk", "@mushi-mushi/plugin-sdk"],
+    headings: ["Install", "Express adapter", "Hono adapter", "Verify a signature manually", "Wire format", "See also"],
+    excerpt: "Build a Mushi plugin in TypeScript with @mushi-mushi/plugin-sdk \u2014 verify webhook signatures, dedupe deliveries and handle lifecycle events in Express."
+  },
+  {
+    title: "SDK presets",
+    url: docUrl("/sdks/presets"),
+    route: "/sdks/presets",
+    markdown: "sdks/presets.md",
+    keywords: ["sdks", "presets", "sdk"],
+    headings: [],
+    excerpt: "Mushi SDK presets such as production-calm set sensible widget and capture defaults in one line, and any explicit Mushi.init option still wins."
+  },
+  {
+    title: "React & Next.js bug reporting SDK",
+    url: docUrl("/sdks/react"),
+    route: "/sdks/react",
+    markdown: "sdks/react.md",
+    keywords: ["sdks", "react", "next.js", "bug", "reporting", "sdk", "@mushi-mushi/react"],
+    headings: ["Identifying users", "Enabling the Rewards program", "useReputation()", "useTier()", "Submitting custom activity"],
+    excerpt: "Reference for @mushi-mushi/react \u2014 MushiProvider, the useMushi, useMushiSdk and useMushiReport hooks, identifying users, and the rewards hooks and badge."
+  },
+  {
+    title: "@mushi-mushi/react-native",
+    url: docUrl("/sdks/react-native"),
+    route: "/sdks/react-native",
+    markdown: "sdks/react-native.md",
+    keywords: ["sdks", "react-native", "react", "native", "@mushi-mushi/react-native"],
+    headings: ["Install", "Mount the provider", "Submit a report from a screen", "Offline queue", "What gets captured (v0.19+)", "Screenshots (react-native-view-shot)", "Manual breadcrumbs", "Reporter identity contract"],
+    excerpt: "Reference for @mushi-mushi/react-native \u2014 MushiProvider, hooks, shake-to-report, screenshots, identity and the offline queue for React Native and Expo."
+  },
+  {
+    title: "Sentry Replay coexistence",
+    url: docUrl("/sdks/sentry-replay-coexistence"),
+    route: "/sdks/sentry-replay-coexistence",
+    markdown: "sdks/sentry-replay-coexistence.md",
+    keywords: ["sdks", "sentry-replay-coexistence", "sentry", "replay", "coexistence"],
+    headings: [],
+    excerpt: "Run Mushi next to Sentry Session Replay \u2014 initialise Sentry first so Mushi attaches the Sentry event and replay IDs to every bug report it sends."
+  },
+  {
+    title: "Agent skills",
+    url: docUrl("/sdks/skills"),
+    route: "/sdks/skills",
+    markdown: "sdks/skills.md",
+    keywords: ["sdks", "skills", "agent"],
+    headings: ["Install skills into your editor", "How skills connect to Mushi", "Console & MCP", "Related"],
+    excerpt: "Install Mushi playbooks into Cursor and Claude Code, sync them into the console catalog, and attach skill chains to bug reports."
+  },
+  {
+    title: "@mushi-mushi/svelte",
+    url: docUrl("/sdks/svelte"),
+    route: "/sdks/svelte",
+    markdown: "sdks/svelte.md",
+    keywords: ["sdks", "svelte", "@mushi-mushi/svelte"],
+    headings: ["API surface", "Setup", "Submitting a report"],
+    excerpt: "Reference for @mushi-mushi/svelte \u2014 initMushi, getMushi and the SvelteKit error hooks that forward client and server errors to your Mushi queue."
+  },
+  {
+    title: "@mushi-mushi/vue",
+    url: docUrl("/sdks/vue"),
+    route: "/sdks/vue",
+    markdown: "sdks/vue.md",
+    keywords: ["sdks", "vue", "@mushi-mushi/vue"],
+    headings: ["API surface", "Setup (Vite / Vue 3)", "Identifying users", "Submitting a report"],
+    excerpt: "Reference for @mushi-mushi/vue \u2014 install MushiPlugin, use the useMushi and useMushiReport composables, identify users and submit reports in Vue 3."
+  },
+  {
+    title: "@mushi-mushi/wasm-classifier",
+    url: docUrl("/sdks/wasm-classifier"),
+    route: "/sdks/wasm-classifier",
+    markdown: "sdks/wasm-classifier.md",
+    keywords: ["sdks", "wasm-classifier", "wasm", "classifier", "@mushi-mushi/wasm-classifier"],
+    headings: [],
+    excerpt: "@mushi-mushi/wasm-classifier runs a small on-device model in the browser to drop junk bug reports before they reach your LLM, cutting classification cost."
+  },
+  {
+    title: "JavaScript bug reporting SDK for the browser",
+    url: docUrl("/sdks/web"),
+    route: "/sdks/web",
+    markdown: "sdks/web.md",
+    keywords: ["sdks", "web", "javascript", "bug", "reporting", "sdk", "browser", "@mushi-mushi/web"],
+    headings: ["Sampling & beforeSend", "Screenshot preview & consent (1.19+)", "Runtime config merge (Jul 2026+)", "Capture availability & errors", "Description draft persistence", "Identifying users & the Rewards program", "Enabling the Rewards program", "Querying points & tier"],
+    excerpt: "Reference for @mushi-mushi/web, the browser SDK \u2014 screenshots, console and network capture, the Shadow DOM widget, sampling, beforeSend and privacy."
+  },
+  {
+    title: "Security & compliance",
+    url: docUrl("/security"),
+    route: "/security",
+    markdown: "security/index.md",
+    keywords: ["security", "compliance"],
+    headings: ["Posture at a glance", "Operational transparency", "Report a vulnerability", "What we do not claim"],
+    excerpt: "How Mushi Mushi protects bug-report data \u2014 residency, your own keys and storage, retention sweeps, RLS coverage, prompt-injection defence and SOC 2."
+  },
+  {
+    title: "BYO storage",
+    url: docUrl("/security/byo-storage"),
+    route: "/security/byo-storage",
+    markdown: "security/byo-storage.md",
+    keywords: ["security", "byo-storage", "byo", "storage"],
+    headings: ["Supported backends", "Setup", "What moves (and what doesn't)", "Health check", "Permissions required"],
+    excerpt: "Keep Mushi screenshots and crash dumps in your own storage bucket instead of Mushi's \u2014 credentials in Vault, signed URLs, and the same console view."
+  },
+  {
+    title: "Bring-your-own-key",
+    url: docUrl("/security/byok"),
+    route: "/security/byok",
+    markdown: "security/byok.md",
+    keywords: ["security", "byok", "bring-your-own-key"],
+    headings: ["Setup", "What uses the key", "Audit trail", "Rotation", "Langfuse trace attribution"],
+    excerpt: "Use your own Anthropic or OpenAI API key for a Mushi project, so every classification, judge and fix run bills to your provider account."
+  },
+  {
+    title: "Data residency",
+    url: docUrl("/security/data-residency"),
+    route: "/security/data-residency",
+    markdown: "security/data-residency.md",
+    keywords: ["security", "data-residency", "data", "residency"],
+    headings: ["Regions", "How the SDK routes", "Attestation", "Self-hosting", "GDPR notes"],
+    excerpt: "Where Mushi Cloud stores data today (Tokyo, ap-northeast-1), how the region picked at project creation works, and what the SDK does about regions."
+  },
+  {
+    title: "No client data leakage \u2014 what we promise and how we enforce it",
+    url: docUrl("/security/no-leakage-claim"),
+    route: "/security/no-leakage-claim",
+    markdown: "security/no-leakage-claim.md",
+    keywords: ["security", "no-leakage-claim", "leakage", "claim", "no", "client", "data", "we", "promise", "enforce"],
+    headings: ["The three promises", "1. Your data doesn't cross project boundaries", "2. PII is scrubbed before it reaches Postgres or an LLM", "3. Screenshots are behind signed, time-limited URLs", "BYOK \u2014 your API keys run against your account", "Your code stays in your repo", "Screenshot URL host validation", "Vault secret scoping"],
+    excerpt: "Explicit enumeration of Mushi Mushi's privacy boundaries, the gaps we've closed, and the controls that keep client data isolated."
+  },
+  {
+    title: "Prompt-injection defence",
+    url: docUrl("/security/prompt-injection"),
+    route: "/security/prompt-injection",
+    markdown: "security/prompt-injection.md",
+    keywords: ["security", "prompt-injection", "prompt", "injection", "defence"],
+    headings: ["Defence layers", "1. Text sanitizer", "2. Structural XML wrapping", "3. Zod-validated structured output", "4. Vision-channel sanitization", "5. Regression suite"],
+    excerpt: "How Mushi defends its LLM pipeline against prompt injection hidden in user bug reports, and the OWASP LLM01 regression suite that runs on every CI push."
+  },
+  {
+    title: "SOC 2 readiness",
+    url: docUrl("/security/soc2"),
+    route: "/security/soc2",
+    markdown: "security/soc2.md",
+    keywords: ["security", "soc2", "soc", "readiness"],
+    headings: ["Automated controls", "Audit dashboard", "Generating an evidence pack manually", "Data retention policies", "DSAR (Data Subject Access Request)"],
+    excerpt: "Mushi's SOC 2 Type 1 readiness module \u2014 automated evidence for access, retention and encryption controls, DSAR exports, and a quarterly evidence pack."
   },
   {
-    title: "MCP setup",
-    path: `${BASE}/guides/mcp-setup`,
-    keywords: ["mcp", "cursor", "api key", "stdio", "http", "multi-project", "account mode", "install", "setup", "deeplink"],
-    excerpt: "Wire Mushi MCP into Cursor, Claude, or any MCP client. Supports per-project and account-level keys."
+    title: "Self-hosting",
+    url: docUrl("/self-hosting"),
+    route: "/self-hosting",
+    markdown: "self-hosting/index.md",
+    keywords: ["self-hosting", "self", "hosting"],
+    headings: ["What you'll deploy", "Fastest path \u2014 Docker Compose", "Managed-Supabase path"],
+    excerpt: "Run the whole Mushi Mushi stack yourself with one command \u2014 Docker Compose, your own keys, AGPLv3 server, MIT SDKs, no usage limits."
   },
   {
-    title: "API key scopes",
-    path: `${BASE}/guides/api-keys`,
-    keywords: ["api key", "mcp:read", "mcp:write", "scopes", "security", "account key", "org-scoped", "multi-project"],
-    excerpt: "Separate SDK ingest keys from MCP read/write keys. Mint an org-scoped account key for multi-project access."
+    title: "Admin SPA deploy",
+    url: docUrl("/self-hosting/admin-spa"),
+    route: "/self-hosting/admin-spa",
+    markdown: "self-hosting/admin-spa.md",
+    keywords: ["self-hosting", "self", "hosting", "admin-spa", "admin", "spa", "deploy"],
+    headings: ["Build", "Deploy options", "SPA routing", "First-run setup"],
+    excerpt: "Build and deploy the Mushi admin console yourself \u2014 a static Vite and React app that talks to your Supabase project, and the env vars it needs."
   },
   {
-    title: "Account key (org-scoped)",
-    path: `${BASE}/guides/mcp-setup`,
-    keywords: ["account key", "org-scoped", "multi-project", "MUSHI_PROJECT_ID", "all projects", "mint-org-key", "get_account_overview"],
-    excerpt: "Mint one org-scoped key that covers all your projects; no MUSHI_PROJECT_ID needed. The agent calls get_account_overview to discover projects."
+    title: "Self-host in minutes (Docker Compose)",
+    url: docUrl("/self-hosting/docker-compose"),
+    route: "/self-hosting/docker-compose",
+    markdown: "self-hosting/docker-compose.md",
+    keywords: ["self-hosting", "self", "hosting", "docker-compose", "docker", "compose", "self-host", "minutes"],
+    headings: ["One command", "Clone and configure", "Bring the stack up", "Open the console", "What's running", "Production notes", "Managed Supabase instead"],
+    excerpt: "Self-host the whole Mushi stack with one Docker Compose file \u2014 Postgres, auth, storage, edge functions, the admin console and a Caddy reverse proxy."
   },
   {
-    title: "Cursor MCP troubleshooting",
-    path: `${BASE}/guides/mcp-setup`,
-    keywords: ["cursor", "mcp.json", "red badge", "transport error", "stdout", "stderr", "json-rpc", "INVALID_TOKEN", "syntax helper", "diagnose_setup"],
-    excerpt: "Cursor stdio MCP requires stdout to contain only JSON-RPC. Use the console syntax helper, restart Cursor MCP, then run diagnose_setup."
+    title: "Edge Functions deploy",
+    url: docUrl("/self-hosting/edge-functions"),
+    route: "/self-hosting/edge-functions",
+    markdown: "self-hosting/edge-functions.md",
+    keywords: ["self-hosting", "self", "hosting", "edge-functions", "edge", "functions", "deploy"],
+    headings: ["Minimal required (ingest + classify)", "Checking what is deployed", "Common optional functions", "Function inventory (core pipeline)", "Required secrets", "JWT verification"],
+    excerpt: "Deploy Mushi's Supabase Edge Functions for a self-hosted install \u2014 the minimal ingest and classification set, the full list, and the secrets they need."
   },
   {
-    title: "Judge loop",
-    path: `${BASE}/concepts/judge-loop`,
-    keywords: ["judge", "sonnet", "quality", "fix scoring"],
-    excerpt: "Sonnet-as-Judge scores fix quality and feeds the lesson library."
+    title: "Langfuse + Sentry",
+    url: docUrl("/self-hosting/observability"),
+    route: "/self-hosting/observability",
+    markdown: "self-hosting/observability.md",
+    keywords: ["self-hosting", "self", "hosting", "observability", "langfuse", "sentry"],
+    headings: ["Langfuse (LLM tracing)", "What gets traced", "Viewing traces", "Sentry (error tracking)", "Admin SPA Sentry", "OpenTelemetry", "Health dashboard"],
+    excerpt: "Wire Langfuse LLM tracing and Sentry error tracking into a self-hosted Mushi server \u2014 the Edge Function secrets and what each trace records."
   },
   {
-    title: "Inventory v2",
-    path: `${BASE}/concepts/inventory`,
-    keywords: ["inventory", "user stories", "spec", "yaml", "actions"],
-    excerpt: "inventory.yaml maps pages, stories, and expected outcomes for spec traceability."
+    title: "Supabase setup",
+    url: docUrl("/self-hosting/supabase"),
+    route: "/self-hosting/supabase",
+    markdown: "self-hosting/supabase.md",
+    keywords: ["self-hosting", "self", "hosting", "supabase", "setup"],
+    headings: ["Required extensions", "Required custom functions", "RLS pattern", "Required seed data", "Verifying the setup"],
+    excerpt: "Set up a Supabase project for self-hosted Mushi \u2014 link the CLI, push every migration, and enable the Postgres extensions the server needs."
   },
   {
-    title: "QA coverage stories",
-    path: `${BASE}/guides/qa-stories`,
-    keywords: ["qa", "playwright", "tdd", "cron", "browserbase", "firecrawl"],
-    excerpt: "Author, approve, and schedule user-story tests."
+    title: "Use cases & comparisons",
+    url: docUrl("/use-cases"),
+    route: "/use-cases",
+    markdown: "use-cases/index.md",
+    keywords: ["use-cases", "use", "cases", "comparisons"],
+    headings: [],
+    excerpt: "Where Mushi Mushi fits \u2014 as an open-source Sentry alternative, a debugger for Cursor and Claude Code apps, and an MCP bug-fixing server for your editor."
   },
   {
-    title: "Skill pipelines",
-    path: `${BASE}/guides/skill-pipelines`,
-    keywords: ["skills", "pipeline", "cursor", "workflow"],
-    excerpt: "Attach agent skills to reports and run handoff or cloud pipelines."
+    title: "AI code bug fixing \u2014 report to merged fix",
+    url: docUrl("/use-cases/ai-code-bug-fixing"),
+    route: "/use-cases/ai-code-bug-fixing",
+    markdown: "use-cases/ai-code-bug-fixing.md",
+    keywords: ["use-cases", "use", "cases", "ai-code-bug-fixing", "code", "bug", "fixing", "ai", "report", "merged", "fix"],
+    headings: ["The pipeline", "Where this fits with your existing tools", "Start with one command"],
+    excerpt: "AI code bug fixing end to end \u2014 user reports become plain-English diagnoses, fix prompts, and optional draft PRs, with lessons that prevent repeats."
   },
   {
-    title: "Dispatch fix",
-    path: `${BASE}/guides/dispatch-fix`,
-    keywords: ["dispatch", "fix", "pr", "cursor cloud", "autofix"],
-    excerpt: "Dispatch the Mushi fix agent or Cursor Cloud for a classified report."
+    title: "Debug apps built with Claude Code",
+    url: docUrl("/use-cases/debug-claude-code-apps"),
+    route: "/use-cases/debug-claude-code-apps",
+    markdown: "use-cases/debug-claude-code-apps.md",
+    keywords: ["use-cases", "use", "cases", "debug-claude-code-apps", "debug", "claude", "code", "apps", "built"],
+    headings: ["The loop, end to end", "What makes this different from error monitoring", "Set it up"],
+    excerpt: "How to debug an app Claude Code built \u2014 bug reports arrive as plain-English diagnoses your Claude Code agent reads and fixes over MCP, fix prompt included."
   },
   {
-    title: "SDK installation",
-    path: `${BASE}/guides/sdk`,
-    keywords: ["sdk", "install", "react", "next", "ingest"],
-    excerpt: "Install @mushi-mushi/web and start capturing user reports."
+    title: "Debug apps built with Cursor",
+    url: docUrl("/use-cases/debug-cursor-apps"),
+    route: "/use-cases/debug-cursor-apps",
+    markdown: "use-cases/debug-cursor-apps.md",
+    keywords: ["use-cases", "use", "cases", "debug-cursor-apps", "debug", "cursor", "apps", "built"],
+    headings: ["The loop, end to end", "Why not just paste the bug into chat?", "Set it up"],
+    excerpt: "How to debug an app Cursor wrote for you \u2014 user bug reports become plain-English diagnoses and fix prompts your Cursor agent applies over MCP."
   },
   {
-    title: "Configuration reference",
-    path: `${BASE}/reference/config`,
-    keywords: ["env", "config", "settings", "byok"],
-    excerpt: "Environment variables and project settings reference."
+    title: "Your Lovable app broke in production",
+    url: docUrl("/use-cases/lovable-app-broke-in-production"),
+    route: "/use-cases/lovable-app-broke-in-production",
+    markdown: "use-cases/lovable-app-broke-in-production.md",
+    keywords: ["use-cases", "use", "cases", "lovable-app-broke-in-production", "lovable", "app", "broke", "production"],
+    headings: ["1. Get the user's exact words and their screen", "2. Reproduce in a private window, logged out", "3. Read the first red line in the console, not the last", "4. Find the file and ask what it assumes", "5. Ask for the smallest fix, and a test", "6. Ship, then tell the user", "7. Write the cause down where the agent will read it", "8. Make the next report arrive with all of this attached"],
+    excerpt: "What to do when a Lovable, Bolt, Cursor or Claude Code app breaks for a real user \u2014 reproduce it, read the first error, and ask the agent for the smallest fix."
   },
   {
-    title: "Evolution loop",
-    path: `${BASE}/concepts/evolution`,
-    keywords: ["evolution", "lessons", "convergence", "prompt promotion"],
-    excerpt: "Closed-loop learning from bugs, fixes, and judge scores."
+    title: "MCP server for bug fixing",
+    url: docUrl("/use-cases/mcp-bug-fixing-server"),
+    route: "/use-cases/mcp-bug-fixing-server",
+    markdown: "use-cases/mcp-bug-fixing-server.md",
+    keywords: ["use-cases", "use", "cases", "mcp-bug-fixing-server", "mcp", "bug", "fixing", "server"],
+    headings: ["What the agent can do with it", "Setup", "Hosted or self-hosted"],
+    excerpt: "What an MCP bug-fixing server is and how Mushi's works \u2014 Cursor, Claude Code, or Codex read live bug reports, pull fix context, and dispatch fixes."
   },
   {
-    title: "Privacy & BYOK",
-    path: `${BASE}/guides/privacy`,
-    keywords: ["privacy", "byok", "data region", "llm"],
-    excerpt: "Data boundaries, BYOK LLM keys, and retention."
+    title: "Sentry alternative for AI-built apps",
+    url: docUrl("/use-cases/sentry-alternative"),
+    route: "/use-cases/sentry-alternative",
+    markdown: "use-cases/sentry-alternative.md",
+    keywords: ["use-cases", "use", "cases", "sentry-alternative", "sentry", "alternative", "ai-built", "apps"],
+    headings: ["Instead of Sentry, or alongside it \u2014 your call", "Side by side", 'What "diagnosis" means here', "Try it on your app"],
+    excerpt: "An open-source Sentry alternative for AI-built apps \u2014 plain-English bug diagnoses and ready fixes instead of raw stack traces. Works with or without Sentry."
   }
 ];
+var QUERY_STOPWORDS = /* @__PURE__ */ new Set(["a", "an", "and", "are", "can", "do", "does", "for", "from", "how", "i", "in", "is", "it", "me", "my", "of", "on", "or", "the", "to", "use", "using", "what", "when", "where", "which", "why", "with", "you", "your", "mushi"]);
 function searchMushiDocs(query, limit = 8) {
   const q = query.trim().toLowerCase();
   if (!q) {
     return MUSHI_DOCS_INDEX.slice(0, limit).map((e) => ({ ...e, score: 0 }));
   }
-  const terms = q.split(/\s+/).filter(Boolean);
+  const allTerms = q.split(/[\s?!,;:()"']+/).filter(Boolean);
+  const meaningful = allTerms.filter((t) => !QUERY_STOPWORDS.has(t));
+  const terms = meaningful.length > 0 ? meaningful : allTerms;
   const scored = MUSHI_DOCS_INDEX.map((entry) => {
-    const hay = `${entry.title} ${entry.keywords.join(" ")} ${entry.excerpt}`.toLowerCase();
+    const title = entry.title.toLowerCase();
+    const headings = entry.headings.join(" ").toLowerCase();
+    const hay = (entry.title + " " + entry.keywords.join(" ") + " " + headings + " " + entry.excerpt).toLowerCase();
     let score = 0;
     for (const term of terms) {
-      if (entry.title.toLowerCase().includes(term)) score += 4;
-      if (entry.keywords.some((k) => k.includes(term))) score += 3;
+      if (title.includes(term)) score += 4;
+      if (entry.keywords.some((k) => k === term)) score += 4;
+      else if (entry.keywords.some((k) => k.includes(term))) score += 2;
+      if (headings.includes(term)) score += 2;
       if (hay.includes(term)) score += 1;
     }
+    if (terms.length > 1 && terms.every((t) => hay.includes(t))) score += 3;
+    if (score > 0 && entry.route.split("/").length <= 3) score += 1;
     return { ...entry, score };
-  }).filter((e) => e.score > 0).sort((a, b) => b.score - a.score);
+  }).filter((e) => e.score > 0).sort((a, b) => b.score - a.score || a.title.localeCompare(b.title));
   return scored.slice(0, limit);
 }
+function findMushiDoc(page) {
+  const raw = page.trim().split(/[?#]/)[0] ?? "";
+  const route = raw.startsWith(MUSHI_DOCS_BASE) ? raw.slice(MUSHI_DOCS_BASE.length) || "/" : raw;
+  const normalised = route === "/" ? "/" : "/" + route.replace(/^\/+|\/+$/g, "");
+  return MUSHI_DOCS_INDEX.find((e) => e.route === normalised) ?? null;
+}
+function mushiDocMarkdownUrl(entry) {
+  return MUSHI_DOCS_BASE + "/llm-md/" + entry.markdown;
+}
 
 // src/wrap-untrusted.ts
 function wrapUntrusted(content, role) {
@@ -209,9 +1967,295 @@ function safeStringify(value) {
   }
 }
 
+// src/arg-aliases.ts
+function snakeAliasOf(name) {
+  return name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+function normalizeArgAliases(args, declared) {
+  const out = { ...args };
+  for (const name of declared) {
+    const alias = snakeAliasOf(name);
+    if (alias === name || !Object.prototype.hasOwnProperty.call(out, alias)) continue;
+    if (out[name] === void 0) out[name] = out[alias];
+    delete out[alias];
+  }
+  return out;
+}
+
+// src/report-shapes.ts
+var REPORT_LIST_FIELDS = [
+  "id",
+  "status",
+  "category",
+  "severity",
+  "summary",
+  "component",
+  "created_at",
+  "processing_error"
+];
+var REPORTER_IDENTITY_FIELDS = [
+  "end_user_id",
+  "reporter_token_hash",
+  "session_id",
+  "reporter_display_name",
+  "reporter_user_id",
+  "reporter_identity",
+  "tester_id"
+];
+var REPORT_DETAIL_FIELDS = [
+  "id",
+  "project_id",
+  "title",
+  "summary",
+  "description",
+  "status",
+  "category",
+  "severity",
+  "component",
+  "area_tag",
+  "source",
+  "confidence",
+  "user_category",
+  "user_intent",
+  "voice_transcript",
+  "created_at",
+  "updated_at",
+  "fixed_at",
+  "verified_at",
+  "reopened_at",
+  "regressed_at",
+  "regression_count",
+  "screenshot_url",
+  "environment",
+  "console_logs",
+  "network_logs",
+  "performance_metrics",
+  "breadcrumbs",
+  "repro_timeline",
+  "selected_element",
+  "tags",
+  "app_version",
+  "sdk_package",
+  "sdk_version",
+  "stage1_classification",
+  "stage2_analysis",
+  "reproduction_steps",
+  "bug_ontology_tags",
+  "extracted_symptoms",
+  "vision_analysis",
+  "judge_score",
+  "judge_eval",
+  "processing_error",
+  "fix_branch",
+  "fix_pr_url",
+  "fix_commit_sha",
+  "fix_attempts",
+  "fix_packet",
+  "inventory_action",
+  "sentry_event_id",
+  "sentry_trace_id",
+  "sentry_replay_id",
+  "sentry_issue_url",
+  "sentry_release",
+  "report_group_id",
+  "parent_report_id",
+  "child_report_ids",
+  "backend_spans",
+  "anomalies"
+];
+var IDENTITY = new Set(REPORTER_IDENTITY_FIELDS);
+function spansWithoutSession(spans) {
+  if (!Array.isArray(spans)) return spans;
+  return spans.map((span) => {
+    if (!span || typeof span !== "object" || Array.isArray(span)) return span;
+    const { session_id: _session, ...rest } = span;
+    return rest;
+  });
+}
+function projectReportListRow(row, includeRaw) {
+  if (includeRaw) return Object.fromEntries(Object.entries(row).filter(([k]) => !IDENTITY.has(k)));
+  const out = {};
+  for (const field of REPORT_LIST_FIELDS) {
+    if (row[field] !== void 0) out[field] = row[field];
+  }
+  return out;
+}
+function projectReportDetail(row, includeRaw) {
+  const out = {};
+  if (includeRaw) {
+    for (const [k, v] of Object.entries(row)) if (!IDENTITY.has(k)) out[k] = v;
+  } else {
+    for (const field of REPORT_DETAIL_FIELDS) if (row[field] !== void 0) out[field] = row[field];
+  }
+  if (out.backend_spans !== void 0) out.backend_spans = spansWithoutSession(out.backend_spans);
+  return out;
+}
+function reportEvidenceOf(report, reportId) {
+  return {
+    report_id: reportId,
+    title: report.title ?? null,
+    summary: report.summary ?? null,
+    description: report.description ?? null,
+    status: report.status ?? null,
+    severity: report.severity ?? null,
+    category: report.category ?? null,
+    screenshot_url: report.screenshot_url ?? null,
+    environment: report.environment ?? null,
+    // LOGS
+    console_logs: report.console_logs ?? null,
+    breadcrumbs: report.breadcrumbs ?? null,
+    repro_timeline: report.repro_timeline ?? null,
+    // TRACES
+    network_requests: report.network_logs ?? null,
+    backend_spans: spansWithoutSession(report.backend_spans ?? null),
+    sentry_replay_id: report.sentry_replay_id ?? null,
+    sentry_trace_id: report.sentry_trace_id ?? null,
+    sentry_event_id: report.sentry_event_id ?? null,
+    sentry_release: report.sentry_release ?? null,
+    // METRICS
+    performance_metrics: report.performance_metrics ?? null,
+    anomalies: report.anomalies ?? null,
+    // context
+    tags: report.tags ?? null,
+    created_at: report.created_at ?? null
+  };
+}
+function fixContextOf(report) {
+  return {
+    // Paste-ready fix prompt composed server-side by composeFixPacket()
+    // (diagnosis + repro + suggested fix + relevant code + blast radius).
+    fixPrompt: report.fix_packet ?? null,
+    reproductionSteps: report.reproduction_steps ?? [],
+    component: report.component ?? null,
+    rootCause: report.stage2_analysis?.rootCause ?? null,
+    bugOntologyTags: report.bug_ontology_tags ?? null
+  };
+}
+function similarityQueryOf(report) {
+  for (const field of ["summary", "description"]) {
+    const value = report[field];
+    if (typeof value === "string" && value.trim()) return value.trim().slice(0, 2e3);
+  }
+  return null;
+}
+function inventoryActionNodeIdOf(report) {
+  const anchor = report.inventory_action;
+  return typeof anchor?.actionNodeId === "string" && anchor.actionNodeId ? anchor.actionNodeId : null;
+}
+function triageRecommendedActions(report, reportId) {
+  if (!report) return [];
+  const actions = [];
+  const status = typeof report.status === "string" ? report.status : "";
+  const processingError = typeof report.processing_error === "string" ? report.processing_error : null;
+  const attempts = Array.isArray(report.fix_attempts) ? report.fix_attempts : [];
+  const latest = attempts[0] ?? null;
+  const latestStatus = latest ? String(latest.status ?? "") : "";
+  const blocked = (processingError?.startsWith("autofix_blocked:") ?? false) || latestStatus.startsWith("skipped") || latestStatus === "failed";
+  if (blocked && status !== "fixing" && status !== "fixed") {
+    const why = processingError || String(latest?.error ?? "the previous fix attempt was skipped or failed");
+    actions.push({
+      action: "unblock_autofix",
+      reason: `Auto-fix is blocked: ${why}. Resolve the blocker (settings/integration/budget), then re-dispatch.`,
+      tool: "diagnose_setup",
+      args: { mode: "dispatch" }
+    });
+    actions.push({
+      action: "redispatch_after_unblock",
+      reason: "Once the blocker above is resolved, dispatch a fresh fix attempt.",
+      tool: "dispatch_fix",
+      args: { reportId }
+    });
+  } else if (status === "new" || status === "classified" || status === "triaged" || status === "reopened") {
+    actions.push({
+      action: "dispatch_fix",
+      reason: "The report is classified and has no fix in flight.",
+      tool: "dispatch_fix",
+      args: { reportId }
+    });
+  } else if (status === "fixing") {
+    actions.push(
+      typeof latest?.id === "string" ? {
+        action: "check_fix_progress",
+        reason: "A fix is in progress \u2014 check its timeline.",
+        tool: "get_fix_timeline",
+        args: { fixId: latest.id }
+      } : {
+        action: "check_fix_progress",
+        reason: "A fix is in progress \u2014 check the report timeline.",
+        tool: "get_report_timeline",
+        args: { reportId }
+      }
+    );
+  } else if (status === "fixed") {
+    actions.push({
+      action: "verify_fix",
+      reason: "A fix was applied \u2014 verify it resolved the issue, then mark the report verified (or reopen it).",
+      tool: "get_fix_context",
+      args: { reportId }
+    });
+  }
+  const actionNodeId = inventoryActionNodeIdOf(report);
+  if ((report.severity === "critical" || report.severity === "high") && actionNodeId) {
+    actions.push({
+      action: "check_blast_radius",
+      reason: "High severity \u2014 check what else the affected inventory action touches.",
+      tool: "get_blast_radius",
+      args: { nodeId: actionNodeId }
+    });
+  }
+  return actions;
+}
+function triageSummaryOf(report, actions) {
+  if (!report) return "Could not fetch the report \u2014 see partial_errors.";
+  const severity = typeof report.severity === "string" ? report.severity : "unknown";
+  const category = typeof report.category === "string" ? report.category : "unknown";
+  const status = typeof report.status === "string" ? report.status : "unknown";
+  const next = actions[0] ? `Recommended: ${actions[0].action}.` : "No action required.";
+  return `[${severity}] ${category} \u2014 status: ${status}. ${next}`;
+}
+
 // src/server.ts
 installStdoutGuard();
 var NO_ARG_INPUT = z.object({});
+var RENAMED_PARAMS = /* @__PURE__ */ new Set([
+  "projectId",
+  "reportId",
+  "includeRaw",
+  "includeLogs",
+  "diffText",
+  "maxTokens",
+  "topK",
+  "runId",
+  "stepIndex",
+  "prUrl",
+  "agentRef",
+  "threadId",
+  "filePath",
+  "symbolName",
+  "scopePrefix",
+  "fixId",
+  "externalUserId",
+  "tierSlug",
+  "rootSkillSlug"
+]);
+function acceptSnakeCaseAliases(schema) {
+  if (!(schema instanceof z.ZodObject)) return schema;
+  const shape = schema.shape;
+  const declared = Object.keys(shape).filter((key) => /[A-Z]/.test(key));
+  if (declared.length === 0) return schema;
+  const documented = {};
+  for (const key of declared) {
+    if (!RENAMED_PARAMS.has(key)) continue;
+    const field = shape[key];
+    const note = `(\`${snakeAliasOf(key)}\` is accepted too.)`;
+    documented[key] = field.describe(field.description ? `${field.description} ${note}` : note);
+  }
+  const target = Object.keys(documented).length > 0 ? schema.extend(documented) : schema;
+  return z.preprocess(
+    (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? normalizeArgAliases(value, declared) : value,
+    target
+  );
+}
 var DEFAULT_API_TIMEOUT_MS = 15e3;
 var MIN_API_TIMEOUT_MS = 250;
 var MAX_API_TIMEOUT_MS = 3e5;
@@ -254,6 +2298,104 @@ var MushiApiError = class extends Error {
   status;
   code;
 };
+var MUSHI_DOC_MAX_CHARS = 8e3;
+var REPORT_STATUSES = [
+  "new",
+  "pending",
+  "submitted",
+  "queued",
+  "classified",
+  "grouped",
+  "fixing",
+  "fixed",
+  "dismissed",
+  "triaged",
+  "in_progress",
+  "resolved",
+  "verified",
+  "reopened"
+];
+var REPORT_CATEGORIES = ["bug", "slow", "visual", "confusing", "other"];
+var REPORT_SEVERITIES = ["critical", "high", "medium", "low"];
+var GATE_IDS = [
+  "dead_handler",
+  "mock_leak",
+  "api_contract",
+  "crawl",
+  "status_claim",
+  "spec_drift",
+  "orphan_endpoint",
+  "unknown_call",
+  "schema_drift",
+  "code_health"
+];
+var GATE_FINDING_SEVERITIES = ["info", "warn", "error"];
+var SKILL_CATEGORIES = [
+  "workflow",
+  "debug",
+  "test",
+  "audit",
+  "enhance",
+  "backend",
+  "design",
+  "deploy",
+  "data",
+  "mobile",
+  "docs",
+  "meta",
+  "mushi",
+  "protocol",
+  "iterate",
+  "other"
+];
+var CODEBASE_SEARCH_MODES = ["semantic", "name"];
+var DISPATCH_AGENTS = [
+  "auto",
+  "claude_code",
+  "codex",
+  "cursor_cloud",
+  "github_cloud_agent",
+  "rest_worker",
+  "rest_fix_worker",
+  "llm",
+  "mcp"
+];
+var nullableString = () => z.string().nullable().optional();
+var REPORT_DETAIL_OUTPUT = z.looseObject({
+  id: z.string().describe("Report UUID"),
+  project_id: nullableString(),
+  title: nullableString(),
+  summary: nullableString().describe("One-line summary written by the classifier"),
+  description: nullableString().describe("What the reporter wrote (untrusted text)"),
+  status: nullableString().describe("Workflow status, e.g. new, classified, fixing, fixed, verified, reopened"),
+  category: nullableString().describe("bug | slow | visual | confusing | other"),
+  severity: nullableString().describe("critical | high | medium | low"),
+  component: nullableString().describe("Component or page the bug was attributed to"),
+  created_at: nullableString(),
+  screenshot_url: nullableString().describe("Signed screenshot URL"),
+  environment: z.unknown().optional().describe("Browser/OS/viewport the SDK captured"),
+  console_logs: z.unknown().optional().describe("Console entries captured with the report"),
+  network_logs: z.unknown().optional().describe("Network requests captured with the report"),
+  breadcrumbs: z.unknown().optional(),
+  stage1_classification: z.unknown().optional().describe("Stage-1 (fast) classification"),
+  stage2_analysis: z.unknown().optional().describe("Stage-2 analysis: rootCause, suggestedFix, \u2026"),
+  reproduction_steps: z.unknown().optional(),
+  fix_attempts: z.array(z.looseObject({ id: z.string(), status: nullableString() })).optional().describe("Latest fix attempts, newest first"),
+  fix_packet: z.unknown().optional().describe("Paste-ready fix prompt composed server-side"),
+  inventory_action: z.unknown().optional().describe("Inventory action the report is filed against, when resolved"),
+  child_report_ids: z.array(z.string()).optional()
+});
+var FIX_CONTEXT_SHAPE = {
+  fixPrompt: z.unknown().describe("Paste-ready fix prompt composed server-side, or null"),
+  reproductionSteps: z.unknown().describe("Reproduction steps recorded on the report ([] if none)"),
+  component: z.string().nullable().describe("Component or page the bug was attributed to"),
+  rootCause: z.unknown().describe("Stage-2 root cause, or null before Stage 2 runs"),
+  bugOntologyTags: z.unknown().describe("Bug ontology tags, or null")
+};
+function isWrappedUntrusted(text) {
+  return text.startsWith('<mushi-data role="');
+}
+var toolCallContext = new AsyncLocalStorage();
 function createMushiServer(config) {
   const { version, apiEndpoint, apiKey, projectId } = config;
   const doFetch = config.fetch ?? globalThis.fetch;
@@ -276,6 +2418,7 @@ function createMushiServer(config) {
     const requestId = crypto.randomUUID().slice(0, 12);
     const started = Date.now();
     const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const toolCall = toolCallContext.getStore();
     let res;
     try {
       res = await doFetch(`${apiEndpoint}${path}`, {
@@ -288,6 +2431,11 @@ function createMushiServer(config) {
           Authorization: `Bearer ${apiKey}`,
           "X-Mushi-Api-Key": apiKey,
           "X-Request-Id": requestId,
+          // Lets the api count stdio tool use once per call and credit the
+          // funnel steps (report opened, fix pulled, fix dispatched) that the
+          // hosted transport already credits. Tool name and a random id only.
+          "X-Mushi-Client": `mcp-stdio/${version}`,
+          ...toolCall ? { "X-Mushi-Mcp-Tool": toolCall.tool, "X-Mushi-Mcp-Invocation": toolCall.invocationId } : {},
           ...projectId ? { "X-Mushi-Project-Id": projectId } : {},
           ...options?.headers ?? {}
         },
@@ -449,13 +2597,26 @@ function createMushiServer(config) {
       structuredContent: value
     };
   }
-  const server = new McpServer({
-    name: MUSHI_SERVER_METADATA.name,
-    version,
-    title: MUSHI_SERVER_METADATA.title,
-    websiteUrl: MUSHI_SERVER_METADATA.websiteUrl,
-    icons: [...MUSHI_SERVER_METADATA.icons]
-  });
+  const server = new McpServer(
+    {
+      name: MUSHI_SERVER_METADATA.name,
+      version,
+      title: MUSHI_SERVER_METADATA.title,
+      websiteUrl: MUSHI_SERVER_METADATA.websiteUrl,
+      icons: [...MUSHI_SERVER_METADATA.icons]
+    },
+    // Returned in `initialize`; used to be null on stdio.
+    { instructions: config.instructions ?? MUSHI_SERVER_INSTRUCTIONS }
+  );
+  const registerTool = server.registerTool.bind(server);
+  server.registerTool = ((name, toolConfig, handler) => registerTool(
+    name,
+    { ...toolConfig, inputSchema: acceptSnakeCaseAliases(toolConfig.inputSchema) },
+    ((...args) => toolCallContext.run(
+      { tool: name, invocationId: crypto.randomUUID() },
+      () => handler(...args)
+    ))
+  ));
   const ALL_TOOL_CATALOG = [...TOOL_CATALOG, ...TDD_TOOL_CATALOG, ...CODEBASE_TOOL_CATALOG];
   function annotationsFor(name, catalog = ALL_TOOL_CATALOG) {
     const spec = catalog.find((t) => t.name === name);
@@ -486,16 +2647,29 @@ function createMushiServer(config) {
       description: descOf("get_recent_reports"),
       annotations: annotationsFor("get_recent_reports"),
       inputSchema: z.object({
-        status: z.string().optional().describe("Filter by status: new, classified, grouped, fixing, fixed, dismissed"),
-        category: z.string().optional().describe("Filter by category: bug, slow, visual, confusing, other"),
-        severity: z.string().optional().describe("Filter by severity: critical, high, medium, low"),
+        status: z.enum(REPORT_STATUSES).optional().describe('Filter by status. "new" also matches queued rows; "classified" and "fixed" include legacy aliases.'),
+        category: z.enum(REPORT_CATEGORIES).optional().describe("Filter by category."),
+        severity: z.enum(REPORT_SEVERITIES).optional().describe("Filter by severity."),
         limit: z.number().optional().describe("Max reports to return (default 20, max 100)"),
-        project_id: z.string().optional().describe(
-          "Project UUID \u2014 defaults to the server-configured project. Useful when you have multiple projects and want to query a specific one by its ID. Get IDs by calling list_projects or get_account_overview first."
+        includeRaw: z.boolean().optional().describe(
+          "Return every column the list route has (breadcrumbs, environment, tags, \u2026) instead of the documented fields. Reporter identifiers are removed either way."
+        ),
+        projectId: z.string().optional().describe(
+          "Project UUID \u2014 defaults to the server-configured project. Useful when your key spans several projects; the error you get without it lists their ids."
         )
       }),
       outputSchema: z.object({
-        reports: z.array(z.unknown()),
+        reports: z.array(
+          z.looseObject({
+            id: z.string(),
+            status: z.string().nullable().optional(),
+            category: z.string().nullable().optional(),
+            severity: z.string().nullable().optional(),
+            summary: z.string().nullable().optional(),
+            component: z.string().nullable().optional(),
+            created_at: z.string().nullable().optional()
+          })
+        ),
         total: z.number()
       })
     },
@@ -505,7 +2679,7 @@ function createMushiServer(config) {
       if (args.category) params.set("category", args.category);
       if (args.severity) params.set("severity", args.severity);
       params.set("limit", String(Math.min(args.limit ?? 20, 100)));
-      const pid = await resolveProjectId(args.project_id);
+      const pid = await resolveProjectId(args.projectId);
       const extraHeaders = pid !== projectId ? { "X-Mushi-Project-Id": pid } : {};
       const data = await apiCall(
         `/v1/admin/reports?${params}`,
@@ -513,7 +2687,10 @@ function createMushiServer(config) {
           headers: extraHeaders
         }
       );
-      return jsonResult(data);
+      return jsonResult({
+        reports: (data.reports ?? []).map((row) => projectReportListRow(row, args.includeRaw === true)),
+        total: data.total ?? 0
+      });
     }
   );
   server.registerTool(
@@ -524,23 +2701,17 @@ function createMushiServer(config) {
       annotations: annotationsFor("get_report_detail"),
       inputSchema: z.object({
         reportId: z.string().describe("The report UUID"),
-        project_id: z.string().optional().describe("Project UUID \u2014 required for org-scoped keys with multiple projects.")
+        includeRaw: z.boolean().optional().describe(
+          "Return every column the detail route has (LLM invocation log, storage paths, custom metadata, \u2026) instead of the documented fields. Reporter identifiers are removed either way."
+        ),
+        projectId: z.string().optional().describe("Project UUID \u2014 required for org-scoped keys with multiple projects.")
       }),
-      outputSchema: z.object({ report: z.unknown() })
+      outputSchema: z.object({ report: REPORT_DETAIL_OUTPUT })
     },
     async (args) => {
-      const { headers } = await projectScopeHeaders(args.project_id);
+      const { headers } = await projectScopeHeaders(args.projectId);
       const data = await apiCall(`/v1/admin/reports/${args.reportId}`, { headers });
-      const res = wrappedJsonResult({ report: data }, "report body");
-      return {
-        ...res,
-        resource_links: [
-          {
-            uri: `project://reports/${args.reportId}`,
-            title: `Report ${args.reportId.slice(0, 8)}\u2026`
-          }
-        ]
-      };
+      return wrappedJsonResult({ report: projectReportDetail(data, args.includeRaw === true) }, "report body");
     }
   );
   server.registerTool(
@@ -626,33 +2797,24 @@ function createMushiServer(config) {
       annotations: annotationsFor("get_fix_context"),
       inputSchema: z.object({
         reportId: z.string().describe("The report UUID to fix"),
-        project_id: z.string().optional().describe("Project UUID \u2014 required for org-scoped keys with multiple projects.")
+        projectId: z.string().optional().describe("Project UUID \u2014 required for org-scoped keys with multiple projects.")
       }),
       outputSchema: z.object({
-        report: z.unknown(),
-        fixPrompt: z.unknown(),
-        reproductionSteps: z.unknown(),
-        component: z.unknown(),
-        rootCause: z.unknown(),
-        bugOntologyTags: z.unknown()
+        report: REPORT_DETAIL_OUTPUT,
+        ...FIX_CONTEXT_SHAPE,
+        inventoryAction: z.unknown().describe("The inventory action (with its expected_outcome contract) the report is filed against, or null")
       })
     },
     async (args) => {
-      const { headers } = await projectScopeHeaders(args.project_id);
+      const { headers } = await projectScopeHeaders(args.projectId);
       const report = await apiCall(`/v1/admin/reports/${args.reportId}`, {
         headers
       });
       return wrappedJsonResult(
         {
-          report,
-          // Paste-ready fix prompt composed server-side by composeFixPacket()
-          // (diagnosis + repro + suggested fix + relevant code + blast radius).
-          // Hand this straight to the editing agent — no second LLM key needed.
-          fixPrompt: report.fix_packet ?? null,
-          reproductionSteps: report.reproduction_steps ?? [],
-          component: report.component,
-          rootCause: report.stage2_analysis?.rootCause,
-          bugOntologyTags: report.bug_ontology_tags
+          report: projectReportDetail(report, false),
+          ...fixContextOf(report),
+          inventoryAction: report.inventory_action ?? null
         },
         "fix context"
       );
@@ -665,12 +2827,12 @@ function createMushiServer(config) {
       description: descOf("get_fix_timeline"),
       annotations: annotationsFor("get_fix_timeline"),
       inputSchema: z.object({
-        fixId: z.string().describe("fix_attempt UUID"),
-        project_id: z.string().optional().describe("Project UUID \u2014 required for org-scoped keys with multiple projects.")
+        fixId: z.string().describe("fix_attempt UUID (or the dispatch id dispatch_fix returned)"),
+        projectId: z.string().optional().describe("Project UUID \u2014 required for org-scoped keys with multiple projects.")
       })
     },
     async (args) => {
-      const { headers } = await projectScopeHeaders(args.project_id);
+      const { headers } = await projectScopeHeaders(args.projectId);
       return jsonText(await apiCall(`/v1/admin/fixes/${args.fixId}/timeline`, { headers }));
     }
   );
@@ -801,8 +2963,8 @@ function createMushiServer(config) {
       annotations: annotationsFor("list_gate_findings"),
       inputSchema: z.object({
         projectId: z.string().optional().describe("Project UUID \u2014 defaults to configured project"),
-        gate: z.string().optional().describe("Filter to one gate id: dead-handler | mock-leak | crawl | status-claim"),
-        severity: z.string().optional().describe("Minimum severity to include: low | medium | high | critical")
+        gate: z.enum(GATE_IDS).optional().describe("Only runs of this gate (and their findings)."),
+        severity: z.enum(GATE_FINDING_SEVERITIES).optional().describe("Only findings with exactly this severity.")
       }),
       outputSchema: z.object({
         runs: z.array(z.unknown()).describe("Recent gate_runs rows, newest first"),
@@ -902,11 +3064,10 @@ function createMushiServer(config) {
         mode: z.enum(["full", "ingest", "dispatch"]).optional().describe(
           "full (default) = ingest + dispatch; ingest = SDK pipeline only; dispatch = fix preflight only."
         ),
-        project_id: z.string().optional().describe("Project UUID for dispatch checks (defaults to configured project)."),
-        projectId: z.string().optional().describe("Alias for project_id.")
+        projectId: z.string().optional().describe("Project UUID for dispatch checks (defaults to configured project).")
       }),
       outputSchema: z.object({
-        mode: z.string(),
+        mode: z.enum(["full", "ingest", "dispatch"]),
         ready: z.boolean(),
         summary: z.string(),
         nextAction: z.string().optional(),
@@ -917,7 +3078,7 @@ function createMushiServer(config) {
     },
     async (args) => {
       const mode = args.mode ?? "full";
-      const resolvedId = args.project_id ?? args.projectId ?? projectId;
+      const resolvedId = args.projectId ?? projectId;
       if (mode === "ingest") {
         const data = await apiCall("/v1/sync/ingest-setup");
         const failed = data.steps.filter((s) => s.required && !s.complete);
@@ -942,7 +3103,7 @@ function createMushiServer(config) {
           throw new MushiApiError(
             400,
             "MISSING_PROJECT",
-            "project_id is required for dispatch mode"
+            "projectId is required for dispatch mode"
           );
         }
         const data = await apiCall(`/v1/admin/projects/${resolvedId}/preflight`);
@@ -1121,7 +3282,7 @@ function createMushiServer(config) {
         results: z.array(
           z.object({
             title: z.string(),
-            path: z.string(),
+            url: z.string(),
             excerpt: z.string(),
             score: z.number()
           })
@@ -1131,15 +3292,58 @@ function createMushiServer(config) {
     async (args) => {
       const query = args.query ?? "";
       const hits = searchMushiDocs(query, args.limit ?? 8);
-      const results = hits.map(({ title, path, excerpt, score }) => ({
-        title,
-        path,
-        excerpt,
-        score
-      }));
+      const results = hits.map(({ title, url, excerpt, score }) => ({ title, url, excerpt, score }));
       return jsonResult({ query, results });
     }
   );
+  server.registerTool(
+    "get_mushi_doc",
+    {
+      title: titleOf("get_mushi_doc"),
+      description: descOf("get_mushi_doc"),
+      annotations: annotationsFor("get_mushi_doc"),
+      inputSchema: z.object({
+        page: z.string().min(1).describe('A url from search_mushi_docs, or a docs route such as "/quickstart/mcp".')
+      }),
+      outputSchema: z.object({
+        title: z.string(),
+        url: z.string(),
+        markdown: z.string(),
+        truncated: z.boolean()
+      })
+    },
+    async (args) => {
+      const entry = findMushiDoc(args.page);
+      if (!entry) {
+        throw new MushiApiError(
+          404,
+          "DOC_NOT_FOUND",
+          `No docs page matches "${args.page}". Call search_mushi_docs and pass one of the urls it returns.`
+        );
+      }
+      const res = await doFetch(mushiDocMarkdownUrl(entry), {
+        headers: { Accept: "text/markdown, text/plain;q=0.9" },
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!res.ok) {
+        throw new MushiApiError(
+          res.status,
+          "DOC_FETCH_FAILED",
+          `The docs site answered ${res.status} for ${entry.url}. Open it in a browser instead.`
+        );
+      }
+      const text = await res.text();
+      const truncated = text.length > MUSHI_DOC_MAX_CHARS;
+      return jsonResult({
+        title: entry.title,
+        url: entry.url,
+        markdown: truncated ? `${text.slice(0, MUSHI_DOC_MAX_CHARS)}
+
+\u2026 (truncated \u2014 read the rest at ${entry.url})` : text,
+        truncated
+      });
+    }
+  );
   server.registerTool(
     "list_projects",
     {
@@ -1199,12 +3403,12 @@ function createMushiServer(config) {
       description: descOf("get_project_context"),
       annotations: annotationsFor("get_project_context"),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID. Defaults to configured project.")
+        projectId: z.string().optional().describe("Project UUID. Defaults to configured project.")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "projectId is required");
       const [preflightRes, activationRes] = await Promise.allSettled([
         apiCall(`/v1/admin/projects/${pid}/preflight`),
         apiCall(`/v1/admin/activation?project_id=${encodeURIComponent(pid)}`)
@@ -1223,7 +3427,7 @@ function createMushiServer(config) {
       description: descOf("get_pipeline_logs"),
       annotations: annotationsFor("get_pipeline_logs"),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID. Defaults to configured project."),
+        projectId: z.string().optional().describe("Project UUID. Defaults to configured project."),
         service: z.enum(["fix-worker", "qa-story-runner", "pipeline", "all"]).optional().describe("Pipeline service to filter (default: all)."),
         since: z.string().optional().describe("ISO-8601 timestamp \u2014 return only entries after this time."),
         limit: z.number().optional().describe("Max entries to return (default 50, max 200)."),
@@ -1231,8 +3435,8 @@ function createMushiServer(config) {
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "projectId is required");
       const qs = new URLSearchParams();
       if (args.service && args.service !== "all") qs.set("service", args.service);
       if (args.since) qs.set("since", args.since);
@@ -1249,41 +3453,17 @@ function createMushiServer(config) {
       description: descOf("get_report_evidence"),
       annotations: annotationsFor("get_report_evidence"),
       inputSchema: z.object({
-        report_id: z.string().describe("Report UUID.")
+        reportId: z.string().describe("Report UUID.")
       })
     },
     async (args) => {
       const [reportRes, timelineRes] = await Promise.allSettled([
-        apiCall(`/v1/admin/reports/${args.report_id}`),
-        apiCall(`/v1/admin/reports/${args.report_id}/timeline`)
+        apiCall(`/v1/admin/reports/${args.reportId}`),
+        apiCall(`/v1/admin/reports/${args.reportId}/timeline`)
       ]);
       const report = reportRes.status === "fulfilled" ? reportRes.value : null;
       const timeline = timelineRes.status === "fulfilled" ? timelineRes.value : null;
-      const r = report;
-      const evidence = r ? {
-        report_id: args.report_id,
-        description: r.description,
-        summary: r.summary,
-        screenshot_url: r.screenshot_url ?? null,
-        environment: r.environment ?? null,
-        // LOGS
-        console_logs: r.console_logs ?? null,
-        breadcrumbs: r.breadcrumbs ?? null,
-        repro_timeline: r.repro_timeline ?? null,
-        // TRACES
-        network_requests: r.network_logs ?? null,
-        backend_spans: r.backend_spans ?? null,
-        sentry_replay_id: r.sentry_replay_id ?? null,
-        sentry_trace_id: r.sentry_trace_id ?? null,
-        sentry_event_id: r.sentry_event_id ?? null,
-        // METRICS
-        performance_metrics: r.performance_metrics ?? null,
-        anomalies: r.anomalies ?? null,
-        // context
-        session_id: r.session_id ?? null,
-        created_at: r.created_at,
-        tags: r.tags ?? null
-      } : { error: String(reportRes.reason) };
+      const evidence = report ? reportEvidenceOf(report, args.reportId) : { error: String(reportRes.reason) };
       return jsonText({
         evidence,
         reporter_thread: timeline ?? {
@@ -1299,94 +3479,82 @@ function createMushiServer(config) {
       description: descOf("triage_issue"),
       annotations: annotationsFor("triage_issue"),
       inputSchema: z.object({
-        report_id: z.string().uuid().describe("Report UUID to triage."),
-        project_id: z.string().optional().describe("Project UUID. Defaults to configured project."),
-        include_logs: z.boolean().optional().describe("Include recent pipeline logs in triage packet (default: true).")
+        reportId: z.string().uuid().describe("Report UUID to triage."),
+        projectId: z.string().optional().describe("Project UUID. Defaults to configured project."),
+        includeLogs: z.boolean().optional().describe("Include recent pipeline logs in triage packet (default: true).")
       }),
       outputSchema: z.object({
-        report_id: z.string(),
-        severity: z.unknown(),
-        category: z.unknown(),
-        status: z.unknown(),
-        report: z.unknown(),
-        reporter_thread: z.unknown().nullable(),
-        similar_bugs: z.unknown().nullable(),
-        fix_context: z.unknown().nullable(),
-        blast_radius: z.unknown().nullable(),
-        recent_logs: z.unknown().nullable(),
-        recommended_actions: z.array(z.unknown()),
-        triage_summary: z.string()
+        report_id: z.string().describe("The triaged report UUID"),
+        severity: z.string().nullable().describe("critical | high | medium | low, or unknown when the report could not be read"),
+        category: z.string().nullable().describe("bug | slow | visual | confusing | other, or unknown"),
+        status: z.string().nullable().describe("Workflow status, or unknown"),
+        partial_errors: z.array(z.string()).describe('Sources that failed, as "source: message"'),
+        notes: z.array(z.string()).describe("Sources that do not apply to this report, and why"),
+        report: z.union([REPORT_DETAIL_OUTPUT, z.object({ error: z.string() })]).describe("The report (documented fields, no reporter identifiers), or the error reading it"),
+        reporter_thread: z.looseObject({ report_id: z.string().optional(), timeline: z.array(z.unknown()).optional() }).nullable().describe("The unified report timeline (comments, fixes, QA), or null"),
+        similar_bugs: z.array(
+          z.looseObject({
+            reportId: z.string(),
+            similarity: z.number(),
+            description: nullableString(),
+            category: nullableString(),
+            createdAt: nullableString(),
+            reportGroupId: nullableString()
+          })
+        ).nullable().describe("Up to five nearest reports by summary, excluding this one; null when not searched"),
+        fix_context: z.object(FIX_CONTEXT_SHAPE).nullable().describe("Fix-context slice, as get_fix_context returns it"),
+        blast_radius: z.looseObject({ affected: z.array(z.unknown()).optional() }).nullable().describe("Downstream nodes of the inventory action the report is filed against, or null"),
+        recent_logs: z.looseObject({ entries: z.array(z.unknown()).optional() }).nullable().describe("Recent warn+ pipeline log entries for the project, or null"),
+        recommended_actions: z.array(
+          z.object({
+            action: z.string(),
+            reason: z.string(),
+            tool: z.string().optional().describe("Tool to call next"),
+            args: z.record(z.string(), z.unknown()).optional().describe("Arguments for that tool")
+          })
+        ).describe("What to do next, most important first"),
+        triage_summary: z.string().describe("One-line summary")
       })
     },
     async (args) => {
-      const { projectId: pid, headers } = await projectScopeHeaders(args.project_id);
-      const includeLogs = args.include_logs !== false;
-      const [reportRes, evidenceRes, similarRes, fixCtxRes, blastRes, logsRes] = await Promise.allSettled([
-        apiCall(`/v1/admin/reports/${args.report_id}`, { headers }),
-        apiCall(`/v1/admin/reports/${args.report_id}/timeline`, {
+      const { projectId: pid, headers } = await projectScopeHeaders(args.projectId);
+      const includeLogs = args.includeLogs !== false;
+      const reportPath = `/v1/admin/reports/${encodeURIComponent(args.reportId)}`;
+      const [reportRes, evidenceRes, logsRes] = await Promise.allSettled([
+        apiCall(reportPath, { headers }),
+        apiCall(`${reportPath}/timeline`, { headers }),
+        includeLogs ? apiCall(`/v1/admin/mcp/logs/${encodeURIComponent(pid)}?limit=20&level=warn`, {
           headers
-        }),
-        apiCall(`/v1/admin/reports/similarity`, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({ report_id: args.report_id })
-        }).catch(() => null),
-        apiCall(`/v1/admin/reports/${args.report_id}/fix-context`, { headers }).catch(
-          () => null
-        ),
-        apiCall(`/v1/admin/reports/${args.report_id}/blast-radius`, { headers }).catch(
-          () => null
-        ),
-        includeLogs ? apiCall(`/v1/admin/mcp/logs/${pid}?limit=20&level=warn`, { headers }).catch(
-          () => null
-        ) : Promise.resolve(null)
+        }) : Promise.resolve(null)
       ]);
       const report = reportRes.status === "fulfilled" ? reportRes.value : null;
-      const severity = report ? report.severity : "unknown";
-      const category = report ? report.category : "unknown";
-      const status = report ? report.status : "unknown";
-      const actions = [];
-      const processingError = report ? report.processing_error : null;
-      const attempts = report ? report.fix_attempts ?? [] : [];
-      const lastAttempt = attempts.length > 0 ? attempts[attempts.length - 1] : null;
-      const lastAttemptStatus = lastAttempt ? String(lastAttempt.status ?? "") : "";
-      const autofixBlocked = typeof processingError === "string" && processingError.startsWith("autofix_blocked:") || lastAttemptStatus.startsWith("skipped") || lastAttemptStatus === "failed";
-      if (autofixBlocked && status !== "fixing" && status !== "fixed") {
-        const blockReason = typeof processingError === "string" && processingError || String(lastAttempt?.error ?? "previous fix attempt was skipped or failed");
-        actions.push({
-          action: "unblock_autofix",
-          reason: `Auto-fix is blocked: ${blockReason}. Resolve the blocker (settings/integration/budget), then re-dispatch.`,
-          tool: "diagnose_setup",
-          args: { mode: "dispatch" }
-        });
-        actions.push({
-          action: "redispatch_after_unblock",
-          reason: "Once the blocker above is resolved, dispatch a fresh fix attempt.",
-          tool: "dispatch_fix",
-          args: { reportId: args.report_id }
-        });
-      } else if (status === "new" || status === "classified") {
-        actions.push({
-          action: "dispatch_fix",
-          reason: "Report is classified and no fix has been attempted",
-          tool: "dispatch_fix",
-          args: { reportId: args.report_id }
-        });
-      } else if (status === "fixing") {
-        actions.push({
-          action: "check_fix_progress",
-          reason: "Fix is in progress \u2014 check the fix timeline for latest status",
-          tool: "get_fix_timeline",
-          args: { reportId: args.report_id }
-        });
-      } else if (status === "fixed") {
-        actions.push({
-          action: "verify_fix",
-          reason: "Fix was applied \u2014 verify it resolved the issue",
-          tool: "get_fix_context",
-          args: { reportId: args.report_id }
-        });
+      const notes = [];
+      const similarityQuery = report ? similarityQueryOf(report) : null;
+      const actionNodeId = report ? inventoryActionNodeIdOf(report) : null;
+      if (report && !similarityQuery) {
+        notes.push("similar_bugs: the report has no summary or description to match on.");
+      }
+      if (report && !actionNodeId) {
+        notes.push(
+          "blast_radius: the report is not filed against an inventory action, so there is no graph node to traverse from. Use get_knowledge_graph with the component as the seed instead."
+        );
       }
+      const [similarRes, blastRes] = await Promise.allSettled([
+        similarityQuery ? apiCall("/v1/admin/reports/similarity", {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ query: similarityQuery, k: 6, threshold: 0.3, projectId: pid })
+        }) : Promise.resolve(null),
+        actionNodeId ? apiCall(`/v1/admin/graph/blast-radius/${encodeURIComponent(actionNodeId)}`, {
+          headers
+        }) : Promise.resolve(null)
+      ]);
+      const similarBugs = similarRes.status === "fulfilled" && similarRes.value ? (similarRes.value.results ?? []).filter((r) => r.reportId !== args.reportId).slice(0, 5) : null;
+      const text = (v) => typeof v === "string" ? v : v == null ? null : String(v);
+      const severity = report ? text(report.severity) : "unknown";
+      const category = report ? text(report.category) : "unknown";
+      const status = report ? text(report.status) : "unknown";
+      const actions = triageRecommendedActions(report, args.reportId);
       const partial_errors = [];
       if (reportRes.status === "rejected") {
         partial_errors.push(`report: ${String(reportRes.reason)}`);
@@ -1397,9 +3565,6 @@ function createMushiServer(config) {
       if (similarRes.status === "rejected") {
         partial_errors.push(`similarity: ${String(similarRes.reason)}`);
       }
-      if (fixCtxRes.status === "rejected") {
-        partial_errors.push(`fix_context: ${String(fixCtxRes.reason)}`);
-      }
       if (blastRes.status === "rejected") {
         partial_errors.push(`blast_radius: ${String(blastRes.reason)}`);
       }
@@ -1407,29 +3572,33 @@ function createMushiServer(config) {
         partial_errors.push(`recent_logs: ${String(logsRes.reason)}`);
       }
       const result = {
-        report_id: args.report_id,
+        report_id: args.reportId,
         severity,
         category,
         status,
         partial_errors,
-        report: reportRes.status === "fulfilled" ? reportRes.value : { error: String(reportRes.reason) },
+        notes,
+        report: report ? projectReportDetail(report, false) : { error: String(reportRes.reason) },
         reporter_thread: evidenceRes.status === "fulfilled" ? evidenceRes.value : null,
-        similar_bugs: similarRes.status === "fulfilled" ? similarRes.value : null,
-        fix_context: fixCtxRes.status === "fulfilled" ? fixCtxRes.value : null,
+        similar_bugs: similarBugs,
+        fix_context: report ? fixContextOf(report) : null,
         blast_radius: blastRes.status === "fulfilled" ? blastRes.value : null,
         recent_logs: logsRes.status === "fulfilled" ? logsRes.value : null,
         recommended_actions: actions,
-        triage_summary: `[${severity}] ${category} \u2014 status: ${status}. ${actions.length > 0 ? `Recommended: ${actions[0]?.action}.` : "No action required."}`
+        triage_summary: triageSummaryOf(report, actions)
       };
       const res = jsonResult(result);
       return {
         ...res,
-        resource_links: [
+        content: [
+          ...res.content,
           {
-            uri: `project://reports/${args.report_id}`,
-            title: `Report ${args.report_id.slice(0, 8)}\u2026`
-          },
-          ...pid ? [{ uri: `project://dashboard`, title: "Project dashboard" }] : []
+            type: "resource_link",
+            uri: "project://dashboard",
+            name: "project_dashboard",
+            title: "Project dashboard",
+            mimeType: "application/json"
+          }
         ]
       };
     }
@@ -1494,7 +3663,7 @@ function createMushiServer(config) {
       description: descOf("triage_next_steps"),
       annotations: annotationsFor("triage_next_steps"),
       inputSchema: z.object({
-        project_id: z.string().uuid().optional().describe("Project UUID (defaults to the configured project).")
+        projectId: z.string().uuid().optional().describe("Project UUID (defaults to the configured project).")
       }),
       outputSchema: z.object({
         steps: z.array(
@@ -1510,7 +3679,7 @@ function createMushiServer(config) {
       })
     },
     async (args) => {
-      const pid = await resolveProjectId(args.project_id);
+      const pid = await resolveProjectId(args.projectId);
       const extraHeaders = pid !== projectId ? { "X-Mushi-Project-Id": pid } : {};
       const data = await apiCall(
         "/v1/admin/reports?limit=100",
@@ -1539,7 +3708,7 @@ function createMushiServer(config) {
           action: `Shepherd in-flight fix: ${label(r)}`,
           reason: "A fix branch/PR is open \u2014 check CI and merge when green.",
           tool: "get_report_timeline",
-          args: { report_id: r.id }
+          args: { reportId: r.id }
         });
       }
       const openUserReports = reports.filter(
@@ -1554,7 +3723,7 @@ function createMushiServer(config) {
           action: `Triage [${r.severity}] ${label(r)}`,
           reason: "User-felt report awaiting triage \u2014 review the packet, then dispatch or dismiss.",
           tool: "triage_issue",
-          args: { report_id: r.id }
+          args: { reportId: r.id }
         });
       }
       const chores = reports.filter((r) => r.status === "classified" && isCron(r) && !isBlocked(r));
@@ -1579,7 +3748,8 @@ function createMushiServer(config) {
       annotations: annotationsFor("dispatch_fix"),
       inputSchema: z.object({
         reportId: z.string().uuid().describe("Report UUID to fix"),
-        agent: z.enum(["claude_code", "codex", "rest_worker", "mcp"]).optional().describe("Override the agent adapter"),
+        agent: z.enum(DISPATCH_AGENTS).optional().describe("Which agent runs the fix. Omit for the project default (auto); cursor_cloud and github_cloud_agent dispatch a cloud agent."),
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the configured project."),
         idempotencyKey: z.string().uuid().optional().describe(
           "Optional RFC 4122 UUID. Resend the same key to safely retry without dispatching a duplicate fix job (Idempotency-Key IETF draft)."
         ),
@@ -1607,6 +3777,7 @@ function createMushiServer(config) {
         } catch {
         }
       }
+      const pid = args.projectId ? await resolveProjectId(args.projectId) : projectId;
       const dispatch = await apiCall("/v1/admin/fixes/dispatch", {
         method: "POST",
         headers: args.idempotencyKey ? { "Idempotency-Key": args.idempotencyKey } : void 0,
@@ -1614,7 +3785,7 @@ function createMushiServer(config) {
           reportId: args.reportId,
           agent: args.agent,
           inventoryActionNodeId: args.inventoryActionNodeId,
-          ...projectId ? { projectId } : {}
+          ...pid ? { projectId: pid } : {}
         })
       });
       if (!dispatch?.dispatchId) {
@@ -1692,6 +3863,10 @@ function createMushiServer(config) {
       outputSchema: z.object({
         merged: z.boolean().optional().describe("True when GitHub accepted the merge in this call"),
         alreadyMerged: z.boolean().optional().describe("True when the PR was already merged (idempotent no-op)"),
+        // The merge route also returns these; declaring them keeps a strict
+        // client from rejecting a merge that already happened.
+        justMerged: z.boolean().optional().describe("True when this call performed the merge"),
+        sha: z.string().nullable().optional().describe("Merge commit SHA, when GitHub reported one"),
         reportId: z.string().describe("Report UUID linked to this fix attempt"),
         reportStatus: z.string().describe("Report workflow status after merge bookkeeping")
       })
@@ -1781,31 +3956,6 @@ function createMushiServer(config) {
       return jsonText(data);
     }
   );
-  server.registerTool(
-    "setup_repo_for_mushi",
-    {
-      title: titleOf("setup_repo_for_mushi"),
-      description: descOf("setup_repo_for_mushi"),
-      annotations: annotationsFor("setup_repo_for_mushi"),
-      inputSchema: z.object({
-        projectId: z.string().optional().describe("Project UUID \u2014 defaults to configured project")
-      })
-    },
-    async (args) => {
-      const pid = args.projectId ?? projectId;
-      if (!pid)
-        throw new MushiApiError(
-          400,
-          "MISSING_PROJECT",
-          "projectId is required for setup_repo_for_mushi"
-        );
-      const data = await apiCall(`/v1/admin/projects/${pid}/repo/bootstrap`, {
-        method: "POST",
-        body: JSON.stringify({})
-      });
-      return jsonText(data);
-    }
-  );
   server.registerTool(
     "query_lessons",
     {
@@ -1813,20 +3963,20 @@ function createMushiServer(config) {
       description: descOf("query_lessons"),
       annotations: annotationsFor("query_lessons"),
       inputSchema: z.object({
-        diff_text: z.string().describe("The PR diff, code snippet, or description of the change being made."),
-        max_tokens: z.number().optional().describe("Maximum tokens for returned lessons context (default 3000, max 8000)."),
-        top_k: z.number().optional().describe("Max number of lessons to return (default 15, max 50)."),
-        project_id: z.string().optional().describe("Project UUID. Defaults to configured project.")
+        diffText: z.string().describe("The PR diff, code snippet, or description of the change being made."),
+        maxTokens: z.number().optional().describe("Maximum tokens for returned lessons context (default 3000, max 8000)."),
+        topK: z.number().optional().describe("Max number of lessons to return (default 15, max 50)."),
+        projectId: z.string().optional().describe("Project UUID. Defaults to configured project.")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
+      const pid = args.projectId ?? projectId;
       const data = await apiCall("/v1/admin/lessons/query", {
         method: "POST",
         body: JSON.stringify({
-          diff_text: args.diff_text,
-          ...args.max_tokens !== void 0 ? { max_tokens: args.max_tokens } : {},
-          ...args.top_k !== void 0 ? { top_k: args.top_k } : {},
+          diff_text: args.diffText,
+          ...args.maxTokens !== void 0 ? { max_tokens: args.maxTokens } : {},
+          ...args.topK !== void 0 ? { top_k: args.topK } : {},
           ...pid ? { project_id: pid } : {}
         })
       });
@@ -1842,14 +3992,14 @@ function createMushiServer(config) {
       inputSchema: z.object({
         severity: z.enum(["info", "warn", "critical"]).optional().describe("Filter to one severity level"),
         limit: z.number().optional().describe("Max lessons to return (default 50, max 200)"),
-        project_id: z.string().optional().describe("Project UUID \u2014 defaults to configured project")
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to configured project")
       }),
       outputSchema: z.object({
         lessons: z.array(z.unknown()).describe("Promoted lesson rows ordered by frequency")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
+      const pid = args.projectId ?? projectId;
       const params = new URLSearchParams();
       if (args.severity) params.set("severity", args.severity);
       params.set("limit", String(Math.min(args.limit ?? 50, 200)));
@@ -1935,12 +4085,12 @@ function createMushiServer(config) {
       description: descOf("award_bonus_points"),
       annotations: annotationsFor("award_bonus_points"),
       inputSchema: z.object({
-        external_user_id: z.string().describe("The host-app user id as passed to Mushi.identify()"),
+        externalUserId: z.string().describe("The host-app user id as passed to Mushi.identify()"),
         points: z.number().int().min(1).max(5e4).describe("Bonus points to award (max 50,000 per call)"),
         reason: z.string().max(200).describe("Human-readable reason, logged to end_user_activity")
       })
     },
-    async ({ external_user_id, points, reason }) => ({
+    async ({ externalUserId, points, reason }) => ({
       content: [
         {
           type: "text",
@@ -1948,7 +4098,7 @@ function createMushiServer(config) {
             await apiCall("/v1/admin/rewards/bonus-points", {
               method: "POST",
               headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ external_user_id, points, reason })
+              body: JSON.stringify({ external_user_id: externalUserId, points, reason })
             }),
             null,
             2
@@ -1964,12 +4114,12 @@ function createMushiServer(config) {
       description: descOf("set_tier"),
       annotations: annotationsFor("set_tier"),
       inputSchema: z.object({
-        external_user_id: z.string().describe("The host-app user id as passed to Mushi.identify()"),
-        tier_slug: z.string().describe('Tier slug to assign, e.g. "champion", "contributor", "explorer"'),
+        externalUserId: z.string().describe("The host-app user id as passed to Mushi.identify()"),
+        tierSlug: z.string().describe('Tier slug to assign, e.g. "champion", "contributor", "explorer"'),
         reason: z.string().max(200).optional().describe("Optional reason for manual override")
       })
     },
-    async ({ external_user_id, tier_slug, reason }) => ({
+    async ({ externalUserId, tierSlug, reason }) => ({
       content: [
         {
           type: "text",
@@ -1977,7 +4127,7 @@ function createMushiServer(config) {
             await apiCall("/v1/admin/rewards/set-tier", {
               method: "POST",
               headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({ external_user_id, tier_slug, reason })
+              body: JSON.stringify({ external_user_id: externalUserId, tier_slug: tierSlug, reason })
             }),
             null,
             2
@@ -2047,13 +4197,13 @@ function createMushiServer(config) {
       description: "Current inventory snapshot for the active project \u2014 all Action nodes with their spec contract (expected_outcome), build-gate status, linked reports, and fix attempts. Subscribe to this resource to receive notifications/resources/updated when the inventory is re-crawled (e.g. after a PR merge or manual trigger). Orchestrators can use this to enumerate work items and pick the next Action to fix."
     },
     async () => {
-      const path = projectId ? `/v1/admin/inventory/${projectId}` : "/v1/admin/inventory";
+      const pid = await resolveProjectId(void 0);
       return {
         contents: [
           {
             uri: "inventory://current",
             mimeType: "application/json",
-            text: JSON.stringify(await apiCall(path), null, 2)
+            text: JSON.stringify(await apiCall(`/v1/admin/inventory/${encodeURIComponent(pid)}`), null, 2)
           }
         ]
       };
@@ -2066,15 +4216,94 @@ function createMushiServer(config) {
       description: descOf("activation_status"),
       annotations: annotationsFor("activation_status"),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to the configured project).")
+        projectId: z.string().optional().describe("Project UUID (defaults to the configured project).")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
+      const pid = args.projectId ?? projectId;
       const qs = pid ? `?project_id=${encodeURIComponent(pid)}` : "";
       return jsonResult(await apiCall(`/v1/admin/activation${qs}`));
     }
   );
+  function eventsQuery(params) {
+    const qs = new URLSearchParams();
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== void 0 && v !== "") qs.set(k, String(v));
+    }
+    return qs.toString();
+  }
+  function trailingRange(windowDays) {
+    const to = /* @__PURE__ */ new Date();
+    const from = new Date(to.getTime() - windowDays * 24 * 60 * 60 * 1e3);
+    return { from: from.toISOString(), to: to.toISOString() };
+  }
+  server.registerTool(
+    "query_funnel",
+    {
+      title: titleOf("query_funnel"),
+      description: descOf("query_funnel"),
+      annotations: annotationsFor("query_funnel"),
+      inputSchema: z.object({
+        steps: z.array(z.string().min(1)).min(2).max(8).describe('Ordered event names, 2\u20138 (e.g. ["landing_view", "signup_completed", "first_report_received"]).'),
+        windowDays: z.number().int().min(1).max(365).optional().describe("Trailing window in days (default 30)."),
+        stepWindow: z.enum(["1h", "1d", "7d", "30d"]).optional().describe("Max time allowed between consecutive steps (default 7d)."),
+        breakdown: z.string().optional().describe('Event property to split every step by (e.g. "utm_source", "$surface").'),
+        projectId: z.string().optional().describe("Project UUID (defaults to the configured project).")
+      })
+    },
+    async (args) => {
+      const qs = eventsQuery({
+        steps: args.steps.join(","),
+        window: args.stepWindow ?? "7d",
+        ...trailingRange(args.windowDays ?? 30),
+        breakdown: args.breakdown,
+        project_id: args.projectId ?? projectId
+      });
+      return jsonResult(await apiCall(`/v1/admin/events/funnel?${qs}`));
+    }
+  );
+  server.registerTool(
+    "get_product_events_summary",
+    {
+      title: titleOf("get_product_events_summary"),
+      description: descOf("get_product_events_summary"),
+      annotations: annotationsFor("get_product_events_summary"),
+      inputSchema: z.object({
+        windowDays: z.number().int().min(1).max(365).optional().describe("Trailing window in days (default 30)."),
+        projectId: z.string().optional().describe("Project UUID (defaults to the configured project).")
+      })
+    },
+    async (args) => {
+      const qs = eventsQuery({
+        window: args.windowDays ?? 30,
+        project_id: args.projectId ?? projectId
+      });
+      return jsonResult(await apiCall(`/v1/admin/events/summary?${qs}`));
+    }
+  );
+  server.registerTool(
+    "get_user_paths",
+    {
+      title: titleOf("get_user_paths"),
+      description: descOf("get_user_paths"),
+      annotations: annotationsFor("get_user_paths"),
+      inputSchema: z.object({
+        fromEvent: z.string().min(1).describe('Event name to start from (e.g. "key_minted").'),
+        windowDays: z.number().int().min(1).max(365).optional().describe("Trailing window in days (default 30)."),
+        limit: z.number().int().min(1).max(50).optional().describe("Max distinct paths to return (default 20, max 50)."),
+        projectId: z.string().optional().describe("Project UUID (defaults to the configured project).")
+      })
+    },
+    async (args) => {
+      const qs = eventsQuery({
+        from_event: args.fromEvent,
+        ...trailingRange(args.windowDays ?? 30),
+        limit: args.limit ?? 20,
+        project_id: args.projectId ?? projectId
+      });
+      return jsonResult(await apiCall(`/v1/admin/events/paths?${qs}`));
+    }
+  );
   server.registerResource(
     "activation_status",
     "mushi://activation",
@@ -2269,7 +4498,11 @@ Be specific. No generic advice.`
         qaStoryId: z.string().describe("UUID of the inserted qa_stories row"),
         prUrl: z.string().nullable().describe("GitHub PR URL when openPr=true and GitHub is connected"),
         approvalStatus: z.string().describe("pending_review | approved \u2014 follows automationMode and project defaults"),
-        needsHumanReview: z.boolean().describe("True when the story requires operator approval before scheduled runs")
+        needsHumanReview: z.boolean().describe("True when the story requires operator approval before scheduled runs"),
+        // test-gen-from-story also returns these; undeclared, a strict client
+        // rejected a generation that had already opened its PR.
+        path: z.string().optional().describe("Repo path of the generated Playwright spec"),
+        firecrawlActionsYaml: z.string().nullable().optional().describe("Firecrawl actions YAML for the story, when the generator produced one")
       })
     },
     async ({ projectId: projectId2, storyNodeId, automationMode, baseUrl, openPr }) => {
@@ -2531,12 +4764,12 @@ Be specific. No generic advice.`
       description: descOf("run_fullstack_audit"),
       annotations: annotationsFor("run_fullstack_audit"),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project ID to audit. Defaults to the configured project.")
+        projectId: z.string().optional().describe("Project ID to audit. Defaults to the configured project.")
       })
     },
-    async ({ project_id }) => {
-      const pid = project_id ?? config.projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "project_id is required");
+    async ({ projectId: requested }) => {
+      const pid = requested ?? config.projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "projectId is required");
       const data = await apiCall(`/v1/admin/projects/${pid}/audit`, {
         method: "POST",
         body: "{}"
@@ -2551,22 +4784,22 @@ Be specific. No generic advice.`
       description: descOf("get_backend_health"),
       annotations: annotationsFor("get_backend_health"),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project ID. Defaults to the configured project."),
-        include_logs: z.boolean().optional().describe("Whether to include recent backend error logs (default: true).")
+        projectId: z.string().optional().describe("Project ID. Defaults to the configured project."),
+        includeLogs: z.boolean().optional().describe("Whether to include recent backend error logs (default: true).")
       })
     },
-    async ({ project_id, include_logs = true }) => {
-      const pid = project_id ?? config.projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "project_id is required");
+    async ({ projectId: requested, includeLogs = true }) => {
+      const pid = requested ?? config.projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT_ID", "projectId is required");
       const [schemaRes, advisorsRes, logsRes] = await Promise.allSettled([
         apiCall(`/v1/admin/projects/${pid}/backend/schema`),
         apiCall(`/v1/admin/projects/${pid}/db-advisors`),
-        include_logs ? apiCall(`/v1/admin/projects/${pid}/backend/logs?service=api`) : Promise.resolve(null)
+        includeLogs ? apiCall(`/v1/admin/projects/${pid}/backend/logs?service=api`) : Promise.resolve(null)
       ]);
       const result = {
         schema: schemaRes.status === "fulfilled" ? schemaRes.value : { error: String(schemaRes.reason) },
         advisors: advisorsRes.status === "fulfilled" ? advisorsRes.value : { error: String(advisorsRes.reason) },
-        logs: logsRes.status === "fulfilled" ? logsRes.value : include_logs ? { error: String(logsRes.reason) } : null
+        logs: logsRes.status === "fulfilled" ? logsRes.value : includeLogs ? { error: String(logsRes.reason) } : null
       };
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
@@ -2578,14 +4811,28 @@ Be specific. No generic advice.`
       description: descOf("get_usage"),
       annotations: annotationsFor("get_usage"),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project ID. Defaults to the configured project.")
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the configured project.")
+      }),
+      // Loose: the billing stats route returns ~30 fields (plan, report and
+      // diagnosis quotas, spend cap, period); the documented ones are typed.
+      outputSchema: z.looseObject({
+        projectId: z.string().nullable().optional(),
+        planId: z.string().optional().describe("Active plan id, e.g. free_cloud, hobby, pro"),
+        planDisplayName: z.string().optional(),
+        diagnosesUsed: z.number().optional().describe("Diagnoses used this billing period"),
+        diagnosesLimit: z.number().nullable().optional().describe("Diagnoses included in the plan (null = unlimited)"),
+        diagnosesUsagePct: z.number().nullable().optional(),
+        overDiagnosisQuota: z.boolean().optional(),
+        approachingDiagnosisQuota: z.boolean().optional(),
+        monthlySpendCapUsd: z.number().nullable().optional(),
+        periodEnd: z.string().nullable().optional().describe("ISO timestamp the billing period ends"),
+        freeLimitDiagnoses: z.number().optional()
       })
     },
-    async ({ project_id }) => {
-      const pid = project_id ?? config.projectId;
-      const path = pid ? `/v1/admin/billing/stats?project_id=${pid}` : "/v1/admin/billing/stats";
-      const data = await apiCall(path);
-      return jsonText(data);
+    async (args) => {
+      const headers = args.projectId ? (await projectScopeHeaders(args.projectId)).headers : void 0;
+      const data = await apiCall("/v1/admin/billing/stats", { headers });
+      return jsonResult(data);
     }
   );
   server.registerTool(
@@ -2595,7 +4842,7 @@ Be specific. No generic advice.`
       description: descOf("list_skills"),
       annotations: annotationsFor("list_skills"),
       inputSchema: z.object({
-        category: z.string().optional().describe("Filter by category: workflow, debug, test, audit, enhance, \u2026"),
+        category: z.enum(SKILL_CATEGORIES).optional().describe("Only skills in this category (the slug prefix)."),
         search: z.string().optional().describe("Free-text search across slug, title, description"),
         page: z.number().optional().describe("Page number (default 1)"),
         limit: z.number().optional().describe("Max results per page (default 200, max 200)")
@@ -2634,20 +4881,25 @@ Be specific. No generic advice.`
       description: descOf("start_skill_pipeline"),
       annotations: annotationsFor("start_skill_pipeline"),
       inputSchema: z.object({
-        root_skill_slug: z.string().describe('Root skill slug to run, e.g. "workflow-fix-and-ship"'),
-        report_id: z.string().optional().describe("Report UUID to attach the pipeline to"),
+        rootSkillSlug: z.string().describe('Root skill slug to run, e.g. "workflow-fix-and-ship"'),
+        reportId: z.string().optional().describe("Report UUID to attach the pipeline to"),
         mode: z.enum(["handoff", "cloud"]).optional().describe(
           "handoff (default): get context packet for local agent. cloud: auto-dispatch via Cursor Cloud."
         ),
-        project_id: z.string().optional().describe("Project UUID. Falls back to the configured project.")
+        projectId: z.string().optional().describe("Project UUID. Falls back to the configured project.")
       })
     },
     async (args) => {
-      const resolvedProjectId = args.project_id ?? projectId;
-      if (!resolvedProjectId) return jsonText({ error: "No project_id provided or configured." });
+      const resolvedProjectId = args.projectId ?? projectId;
+      if (!resolvedProjectId) return jsonText({ error: "No projectId provided or configured." });
       const data = await apiCall("/v1/admin/skills/pipelines", {
         method: "POST",
-        body: JSON.stringify({ ...args, project_id: resolvedProjectId })
+        body: JSON.stringify({
+          root_skill_slug: args.rootSkillSlug,
+          report_id: args.reportId,
+          mode: args.mode,
+          project_id: resolvedProjectId
+        })
       });
       return jsonText(data);
     }
@@ -2659,11 +4911,11 @@ Be specific. No generic advice.`
       description: descOf("get_pipeline_run"),
       annotations: annotationsFor("get_pipeline_run"),
       inputSchema: z.object({
-        run_id: z.string().describe("Pipeline run UUID")
+        runId: z.string().describe("Pipeline run UUID")
       })
     },
     async (args) => {
-      const data = await apiCall(`/v1/admin/skills/pipelines/${args.run_id}`);
+      const data = await apiCall(`/v1/admin/skills/pipelines/${args.runId}`);
       return jsonText(data);
     }
   );
@@ -2674,21 +4926,20 @@ Be specific. No generic advice.`
       description: descOf("checkin_pipeline_step"),
       annotations: annotationsFor("checkin_pipeline_step"),
       inputSchema: z.object({
-        run_id: z.string().describe("Pipeline run UUID"),
-        step_index: z.number().describe("Step index (0-based)"),
+        runId: z.string().describe("Pipeline run UUID"),
+        stepIndex: z.number().describe("Step index (0-based)"),
         status: z.enum(["running", "passed", "failed", "skipped"]).describe("Step status"),
         notes: z.string().optional().describe("Optional notes or output summary"),
-        pr_url: z.string().optional().describe("PR URL opened during this step"),
-        agent_ref: z.string().optional().describe("Cursor agentId or external agent reference")
+        prUrl: z.string().optional().describe("PR URL opened during this step"),
+        agentRef: z.string().optional().describe("Cursor agentId or external agent reference")
       })
     },
     async (args) => {
-      const { run_id, step_index, ...body } = args;
-      await apiCall(`/v1/admin/skills/pipelines/${run_id}/steps/${step_index}/checkin`, {
+      await apiCall(`/v1/admin/skills/pipelines/${args.runId}/steps/${args.stepIndex}/checkin`, {
         method: "POST",
-        body: JSON.stringify(body)
+        body: JSON.stringify({ status: args.status, notes: args.notes, pr_url: args.prUrl, agent_ref: args.agentRef })
       });
-      return jsonText({ ok: true, message: `Step ${step_index} \u2192 ${args.status}` });
+      return jsonText({ ok: true, message: `Step ${args.stepIndex} \u2192 ${args.status}` });
     }
   );
   server.registerTool(
@@ -2698,24 +4949,24 @@ Be specific. No generic advice.`
       description: descOf("ask_codebase", CODEBASE_TOOL_CATALOG),
       annotations: annotationsFor("ask_codebase", CODEBASE_TOOL_CATALOG),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
         question: z.string().describe("Plain-English question about the repo"),
-        thread_id: z.string().optional().describe("Optional thread UUID to continue a conversation"),
-        file_path: z.string().optional().describe("Optional file path focus"),
-        symbol_name: z.string().optional().describe("Optional symbol name focus")
+        threadId: z.string().optional().describe("Optional thread UUID to continue a conversation"),
+        filePath: z.string().optional().describe("Optional file path focus"),
+        symbolName: z.string().optional().describe("Optional symbol name focus")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
       const body = {
         messages: [{ role: "user", content: args.question }]
       };
-      if (args.thread_id) body.threadId = args.thread_id;
-      if (args.file_path) {
+      if (args.threadId) body.threadId = args.threadId;
+      if (args.filePath) {
         body.fileFocus = {
-          file_path: args.file_path,
-          symbol_name: args.symbol_name ?? null
+          file_path: args.filePath,
+          symbol_name: args.symbolName ?? null
         };
       }
       const data = await apiCall(`/v1/admin/projects/${pid}/codebase/chat`, {
@@ -2732,17 +4983,17 @@ Be specific. No generic advice.`
       description: descOf("get_file_summary", CODEBASE_TOOL_CATALOG),
       annotations: annotationsFor("get_file_summary", CODEBASE_TOOL_CATALOG),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to configured project)"),
-        file_path: z.string().describe("Indexed file path"),
-        symbol_name: z.string().optional().describe("Optional symbol name within the file"),
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        filePath: z.string().describe("Indexed file path"),
+        symbolName: z.string().optional().describe("Optional symbol name within the file"),
         force: z.boolean().optional().describe("Bypass cache and regenerate")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "project_id is required");
-      const qs = new URLSearchParams({ file_path: args.file_path });
-      if (args.symbol_name) qs.set("symbol_name", args.symbol_name);
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
+      const qs = new URLSearchParams({ file_path: args.filePath });
+      if (args.symbolName) qs.set("symbol_name", args.symbolName);
       if (args.force) qs.set("force", "1");
       const data = await apiCall(`/v1/admin/projects/${pid}/codebase/summary?${qs}`);
       return jsonText(data);
@@ -2755,13 +5006,13 @@ Be specific. No generic advice.`
       description: descOf("get_codebase_tour", CODEBASE_TOOL_CATALOG),
       annotations: annotationsFor("get_codebase_tour", CODEBASE_TOOL_CATALOG),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
         force: z.boolean().optional().describe("Bypass cache and regenerate")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
       const qs = args.force ? "?force=1" : "";
       const data = await apiCall(`/v1/admin/projects/${pid}/codebase/tour${qs}`);
       return jsonText(data);
@@ -2774,20 +5025,21 @@ Be specific. No generic advice.`
       description: descOf("search_codebase", CODEBASE_TOOL_CATALOG),
       annotations: annotationsFor("search_codebase", CODEBASE_TOOL_CATALOG),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
         query: z.string().describe("Plain-English search query against indexed source files"),
         k: z.number().int().min(1).max(20).optional().describe("Max hits to return (default 8, max 20)"),
-        scope_prefix: z.string().optional().describe("Optional repo subdirectory prefix to limit search scope")
+        scopePrefix: z.string().optional().describe("Optional repo subdirectory prefix to limit search scope"),
+        mode: z.enum(CODEBASE_SEARCH_MODES).optional().describe("semantic (default): embedding similarity. name: substring match on file path and symbol name.")
       }),
       outputSchema: z.object({
         results: z.array(z.unknown()).describe("Ranked file/symbol hits with paths, line ranges, and similarity"),
         query: z.string().describe("Normalized query string that was searched"),
-        mode: z.string().optional().describe("semantic (embeddings) or name (path/symbol match)")
+        mode: z.enum(CODEBASE_SEARCH_MODES).optional().describe("Which search ran: semantic or name")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
       const data = await apiCall(
         `/v1/admin/projects/${pid}/codebase/search`,
         {
@@ -2795,7 +5047,8 @@ Be specific. No generic advice.`
           body: JSON.stringify({
             query: args.query,
             k: args.k ?? 8,
-            scope_prefix: args.scope_prefix ?? void 0
+            scope_prefix: args.scopePrefix ?? void 0,
+            mode: args.mode
           })
         }
       );
@@ -2809,17 +5062,17 @@ Be specific. No generic advice.`
       description: descOf("get_codebase_domains", CODEBASE_TOOL_CATALOG),
       annotations: annotationsFor("get_codebase_domains", CODEBASE_TOOL_CATALOG),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
         force: z.boolean().optional().describe("Bypass cache and regenerate"),
-        scope_prefix: z.string().optional().describe("Optional subdirectory scope prefix")
+        scopePrefix: z.string().optional().describe("Optional subdirectory scope prefix")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
       const qs = new URLSearchParams();
       if (args.force) qs.set("force", "1");
-      if (args.scope_prefix) qs.set("scope_prefix", args.scope_prefix);
+      if (args.scopePrefix) qs.set("scope_prefix", args.scopePrefix);
       const suffix = qs.toString() ? `?${qs}` : "";
       const data = await apiCall(`/v1/admin/projects/${pid}/codebase/domains${suffix}`);
       return jsonText(data);
@@ -2832,11 +5085,11 @@ Be specific. No generic advice.`
       description: descOf("analyze_codebase_impact", CODEBASE_TOOL_CATALOG),
       annotations: annotationsFor("analyze_codebase_impact", CODEBASE_TOOL_CATALOG),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
         paths: z.array(z.string()).optional().describe("Changed repo-relative file paths to analyze"),
         source: z.enum(["last_push", "compare", "fix"]).optional().describe("Auto-resolve changed paths instead of manual paths"),
         compare: z.string().optional().describe("GitHub compare range base...head when source=compare"),
-        fix_id: z.string().optional().describe("Fix attempt UUID \u2014 uses that PR's changed files when source=fix")
+        fixId: z.string().optional().describe("Fix attempt UUID \u2014 uses that PR's changed files when source=fix")
       }),
       outputSchema: z.object({
         changed_paths: z.array(z.string()).describe("Resolved set of changed paths analyzed"),
@@ -2847,13 +5100,13 @@ Be specific. No generic advice.`
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
       const qs = new URLSearchParams();
       if (args.paths?.length) qs.set("paths", args.paths.join(","));
       if (args.source === "last_push") qs.set("ref", "last_push");
       if (args.compare) qs.set("compare", args.compare);
-      if (args.fix_id) qs.set("fix_id", args.fix_id);
+      if (args.fixId) qs.set("fix_id", args.fixId);
       if (!qs.toString()) {
         throw new MushiApiError(
           400,
@@ -2872,12 +5125,12 @@ Be specific. No generic advice.`
       description: descOf("analyze_wiki_knowledge", CODEBASE_TOOL_CATALOG),
       annotations: annotationsFor("analyze_wiki_knowledge", CODEBASE_TOOL_CATALOG),
       inputSchema: z.object({
-        project_id: z.string().optional().describe("Project UUID (defaults to configured project)")
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)")
       })
     },
     async (args) => {
-      const pid = args.project_id ?? projectId;
-      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "project_id is required");
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
       const data = await apiCall(`/v1/admin/projects/${pid}/codebase/knowledge/graph`);
       return jsonText(data);
     }
@@ -2895,23 +5148,29 @@ Be specific. No generic advice.`
       annotations: annotationsFor("use_mushi")
     },
     async (args) => {
-      const intent = (args.intent ?? "").toLowerCase();
-      let matched = Object.entries(USE_MUSHI_INTENTS).find(([key]) => intent.includes(key));
-      if (!matched) matched = ["status", USE_MUSHI_INTENTS["status"]];
-      const [, cluster] = matched;
-      const projectLine = projectId ? `Connected project: \`${projectId}\`. ` : "No project configured \u2014 run `mushi_setup` or set MUSHI_PROJECT_ID. ";
+      const registered = server._registeredTools;
+      const isAvailable = (tool) => Object.prototype.hasOwnProperty.call(registered, tool);
+      const route = routeUseMushiIntent(args.intent ?? "", isAvailable);
+      const projectLine = projectId ? `Connected project: \`${projectId}\`. ` : "No project configured \u2014 set MUSHI_PROJECT_ID, or pass projectId to project-scoped tools. ";
+      const hiddenGroups = [
+        ...new Set(route.hidden.map((t) => TOOL_FEATURE_MAP[t]).filter((g) => !!g))
+      ];
       const orientation = [
-        `## Mushi \u2014 ${cluster.label}`,
+        `## Mushi \u2014 ${route.label}`,
         "",
-        projectLine + cluster.hint,
+        projectLine + route.hint,
         "",
         "### Recommended tools for this intent",
-        cluster.tools.map((t) => `- \`${t}\``).join("\n"),
-        "",
-        "### First step",
-        `Call \`${cluster.tools[0]}\` to get started.`,
+        route.tools.length > 0 ? route.tools.map((t) => `- \`${t}\``).join("\n") : "- (none enabled)",
+        ...route.firstTool ? ["", "### First step", `Call \`${route.firstTool}\` to get started.`] : [],
+        ...route.hidden.length > 0 ? [
+          "",
+          "### Also relevant, not enabled on this connection",
+          route.hidden.map((t) => `- \`${t}\``).join("\n"),
+          hiddenGroups.length > 0 ? `Enable them by adding ${hiddenGroups.map((g) => `\`${g}\``).join(", ")} to MUSHI_FEATURES (or set it to \`all\`).` : "They need a key with more scope."
+        ] : [],
         "",
-        "> Tip: call any tool by name \u2014 `use_mushi` is a read-only helper that never calls other tools itself. All 71 tools remain available."
+        `> Tip: \`use_mushi\` is a read-only helper that never calls other tools itself. This connection exposes ${Object.keys(registered).length} tools.`
       ].join("\n");
       return { content: [{ type: "text", text: orientation }] };
     }
@@ -2930,6 +5189,34 @@ Be specific. No generic advice.`
       }
     }
   }
+  {
+    const untrustedTools = new Set(
+      ALL_TOOL_CATALOG.filter((t) => t.returnsUntrusted).map((t) => t.name)
+    );
+    const llUntrustedServer = server.server;
+    const sdkToolsCallHandler = llUntrustedServer?._requestHandlers?.get("tools/call");
+    if (typeof sdkToolsCallHandler === "function") {
+      llUntrustedServer._requestHandlers.set("tools/call", async (...args) => {
+        const result = await sdkToolsCallHandler(...args);
+        const name = args[0]?.params?.name;
+        if (!name || !untrustedTools.has(name) || result === null || typeof result !== "object") {
+          return result;
+        }
+        const r = result;
+        if (r.isError || !Array.isArray(r.content)) return result;
+        return {
+          ...r,
+          content: r.content.map((block) => {
+            const b = block;
+            if (b?.type !== "text" || typeof b.text !== "string" || isWrappedUntrusted(b.text)) {
+              return block;
+            }
+            return { ...b, text: wrapUntrustedJson(b.text, name) };
+          })
+        };
+      });
+    }
+  }
   const _nativeFetch = globalThis.fetch;
   let _firstToolCallSignalled = false;
   const _signalFirstToolCall = () => {
@@ -2991,8 +5278,76 @@ Be specific. No generic advice.`
   }
   return server;
 }
+var SETUP_MODE_TOOLS = ["search_mushi_docs", "get_mushi_doc", "diagnose_setup"];
+var MUSHI_CONSOLE_URL = "https://kensaur.us/mushi-mushi/admin";
+var MUSHI_MCP_QUICKSTART_URL = "https://kensaur.us/mushi-mushi/docs/quickstart/mcp";
+function createSetupModeServer(config) {
+  const server = createMushiServer({
+    version: config.version,
+    // Nothing reaches the API in setup mode: every API-backed tool, resource
+    // and prompt is removed below before a client can list them.
+    apiEndpoint: "https://setup-mode.invalid",
+    apiKey: "",
+    features: "all",
+    ...config.fetch ? { fetch: config.fetch } : {},
+    ...config.timeoutMs ? { timeoutMs: config.timeoutMs } : {},
+    instructions: "Mushi is running in setup mode: no API key is configured, so only search_mushi_docs, get_mushi_doc and diagnose_setup work. Call diagnose_setup for the exact steps to connect (run `npx mushi-mushi` or `mushi login`, or put MUSHI_API_KEY in this server's env block), then restart the MCP server."
+  });
+  const internals = server;
+  for (const [name, tool] of Object.entries(internals._registeredTools)) {
+    if (name === "diagnose_setup" || !SETUP_MODE_TOOLS.includes(name)) tool.remove();
+  }
+  for (const registry of [
+    internals._registeredResources,
+    internals._registeredResourceTemplates,
+    internals._registeredPrompts
+  ]) {
+    for (const entry of Object.values(registry ?? {})) entry.remove();
+  }
+  const spec = TOOL_CATALOG.find((t) => t.name === "diagnose_setup");
+  if (!spec) throw new Error("[mushi-mcp] diagnose_setup is missing from TOOL_CATALOG");
+  const nextAction = "Run `npx mushi-mushi` in your project (signs you in and writes the key) or `mushi login`, then restart this MCP server.";
+  server.registerTool(
+    "diagnose_setup",
+    {
+      title: spec.title,
+      description: spec.description,
+      annotations: {
+        title: spec.title,
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: false
+      },
+      inputSchema: z.object({
+        mode: z.enum(["full", "ingest", "dispatch"]).optional(),
+        projectId: z.string().optional()
+      })
+    },
+    async () => {
+      const diagnosis = {
+        ready: false,
+        mode: "setup",
+        steps: [
+          {
+            label: "MCP server has an API key",
+            complete: false,
+            required: true,
+            hint: `${nextAction} Or mint a key in the console (${MUSHI_CONSOLE_URL} \u2192 Settings \u2192 API keys) and add MUSHI_API_KEY (and MUSHI_PROJECT_ID) to the "env" block of this server in your MCP client config \u2014 a key exported in your shell does not reach the server.`
+          }
+        ],
+        nextAction,
+        alternative: `No local key at all: connect the hosted server over OAuth instead \u2014 ${MUSHI_MCP_QUICKSTART_URL}`,
+        details: config.missingKeyReport.trim()
+      };
+      return { content: [{ type: "text", text: JSON.stringify(diagnosis, null, 2) }] };
+    }
+  );
+  return server;
+}
 export {
   MushiApiError,
+  SETUP_MODE_TOOLS,
   createMushiServer,
+  createSetupModeServer,
   resolveTimeoutMsFromEnv
 };