loaditout-mcp-server 0.1.0 → 0.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anand Jain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,19 +1,27 @@
-# @loaditout/mcp-server
+# Loaditout MCP Server
 
-MCP server for discovering, installing, and managing AI agent skills from the Loaditout registry. It connects your agent to a curated catalog of MCP servers and SKILL.md behaviors, with search, recommendations, and usage reporting.
+[![loaditout-mcp-server MCP server](https://glama.ai/mcp/servers/loaditoutadmin/loaditout-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/loaditoutadmin/loaditout-mcp-server)
 
-## Installation
+An MCP server for discovering, security-grading, and installing AI agent skills from [Loaditout](https://loaditout.ai).
+
+Search 20,000+ MCP servers and agent skills, check security grades (A/B/C/F), and install directly from your agent.
+
+## Quick Start
+
+```bash
+npx loaditout-mcp-server
+```
 
 ### Claude Code
 
-Add to your Claude Code MCP settings (`~/.claude/settings.json`):
+Add to `.claude/settings.json`:
 
 ```json
 {
   "mcpServers": {
     "loaditout": {
       "command": "npx",
-      "args": ["-y", "@loaditout/mcp-server"]
+      "args": ["-y", "loaditout-mcp-server"]
     }
   }
 }
@@ -21,37 +29,63 @@ Add to your Claude Code MCP settings (`~/.claude/settings.json`):
 
 ### Cursor
 
-Add to your Cursor MCP config (`.cursor/mcp.json` in your project or `~/.cursor/mcp.json` globally):
+Add to `.cursor/mcp.json`:
 
 ```json
 {
   "mcpServers": {
     "loaditout": {
       "command": "npx",
-      "args": ["-y", "@loaditout/mcp-server"]
+      "args": ["-y", "loaditout-mcp-server"]
     }
   }
 }
 ```
 
-## Available Tools
+## Tools
 
 | Tool | Description |
-|---|---|
-| `search_skills` | Search the registry for skills by natural language query. Supports filtering by type and agent platform. |
-| `get_skill` | Get full details for a specific skill by its slug (owner/repo format). |
-| `install_skill` | Get the exact configuration JSON needed to install a skill for a specific agent. Returns config and instructions but does not write files. |
-| `list_categories` | List all skill categories with descriptions and skill counts. |
-| `recommend_skills` | Get skill recommendations based on a description of your project or task. |
-| `check_capability_gap` | Analyze what the agent is trying to do and suggest skills that would help. Designed for when you encounter a task you cannot complete or need specialized tools for. |
-| `report_skill_usage` | Report whether an installed skill worked correctly. Helps improve quality scores across the registry. |
+|------|-------------|
+| `search_skills` | Search 20,000+ MCP servers and agent skills by keyword |
+| `smart_search` | Personalized search with history and preferences applied |
+| `get_skill` | Get full details, security grade, and install config for a specific skill |
+| `install_skill` | Get platform-specific install configuration for any skill |
+| `install_batch` | Install multiple skills at once (up to 20) |
+| `install_pack` | Install an entire curated pack (e.g., research-agent, data-engineer) |
+| `recommend_skills` | Get skill recommendations based on your project context |
+| `check_capability_gap` | Analyze what tools you need for a specific task |
+| `list_categories` | Browse skills by category |
+| `validate_action` | Check if an action on a skill is safe before executing |
+| `report_skill_usage` | Report whether a skill worked correctly |
+| `flag_skill` | Report problematic or unsafe skills |
+| `save_memory` | Save key-value pairs to persistent agent memory |
+| `recall_memory` | Retrieve previously saved memories |
+| `request_permission` | Request human approval to install a skill |
+| `check_permission` | Check status of a permission request |
+| `list_my_proofs` | List your verified skill usage history |
+| `verify_proof` | Verify an execution proof by ID |
+| `share_loadout` | Get your public skill configuration |
+
+## Security Grading
+
+Every server is graded A/B/C/F based on 7 criteria:
+
+1. Zero prompt injection flags
+2. Zero capability flags (no shell, exec, sudo, filesystem, process.env)
+3. README content present
+4. Description present
+5. Committed within 12 months
+6. At least 5 GitHub stars
+7. No secret env vars required
+
+Only 20.5% of the 20,652 servers in our index earn an A grade.
 
-## Resources
+## Links
 
-| URI | Description |
-|---|---|
-| `loaditout://catalog` | Browse the full skill catalog organized by category with counts. |
+- **Website:** [loaditout.ai](https://loaditout.ai)
+- **CLI:** `npx loaditout add owner/repo`
+- **npm:** [loaditout-mcp-server](https://www.npmjs.com/package/loaditout-mcp-server)
 
-## Zero Dependencies
+## License
 
-This server uses only Node.js built-in modules (https, readline) for HTTP communication. No external packages are required.
+MIT

package/dist/index.js

@@ -40,7 +40,7 @@ const crypto = __importStar(require("crypto"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
-const API_BASE = "https://loaditout.ai/api/agent";
+const API_BASE = "https://www.loaditout.ai/api/agent";
 const SERVER_NAME = "loaditout";
 const SERVER_VERSION = "0.1.0";
 // --- Agent key management ---
@@ -76,7 +76,7 @@ function fetchJSON(url, extraHeaders) {
         };
         https
             .get(url, { headers }, (res) => {
-            if (res.statusCode === 301 || res.statusCode === 302) {
+            if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) {
                 const location = res.headers.location;
                 if (location) {
                     fetchJSON(location).then(resolve, reject);
@@ -101,7 +101,7 @@ function fetchJSON(url, extraHeaders) {
             .on("error", reject);
     });
 }
-function postJSON(url, body) {
+function postJSON(url, body, extraHeaders) {
     return new Promise((resolve, reject) => {
         const payload = JSON.stringify(body);
         const parsed = new URL(url);
@@ -114,6 +114,7 @@ function postJSON(url, body) {
                 "Content-Type": "application/json",
                 "Content-Length": Buffer.byteLength(payload),
                 "User-Agent": `loaditout-mcp/${SERVER_VERSION}`,
+                ...extraHeaders,
             },
         };
         const req = https.request(options, (res) => {
@@ -297,6 +298,28 @@ const TOOLS = [
             required: ["slug", "status"],
         },
     },
+    {
+        name: "list_my_proofs",
+        description: "List all execution proofs for this agent. Shows your verified skill usage history -- your agent resume.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "verify_proof",
+        description: "Verify an execution proof by its proof ID. Confirms whether a proof is valid and which skill it covers.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                proof_id: {
+                    type: "string",
+                    description: "The proof ID to verify. Example: 'lp_a1b2c3d4e5f6g7h8'",
+                },
+            },
+            required: ["proof_id"],
+        },
+    },
     {
         name: "save_memory",
         description: "Save a key-value pair to persistent agent memory. Survives across sessions. Use this to remember installed skills, preferences, search context, or any data you want to recall later.",
@@ -412,9 +435,178 @@ const TOOLS = [
             required: ["slug", "agent"],
         },
     },
+    {
+        name: "validate_action",
+        description: "Validate whether an action on a skill is safe before executing it. Checks security grade, safety manifest, parameter injection, and skill freshness.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: {
+                    type: "string",
+                    description: "Skill slug in owner/repo format. Example: 'supabase/mcp'",
+                },
+                action: {
+                    type: "string",
+                    description: "The action about to be performed. Example: 'query_database'",
+                },
+                parameters: {
+                    type: "object",
+                    description: "Parameters that will be passed to the action. Checked for injection patterns.",
+                },
+            },
+            required: ["slug", "action"],
+        },
+    },
+    {
+        name: "flag_skill",
+        description: "Report a skill that behaves unexpectedly, contains prompt injection, is broken, or is otherwise problematic. Helps the community identify unsafe skills.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: {
+                    type: "string",
+                    description: "Skill slug in owner/repo format. Example: 'owner/repo-name'",
+                },
+                reason: {
+                    type: "string",
+                    enum: [
+                        "prompt_injection",
+                        "malicious",
+                        "broken",
+                        "misleading",
+                        "spam",
+                        "other",
+                    ],
+                    description: "Why the skill is being flagged",
+                },
+                details: {
+                    type: "string",
+                    description: "Additional context about the issue. Example: 'The SKILL.md contains instructions to ignore safety checks'",
+                },
+            },
+            required: ["slug", "reason"],
+        },
+    },
+    {
+        name: "review_skill",
+        description: "Leave a review for a skill you have used. Helps other agents and humans decide whether to install it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                slug: {
+                    type: "string",
+                    description: "Skill slug in owner/repo format. Example: 'supabase/mcp'",
+                },
+                rating: {
+                    type: "number",
+                    description: "Rating from 1 to 5. 5 = excellent, 1 = unusable.",
+                },
+                comment: {
+                    type: "string",
+                    description: "Optional comment about your experience. Example: 'Works great for database queries, fast and reliable'",
+                },
+            },
+            required: ["slug", "rating"],
+        },
+    },
+    {
+        name: "set_profile",
+        description: "Set your agent's public profile display name and bio. This information appears on your public profile page at loaditout.ai/agents/{key}.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                display_name: {
+                    type: "string",
+                    description: "Display name for your agent profile (max 100 characters). Example: 'Full-Stack Dev Agent'",
+                },
+                bio: {
+                    type: "string",
+                    description: "Short bio for your agent profile (max 500 characters). Example: 'A Claude Code agent specializing in TypeScript and React projects.'",
+                },
+            },
+        },
+    },
+    {
+        name: "smart_search",
+        description: "Search for skills with your history and preferences automatically applied. Returns personalized results excluding skills you already have. Use this by default instead of search_skills.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Natural language search query. Examples: 'postgres database', 'browser automation', 'github issues'",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results to return (default 10, max 25)",
+                },
+            },
+            required: ["query"],
+        },
+    },
 ];
