@recapt/mcp 0.0.2-beta → 0.0.4-beta

package/dist/api/client.d.ts

@@ -8,5 +8,7 @@ interface ApiResponse<T> {
     error?: string;
 }
 export declare function apiGet<T>(path: string, params?: Record<string, string | number | undefined>): Promise<ApiResponse<T>>;
-export declare function apiPost<T>(path: string, body: Record<string, unknown>): Promise<ApiResponse<T>>;
+export declare function apiPost<T>(path: string, body?: Record<string, unknown>): Promise<ApiResponse<T>>;
+export declare function apiPatch<T>(path: string, body?: Record<string, unknown>): Promise<ApiResponse<T>>;
+export declare function apiDelete<T>(path: string): Promise<ApiResponse<T>>;
 export {};

package/dist/api/client.js

@@ -1,7 +1,7 @@
 /**
  * HTTP client for calling external-api query endpoints.
  */
-const API_URL = process.env.EXTERNAL_API_URL || "http://localhost:4000";
+const API_URL = process.env.EXTERNAL_API_URL || "https://api.recapt.app";
 const SECRET_KEY = process.env.RECAPT_SECRET_KEY;
 export function isApiConfigured() {
     return !!SECRET_KEY;
@@ -40,7 +40,7 @@ export async function apiGet(path, params) {
         return { error: err instanceof Error ? err.message : String(err) };
     }
 }
