@mushi-mushi/mcp 0.22.1 → 0.24.0

package/dist/server.js

@@ -4,7 +4,7 @@ import {
   TDD_TOOL_CATALOG,
   TOOL_CATALOG,
   routeUseMushiIntent
-} from "./chunk-RPSPV4FC.js";
+} from "./chunk-2NW2VVWV.js";
 import {
   MUSHI_SERVER_METADATA
 } from "./chunk-FJRPC4VR.js";
@@ -12,7 +12,7 @@ import {
   DEPRECATED_TOOL_ALIASES,
   TOOL_FEATURE_MAP,
   toolMatchesFeatures
-} from "./chunk-LFSAKI6Z.js";
+} from "./chunk-F65T4IGT.js";
 
 // src/server.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -32,7 +32,7 @@ var MUSHI_DOCS_INDEX = [
     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."],
+    headings: ["This is what a diagnosis looks like", "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."
   },
   {
@@ -185,7 +185,7 @@ var MUSHI_DOCS_INDEX = [
     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"],
+    headings: ["Tab groups", "Copy digest", "Map views", "Diagram", "Graph", "Layers", "Search", "The detail panel"],
     excerpt: "Visual, searchable map of every indexed source file \u2014 explore architectural layers, import dependencies, and find code by meaning."
   },
   {
@@ -221,7 +221,7 @@ var MUSHI_DOCS_INDEX = [
     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"],
+    headings: ["The fixes list", "Streaming view", "Spec-validation warnings", "Cursor Cloud Agent runs", "Notes-only pull requests", "Dispatching a fix", "Webhooks", "CI feedback on open PRs"],
     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."
   },
   {
@@ -230,7 +230,7 @@ var MUSHI_DOCS_INDEX = [
     route: "/admin/fullstack-audit",
     markdown: "admin/fullstack-audit.md",
     keywords: ["admin", "fullstack-audit", "fullstack", "audit", "full-stack"],
-    headings: ["Scorecard sections", "Prerequisites", "CLI", "Related pages"],
+    headings: ["Scorecard sections", "Open findings by check", 'Mushi setup checks and "Apply suggested caps"', "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."
   },
   {
@@ -368,6 +368,15 @@ var MUSHI_DOCS_INDEX = [
     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: "Portfolio",
+    url: docUrl("/admin/portfolio"),
+    route: "/admin/portfolio",
+    markdown: "admin/portfolio.md",
+    keywords: ["admin", "portfolio"],
+    headings: ["What you see", "When something could not be read", "Spend per app", "Daily digest", "Accounts and resilience", "From your editor", "Who can see it"],
+    excerpt: "The Portfolio page shows every app in a team at once, with each app's worst recipe state, hole checks and SDK version, plus fixes that apply across apps."
+  },
   {
     title: "Projects",
     url: docUrl("/admin/projects"),
@@ -428,7 +437,7 @@ var MUSHI_DOCS_INDEX = [
     route: "/admin/releases",
     markdown: "admin/releases.md",
     keywords: ["admin", "releases"],
-    headings: ["What it generates", "Creating a release", "Release entry fields", "SDK surface", "Related pages"],
+    headings: ["What it generates", "Creating a release", "Release automatically when you ship", "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."
   },
   {
@@ -683,6 +692,15 @@ var MUSHI_DOCS_INDEX = [
     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: "App recipe and design system",
+    url: docUrl("/concepts/app-recipe"),
+    route: "/concepts/app-recipe",
+    markdown: "concepts/app-recipe.md",
+    keywords: ["concepts", "app-recipe", "app", "recipe", "design", "system"],
+    headings: ["The five states", "mushi.recipe.json", "The design system page", "Directions", "The deviance check", "The deviance score", "When the score is too high", "Hole checks"],
+    excerpt: "The App Recipe records what your app is made of, so a diagnosis can say what changed and a fix can respect your design system."
+  },
   {
     title: "Architecture",
     url: docUrl("/concepts/architecture"),
@@ -827,6 +845,15 @@ var MUSHI_DOCS_INDEX = [
     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: "One login and one purchase across your apps",
+    url: docUrl("/concepts/shared-login"),
+    route: "/concepts/shared-login",
+    markdown: "concepts/shared-login.md",
+    keywords: ["concepts", "shared-login", "shared", "login", "one", "purchase", "across", "apps"],
+    headings: ["Signing in once", "What Mushi checks", "Keeping a purchase in every app", "Sending users between your apps", "Comparing apps"],
+    excerpt: "How to let people sign in once and keep what they bought across several of your apps, and what Mushi checks so it keeps working."
+  },
   {
     title: "Where the report button lives",
     url: docUrl("/concepts/trigger-modes"),
@@ -1043,6 +1070,15 @@ var MUSHI_DOCS_INDEX = [
     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: "Open metrics",
+    url: docUrl("/open"),
+    route: "/open",
+    markdown: "open.md",
+    keywords: ["open", "metrics"],
+    headings: ["What is not on this page, and why", "Where the numbers come from"],
+    excerpt: "Mushi Mushi's public numbers (releases, commits, contributors, npm downloads), fetched from public APIs at build time, with what each one does not mean."
+  },
   {
     title: "Operating (maintainers)",
     url: docUrl("/operating"),
@@ -1202,7 +1238,7 @@ var MUSHI_DOCS_INDEX = [
     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"],
+    headings: ["Setup", "What's on the card", "Acting from the channel", "Slash commands", "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."
   },
   {
@@ -1328,7 +1364,7 @@ var MUSHI_DOCS_INDEX = [
     route: "/quickstart/react-native",
     markdown: "quickstart/react-native.md",
     keywords: ["quickstart", "react-native", "react", "native"],
-    headings: ["1. Install", "2. Mount the provider", "3. Verify"],
+    headings: ["1. Install", "2. Mount the provider", "Optional native modules", "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."
   },
   {
@@ -1445,7 +1481,7 @@ var MUSHI_DOCS_INDEX = [
     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"],
+    headings: ["Console \u2194 CLI setup loop", "Setup & health", "mushi doctor", "mushi nudge", "Reports & lessons", "Sentry issues already open", "Reporter updates held for review", "Agentic 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."
   },
   {
@@ -1607,7 +1643,7 @@ var MUSHI_DOCS_INDEX = [
     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"],
+    headings: ["Install", "Mount the provider", "Submit a report from a screen", "Offline queue", "What gets captured (v0.19+)", "Screenshots (react-native-view-shot)", "Theming the report sheet", "Manual breadcrumbs"],
     excerpt: "Reference for @mushi-mushi/react-native \u2014 MushiProvider, hooks, shake-to-report, screenshots, identity and the offline queue for React Native and Expo."
   },
   {
@@ -2131,6 +2167,43 @@ function fixContextOf(report) {
     bugOntologyTags: report.bug_ontology_tags ?? null
   };
 }
+var RECIPE_STATES = ["ok", "drift", "unknown", "not_connected", "error"];
+var DESIGN_EXCERPT_MAX_FILES = 20;
+function designExcerptFilesOf(report) {
+  const out = [];
+  const add = (path) => {
+    if (typeof path !== "string") return;
+    const p = path.trim();
+    if (!p || p.includes(",") || out.includes(p) || out.length >= DESIGN_EXCERPT_MAX_FILES) return;
+    out.push(p);
+  };
+  const attempts = Array.isArray(report.fix_attempts) ? report.fix_attempts : [];
+  for (const attempt of attempts) {
+    if (Array.isArray(attempt?.files_changed)) attempt.files_changed.forEach(add);
+  }
+  if (typeof report.fix_packet === "string") {
+    for (const m of report.fix_packet.matchAll(/^### `([^`\n]+)`$/gm)) add(m[1]);
+  }
+  return out;
+}
+function designExcerptQueryOf(report) {
+  const params = new URLSearchParams();
+  const files = designExcerptFilesOf(report);
+  if (files.length > 0) params.set("files", files.join(","));
+  if (typeof report.id === "string" && /^[0-9a-f-]{36}$/i.test(report.id)) params.set("reportId", report.id);
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+function recipeFromExcerpt(excerpt) {
+  const row = excerpt && typeof excerpt === "object" ? excerpt : null;
+  if (!row || !RECIPE_STATES.includes(row.state)) {
+    return recipeError("The design excerpt came back without a state.");
+  }
+  return typeof row.note === "string" ? row : { ...row, note: "" };
+}
+function recipeError(note) {
+  return { state: "error", note };
+}
 function similarityQueryOf(report) {
   for (const field of ["summary", "description"]) {
     const value = report[field];
@@ -2327,7 +2400,15 @@ var GATE_IDS = [
   "orphan_endpoint",
   "unknown_call",
   "schema_drift",
-  "code_health"
+  "code_health",
+  "design_drift",
+  "ci_drift",
+  "deploy_drift",
+  "env_drift",
+  "radar",
+  "portfolio_radar",
+  "portfolio_radar_ci",
+  "store_review"
 ];
 var GATE_FINDING_SEVERITIES = ["info", "warn", "error"];
 var SKILL_CATEGORIES = [
@@ -2392,6 +2473,22 @@ var FIX_CONTEXT_SHAPE = {
   rootCause: z.unknown().describe("Stage-2 root cause, or null before Stage 2 runs"),
   bugOntologyTags: z.unknown().describe("Bug ontology tags, or null")
 };
+var RECIPE_EXCERPT_OUTPUT = z.looseObject({
+  state: z.enum(RECIPE_STATES).describe("ok | drift | unknown | not_connected | error; unknown never means healthy"),
+  note: z.string().describe("Why this state, in plain English"),
+  set: z.string().nullable().optional().describe("The token set the excerpt was taken from"),
+  tokens: z.array(z.unknown()).optional().describe("Most useful tokens first: { path, value, cssVar, ts }. Use these names, not literals."),
+  findings: z.array(z.unknown()).optional().describe("Open design deviance findings in the files this fix touches"),
+  score: z.number().nullable().optional().describe("Design deviance score 0\u2013100, lower is better; null = not scored"),
+  truncated: z.boolean().optional().describe("True when the excerpt was cut to stay under 4 KB"),
+  context: z.looseObject({
+    schema: z.unknown().describe("{ state, note, snapshotAt, tables: [{ name, columns }], missing }: tables the stack trace names, from the latest schema snapshot"),
+    deploy: z.unknown().describe("{ state: live | deployed_since_merge | not_live | probe_failed | unknown | no_merged_fix | error, note, lastFix, targets }"),
+    radar: z.unknown().describe("{ state, note, checkedAt, findings: [{ rule, severity, message, fix }] }: open hole checks")
+  }).optional().describe("Backend and release context for this bug; each section has its own state, and unknown never means healthy")
+}).describe(
+  "Design excerpt (\u2264 4 KB) for the report's project: tokens with CSS var / TS names, the deviance score, findings in the files this fix touches, and context (tables the stack trace names, whether the last fix is live, open hole checks). Never null; when it could not be read, { state: 'error', note }."
+);
 function isWrappedUntrusted(text) {
   return text.startsWith('<mushi-data role="');
 }
@@ -2414,10 +2511,11 @@ function createMushiServer(config) {
       icons: [...MUSHI_SERVER_METADATA.icons]
     });
   }
-  async function apiCall(path, options) {
+  async function apiCall(path, options, callOptions) {
     const requestId = crypto.randomUUID().slice(0, 12);
     const started = Date.now();
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const effectiveTimeoutMs = Math.max(timeoutMs, callOptions?.minTimeoutMs ?? 0);
+    const timeoutSignal = AbortSignal.timeout(effectiveTimeoutMs);
     const toolCall = toolCallContext.getStore();
     let res;
     try {
@@ -2454,11 +2552,11 @@ function createMushiServer(config) {
     function classifyTransportError(err) {
       const durationMs2 = Date.now() - started;
       if (timeoutSignal.aborted) {
-        apiLog.warn("api.timeout", { path, requestId, durationMs: durationMs2, timeoutMs });
+        apiLog.warn("api.timeout", { path, requestId, durationMs: durationMs2, timeoutMs: effectiveTimeoutMs });
         return new MushiApiError(
           504,
           "MUSHI_TIMEOUT",
-          `Timed out after ${timeoutMs}ms waiting for ${path}. The Mushi API accepted the connection but did not answer in time \u2014 retry, or raise the budget with MUSHI_MCP_TIMEOUT_MS (ms) in your MCP env block if you self-host and cold starts are slow. Endpoint: ${apiEndpoint}`
+          `Timed out after ${effectiveTimeoutMs}ms waiting for ${path}. The Mushi API accepted the connection but did not answer in time \u2014 retry, or raise the budget with MUSHI_MCP_TIMEOUT_MS (ms) in your MCP env block if you self-host and cold starts are slow. Endpoint: ${apiEndpoint}`
         );
       }
       const name = err instanceof Error ? err.name : "";
@@ -2597,6 +2695,19 @@ function createMushiServer(config) {
       structuredContent: value
     };
   }
+  async function designRecipeFor(report, fallbackProjectId, headers) {
+    const pid = typeof report.project_id === "string" && report.project_id ? report.project_id : fallbackProjectId;
+    const query = designExcerptQueryOf(report);
+    try {
+      return recipeFromExcerpt(
+        await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/design/excerpt${query}`, {
+          headers
+        })
+      );
+    } catch (err) {
+      return recipeError(`Could not read the design excerpt: ${bareMessage(err)}`);
+    }
+  }
   const server = new McpServer(
     {
       name: MUSHI_SERVER_METADATA.name,
@@ -2802,19 +2913,22 @@ function createMushiServer(config) {
       outputSchema: z.object({
         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")
+        inventoryAction: z.unknown().describe("The inventory action (with its expected_outcome contract) the report is filed against, or null"),
+        recipe: RECIPE_EXCERPT_OUTPUT
       })
     },
     async (args) => {
-      const { headers } = await projectScopeHeaders(args.projectId);
+      const { projectId: scopedProjectId, headers } = await projectScopeHeaders(args.projectId);
       const report = await apiCall(`/v1/admin/reports/${args.reportId}`, {
         headers
       });
+      const recipe = await designRecipeFor(report, scopedProjectId, headers);
       return wrappedJsonResult(
         {
           report: projectReportDetail(report, false),
           ...fixContextOf(report),
-          inventoryAction: report.inventory_action ?? null
+          inventoryAction: report.inventory_action ?? null,
+          recipe
         },
         "fix context"
       );
@@ -2989,6 +3103,598 @@ function createMushiServer(config) {
       return jsonResult(data);
     }
   );
+  server.registerTool(
+    "get_app_recipe",
+    {
+      title: titleOf("get_app_recipe"),
+      description: descOf("get_app_recipe"),
+      annotations: annotationsFor("get_app_recipe"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/recipe`));
+    }
+  );
+  server.registerTool(
+    "get_design_tokens",
+    {
+      title: titleOf("get_design_tokens"),
+      description: descOf("get_design_tokens"),
+      annotations: annotationsFor("get_design_tokens"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        group: z.string().max(80).optional().describe("Only tokens in this group (first path segment, e.g. color, space, radius)."),
+        type: z.string().max(40).optional().describe("Only tokens of this DTCG $type (color, dimension, fontFamily, \u2026)."),
+        direction: z.string().max(80).optional().describe("A named token set (directions/<name>/) instead of the active one.")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      const q = new URLSearchParams();
+      if (args.group) q.set("group", args.group);
+      if (args.type) q.set("type", args.type);
+      if (args.direction) q.set("direction", args.direction);
+      const suffix = q.toString() ? `?${q}` : "";
+      return jsonText(
+        await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/design/tokens${suffix}`)
+      );
+    }
+  );
+  server.registerTool(
+    "get_design_deviance",
+    {
+      title: titleOf("get_design_deviance"),
+      description: descOf("get_design_deviance"),
+      annotations: annotationsFor("get_design_deviance"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        limit: z.number().int().min(1).max(200).optional().describe("Findings to return, 1\u2013200 (default 25).")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      const suffix = args.limit !== void 0 ? `?${new URLSearchParams({ limit: String(args.limit) })}` : "";
+      return jsonText(
+        await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/design/deviance${suffix}`)
+      );
+    }
+  );
+  const ORG_ID_INPUT = z.object({
+    organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization when omitted")
+  });
+  server.registerTool(
+    "get_portfolio",
+    {
+      title: titleOf("get_portfolio"),
+      description: descOf("get_portfolio"),
+      annotations: annotationsFor("get_portfolio"),
+      inputSchema: ORG_ID_INPUT
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/portfolio`));
+    }
+  );
+  server.registerTool(
+    "list_portfolio_findings",
+    {
+      title: titleOf("list_portfolio_findings"),
+      description: descOf("list_portfolio_findings"),
+      annotations: annotationsFor("list_portfolio_findings"),
+      inputSchema: ORG_ID_INPUT
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/portfolio/findings`));
+    }
+  );
+  server.registerTool(
+    "get_recipe_drift",
+    {
+      title: titleOf("get_recipe_drift"),
+      description: descOf("get_recipe_drift"),
+      annotations: annotationsFor("get_recipe_drift"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/recipe/drift`));
+    }
+  );
+  server.registerTool(
+    "list_connectors",
+    {
+      title: titleOf("list_connectors"),
+      description: descOf("list_connectors"),
+      annotations: annotationsFor("list_connectors"),
+      inputSchema: ORG_ID_INPUT
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/connectors`));
+    }
+  );
+  const EDIT_INPUT = z.object({
+    path: z.string().min(1).max(400).describe("Repo-relative path the recipe allows"),
+    content: z.string().max(512 * 1024).describe("The full new file content"),
+    reason: z.string().max(200).optional(),
+    baseSha: z.string().min(1).max(80).nullable().optional().describe("The file's baseSha from the dry run (null = it did not exist). The confirm is refused if the file changed since, so it never reverts someone else's edit")
+  });
+  const ELEMENT_INPUT = z.enum(["design", "gates", "env", "routes", "store", "release"]).describe("Which part of the recipe the edit belongs to");
+  server.registerTool(
+    "propose_recipe_change",
+    {
+      title: titleOf("propose_recipe_change"),
+      description: descOf("propose_recipe_change"),
+      annotations: annotationsFor("propose_recipe_change"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        element: ELEMENT_INPUT,
+        edits: z.array(EDIT_INPUT).min(1).max(30),
+        title: z.string().min(1).max(120).optional(),
+        confirm: z.boolean().optional().describe("true opens the draft PR; omitted or false is a dry run")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/recipe/changes`, {
+        method: "POST",
+        body: JSON.stringify({ element: args.element, edits: args.edits, title: args.title, dryRun: args.confirm !== true })
+      }));
+    }
+  );
+  server.registerTool(
+    "propose_portfolio_change",
+    {
+      title: titleOf("propose_portfolio_change"),
+      description: descOf("propose_portfolio_change"),
+      annotations: annotationsFor("propose_portfolio_change"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        element: ELEMENT_INPUT,
+        changes: z.array(z.object({ projectId: z.string().uuid(), edits: z.array(EDIT_INPUT).min(1).max(30) })).min(1).max(10),
+        title: z.string().min(1).max(120).optional(),
+        confirm: z.boolean().optional().describe("true opens one draft PR per repo; omitted or false is a dry run")
+      })
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/portfolio/changes`, {
+        method: "POST",
+        body: JSON.stringify({ element: args.element, changes: args.changes, title: args.title, dryRun: args.confirm !== true })
+      }));
+    }
+  );
+  server.registerTool(
+    "request_connector_action",
+    {
+      title: titleOf("request_connector_action"),
+      description: descOf("request_connector_action"),
+      annotations: annotationsFor("request_connector_action"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        connectorId: z.string().uuid().describe("Connector instance id (list_connectors)"),
+        action: z.string().min(1).max(60).describe("For example set_rollout or promote_track"),
+        payload: z.record(z.string(), z.unknown()).describe("The exact action input; the approval binds its hash"),
+        projectId: z.string().uuid().optional(),
+        reason: z.string().max(500).optional().describe("Why, shown to the approver")
+      })
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      const body = { connectorId: args.connectorId, action: args.action, payload: args.payload, projectId: args.projectId, reason: args.reason };
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/connector-actions`, { method: "POST", body: JSON.stringify(body) }));
+    }
+  );
+  server.registerTool(
+    "get_store_status",
+    {
+      title: titleOf("get_store_status"),
+      description: descOf("get_store_status"),
+      annotations: annotationsFor("get_store_status"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/store`));
+    }
+  );
+  server.registerTool(
+    "get_radar",
+    {
+      title: titleOf("get_radar"),
+      description: descOf("get_radar"),
+      annotations: annotationsFor("get_radar"),
+      inputSchema: z.object({
+        scope: z.enum(["project", "organization"]).optional().describe("project (default) or organization"),
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project (scope project)"),
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization (scope organization)")
+      })
+    },
+    async (args) => {
+      if (args.scope === "organization") {
+        const org = encodeURIComponent(args.organizationId ?? "current");
+        return jsonText(await apiCall(`/v1/admin/orgs/${org}/radar`));
+      }
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/radar`));
+    }
+  );
+  const PROJECT_ID_INPUT = z.object({
+    projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted")
+  });
+  server.registerTool(
+    "run_radar",
+    {
+      title: titleOf("run_radar"),
+      description: descOf("run_radar"),
+      annotations: annotationsFor("run_radar"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/radar/run`, { method: "POST" }));
+    }
+  );
+  server.registerTool(
+    "refresh_recipe",
+    {
+      title: titleOf("refresh_recipe"),
+      description: descOf("refresh_recipe"),
+      annotations: annotationsFor("refresh_recipe"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/recipe/refresh`, { method: "POST" }));
+    }
+  );
+  server.registerTool(
+    "run_design_deviance",
+    {
+      title: titleOf("run_design_deviance"),
+      description: descOf("run_design_deviance"),
+      annotations: annotationsFor("run_design_deviance"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/design/deviance/run`, { method: "POST" }));
+    }
+  );
+  server.registerTool(
+    "run_store_review",
+    {
+      title: titleOf("run_store_review"),
+      description: descOf("run_store_review"),
+      annotations: annotationsFor("run_store_review"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(
+        await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/store/review`, { method: "POST" }, { minTimeoutMs: 9e4 })
+      );
+    }
+  );
+  server.registerTool(
+    "get_release_calendar",
+    {
+      title: titleOf("get_release_calendar"),
+      description: descOf("get_release_calendar"),
+      annotations: annotationsFor("get_release_calendar"),
+      inputSchema: ORG_ID_INPUT
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/releases`));
+    }
+  );
+  server.registerTool(
+    "get_code_health",
+    {
+      title: titleOf("get_code_health"),
+      description: descOf("get_code_health"),
+      annotations: annotationsFor("get_code_health"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        days: z.number().int().min(1).max(365).optional().describe("Trend window in days (default 30)")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      const qs = new URLSearchParams({ project_id: pid, days: String(args.days ?? 30) });
+      return jsonText(await apiCall(`/v1/admin/code-health?${qs}`));
+    }
+  );
+  server.registerTool(
+    "explain_finding",
+    {
+      title: titleOf("explain_finding"),
+      description: descOf("explain_finding"),
+      annotations: annotationsFor("explain_finding"),
+      inputSchema: z.object({
+        findingId: z.string().uuid().describe("Gate finding id (the id field of a finding in list_gate_findings, get_radar, get_code_health\u2026)")
+      })
+    },
+    async (args) => {
+      return jsonText(await apiCall(`/v1/admin/findings/${encodeURIComponent(args.findingId)}`));
+    }
+  );
+  server.registerTool(
+    "get_auto_release_status",
+    {
+      title: titleOf("get_auto_release_status"),
+      description: descOf("get_auto_release_status"),
+      annotations: annotationsFor("get_auto_release_status"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/releases/auto-release?${new URLSearchParams({ project_id: pid })}`));
+    }
+  );
+  server.registerTool(
+    "get_design_settings",
+    {
+      title: titleOf("get_design_settings"),
+      description: descOf("get_design_settings"),
+      annotations: annotationsFor("get_design_settings"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/design/settings`));
+    }
+  );
+  server.registerTool(
+    "set_design_settings",
+    {
+      title: titleOf("set_design_settings"),
+      description: descOf("set_design_settings"),
+      annotations: annotationsFor("set_design_settings"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        threshold: z.number().int().min(0).max(100).optional().describe("0\u2013100; the actions fire when the score is above it"),
+        failCi: z.boolean().optional().describe("true: `mushi recipe check --push` fails CI above the threshold"),
+        autofix: z.boolean().optional().describe("false turns the design auto-fix off; an API key cannot turn it on")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      const body = { threshold: args.threshold, failCi: args.failCi, autofix: args.autofix };
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/design/settings`, { method: "PUT", body: JSON.stringify(body) }));
+    }
+  );
+  server.registerTool(
+    "get_recipe_sources",
+    {
+      title: titleOf("get_recipe_sources"),
+      description: descOf("get_recipe_sources"),
+      annotations: annotationsFor("get_recipe_sources"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        element: z.enum(["gates", "env", "routes"]).describe("gates (mushi.recipe.json budgets), env (.env.example) or routes (the inventory file)")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      const qs = new URLSearchParams({ element: args.element });
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/recipe/sources?${qs}`));
+    }
+  );
+  server.registerTool(
+    "get_recipe_change",
+    {
+      title: titleOf("get_recipe_change"),
+      description: descOf("get_recipe_change"),
+      annotations: annotationsFor("get_recipe_change"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        jobId: z.string().uuid().describe("The jobId propose_recipe_change returned")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/recipe/changes/${encodeURIComponent(args.jobId)}`));
+    }
+  );
+  server.registerTool(
+    "get_store_reviews",
+    {
+      title: titleOf("get_store_reviews"),
+      description: descOf("get_store_reviews"),
+      annotations: annotationsFor("get_store_reviews"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/store/reviews`));
+    }
+  );
+  server.registerTool(
+    "pull_store_reviews",
+    {
+      title: titleOf("pull_store_reviews"),
+      description: descOf("pull_store_reviews"),
+      annotations: annotationsFor("pull_store_reviews"),
+      inputSchema: PROJECT_ID_INPUT
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      return jsonText(
+        await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/store/reviews/pull`, { method: "POST" }, { minTimeoutMs: 9e4 })
+      );
+    }
+  );
+  server.registerTool(
+    "set_store_review_intake",
+    {
+      title: titleOf("set_store_review_intake"),
+      description: descOf("set_store_review_intake"),
+      annotations: annotationsFor("set_store_review_intake"),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID \u2014 defaults to the server-configured project when omitted"),
+        enabled: z.boolean().describe("false turns intake off; true keeps it on (only the console can turn it on)"),
+        maxRating: z.number().int().min(1).max(5).optional().describe("Reviews at or under this many stars are filed (1\u20135)")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      const body = { enabled: args.enabled, maxRating: args.maxRating };
+      return jsonText(await apiCall(`/v1/admin/projects/${encodeURIComponent(pid)}/store/reviews/settings`, { method: "PUT", body: JSON.stringify(body) }));
+    }
+  );
+  const ACCOUNT_PROVIDER = z.enum(["apple", "google_play", "aws", "supabase", "vercel", "registrar", "stripe", "github", "cloudflare", "other"]);
+  server.registerTool(
+    "get_accounts_register",
+    {
+      title: titleOf("get_accounts_register"),
+      description: descOf("get_accounts_register"),
+      annotations: annotationsFor("get_accounts_register"),
+      inputSchema: ORG_ID_INPUT
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/accounts`));
+    }
+  );
+  server.registerTool(
+    "save_register_account",
+    {
+      title: titleOf("save_register_account"),
+      description: descOf("save_register_account"),
+      annotations: annotationsFor("save_register_account"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        id: z.string().uuid().optional().describe("Account id to change (get_accounts_register); omit to record a new account"),
+        provider: ACCOUNT_PROVIDER.optional().describe("Required when recording a new account"),
+        displayName: z.string().min(1).max(120).optional().describe("Required when recording a new account"),
+        ownerEmail: z.string().email().max(254).nullable().optional(),
+        twoFactorDeclared: z.boolean().nullable().optional(),
+        recoveryContact: z.string().max(200).nullable().optional().describe("A person who can recover the account (never a recovery code)"),
+        adminCount: z.number().int().min(1).max(100).optional(),
+        autoRenew: z.boolean().nullable().optional()
+      })
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      const { organizationId: _org, id, ...fields } = args;
+      if (!id && (!fields.provider || !fields.displayName)) {
+        throw new MushiApiError(400, "VALIDATION_ERROR", "provider and displayName are required to record a new account (pass id to change one).");
+      }
+      const path = id ? `/v1/admin/orgs/${org}/accounts/${encodeURIComponent(id)}` : `/v1/admin/orgs/${org}/accounts`;
+      return jsonText(await apiCall(path, { method: id ? "PATCH" : "POST", body: JSON.stringify(fields) }));
+    }
+  );
+  server.registerTool(
+    "remove_register_account",
+    {
+      title: titleOf("remove_register_account"),
+      description: descOf("remove_register_account"),
+      annotations: annotationsFor("remove_register_account"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        id: z.string().uuid().describe("Account id (get_accounts_register)")
+      })
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/accounts/${encodeURIComponent(args.id)}`, { method: "DELETE" }));
+    }
+  );
+  server.registerTool(
+    "set_domain_auto_renew",
+    {
+      title: titleOf("set_domain_auto_renew"),
+      description: descOf("set_domain_auto_renew"),
+      annotations: annotationsFor("set_domain_auto_renew"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        domainId: z.string().uuid().describe("Domain id (the id of a domain in get_accounts_register)"),
+        autoRenew: z.boolean().nullable().describe("true, false, or null for not known")
+      })
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/domains/${encodeURIComponent(args.domainId)}`, {
+        method: "PATCH",
+        body: JSON.stringify({ autoRenew: args.autoRenew })
+      }));
+    }
+  );
+  server.registerTool(
+    "get_spend_ledger",
+    {
+      title: titleOf("get_spend_ledger"),
+      description: descOf("get_spend_ledger"),
+      annotations: annotationsFor("get_spend_ledger"),
+      inputSchema: ORG_ID_INPUT
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/spend`));
+    }
+  );
+  server.registerTool(
+    "import_spend_bill",
+    {
+      title: titleOf("import_spend_bill"),
+      description: descOf("import_spend_bill"),
+      annotations: annotationsFor("import_spend_bill"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        vendor: z.enum(["vercel", "aws", "supabase", "other"]),
+        csv: z.string().min(1).describe("The bill CSV content (at most 5 MB)"),
+        projectId: z.string().uuid().optional().describe("Put every row on this app; omit to match an app column by name or slug"),
+        filename: z.string().max(200).optional()
+      })
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      const body = { vendor: args.vendor, csv: args.csv, projectId: args.projectId, filename: args.filename };
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/spend/imports`, { method: "POST", body: JSON.stringify(body) }, { minTimeoutMs: 6e4 }));
+    }
+  );
+  server.registerTool(
+    "remove_spend_import",
+    {
+      title: titleOf("remove_spend_import"),
+      description: descOf("remove_spend_import"),
+      annotations: annotationsFor("remove_spend_import"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        importId: z.string().uuid().describe("Import id (get_spend_ledger imports)")
+      })
+    },
+    async (args) => {
+      const org = encodeURIComponent(args.organizationId ?? "current");
+      return jsonText(await apiCall(`/v1/admin/orgs/${org}/spend/imports/${encodeURIComponent(args.importId)}`, { method: "DELETE" }));
+    }
+  );
+  server.registerTool(
+    "import_portfolio_resources",
+    {
+      title: titleOf("import_portfolio_resources"),
+      description: descOf("import_portfolio_resources"),
+      annotations: annotationsFor("import_portfolio_resources"),
+      inputSchema: z.object({
+        organizationId: z.string().uuid().optional().describe("Organization UUID \u2014 defaults to the key owner's only organization"),
+        csv: z.string().min(1).max(256 * 1024).describe("CSV with the columns kind, external_id, project and optionally role")
+      })
+    },
+    async (args) => {
+      const body = { organizationId: args.organizationId ?? "current", csv: args.csv };
+      return jsonText(await apiCall("/v1/ingest/recipe/csv", { method: "POST", body: JSON.stringify(body) }));
+    }
+  );
   server.registerTool(
     "suggest_fix",
     {
@@ -3701,6 +4407,18 @@ function createMushiServer(config) {
           args: { mode: "dispatch" }
         });
       }
+      const waiting = reports.filter(
+        (r) => typeof r.last_reporter_reply_at === "string" && (typeof r.admin_seen_at !== "string" || Date.parse(r.last_reporter_reply_at) > Date.parse(r.admin_seen_at))
+      );
+      if (waiting.length > 0) {
+        steps.push({
+          priority: priority++,
+          action: `Answer ${waiting.length} reporter${waiting.length === 1 ? "" : "s"} waiting for a reply`,
+          reason: `They replied in your app's "Your reports" thread. Latest: ${label(waiting[0])}. Read it, then answer with reply_to_reporter.`,
+          tool: "get_report_timeline",
+          args: { reportId: waiting[0].id }
+        });
+      }
       const fixing = reports.filter((r) => r.status === "fixing");
       for (const r of fixing.slice(0, 2)) {
         steps.push({
@@ -3736,7 +4454,7 @@ function createMushiServer(config) {
           args: { status: "classified" }
         });
       }
-      const summary = steps.length === 0 ? "Inbox is clear \u2014 no blocked fixes, no open user reports, no chores. Nothing needs your attention." : `${steps.length} prioritised step${steps.length === 1 ? "" : "s"}: ` + steps.map((s) => s.action).join(" \u2192 ");
+      const summary = steps.length === 0 ? "Inbox is clear \u2014 no blocked fixes, no reporters waiting, no open user reports, no chores. Nothing needs your attention." : `${steps.length} prioritised step${steps.length === 1 ? "" : "s"}: ` + steps.map((s) => s.action).join(" \u2192 ");
       return jsonResult({ steps, summary });
     }
   );
@@ -3921,6 +4639,57 @@ function createMushiServer(config) {
       return jsonResult({ report });
     }
   );
+  server.registerTool(
+    "import_sentry_issues",
+    {
+      title: titleOf("import_sentry_issues"),
+      description: descOf("import_sentry_issues"),
+      annotations: annotationsFor("import_sentry_issues"),
+      inputSchema: z.object({
+        issueIds: z.array(z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/)).max(10).optional().describe('Sentry issue ids or short ids (e.g. "4501", "WEB-12"), at most 10'),
+        query: z.string().max(200).optional().describe("Sentry search query within the configured Sentry project (default is:unresolved). Not with issueIds."),
+        limit: z.number().int().min(1).max(10).optional().describe("How many issues a query imports (1-10, default 5)"),
+        sinceDays: z.number().int().min(1).max(90).optional().describe("Only issues seen in the last N days (1-90). Search mode only."),
+        cursor: z.string().regex(/^[0-9][0-9.:-]{0,63}$/).optional().describe("nextCursor from the previous import, to fetch the next page of a backlog. Search mode only."),
+        sentryProject: z.string().regex(/^[a-z0-9][a-z0-9_-]{0,49}$/).optional().describe("Which of the project's Sentry projects to search (default: the primary one). Search mode only."),
+        projectId: z.string().optional().describe("Project UUID. Defaults to configured project.")
+      }),
+      outputSchema: z.object({
+        items: z.array(
+          z.looseObject({
+            input: z.string(),
+            issueId: z.string().nullable(),
+            shortId: z.string().nullable(),
+            outcome: z.string().describe("created | linked | deduped | ignored | error"),
+            reportId: z.string().nullable(),
+            error: z.string().optional()
+          })
+        ).describe("One entry per requested or matched issue"),
+        created: z.array(z.string().nullable()).describe("Report ids created by this import"),
+        linked: z.array(z.string().nullable()).describe("Report ids that already existed for these issues"),
+        failed: z.number().describe("Issues that could not be imported"),
+        indexing: z.looseObject({ queued: z.boolean(), paths: z.number() }).describe("Whether stack-frame files were queued for codebase indexing"),
+        sentryProject: z.string().nullable().optional().describe("The Sentry project a search ran in (null for issueIds)"),
+        sentryProjects: z.array(z.string()).optional().describe("This project's Sentry projects, primary first"),
+        nextCursor: z.string().nullable().optional().describe("Pass back as cursor to import the next page; null when the backlog is done")
+      })
+    },
+    async (args) => {
+      const pid = await resolveProjectId(args.projectId);
+      const data = await apiCall(`/v1/admin/projects/${pid}/sentry/import`, {
+        method: "POST",
+        body: JSON.stringify({
+          issueIds: args.issueIds,
+          query: args.query,
+          limit: args.limit,
+          sinceDays: args.sinceDays,
+          cursor: args.cursor,
+          sentryProject: args.sentryProject
+        })
+      });
+      return jsonResult(data);
+    }
+  );
   server.registerTool(
     "transition_status",
     {
@@ -3945,13 +4714,20 @@ function createMushiServer(config) {
           "reopened",
           "dismissed"
         ]).describe("Target status (resolved is stored as fixed)"),
-        reason: z.string().optional().describe("Reason for the transition (audit trail)")
+        reason: z.string().optional().describe("Reason for the transition (audit trail)"),
+        closedReason: z.enum(["duplicate", "not_reproducible", "wont_fix", "working_as_intended", "spam"]).optional().describe("When dismissing: what the reporter is told (spam closes silently)"),
+        reporterMessage: z.string().max(1e4).optional().describe("Optional note posted to the reporter verbatim")
       })
     },
     async (args) => {
       const data = await apiCall(`/v1/admin/reports/${args.reportId}`, {
         method: "PATCH",
-        body: JSON.stringify({ status: args.status, reason: args.reason })
+        body: JSON.stringify({
+          status: args.status,
+          reason: args.reason,
+          closed_reason: args.closedReason,
+          reporter_message: args.reporterMessage
+        })
       });
       return jsonText(data);
     }