+/**
+ * Load agent memory entries. Returns parsed memories or empty array.
+ * Never throws -- failures are silently ignored so callers always proceed.
+ */
+async function loadAgentMemory(typeFilter) {
+    try {
+        const params = new URLSearchParams({ agent_key: AGENT_KEY });
+        if (typeFilter)
+            params.set("type", typeFilter);
+        const result = (await fetchJSON(`${API_BASE}/memory?${params.toString()}`));
+        return result.memories ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Extract installed skill slugs from memory entries.
+ */
+function extractInstalledSlugs(memories) {
+    for (const m of memories) {
+        if (m.key === "installed_skills" && Array.isArray(m.value)) {
+            return m.value;
+        }
+    }
+    return [];
+}
+/**
+ * Extract recent search queries from memory entries.
+ */
+function extractRecentSearches(memories) {
+    for (const m of memories) {
+        if (m.key === "recent_searches" && Array.isArray(m.value)) {
+            return m.value;
+        }
+    }
+    return [];
+}
+/**
+ * Fire-and-forget save to agent memory. Never throws.
+ */
+function saveMemoryAsync(key, value, type) {
+    postJSON(`${API_BASE}/memory`, {
+        agent_key: AGENT_KEY,
+        key,
+        value,
+        type,
+    }).catch(() => { });
+}
+/**
+ * Append a search query to the recent_searches memory (keep last 20).
+ */
+function recordSearchQuery(query, existingSearches) {
+    const updated = [...existingSearches.filter((q) => q !== query), query].slice(-20);
+    saveMemoryAsync("recent_searches", updated, "search");
+}
 // --- Tool handlers ---
 async function handleSearchSkills(args) {
+    // Auto-load agent memory to get installed skills and search history
+    const memories = await loadAgentMemory();
+    const installedSlugs = extractInstalledSlugs(memories);
+    const recentSearches = extractRecentSearches(memories);
     const params = new URLSearchParams({ q: args.query });
     if (args.type)
         params.set("type", args.type);
@@ -422,8 +614,18 @@ async function handleSearchSkills(args) {
         params.set("agent", args.agent);
     if (args.limit)
         params.set("limit", String(args.limit));
-    const result = await fetchJSON(`${API_BASE}/search?${params.toString()}`);
-    return JSON.stringify(result, null, 2);
+    const result = await fetchJSON(`${API_BASE}/search?${params.toString()}`, {
+        "X-Agent-Key": AGENT_KEY,
+    });
+    // Fire-and-forget: record this search query to memory
+    recordSearchQuery(args.query, recentSearches);
+    // Filter out already-installed skills from results client-side
+    const parsed = result;
+    if (parsed.results && installedSlugs.length > 0) {
+        const installedSet = new Set(installedSlugs);
+        parsed.results = parsed.results.filter((r) => !r.slug || !installedSet.has(r.slug));
+    }
+    return JSON.stringify(parsed, null, 2);
 }
 async function handleGetSkill(args) {
     const result = await fetchJSON(`${API_BASE}/skill/${encodeURIComponent(args.slug)}`);
@@ -432,6 +634,12 @@ async function handleGetSkill(args) {
 async function handleInstallSkill(args) {
     const params = new URLSearchParams({ agent: args.agent });
     const result = await fetchJSON(`${API_BASE}/install/${encodeURIComponent(args.slug)}?${params.toString()}`, { "X-Agent-Key": AGENT_KEY });
+    // Fire-and-forget: save this slug to installed_skills memory
+    const memories = await loadAgentMemory().catch(() => []);
+    const existing = extractInstalledSlugs(memories);
+    if (!existing.includes(args.slug)) {
+        saveMemoryAsync("installed_skills", [...existing, args.slug], "install");
+    }
     return JSON.stringify(result, null, 2);
 }
 async function handleListCategories() {
@@ -439,9 +647,27 @@ async function handleListCategories() {
     return JSON.stringify(result, null, 2);
 }
 async function handleRecommendSkills(args) {
-    const params = new URLSearchParams({ context: args.context });
-    if (args.installed)
-        params.set("installed", args.installed);
+    // Auto-load agent memory for personalization
+    const memories = await loadAgentMemory();
+    const installedSlugs = extractInstalledSlugs(memories);
+    const recentSearches = extractRecentSearches(memories);
+    // Merge installed skills from memory with any explicitly provided
+    const allInstalled = new Set(installedSlugs);
+    if (args.installed) {
+        for (const s of args.installed.split(",").map((s) => s.trim()).filter(Boolean)) {
+            allInstalled.add(s);
+        }
+    }
+    // Enrich context with relevant search history keywords
+    let enrichedContext = args.context;
+    if (recentSearches.length > 0) {
+        const recentKeywords = recentSearches.slice(-5).join(", ");
+        enrichedContext = `${args.context} (recent interests: ${recentKeywords})`;
+    }
+    const params = new URLSearchParams({ context: enrichedContext });
+    if (allInstalled.size > 0) {
+        params.set("installed", Array.from(allInstalled).join(","));
+    }
     const result = await fetchJSON(`${API_BASE}/recommend?${params.toString()}`, { "X-Agent-Key": AGENT_KEY });
     return JSON.stringify(result, null, 2);
 }
@@ -469,13 +695,67 @@ async function handleReportSkillUsage(args) {
     const body = {
         slug: args.slug,
         status: args.status,
+        agent: "claude-code",
+        agent_key: AGENT_KEY,
     };
     if (args.error_message) {
         body.error_message = args.error_message;
     }
-    const result = await postJSON(`${API_BASE}/report`, body);
+    const result = (await postJSON(`${API_BASE}/report`, body));
+    if (result.proof) {
+        const shareUrl = `https://loaditout.ai/proof/${result.proof.proof_id}`;
+        const lines = [
+            "Skill usage reported successfully.",
+            "",
+            "Execution Proof:",
+            `  Proof ID: ${result.proof.proof_id}`,
+            `  Verify: ${result.proof.verify_url}`,
+            `  Share: ${shareUrl}`,
+            `  ${result.proof.shareable_text}`,
+        ];
+        return lines.join("\n");
+    }
     return JSON.stringify(result, null, 2);
 }
+async function handleListMyProofs() {
+    const params = new URLSearchParams({ agent_key: AGENT_KEY });
+    const result = (await fetchJSON(`${API_BASE}/proofs?${params.toString()}`));
+    if (result.error) {
+        return `Failed to list proofs: ${result.error}`;
+    }
+    const proofs = result.proofs ?? [];
+    if (proofs.length === 0) {
+        return "No execution proofs yet. Report successful skill usage to earn proofs.";
+    }
+    const lines = [
+        `Execution Proofs (${proofs.length} total):`,
+        "",
+    ];
+    proofs.forEach((p, i) => {
+        lines.push(`${i + 1}. ${p.skill_name ?? p.skill_slug} [${p.proof_id}]`);
+        lines.push(`   Skill: ${p.skill_slug}`);
+        lines.push(`   Verify: ${p.verify_url}`);
+        lines.push(`   Share: https://loaditout.ai/proof/${p.proof_id}`);
+        lines.push(`   Date: ${p.created_at ?? "unknown"}`);
+        lines.push("");
+    });
+    return lines.join("\n");
+}
+async function handleVerifyProof(args) {
+    const result = (await fetchJSON(`${API_BASE}/verify/${encodeURIComponent(args.proof_id)}`));
+    if (result.error) {
+        return `Verification failed: ${result.error}`;
+    }
+    if (!result.valid) {
+        return `Proof ${args.proof_id} is NOT valid.`;
+    }
+    return [
+        `Proof ${result.proof_id} is VALID.`,
+        `  Skill: ${result.skill}`,
+        `  Verified at: ${result.verified_at}`,
+        `  Platform: ${result.platform}`,
+    ].join("\n");
+}
 async function handleSaveMemory(args) {
     const body = {
         agent_key: AGENT_KEY,
@@ -526,7 +806,28 @@ async function handleInstallBatch(args) {
 }
 async function handleShareLoadout() {
     const result = await fetchJSON(`${API_BASE}/loadout/${encodeURIComponent(AGENT_KEY)}`);
-    return JSON.stringify(result, null, 2);
+    const parsed = result;
+    parsed.profile_url = `https://loaditout.ai/agents/${AGENT_KEY}`;
+    return JSON.stringify(parsed, null, 2);
+}
+async function handleSetProfile(args) {
+    const body = {
+        agent_key: AGENT_KEY,
+    };
+    if (args.display_name !== undefined)
+        body.display_name = args.display_name;
+    if (args.bio !== undefined)
+        body.bio = args.bio;
+    const result = (await postJSON(`${API_BASE}/profile`, body));
+    if (result.error) {
+        return `Failed to update profile: ${result.error}`;
+    }
+    const lines = [
+        "Profile updated successfully.",
+        `  Trust score: ${result.trust_score}`,
+        `  Profile: https://loaditout.ai/agents/${AGENT_KEY}`,
+    ];
+    return lines.join("\n");
 }
 async function handleInstallPack(args) {
     const params = new URLSearchParams({ agent: args.agent });
@@ -554,6 +855,98 @@ async function handleInstallPack(args) {
     });
     return lines.join("\n");
 }
+async function handleSmartSearch(args) {
+    // Load all agent memory (installed skills, recent searches, preferences)
+    const memories = await loadAgentMemory();
+    const installedSlugs = extractInstalledSlugs(memories);
+    const recentSearches = extractRecentSearches(memories);
+    const params = new URLSearchParams({ q: args.query });
+    if (args.limit)
+        params.set("limit", String(args.limit));
+    const result = await fetchJSON(`${API_BASE}/search?${params.toString()}`, {
+        "X-Agent-Key": AGENT_KEY,
+    });
+    // Fire-and-forget: record this search query
+    recordSearchQuery(args.query, recentSearches);
+    // Filter out already-installed skills
+    const parsed = result;
+    const excludedCount = { value: 0 };
+    if (parsed.results && installedSlugs.length > 0) {
+        const installedSet = new Set(installedSlugs);
+        const originalLength = parsed.results.length;
+        parsed.results = parsed.results.filter((r) => !r.slug || !installedSet.has(r.slug));
+        excludedCount.value = originalLength - parsed.results.length;
+    }
+    // Add metadata about personalization
+    const output = { ...parsed };
+    output._personalization = {
+        installed_skills_excluded: excludedCount.value,
+        installed_skills_count: installedSlugs.length,
+        recent_searches: recentSearches.slice(-5),
+    };
+    return JSON.stringify(output, null, 2);
+}
+async function handleFlagSkill(args) {
+    const body = {
+        reason: args.reason,
+    };
+    if (args.details) {
+        body.details = args.details;
+    }
+    const url = `https://loaditout.ai/api/skills/${encodeURIComponent(args.slug)}/flag`;
+    const result = (await postJSON(url, body, { "X-Agent-Key": AGENT_KEY }));
+    if (result.error) {
+        return `Flag failed: ${result.error}`;
+    }
+    return `Skill "${args.slug}" has been flagged for "${args.reason}". Thank you for helping keep the registry safe.`;
+}
+async function handleReviewSkill(args) {
+    const body = {
+        agent_key: AGENT_KEY,
+        slug: args.slug,
+        rating: args.rating,
+    };
+    if (args.comment) {
+        body.comment = args.comment;
+    }
+    const result = (await postJSON(`${API_BASE}/review`, body));
+    if (result.error) {
+        return `Review failed: ${result.error}`;
+    }
+    return `Review submitted for "${args.slug}" (${args.rating}/5). Thank you for your feedback.`;
+}
+async function handleValidateAction(args) {
+    const body = {
+        slug: args.slug,
+        action: args.action,
+        agent_key: AGENT_KEY,
+    };
+    if (args.parameters) {
+        body.parameters = args.parameters;
+    }
+    const result = (await postJSON(`${API_BASE}/validate`, body));
+    if (result.error) {
+        return `Validation failed: ${result.error}`;
+    }
+    const lines = [
+        `Validation result for ${args.slug} / ${args.action}:`,
+        `  Safe to proceed: ${result.valid ? "YES" : "NO"}`,
+        `  Risk level: ${result.risk_level ?? "unknown"}`,
+        `  Security grade: ${result.security_grade ?? "unknown"}`,
+        `  Skill verified: ${result.skill_verified ? "yes" : "no"}`,
+    ];
+    if (result.last_updated_days_ago !== undefined) {
+        lines.push(`  Last updated: ${result.last_updated_days_ago} days ago`);
+    }
+    const warnings = result.warnings ?? [];
+    if (warnings.length > 0) {
+        lines.push(`  Warnings:`);
+        for (const w of warnings) {
+            lines.push(`    - ${w}`);
+        }
+    }
+    return lines.join("\n");
+}
 function makeResponse(id, result) {
     return { jsonrpc: "2.0", id, result };
 }
@@ -617,6 +1010,12 @@ async function handleRequest(request) {
                     case "report_skill_usage":
                         resultText = await handleReportSkillUsage(toolArgs);
                         break;
+                    case "list_my_proofs":
+                        resultText = await handleListMyProofs();
+                        break;
+                    case "verify_proof":
+                        resultText = await handleVerifyProof(toolArgs);
+                        break;
                     case "save_memory":
                         resultText = await handleSaveMemory(toolArgs);
                         break;
@@ -635,9 +1034,24 @@ async function handleRequest(request) {
                     case "share_loadout":
                         resultText = await handleShareLoadout();
                         break;
+                    case "set_profile":
+                        resultText = await handleSetProfile(toolArgs);
+                        break;
                     case "install_pack":
                         resultText = await handleInstallPack(toolArgs);
                         break;
+                    case "validate_action":
+                        resultText = await handleValidateAction(toolArgs);
+                        break;
+                    case "flag_skill":
+                        resultText = await handleFlagSkill(toolArgs);
+                        break;
+                    case "review_skill":
+                        resultText = await handleReviewSkill(toolArgs);
+                        break;
+                    case "smart_search":
+                        resultText = await handleSmartSearch(toolArgs);
+                        break;
                     default:
                         send(makeError(id, -32601, `Unknown tool: ${toolName}`));
                         return;

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};