-export async function apiPost(path, body) {
+export async function apiPost(path, body = {}) {
     if (!SECRET_KEY) {
         return { error: "RECAPT_SECRET_KEY not configured" };
     }
@@ -65,3 +65,52 @@ export async function apiPost(path, body) {
         return { error: err instanceof Error ? err.message : String(err) };
     }
 }
+export async function apiPatch(path, body = {}) {
+    if (!SECRET_KEY) {
+        return { error: "RECAPT_SECRET_KEY not configured" };
+    }
+    const url = `${API_URL}/v1beta/query${path}`;
+    try {
+        const res = await fetch(url, {
+            method: "PATCH",
+            headers: {
+                "x-private-key": SECRET_KEY,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const responseData = (await res.json().catch(() => ({})));
+            return { error: responseData.error || `HTTP ${res.status}` };
+        }
+        const data = (await res.json());
+        return { data };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+export async function apiDelete(path) {
+    if (!SECRET_KEY) {
+        return { error: "RECAPT_SECRET_KEY not configured" };
+    }
+    const url = `${API_URL}/v1beta/query${path}`;
+    try {
+        const res = await fetch(url, {
+            method: "DELETE",
+            headers: {
+                "x-private-key": SECRET_KEY,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!res.ok) {
+            const responseData = (await res.json().catch(() => ({})));
+            return { error: responseData.error || `HTTP ${res.status}` };
+        }
+        const data = (await res.json());
+        return { data };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/dist/index.js

@@ -39,6 +39,10 @@ import { registerPredictOutcomes } from "./tools/predictOutcomes.js";
 import { registerMemoryTools } from "./tools/memory.js";
 import { registerListSessions } from "./tools/listSessions.js";
 import { registerTriageSessions } from "./tools/triageSessions.js";
+import { registerDiagnosticTools } from "./tools/diagnostic.js";
+import { registerTriageTools } from "./tools/triage.js";
+import { registerRemediationTools } from "./tools/remediation.js";
+import { registerKnowledgeTools } from "./tools/knowledge.js";
 async function main() {
     console.error("[MCP] Starting recapt behavioral intelligence server...");
     if (!isApiConfigured()) {
@@ -177,7 +181,83 @@ When triaging, prioritize:
 3. Sessions with console errors + high frustration (likely bugs)
 
 ### Working Memory
-- \`memory_save\`, \`memory_recall\`, \`memory_list\`, \`memory_delete\`, \`memory_clear\`: Store and retrieve intermediate results`,
+- \`memory_save\`, \`memory_recall\`, \`memory_list\`, \`memory_delete\`, \`memory_clear\`: Store and retrieve intermediate results
+
+## Self-Healing Workflow
+
+When asked to "fix all issues", "heal the site", or "improve my site via recapt":
+
+### 1. Full Diagnostic
+- Call \`run_full_diagnostic\` to get prioritized issue list with severity scores
+- Call \`get_site_knowledge\` to load known false positives and intended behaviors
+- Review the \`recommended_investigation_order\` to prioritize your work
+
+### 2. Triage Each Issue
+For each issue in priority order, determine if it's actionable:
+- Call \`validate_issue\` to check if still occurring (not stale)
+- Check against site knowledge for known false positives
+- If recommendation is "dismiss_stale", consider dismissing
+- If uncertain, call \`investigate_issue\` for deep context
+- **Always ask user to confirm** if behavior is intended when unclear
+
+### 3. Propose Fixes
+For confirmed issues:
+- Analyze root cause from evidence and element context
+- Call \`get_similar_fixes\` to see what worked before for similar issues
+- Call \`get_fix_history\` to see past attempts on this specific issue
+- Call \`propose_fix\` with detailed diagnosis and code suggestion
+- Explain confidence level and reasoning to user
+- **Ask for confirmation when confidence < 0.7**
+
+### 4. Track Deployments
+- Show user all pending fixes with \`list_pending_fixes\`
+- When user confirms "I have deployed this fix", call \`confirm_deployment\`
+- Explain that evaluation will happen after 24-48 hours of data collection
+
+### 5. Evaluate Results
+- After deployment window (24-48h), call \`evaluate_fix\`
+- If outcome is "success": celebrate, the issue will be auto-resolved
+- If outcome is "partial": discuss with user whether to iterate
+- If outcome is "failed": analyze why, propose alternative approach
+- Store learnings with \`add_site_knowledge\` for future reference
+
+### Evaluation Thresholds
+- **Success**: frustration decreased >15% OR health score increased >10 points
+- **Partial**: frustration decreased 5-15% OR health score increased 3-10 points
+- **Failed**: no improvement or regression
+
+### Asking for Confirmation
+Always ask user before:
+- Dismissing an issue as false positive
+- Marking behavior as intended
+- When confidence in fix is <0.7
+- Before evaluating (ensure they've actually deployed)
+
+### Self-Healing Tools
+
+#### Diagnostic
+- \`run_full_diagnostic\`: Comprehensive site analysis with prioritized issues
+- \`investigate_issue\`: Deep-dive into specific issue with sessions and errors
+- \`validate_issue\`: Check if issue is still occurring (not stale)
+
+#### Triage
+- \`dismiss_issue\`: Mark issue as false positive with reason
+- \`mark_intended_behavior\`: Flag behavior as by design
+- \`get_issue_history\`: View past occurrences and fix attempts
+
+#### Remediation
+- \`propose_fix\`: Create remediation record with baseline metrics
+- \`list_pending_fixes\`: Show fixes awaiting deployment
+- \`list_remediations\`: Browse all remediation records
+- \`confirm_deployment\`: Mark fix as deployed, start evaluation timer
+- \`evaluate_fix\`: Compare post-deploy metrics to baseline
+- \`get_fix_history\`: View all fix attempts for an issue
+
+#### Knowledge
+- \`get_site_knowledge\`: Retrieve learned patterns and false positives
+- \`add_site_knowledge\`: Store new learning for future reference
+- \`delete_site_knowledge\`: Remove outdated knowledge
+- \`get_similar_fixes\`: Find past fixes for similar issues`,
     });
     registerGetDomains(server);
     registerGetPageMetrics(server);
@@ -207,6 +287,11 @@ When triaging, prioritize:
     registerMemoryTools(server);
     registerListSessions(server);
     registerTriageSessions(server);
+    // Self-healing tools
+    registerDiagnosticTools(server);
+    registerTriageTools(server);
+    registerRemediationTools(server);
+    registerKnowledgeTools(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("[MCP] Server running on stdio");

package/dist/tools/diagnostic.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Diagnostic tools for self-healing workflow.
+ *
+ * Provides comprehensive site diagnostics, issue investigation, and validation.
+ */
+export declare function registerDiagnosticTools(server: any): void;

package/dist/tools/diagnostic.js

@@ -0,0 +1,102 @@
+/**
+ * Diagnostic tools for self-healing workflow.
+ *
+ * Provides comprehensive site diagnostics, issue investigation, and validation.
+ */
+import { z } from "zod";
+import { apiGet, apiPost, isApiConfigured } from "../api/client.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerDiagnosticTools(server) {
+    server.registerTool("run_full_diagnostic", {
+        description: "Run a comprehensive site diagnostic. Returns prioritized issues, problem pages, regressions, and recommended investigation order. Use this as the first step in a self-healing workflow.",
+        inputSchema: z.object({
+            days: z
+                .number()
+                .optional()
+                .default(7)
+                .describe("Number of days to analyze (default: 7)"),
+        }),
+    }, async ({ days }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet("/diagnostic/full", { days: days ?? 7 });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("investigate_issue", {
+        description: "Deep-dive into a specific issue. Returns affected sessions, element friction data, related console errors, similar issues, and page context. Use after identifying an issue to understand root cause.",
+        inputSchema: z.object({
+            issue_id: z.string().describe("The ID of the issue to investigate"),
+            days: z
+                .number()
+                .optional()
+                .default(7)
+                .describe("Number of days to look back (default: 7)"),
+        }),
+    }, async ({ issue_id, days }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet(`/issues/${issue_id}/investigate`, { days: days ?? 7 });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("validate_issue", {
+        description: "Check if an issue is still actively occurring. Returns staleness info and recommendation (investigate, dismiss_stale, or monitor). Use to filter out stale issues before proposing fixes.",
+        inputSchema: z.object({
+            issue_id: z.string().describe("The ID of the issue to validate"),
+            lookback_days: z
+                .number()
+                .optional()
+                .default(3)
+                .describe("Number of days to look back for recent occurrences (default: 3)"),
+        }),
+    }, async ({ issue_id, lookback_days, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost(`/issues/${issue_id}/validate`, { lookback_days: lookback_days ?? 3 });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/dist/tools/knowledge.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Knowledge tools for self-healing workflow.
+ *
+ * Provides site-specific knowledge management for learning from past fixes.
+ */
+export declare function registerKnowledgeTools(server: any): void;

package/dist/tools/knowledge.js

@@ -0,0 +1,186 @@
+/**
+ * Knowledge tools for self-healing workflow.
+ *
+ * Provides site-specific knowledge management for learning from past fixes.
+ */
+import { z } from "zod";
+import { apiGet, apiPost, apiDelete, isApiConfigured } from "../api/client.js";
+const KNOWLEDGE_CATEGORIES = [
+    "false_positive",
+    "intended_behavior",
+    "fix_pattern",
+    "context",
+];
+const ISSUE_CATEGORIES = [
+    "code_error",
+    "dead_click",
+    "rage_click",
+    "ux_friction",
+    "performance",
+    "form_issue",
+    "behavioral_anomaly",
+    "structural_issue",
+];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerKnowledgeTools(server) {
+    server.registerTool("get_site_knowledge", {
+        description: "Retrieve site-specific learnings including known false positives, intended behaviors, and successful fix patterns. Use at the start of a self-healing workflow to avoid re-flagging known issues.",
+        inputSchema: z.object({
+            category: z
+                .enum(KNOWLEDGE_CATEGORIES)
+                .optional()
+                .describe("Filter by knowledge category"),
+            page_path: z.string().optional().describe("Filter by page path"),
+            issue_category: z
+                .enum(ISSUE_CATEGORIES)
+                .optional()
+                .describe("Filter by issue category"),
+            limit: z
+                .number()
+                .optional()
+                .default(50)
+                .describe("Maximum number of entries to return (default: 50)"),
+        }),
+    }, async ({ category, page_path, issue_category, limit, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet("/knowledge", {
+            category,
+            page_path,
+            issue_category,
+            limit: limit ?? 50,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("add_site_knowledge", {
+        description: "Store a site-specific learning. Use to record false positives, intended behaviors, successful fix patterns, or important context about the site.",
+        inputSchema: z.object({
+            category: z
+                .enum(KNOWLEDGE_CATEGORIES)
+                .describe("Category of knowledge: false_positive, intended_behavior, fix_pattern, or context"),
+            subject: z
+                .string()
+                .describe("Unique identifier/title for this knowledge entry"),
+            content: z.string().describe("Detailed description of the learning"),
+            page_path: z
+                .string()
+                .optional()
+                .describe("Associated page path (if applicable)"),
+            element_selector: z
+                .string()
+                .optional()
+                .describe("Associated element selector (if applicable)"),
+            issue_category: z
+                .enum(ISSUE_CATEGORIES)
+                .optional()
+                .describe("Associated issue category (if applicable)"),
+        }),
+    }, async ({ category, subject, content, page_path, element_selector, issue_category, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost("/knowledge", {
+            category,
+            subject,
+            content,
+            page_path,
+            element_selector,
+            issue_category,
+            source: "agent",
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("delete_site_knowledge", {
+        description: "Delete a site knowledge entry. Use when a learning is no longer valid or was created in error.",
+        inputSchema: z.object({
+            knowledge_id: z
+                .string()
+                .describe("The ID of the knowledge entry to delete"),
+        }),
+    }, async ({ knowledge_id }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiDelete(`/knowledge/${knowledge_id}`);
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("get_similar_fixes", {
+        description: "Find past fixes for similar issues. Returns successful and failed remediation attempts for issues with the same category, page, or element. Use before proposing a fix to learn from past attempts.",
+        inputSchema: z.object({
+            issue_id: z
+                .string()
+                .describe("The ID of the issue to find similar fixes for"),
+            limit: z
+                .number()
+                .optional()
+                .default(5)
+                .describe("Maximum number of similar fixes to return (default: 5)"),
+        }),
+    }, async ({ issue_id, limit }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet("/knowledge/similar-fixes", {
+            issue_id,
+            limit: limit ?? 5,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/dist/tools/remediation.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remediation tools for self-healing workflow.
+ *
+ * Provides fix proposal, deployment confirmation, evaluation, and history tracking.
+ */
+export declare function registerRemediationTools(server: any): void;

package/dist/tools/remediation.js

@@ -0,0 +1,223 @@
+/**
+ * Remediation tools for self-healing workflow.
+ *
+ * Provides fix proposal, deployment confirmation, evaluation, and history tracking.
+ */
+import { z } from "zod";
+import { apiGet, apiPost, apiPatch, isApiConfigured } from "../api/client.js";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerRemediationTools(server) {
+    server.registerTool("propose_fix", {
+        description: "Propose a fix for an issue. Creates a remediation record with baseline metrics for later evaluation. Include detailed diagnosis and code suggestions when possible.",
+        inputSchema: z.object({
+            issue_id: z.string().describe("The ID of the issue to fix"),
+            diagnosis: z
+                .string()
+                .describe("Detailed analysis of the root cause of the issue"),
+            proposed_fix: z
+                .string()
+                .describe("Description of the proposed fix and how it addresses the root cause"),
+            code_snippet: z
+                .string()
+                .optional()
+                .describe("Suggested code changes (if applicable)"),
+            affected_files: z
+                .array(z.string())
+                .optional()
+                .describe("List of files that need to be modified"),
+            confidence: z
+                .number()
+                .min(0)
+                .max(1)
+                .describe("Confidence level in the fix (0-1). Use <0.7 when uncertain."),
+        }),
+    }, async ({ issue_id, diagnosis, proposed_fix, code_snippet, affected_files, confidence, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost("/remediations", {
+            issue_id,
+            diagnosis,
+            proposed_fix,
+            code_snippet,
+            affected_files,
+            confidence,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("list_pending_fixes", {
+        description: "List all proposed fixes awaiting deployment. Use to show the user what fixes are ready to be deployed.",
+        inputSchema: z.object({}),
+    }, async () => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet("/remediations/pending");
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("list_remediations", {
+        description: "List remediation records with optional filters. Use to review past and current fix attempts.",
+        inputSchema: z.object({
+            status: z
+                .enum([
+                "proposed",
+                "deployed",
+                "evaluating",
+                "succeeded",
+                "failed",
+                "reverted",
+            ])
+                .optional()
+                .describe("Filter by remediation status"),
+            issue_id: z.string().optional().describe("Filter by issue ID"),
+            page_path: z.string().optional().describe("Filter by page path"),
+            limit: z
+                .number()
+                .optional()
+                .default(20)
+                .describe("Maximum number of results (default: 20)"),
+        }),
+    }, async ({ status, issue_id, page_path, limit, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet("/remediations", {
+            status,
+            issue_id,
+            page_path,
+            limit: limit ?? 20,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("confirm_deployment", {
+        description: "Confirm that a proposed fix has been deployed to production. This starts the evaluation timer. Call this when the user confirms they have deployed the fix.",
+        inputSchema: z.object({
+            remediation_id: z
+                .string()
+                .describe("The ID of the remediation to mark as deployed"),
+        }),
+    }, async ({ remediation_id }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPatch(`/remediations/${remediation_id}/deploy`, {});
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("evaluate_fix", {
+        description: "Evaluate if a deployed fix improved metrics. Compares post-deployment metrics to baseline. Returns success/partial/failed outcome with detailed verdict. Wait at least 24 hours after deployment for reliable results.",
+        inputSchema: z.object({
+            remediation_id: z
+                .string()
+                .describe("The ID of the remediation to evaluate"),
+            min_hours: z
+                .number()
+                .optional()
+                .default(24)
+                .describe("Minimum hours since deployment required (default: 24)"),
+        }),
+    }, async ({ remediation_id, min_hours, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost(`/remediations/${remediation_id}/evaluate`, { min_hours: min_hours ?? 24 });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("get_fix_history", {
+        description: "Get the full remediation history for an issue. Shows all fix attempts, their outcomes, and current status. Use before proposing a new fix to learn from past attempts.",
+        inputSchema: z.object({
+            issue_id: z
+                .string()
+                .describe("The ID of the issue to get fix history for"),
+        }),
+    }, async ({ issue_id }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet(`/remediations/history/${issue_id}`);
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/dist/tools/triage.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Triage tools for self-healing workflow.
+ *
+ * Provides issue dismissal, marking intended behavior, and issue history.
+ */
+export declare function registerTriageTools(server: any): void;

package/dist/tools/triage.js

@@ -0,0 +1,114 @@
+/**
+ * Triage tools for self-healing workflow.
+ *
+ * Provides issue dismissal, marking intended behavior, and issue history.
+ */
+import { z } from "zod";
+import { apiGet, apiPost, isApiConfigured } from "../api/client.js";
+const DISMISS_REASONS = [
+    "stale",
+    "intended",
+    "duplicate",
+    "false_positive",
+];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function registerTriageTools(server) {
+    server.registerTool("dismiss_issue", {
+        description: "Dismiss an issue as a false positive. Creates site knowledge to prevent re-flagging. Use when an issue is stale, intended behavior, a duplicate, or a false positive. Always confirm with user before dismissing.",
+        inputSchema: z.object({
+            issue_id: z.string().describe("The ID of the issue to dismiss"),
+            reason: z
+                .enum(DISMISS_REASONS)
+                .describe("Reason for dismissal: stale, intended, duplicate, or false_positive"),
+            explanation: z
+                .string()
+                .describe("Detailed explanation of why this issue is being dismissed"),
+            create_knowledge: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe("Whether to create site knowledge entry (default: true)"),
+        }),
+    }, async ({ issue_id, reason, explanation, create_knowledge, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost(`/issues/${issue_id}/dismiss`, {
+            reason,
+            explanation,
+            create_knowledge: create_knowledge ?? true,
+        });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("mark_intended_behavior", {
+        description: "Mark an issue as intended behavior. This is a shortcut for dismissing with reason 'intended' and always creates site knowledge. Use when the detected behavior is by design (e.g., disabled button clicks are expected).",
+        inputSchema: z.object({
+            issue_id: z
+                .string()
+                .describe("The ID of the issue to mark as intended"),
+            explanation: z
+                .string()
+                .describe("Explanation of why this behavior is intended"),
+        }),
+    }, async ({ issue_id, explanation, }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiPost(`/issues/${issue_id}/mark-intended`, { explanation });
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+    server.registerTool("get_issue_history", {
+        description: "Get the full history of an issue including status changes, remediation attempts, and outcomes. Use to understand past fix attempts before proposing new ones.",
+        inputSchema: z.object({
+            issue_id: z.string().describe("The ID of the issue to get history for"),
+        }),
+    }, async ({ issue_id }) => {
+        if (!isApiConfigured()) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ error: "API not configured" }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const { data, error } = await apiGet(`/issues/${issue_id}/history`);
+        if (error) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error }) }],
+                isError: true,
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recapt/mcp",
-  "version": "0.0.2-beta",
+  "version": "0.0.4-beta",
   "description": "MCP exposing recapt behavioral intelligence to AI coding agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",