@@ -4695,6 +5471,65 @@ Be specific. No generic advice.`
       return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
     }
   );
+  server.registerTool(
+    "request_reporter_info",
+    {
+      title: titleOf("request_reporter_info", TDD_TOOL_CATALOG),
+      description: descOf("request_reporter_info", TDD_TOOL_CATALOG),
+      annotations: annotationsFor("request_reporter_info", TDD_TOOL_CATALOG),
+      inputSchema: z.object({
+        reportId: z.string().describe("Report id to ask about"),
+        question: z.string().min(1).max(2e3).describe("The question, shown to the reporter verbatim"),
+        authorName: z.string().optional().describe('Display name for the sender (default: "Developer")')
+      })
+    },
+    async ({ reportId, question, authorName }) => {
+      const data = await apiCall(`/v1/admin/reports/${reportId}/request-info`, {
+        method: "POST",
+        body: JSON.stringify({ question, author_name: authorName })
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "list_reporter_outbox",
+    {
+      title: titleOf("list_reporter_outbox", TDD_TOOL_CATALOG),
+      description: descOf("list_reporter_outbox", TDD_TOOL_CATALOG),
+      annotations: annotationsFor("list_reporter_outbox", TDD_TOOL_CATALOG),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID. Defaults to configured project.")
+      })
+    },
+    async ({ projectId: pid }) => {
+      const scoped = pid ?? config.projectId;
+      const data = await apiCall(
+        `/v1/admin/reporter-outbox${scoped ? `?project_id=${encodeURIComponent(scoped)}` : ""}`
+      );
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "release_reporter_update",
+    {
+      title: titleOf("release_reporter_update", TDD_TOOL_CATALOG),
+      description: descOf("release_reporter_update", TDD_TOOL_CATALOG),
+      annotations: annotationsFor("release_reporter_update", TDD_TOOL_CATALOG),
+      inputSchema: z.object({
+        messageId: z.string().describe("Held message id from list_reporter_outbox"),
+        action: z.enum(["release", "discard"]).optional().describe("release (default) sends it; discard drops it"),
+        bodyOverride: z.string().min(1).max(1e3).optional().describe("Replacement text to send instead")
+      })
+    },
+    async ({ messageId, action, bodyOverride }) => {
+      const verb = action === "discard" ? "discard" : "release";
+      const data = await apiCall(`/v1/admin/reporter-outbox/${messageId}/${verb}`, {
+        method: "POST",
+        body: JSON.stringify(verb === "release" && bodyOverride ? { body_override: bodyOverride } : {})
+      });
+      return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
   server.registerTool(
     "list_qa_story_runs",
     {
@@ -5135,6 +5970,66 @@ Be specific. No generic advice.`
       return jsonText(data);
     }
   );
