@noelclaw/mcp 2.3.1 → 3.0.0

package/dist/tools/coder.js

@@ -27,53 +27,6 @@ function err(text) {
 }
 // ── Tool definitions ──────────────────────────────────────────────────────────
 exports.CODER_TOOLS = [
-    {
-        name: "scaffold_project",
-        description: "Generate a complete project scaffold for a described idea — file tree + key file contents. " +
-            "Supports: Solidity contract projects, MCP skill packages, React/Next.js dApps, Convex backends, CLI tools.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                description: {
-                    type: "string",
-                    description: "What to build — be specific: tech stack, purpose, target chain, key features",
-                },
-                stack: {
-                    type: "string",
-                    enum: ["solidity", "mcp-skill", "react-dapp", "convex-backend", "node-cli", "auto"],
-                    description: "Tech stack. Use 'auto' to let Noel decide based on description.",
-                },
-                extras: {
-                    type: "string",
-                    description: "Optional: extra requirements, constraints, or preferred libraries",
-                },
-            },
-            required: ["description"],
-        },
-    },
-    {
-        name: "generate_component",
-        description: "Generate a production-ready React/TypeScript component. Returns the full .tsx file content. " +
-            "Includes props typing, Tailwind styling, and any hooks needed.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                description: {
-                    type: "string",
-                    description: "What the component does, what it shows, and how it should behave",
-                },
-                name: {
-                    type: "string",
-                    description: "Component name in PascalCase, e.g. 'TokenPriceCard'",
-                },
-                context: {
-                    type: "string",
-                    description: "Optional: existing imports, store usage, or API calls the component should use",
-                },
-            },
-            required: ["description", "name"],
-        },
-    },
     {
         name: "generate_contract",
         description: "Generate a Solidity smart contract from a description. Returns the full .sol file. " +
@@ -138,6 +91,33 @@ exports.CODER_TOOLS = [
             required: ["code"],
         },
     },
+    {
+        name: "generate_mcp_skill",
+        description: "Generate a complete Claude Code skill (.md file) from a description. " +
+            "Skills are slash-command workflows that run inside Claude Code — they can call tools, " +
+            "loop, delegate to subagents, and have persistent behavior. " +
+            "Returns a ready-to-use .md file you can drop into your .claude/skills/ directory. " +
+            "Use this to automate repetitive Claude Code workflows without writing TypeScript.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                description: {
+                    type: "string",
+                    description: "What the skill should do — be specific about inputs, outputs, and any tools it should use",
+                },
+                name: {
+                    type: "string",
+                    description: "Skill name in kebab-case, e.g. 'daily-standup', 'code-review', 'deploy-check'",
+                },
+                tools: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional: list of Claude Code tools or MCP tools the skill should use, e.g. ['Bash', 'Read', 'memory_search']",
+                },
+            },
+            required: ["description", "name"],
+        },
+    },
     {
         name: "review_code",
         description: "Review and improve a piece of code. Returns the improved version with a summary of changes. " +
@@ -163,16 +143,6 @@ exports.CODER_TOOLS = [
     },
 ];
 // ── Handlers ──────────────────────────────────────────────────────────────────