+  server.registerTool(
+    "get_repo_digest",
+    {
+      title: titleOf("get_repo_digest", CODEBASE_TOOL_CATALOG),
+      description: descOf("get_repo_digest", CODEBASE_TOOL_CATALOG),
+      annotations: annotationsFor("get_repo_digest", CODEBASE_TOOL_CATALOG),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        reportId: z.string().optional().describe("Scope to one bug: the report's files come first, then the rest of the repo by priority"),
+        path: z.string().optional().describe('Scope to one folder, e.g. "apps/web/src"'),
+        budgetTokens: z.number().int().min(2e3).max(2e5).optional().describe("Estimated token budget for the whole digest (default 50,000)"),
+        include: z.array(z.string()).max(50).optional().describe('Glob patterns a file must match, e.g. ["src/**/*.ts", "*.md"]'),
+        exclude: z.array(z.string()).max(50).optional().describe('Glob patterns to leave out, e.g. ["tests/"]'),
+        ref: z.string().optional().describe("Branch, tag or commit SHA (default: the repo default branch)")
+      })
+    },
+    async (args) => {
+      const pid = args.projectId ?? projectId;
+      if (!pid) throw new MushiApiError(400, "MISSING_PROJECT", "projectId is required");
+      const qs = new URLSearchParams();
+      if (args.budgetTokens) qs.set("budget", String(args.budgetTokens));
+      if (args.reportId) qs.set("report_id", args.reportId);
+      if (args.path) qs.set("path", args.path);
+      if (args.include?.length) qs.set("include", args.include.join(","));
+      if (args.exclude?.length) qs.set("exclude", args.exclude.join(","));
+      if (args.ref) qs.set("ref", args.ref);
+      const query = qs.toString();
+      const data = await apiCall(
+        `/v1/admin/projects/${pid}/codebase/digest${query ? `?${query}` : ""}`,
+        void 0,
+        // The server reads up to a few hundred files from GitHub (60 s deadline).
+        { minTimeoutMs: 9e4 }
+      );
+      return jsonText(data);
+    }
+  );
+  server.registerTool(
+    "get_repo_diagram",
+    {
+      title: titleOf("get_repo_diagram", CODEBASE_TOOL_CATALOG),
+      description: descOf("get_repo_diagram", CODEBASE_TOOL_CATALOG),
+      annotations: annotationsFor("get_repo_diagram", CODEBASE_TOOL_CATALOG),
+      inputSchema: z.object({
+        projectId: z.string().optional().describe("Project UUID (defaults to configured project)"),
+        overlay: z.boolean().optional().describe("Also place the open bug reports and code findings on each part of the diagram")
+      })
+    },
+    async (args) => {
+      const pid = encodeURIComponent(await resolveProjectId(args.projectId));
+      const data = await apiCall(
+        `/v1/admin/projects/${pid}/codebase/diagram`
+      );
+      if (args.overlay !== true) return jsonText(data);
+      const overlay = data.diagram ? await apiCall(`/v1/admin/projects/${pid}/codebase/diagram/overlay`, void 0, {
+        // One GitHub tree read plus up to a few hundred reports.
+        minTimeoutMs: 6e4
+      }) : null;
+      return jsonText({ ...data, overlay });
+    }
+  );
   server.registerTool(
     "use_mushi",
     {