-const ScaffoldSchema = zod_1.z.object({
-    description: zod_1.z.string().min(10),
-    stack: zod_1.z.enum(["solidity", "mcp-skill", "react-dapp", "convex-backend", "node-cli", "auto"]).optional(),
-    extras: zod_1.z.string().optional(),
-});
-const ComponentSchema = zod_1.z.object({
-    description: zod_1.z.string().min(5),
-    name: zod_1.z.string().min(1),
-    context: zod_1.z.string().optional(),
-});
 const ContractSchema = zod_1.z.object({
     description: zod_1.z.string().min(5),
     name: zod_1.z.string().min(1),
@@ -191,56 +161,13 @@ const ReviewSchema = zod_1.z.object({
     language: zod_1.z.string().optional(),
     goals: zod_1.z.string().optional(),
 });
+const McpSkillSchema = zod_1.z.object({
+    description: zod_1.z.string().min(10),
+    name: zod_1.z.string().min(1).regex(/^[a-z0-9-]+$/, "must be kebab-case"),
+    tools: zod_1.z.array(zod_1.z.string()).optional(),
+});
 async function handleCoderTool(name, args) {
     switch (name) {
-        case "scaffold_project": {
-            const p = ScaffoldSchema.safeParse(args);
-            if (!p.success)
-                return err(`Invalid input: ${p.error.message}`);
-            const { description, stack = "auto", extras } = p.data;
-            const prompt = `Generate a complete project scaffold for the following:\n\n` +
-                `Description: ${description}\n` +
-                `Stack: ${stack}\n` +
-                (extras ? `Extra requirements: ${extras}\n` : "") +
-                `\nOutput format:\n` +
-                `1. Brief overview (2-3 sentences)\n` +
-                `2. Full file tree with all files listed\n` +
-                `3. Full content of each key file (package.json, main entry, config, one core module)\n` +
-                `4. Setup instructions (3-5 steps)\n\n` +
-                `Use real, runnable code. No TODO placeholders.`;
-            try {
-                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 4096);
-                return ok(response);
-            }
-            catch (e) {
-                return err(`scaffold_project failed: ${e.message}`);
-            }
-        }
-        case "generate_component": {
-            const p = ComponentSchema.safeParse(args);
-            if (!p.success)
-                return err(`Invalid input: ${p.error.message}`);
-            const { description, name: componentName, context } = p.data;
-            const prompt = `Generate a production-ready React TypeScript component.\n\n` +
-                `Component name: ${componentName}\n` +
-                `Description: ${description}\n` +
-                (context ? `Context / existing code to integrate with:\n${context}\n` : "") +
-                `\nRequirements:\n` +
-                `- Full .tsx file, no omissions\n` +
-                `- TypeScript props interface\n` +
-                `- Tailwind CSS for styling\n` +
-                `- Use lucide-react for icons if needed\n` +
-                `- Framer Motion for animations if the component is interactive\n` +
-                `- Named export (not default)\n` +
-                `Output only the .tsx file content, no prose before or after.`;
-            try {
-                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 3000);
-                return ok(response);
-            }
-            catch (e) {
-                return err(`generate_component failed: ${e.message}`);
-            }
-        }
         case "generate_contract": {
             const p = ContractSchema.safeParse(args);
             if (!p.success)
@@ -341,6 +268,36 @@ async function handleCoderTool(name, args) {
                 return err(`review_code failed: ${e.message}`);
             }
         }
+        case "generate_mcp_skill": {
+            const p = McpSkillSchema.safeParse(args);
+            if (!p.success)
+                return err(`Invalid input: ${p.error.message}`);
+            const { description, name: skillName, tools = [] } = p.data;
+            const prompt = `Generate a complete Claude Code skill (.md file) for the following workflow:\n\n` +
+                `Skill name: /${skillName}\n` +
+                `Description: ${description}\n` +
+                (tools.length ? `Tools to use: ${tools.join(", ")}\n` : "") +
+                `\n` +
+                `Claude Code skill format rules:\n` +
+                `- The file is a markdown document that serves as a system prompt for a Claude Code slash command\n` +
+                `- It should start with a brief description of what the skill does\n` +
+                `- Include an "## Input" section explaining what arguments the skill accepts (if any)\n` +
+                `- Include a "## Steps" section with numbered, concrete steps\n` +
+                `- Include a "## Output" section describing what the skill produces\n` +
+                `- Steps can reference tool calls like "Use the Bash tool to run X" or "Use memory_search to find Y"\n` +
+                `- Steps can reference conditional logic and loops\n` +
+                `- Keep it under 200 lines — skills should be focused, not monolithic\n` +
+                `- Write in imperative second person ("Run...", "Check...", "If X, then...")\n` +
+                `- Do NOT include markdown fences around the output — output the raw .md content directly\n\n` +
+                `Output only the .md file content, ready to save as .claude/skills/${skillName}.md`;
+            try {
+                const response = await (0, llm_js_1.callLLM)(CODER_SYSTEM, prompt, 2000);
+                return ok(`# /${skillName} skill — save to .claude/skills/${skillName}.md\n\n---\n\n${response}`);
+            }
+            catch (e) {
+                return err(`generate_mcp_skill failed: ${e.message}`);
+            }
+        }
         default:
             return null;
     }

package/dist/tools/defi.js

@@ -51,13 +51,44 @@ exports.DEFI_TOOLS = [
         },
     },
     {
-        name: "scan_wallet",
-        description: "AI-powered portfolio scan — concentration risk, volatility exposure, Base ecosystem opportunities, and a concrete 3-step action plan based on your actual holdings. Requires wallet auth.",
-        inputSchema: { type: "object", properties: {}, required: [] },
+        name: "analyze_wallet",
+        description: "AI-powered analysis of any public wallet on Base — not just your own. " +
+            "Enter any 0x address: see token holdings, portfolio value, concentration risk, " +
+            "DeFi positions, and a behavioral profile (whale, degen, LP provider, etc.). " +
+            "Use to track smart money, research whales, or audit any wallet before copying trades.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                address: { type: "string", description: "Wallet address to analyze (0x...)" },
+                label: { type: "string", description: "Optional label for this wallet (e.g. 'whale from Twitter')" },
+            },
+            required: ["address"],
+        },
+    },
+    {
+        name: "get_defi_yields",
+        description: "Fetch top DeFi yield opportunities on Base — Morpho, Moonwell, Aerodrome, Uniswap, and more. " +
+            "Returns live APY, TVL, and pool info from DeFiLlama (no API key required). " +
+            "Filter by token or minimum APY. Use before depositing to find the best rates.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Optional: filter by token symbol, e.g. 'USDC', 'ETH', 'WETH'" },
+                minApy: { type: "number", description: "Optional: minimum APY % to show (default 1)" },
+                limit: { type: "number", description: "Max results to return (default 20)" },
+            },
+            required: [],
+        },
     },
 ];
 const SwapSchema = zod_1.z.object({ fromToken: zod_1.z.string().min(1), toToken: zod_1.z.string().min(1), amount: zod_1.z.string().min(1) });
 const SendSchema = zod_1.z.object({ token: zod_1.z.string().min(1), toAddress: zod_1.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a valid 0x address"), amount: zod_1.z.string().min(1) });
+const AnalyzeWalletSchema = zod_1.z.object({ address: zod_1.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be a valid 0x address"), label: zod_1.z.string().optional() });
+const DefiYieldsSchema = zod_1.z.object({
+    token: zod_1.z.string().optional(),
+    minApy: zod_1.z.number().optional(),
+    limit: zod_1.z.number().int().min(1).max(100).optional(),
+}).default({});
 const BUY_DECIMALS = { USDC: 6, USDT: 6, DAI: 18, ETH: 18, WETH: 18 };
 function formatTokenAmount(raw, token) {
     const dec = BUY_DECIMALS[token.toUpperCase()] ?? 18;
@@ -150,38 +181,96 @@ async function handleDefiTool(name, args) {
                     }],
             };
         }
-        case "scan_wallet": {
-            const data = await (0, convex_js_1.callConvex)("/wallet/scan", "GET", undefined, "scan_wallet");
-            if (data.error) {
-                return { content: [{ type: "text", text: `Scan failed: ${data.error}` }], isError: true };
-            }
+        case "analyze_wallet": {
+            const parsed = AnalyzeWalletSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { address, label } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/wallet/analyze", "POST", { address, label }, "analyze_wallet");
+            if (data.error)
+                return { content: [{ type: "text", text: `Wallet analysis failed: ${data.error}` }], isError: true };
             const total = (data.totalUsd ?? 0).toFixed(2);
+            const walletLabel = label ? ` — ${label}` : "";
             const topHoldings = (data.holdings ?? [])
-                .slice(0, 5)
-                .map((h) => `• **${h.token}**: $${(h.valueUsd ?? 0).toFixed(2)}${h.pct != null ? ` (${h.pct}%)` : ""}`)
+                .slice(0, 8)
+                .map(h => `• **${h.token}**: $${(h.valueUsd ?? 0).toFixed(2)}${h.pct != null ? ` (${h.pct}%)` : ""}`)
                 .join("\n");
+            const profileLine = data.profile ? `**Profile:** ${data.profile}\n` : "";
             const header = [
-                `**Portfolio Scan** — Total: $${total}`,
-                `Wallet: \`${data.address ?? "unknown"}\``,
+                `**Wallet Analysis**${walletLabel}`,
+                `\`${address}\``,
+                `**Portfolio value:** $${total}`,
                 ``,
+                profileLine,
                 `**Holdings:**`,
-                topHoldings,
+                topHoldings || "No token holdings found.",
                 ``,
             ].join("\n");
-            let body;
-            if (data.analysis) {
-                body = data.analysis;
+            const body = data.analysis ?? (data.analysisError ? `*AI analysis unavailable: ${data.analysisError}*` : "*AI analysis not available*");
+            return { content: [{ type: "text", text: header + body }] };
+        }
+        case "get_defi_yields": {
+            const parsed = DefiYieldsSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { token, minApy = 1, limit = 20 } = parsed.data;
+            let pools;
+            try {
+                const res = await fetch("https://yields.llama.fi/pools", { signal: AbortSignal.timeout(15000) });
+                if (!res.ok)
+                    throw new Error(`HTTP ${res.status}`);
+                const data = await res.json();
+                pools = data.data ?? [];
+            }
+            catch (e) {
+                return { content: [{ type: "text", text: `DeFiLlama fetch failed: ${e.message}` }], isError: true };
             }
-            else if (data.analysisError) {
-                body = `*AI analysis unavailable: ${data.analysisError}*`;
+            // Filter to Base chain
+            let filtered = pools.filter((p) => p.chain === "Base");
+            // Filter by token if specified
+            if (token) {
+                const upper = token.toUpperCase();
+                filtered = filtered.filter((p) => (p.symbol ?? "").toUpperCase().includes(upper) ||
+                    (p.underlyingTokens ?? []).some((t) => t.toUpperCase().includes(upper)));
             }
-            else {
-                body = "*AI analysis not available*";
+            // Filter by minimum APY and remove outliers (>10000% are usually broken)
+            filtered = filtered
+                .filter((p) => (p.apy ?? 0) >= minApy && (p.apy ?? 0) <= 10000)
+                .sort((a, b) => (b.apy ?? 0) - (a.apy ?? 0))
+                .slice(0, limit);
+            if (!filtered.length) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `## DeFi Yields on Base`,
+                                `No pools found${token ? ` for ${token.toUpperCase()}` : ""} with APY ≥ ${minApy}%.`,
+                                ``,
+                                `Try lowering \`minApy\` or removing the token filter.`,
+                            ].join("\n"),
+                        }],
+                };
             }
-            const footer = data.tokensUsed
-                ? `\n\n*Tokens used: ${data.tokensUsed} · Scanned: ${data.scannedAt ?? ""}*`
-                : "";
-            return { content: [{ type: "text", text: header + body + footer }] };
+            const fmt = (n) => n >= 1000000000 ? `$${(n / 1000000000).toFixed(1)}B`
+                : n >= 1000000 ? `$${(n / 1000000).toFixed(1)}M`
+                    : n >= 1000 ? `$${(n / 1000).toFixed(0)}K`
+                        : `$${n.toFixed(0)}`;
+            const lines = [
+                `## DeFi Yields on Base${token ? ` — ${token.toUpperCase()}` : ""}`,
+                `Top ${filtered.length} pools · APY ≥ ${minApy}% · Source: DeFiLlama`,
+                ``,
+                `| # | Pool | Protocol | APY | TVL |`,
+                `|---|------|----------|-----|-----|`,
+            ];
+            filtered.forEach((p, i) => {
+                const apy = (p.apy ?? 0).toFixed(1);
+                const tvl = fmt(p.tvlUsd ?? 0);
+                const name = (p.symbol ?? p.pool ?? "—").replace(/-/g, " ");
+                const proj = p.project ?? "—";
+                lines.push(`| ${i + 1} | ${name} | ${proj} | **${apy}%** | ${tvl} |`);
+            });
+            lines.push(``, `Use \`swap_tokens\` to position, then deposit via the protocol's UI. Always check smart contract risk before depositing.`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
         }
         default:
             return null;

package/dist/tools/framework.js

@@ -4,32 +4,6 @@ exports.FRAMEWORK_TOOLS = void 0;
 exports.handleFrameworkTool = handleFrameworkTool;
 const convex_js_1 = require("../convex.js");
 exports.FRAMEWORK_TOOLS = [
-    {
-        name: "create_task_packet",
-        description: "Define a scoped task for Noel Framework. Converts plain-English intent into a " +
-            "structured Task Packet (territory, permissions, doNotDo constraints). " +
-            "Sentinel validates before any agent action. " +
-            "Example: 'buy ETH when it drops 5%, max $20, don't touch my USDC'.",
-        inputSchema: {
-            type: "object",
-            properties: {
-                task: {
-                    type: "string",
-                    description: "What you want the agents to do, in plain English.",
-                },
-                name: {
-                    type: "string",
-                    description: "Optional short name for this task (max 5 words).",
-                },
-            },
-            required: ["task"],
-        },
-    },
-    {
-        name: "list_task_packets",
-        description: "List all your Task Packets — draft, active, completed, and blocked.",
-        inputSchema: { type: "object", properties: {}, required: [] },
-    },
     {
         name: "list_playbooks",
         description: "List available Noel Framework playbooks — predefined multi-step agent workflows. " +
@@ -65,62 +39,10 @@ exports.FRAMEWORK_TOOLS = [
             "Full transparency on what agents are and aren't allowed to do.",
         inputSchema: { type: "object", properties: {}, required: [] },
     },
-    {
-        name: "get_sentinel_rules",
-        description: "Get Sentinel rules for each swarm agent and each playbook role — " +
-            "territory, permissions, blocked actions, and value caps. " +
-            "Shows exactly what each agent is and isn't allowed to do.",
-        inputSchema: { type: "object", properties: {}, required: [] },
-    },
 ];
 async function handleFrameworkTool(name, args) {
     const a = (args ?? {});
     switch (name) {
-        // ── create_task_packet ──────────────────────────────────────────────────
-        case "create_task_packet": {
-            if (!a.task) {
-                return { content: [{ type: "text", text: "task is required" }], isError: true };
-            }
-            const result = await (0, convex_js_1.callConvex)("/framework/task", "POST", {
-                naturalLanguage: a.task,
-                name: a.name,
-            }, "create_task_packet");
-            if (result.error) {
-                return { content: [{ type: "text", text: `Failed: ${result.error}` }], isError: true };
-            }
-            const p = result.packet ?? {};
-            const lines = [
-                `✅ **Task Packet created**`,
-                ``,
-                `**Name:** ${p.name ?? "—"}`,
-                `**Task:** ${p.task ?? a.task}`,
-                `**Territory:** ${(p.territory ?? []).join(", ") || "—"}`,
-                `**Permissions:** ${(p.permissions ?? []).join(", ") || "—"}`,
-                `**Blocked:** ${(p.doNotDo ?? []).join(", ") || "none"}`,
-                `**Max value:** ${p.maxValueUsd != null ? `$${p.maxValueUsd}` : "no limit"}`,
-                ``,
-                `ID: \`${result.id}\``,
-                `Ready to run a playbook with this task scope.`,
-            ];
-            return { content: [{ type: "text", text: lines.join("\n") }] };
-        }
-        // ── list_task_packets ───────────────────────────────────────────────────
-        case "list_task_packets": {
-            const result = await (0, convex_js_1.callConvex)("/framework/tasks", "GET", undefined, "list_task_packets");
-            const tasks = result.tasks ?? [];
-            if (tasks.length === 0) {
-                return {
-                    content: [{
-                            type: "text",
-                            text: "No task packets yet. Use create_task_packet to define your first task.",
-                        }],
-                };
-            }
-            const list = tasks
-                .map((t) => `• **${t.name}** [${t.status}]\n  ${t.task}`)
-                .join("\n\n");
-            return { content: [{ type: "text", text: `**Your Task Packets**\n\n${list}` }] };
-        }
         // ── list_playbooks ──────────────────────────────────────────────────────
         case "list_playbooks": {
             const result = await (0, convex_js_1.callConvex)("/framework/playbooks", "GET", undefined, "list_playbooks");
@@ -223,36 +145,6 @@ async function handleFrameworkTool(name, args) {
                     }],
             };
         }
-        // ── get_sentinel_rules ──────────────────────────────────────────────────
-        case "get_sentinel_rules": {
-            const rules = {
-                "market-monitor": { territory: ["market_data", "price_check", "market"], permissions: ["read:market", "write:memory"], doNotDo: ["swap", "send", "transfer", "buy", "sell", "drain"], maxValueUsd: 0 },
-                "sentiment-tracker": { territory: ["sentiment", "news_analysis", "news"], permissions: ["read:market", "read:social", "write:memory"], doNotDo: ["swap", "send", "transfer", "buy", "sell"], maxValueUsd: 0 },
-                "workflow-executor": { territory: ["swap", "send", "automation"], permissions: ["read:market", "write:tx", "write:memory"], doNotDo: ["delete_wallet", "change_keys", "drain_wallet"], maxValueUsd: 500 },
-                "memory-manager": { territory: ["memory_compress", "memory_prune", "memory"], permissions: ["read:memory", "write:memory", "delete:memory"], doNotDo: ["swap", "send", "transfer"], maxValueUsd: 0 },
-                "risk-verifier": { territory: ["risk_check", "verify", "risk"], permissions: ["read:market", "read:memory"], doNotDo: ["swap", "send", "transfer", "modify_rules"], maxValueUsd: 0 },
-                "playbook:scout": { territory: ["get", "read", "list", "market", "signal", "portfolio", "insight", "research", "data", "recap", "whale", "score", "execution", "memory", "noel", "swarm", "smart"], permissions: ["read:market", "read:signals", "read:portfolio", "read:memory", "write:memory"], doNotDo: ["send_token", "deploy_token", "mint_nft", "claim_fees", "swap_tokens", "delete_automation", "stop_swarm"], maxValueUsd: 0, note: "Playbook read-only scout role" },
-                "playbook:tinker": { territory: ["create", "write", "start", "run", "swap", "send", "deploy", "mint", "claim", "automation", "memory", "swarm"], permissions: ["write:tx", "write:memory", "execute:automation", "swap:token", "deploy:token"], doNotDo: ["delete_wallet", "drain_wallet"], maxValueUsd: 100, note: "Playbook execution role" },
-                "playbook:skeptic": { territory: ["get", "read", "ask", "analyze", "verify", "research", "check", "market", "signal", "execution", "score", "portfolio", "memory", "noel", "insight"], permissions: ["read:market", "read:signals", "read:portfolio", "read:memory"], doNotDo: ["send_token", "deploy_token", "mint_nft", "claim_fees", "swap_tokens", "delete"], maxValueUsd: 0, note: "Playbook analysis/verification role" },
-                "playbook:memory": { territory: ["memory", "write", "read", "compress", "prune", "summarize"], permissions: ["read:memory", "write:memory", "delete:memory"], doNotDo: ["send_token", "swap_tokens", "deploy_token", "mint_nft", "claim_fees"], maxValueUsd: 0, note: "Playbook memory management role" },
-            };
-            const sections = [
-                "**Sentinel Rules**",
-                "",
-                "**Swarm Agents (DEFAULT_RULES)**",
-                ...["market-monitor", "sentiment-tracker", "workflow-executor", "memory-manager", "risk-verifier"].map(agent => {
-                    const r = rules[agent];
-                    return `\n**${agent}**\n  Territory: ${r.territory.join(", ")}\n  Permissions: ${r.permissions.join(", ")}\n  Blocked: ${r.doNotDo.join(", ")}\n  Max value: $${r.maxValueUsd}`;
-                }),
-                "",
-                "**Playbook Roles (DB rules — seeded at deploy)**",
-                ...["playbook:scout", "playbook:tinker", "playbook:skeptic", "playbook:memory"].map(agent => {
-                    const r = rules[agent];
-                    return `\n**${agent}** _(${r.note})_\n  Territory: ${r.territory.slice(0, 6).join(", ")}…\n  Blocked: ${r.doNotDo.join(", ")}\n  Max value: $${r.maxValueUsd}`;
-                }),
-            ];
-            return { content: [{ type: "text", text: sections.join("\n") }] };
-        }
         default:
             return null;
     }