@noelclaw/mcp 1.0.0

package/dist/tools/defi.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFI_TOOLS = void 0;
+exports.handleDefiTool = handleDefiTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+const wallet_js_1 = require("../wallet.js");
+exports.DEFI_TOOLS = [
+    {
+        name: "get_portfolio",
+        description: "Get your Base wallet address and full token portfolio including all token balances with USD values. Auto-creates a secure encrypted wallet on first use.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "swap_tokens",
+        description: "Swap tokens on Base mainnet via 0x Permit2. Supported: ETH, USDC, USDT, DAI, WETH. Amount is human-readable. Signed and broadcast locally from your wallet.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromToken: { type: "string", description: "Token to sell: ETH, USDC, USDT, DAI, WETH" },
+                toToken: { type: "string", description: "Token to buy: ETH, USDC, USDT, DAI, WETH" },
+                amount: { type: "string", description: "Amount to swap. Human-readable (e.g. '0.001') or percentage of balance (e.g. '50%', '100%')" },
+            },
+            required: ["fromToken", "toToken", "amount"],
+        },
+    },
+    {
+        name: "send_token",
+        description: "Send ETH or ERC-20 tokens (USDC, USDT, DAI, WETH) to any address on Base mainnet. Signed and broadcast locally from your wallet.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                token: { type: "string", description: "Token to send: ETH, USDC, USDT, DAI, WETH" },
+                toAddress: { type: "string", description: "Destination address (0x...)" },
+                amount: { type: "string", description: "Human-readable amount" },
+            },
+            required: ["token", "toAddress", "amount"],
+        },
+    },
+    {
+        name: "deploy_token",
+        description: "Launch a new memecoin on Base via Flaunch. Deploys with fair launch period, sets your revenue share (default 80% of swap fees), and returns a Memestream NFT that earns ETH from every swap forever. Image must be a publicly accessible URL.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Token name e.g. 'Pepe Noel'" },
+                symbol: { type: "string", description: "Ticker 3-6 chars e.g. 'PNOEL'" },
+                imageUrl: { type: "string", description: "Public image URL for the token" },
+                description: { type: "string", description: "Token description (optional)" },
+                initialMarketCapUSD: { type: "number", description: "Starting mcap in USD (default: 10000, min: 1000)" },
+                creatorFeePercent: { type: "number", description: "Your % of swap fees (default: 80, max: 100)" },
+                preminePercent: { type: "number", description: "% of supply to premine at launch (default: 0)" },
+                fairLaunchDurationMinutes: { type: "number", description: "Fair launch window in minutes (default: 30)" },
+            },
+            required: ["name", "symbol", "imageUrl"],
+        },
+    },
+    {
+        name: "claim_fees",
+        description: "Claim accumulated ETH from your Flaunch token swap fees. Calls claim() on the Flaunch PositionManager — pulls all pending ETH from your deployed tokens to your wallet.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "mint_nft",
+        description: "Auto-mint any NFT on Base. Pass the mint page URL or contract address. " +
+            "Noel detects the contract, checks your eligibility and balance, " +
+            "then mints directly from your wallet. Works with OpenSea, Zora, Highlight, and most Base NFT projects.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                mintUrl: {
+                    type: "string",
+                    description: "NFT mint URL (OpenSea, Zora, Highlight) or raw contract address (0x...)",
+                },
+                quantity: {
+                    type: "number",
+                    description: "How many to mint (default: 1)",
+                },
+            },
+            required: ["mintUrl"],
+        },
+    },
+];
+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 MintNftSchema = zod_1.z.object({
+    mintUrl: zod_1.z.string().min(1),
+    quantity: zod_1.z.number().min(1).max(100).optional(),
+});
+const DeployTokenSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    symbol: zod_1.z.string().min(3).max(6),
+    imageUrl: zod_1.z.string().url(),
+    description: zod_1.z.string().optional(),
+    initialMarketCapUSD: zod_1.z.number().min(1000).optional(),
+    creatorFeePercent: zod_1.z.number().min(0).max(100).optional(),
+    preminePercent: zod_1.z.number().min(0).max(50).optional(),
+    fairLaunchDurationMinutes: zod_1.z.number().min(1).optional(),
+});
+async function handleDefiTool(name, args) {
+    switch (name) {
+        case "get_portfolio": {
+            const data = await (0, convex_js_1.callConvex)("/mcp/defi/portfolio", "GET", undefined, "get_portfolio");
+            if (data.error)
+                return { content: [{ type: "text", text: `Portfolio error: ${data.error}` }], isError: true };
+            const lines = [
+                `**Portfolio — Base Mainnet**`, `Address: \`${data.address}\``, ``, `**Balances**`,
+            ];
+            for (const b of (data.balances ?? [])) {
+                lines.push(`• ${b.token}: ${b.balance}${b.valueUsd ? ` (~$${Number(b.valueUsd).toFixed(2)})` : ""}`);
+            }
+            lines.push(``, `**Total Value:** ~$${Number(data.totalValueUsd ?? 0).toFixed(2)}`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "swap_tokens": {
+            const parsed = SwapSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${String(parsed.error.issues[0].path[0])} ${parsed.error.issues[0].message}` }], isError: true };
+            let { fromToken, toToken, amount } = parsed.data;
+            // Resolve percentage amounts e.g. "50%", "100%", "25%"
+            const pctMatch = amount.trim().match(/^(\d+(?:\.\d+)?)\s*%$/);
+            if (pctMatch) {
+                const pct = parseFloat(pctMatch[1]) / 100;
+                const portfolio = await (0, convex_js_1.callConvex)("/mcp/defi/portfolio", "GET", undefined, "get_portfolio");
+                const balance = (portfolio.balances ?? []).find((b) => b.token?.toUpperCase() === fromToken.toUpperCase());
+                if (!balance)
+                    return { content: [{ type: "text", text: `No ${fromToken.toUpperCase()} balance found in portfolio.` }], isError: true };
+                const rawBalance = parseFloat(balance.balance ?? "0");
+                if (rawBalance <= 0)
+                    return { content: [{ type: "text", text: `${fromToken.toUpperCase()} balance is 0.` }], isError: true };
+                const resolved = (rawBalance * pct).toFixed(6).replace(/\.?0+$/, "");
+                amount = resolved;
+            }
+            const wallet = await (0, wallet_js_1.getOrCreateWallet)();
+            const result = await (0, convex_js_1.callConvex)("/mcp/defi/swap", "POST", { fromToken, toToken, amount }, "swap_tokens");
+            if (!result.success)
+                return { content: [{ type: "text", text: `Swap failed: ${result.error}` }], isError: true };
+            const txHash = await (0, wallet_js_1.signAndBroadcast)(wallet, result.quote);
+            const buyAmountHuman = (parseInt(result.quote.buyAmount) / 1e6).toFixed(4);
+            return {
+                content: [{
+                        type: "text",
+                        text: [`✅ Swap executed!`, `${amount} ${fromToken.toUpperCase()} → ${buyAmountHuman} ${result.quote.buyToken}`, `Tx Hash: \`${txHash}\``, `https://basescan.org/tx/${txHash}`].join("\n"),
+                    }],
+            };
+        }
+        case "send_token": {
+            const parsed = SendSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${String(parsed.error.issues[0].path[0])} ${parsed.error.issues[0].message}` }], isError: true };
+            const { token, toAddress, amount } = parsed.data;
+            const wallet = await (0, wallet_js_1.getOrCreateWallet)();
+            const result = await (0, convex_js_1.callConvex)("/mcp/defi/send", "POST", parsed.data, "send_token");
+            if (!result.success)
+                return { content: [{ type: "text", text: `Send failed: ${result.error}` }], isError: true };
+            const txHash = await (0, wallet_js_1.signAndBroadcast)(wallet, result.txData);
+            // Collect 0.5% platform fee as a separate tx if the server returned fee data
+            if (result.feeTxData) {
+                try {
+                    await (0, wallet_js_1.signAndBroadcast)(wallet, result.feeTxData);
+                }
+                catch { /* non-fatal */ }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: [`✅ Sent!`, `${amount} ${token.toUpperCase()} → \`${toAddress}\``, `Tx Hash: \`${txHash}\``, `https://basescan.org/tx/${txHash}`].join("\n"),
+                    }],
+            };
+        }
+        case "mint_nft": {
+            const parsed = MintNftSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { mintUrl, quantity } = parsed.data;
+            const wallet = await (0, wallet_js_1.getOrCreateWallet)();
+            const result = await (0, convex_js_1.callConvex)("/mcp/nft/mint", "POST", { mintUrl, quantity: quantity ?? 1 }, "mint_nft");
+            if (result.error)
+                return { content: [{ type: "text", text: `Mint failed: ${result.error}` }], isError: true };
+            if (result.action !== "sign_and_broadcast")
+                return { content: [{ type: "text", text: "Unexpected response from server" }], isError: true };
+            const txHash = await (0, wallet_js_1.signAndBroadcast)(wallet, result);
+            const meta = result.metadata ?? {};
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `✅ Minted successfully!`,
+                            `Contract: ${meta.contractAddress ?? result.to}`,
+                            `Quantity: ${meta.quantity ?? quantity ?? 1}`,
+                            `Cost: ${meta.totalCost ?? "0"} ETH`,
+                            `Tx: \`${txHash}\``,
+                            `https://basescan.org/tx/${txHash}`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        case "deploy_token": {
+            const parsed = DeployTokenSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const wallet = await (0, wallet_js_1.getOrCreateWallet)();
+            const result = await (0, convex_js_1.callConvex)("/mcp/token/deploy", "POST", parsed.data, "deploy_token");
+            if (result.error)
+                return { content: [{ type: "text", text: `Deploy failed: ${result.error}` }], isError: true };
+            const txHash = await (0, wallet_js_1.signAndBroadcast)(wallet, result);
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `✅ Token deployed!`,
+                            `Name: ${parsed.data.name} ($${parsed.data.symbol})`,
+                            `Tx Hash: \`${txHash}\``,
+                            `https://basescan.org/tx/${txHash}`,
+                            ``,
+                            `Your Memestream NFT earns ETH from every swap.`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        case "claim_fees": {
+            const wallet = await (0, wallet_js_1.getOrCreateWallet)();
+            const result = await (0, convex_js_1.callConvex)("/mcp/token/claim", "POST", {}, "claim_fees");
+            if (result.error)
+                return { content: [{ type: "text", text: `Claim failed: ${result.error}` }], isError: true };
+            const txHash = await (0, wallet_js_1.signAndBroadcast)(wallet, result);
+            return {
+                content: [{
+                        type: "text",
+                        text: [`✅ ETH claimed successfully!`, `Tx Hash: \`${txHash}\``, `https://basescan.org/tx/${txHash}`].join("\n"),
+                    }],
+            };
+        }
+        default:
+            return null;
+    }
+}

package/dist/tools/framework.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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. " +
+            "Includes 4 system playbooks (Daily Market Scan, DCA Setup, Portfolio Rebalance Check, " +
+            "Swarm Intel Sweep) plus any you've created. Each step is Sentinel-gated.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "run_playbook",
+        description: "Execute a Noel Framework playbook. Each step runs through Sentinel before the " +
+            "appropriate swarm agent executes it (Scout → market-monitor, Tinker → workflow-executor, " +
+            "Skeptic → risk-verifier, Memory → memory-manager). " +
+            "Playbook halts immediately if Sentinel blocks a step.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                playbook_name: {
+                    type: "string",
+                    description: "Exact name of the playbook. Use list_playbooks to see available ones.",
+                },
+                task_description: {
+                    type: "string",
+                    description: "Optional context passed as overrideParams to the playbook run.",
+                },
+            },
+            required: ["playbook_name"],
+        },
+    },
+    {
+        name: "get_noel_ledger",
+        description: "Get the Noel Framework audit trail — every Sentinel gate decision " +
+            "(approved / blocked / warned), which checks ran, duration, and reason. " +
+            "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");
+            const pbs = result.playbooks ?? [];
+            if (pbs.length === 0) {
+                return { content: [{ type: "text", text: "No playbooks found." }] };
+            }
+            const list = pbs
+                .map((p) => {
+                const steps = (() => {
+                    try {
+                        return JSON.parse(p.steps).length;
+                    }
+                    catch {
+                        return "?";
+                    }
+                })();
+                return `• **${p.name}**${p.isPublic ? " 🌐" : " 👤"} — ${steps} steps\n  ${p.description}\n  Used ${p.usageCount} times`;
+            })
+                .join("\n\n");
+            return { content: [{ type: "text", text: `**Available Playbooks**\n\n${list}` }] };
+        }
+        // ── run_playbook ────────────────────────────────────────────────────────
+        case "run_playbook": {
+            if (!a.playbook_name) {
+                return { content: [{ type: "text", text: "playbook_name is required" }], isError: true };
+            }
+            // Resolve playbook ID by name
+            const pbList = await (0, convex_js_1.callConvex)("/framework/playbooks", "GET", undefined, "run_playbook");
+            const playbook = (pbList.playbooks ?? []).find((p) => p.name.toLowerCase() === String(a.playbook_name).toLowerCase());
+            if (!playbook) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Playbook "${a.playbook_name}" not found. Use list_playbooks to see available ones.`,
+                        }],
+                    isError: true,
+                };
+            }
+            const result = await (0, convex_js_1.callConvex)("/framework/playbook/run", "POST", {
+                playbookId: playbook._id,
+                overrideParams: a.task_description,
+            }, "run_playbook");
+            if (result.error) {
+                return { content: [{ type: "text", text: `Run failed: ${result.error}` }], isError: true };
+            }
+            if (result.blocked) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `🛡️ **Sentinel blocked playbook at step ${result.step}**`,
+                                ``,
+                                `**Tool:** ${result.tool}`,
+                                `**Reason:** ${result.reason}`,
+                                ``,
+                                `This is a mechanical safety gate. The action violates the agent's permission boundary.`,
+                                `Completed steps before block: ${result.results?.length ?? 0}`,
+                            ].join("\n"),
+                        }],
+                };
+            }
+            const steps = result.results ?? [];
+            const succeeded = steps.filter(r => r.success).length;
+            const stepLines = steps.map((r) => `${r.success ? "✅" : "❌"} Step ${r.step} [${r.role}]: ${r.tool}${r.error ? ` — ${r.error}` : ""}`);
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `✅ **Playbook "${a.playbook_name}" completed**`,
+                            ``,
+                            `${succeeded}/${steps.length} steps successful`,
+                            `Run ID: \`${result.runId}\``,
+                            ``,
+                            ...stepLines,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        // ── get_noel_ledger ─────────────────────────────────────────────────────
+        case "get_noel_ledger": {
+            const result = await (0, convex_js_1.callConvex)("/swarm/ledger", "GET", undefined, "get_noel_ledger");
+            const entries = result.entries ?? [];
+            if (entries.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: "No ledger entries yet. Run a playbook to see Sentinel decisions.",
+                        }],
+                };
+            }
+            const lines = entries.map((e) => {
+                const icon = e.decision === "approved" ? "✅" : e.decision === "blocked" ? "🚫" : "⚠️";
+                return `${icon} **${e.agentId}** → \`${e.action}\`\n  ${e.reason} (${e.durationMs}ms)`;
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `**Noel Ledger** (last ${entries.length} decisions)\n\n${lines.join("\n\n")}`,
+                    }],
+            };
+        }
+        // ── 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;
+    }
+}

package/dist/tools/humanizer.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HUMANIZER_TOOLS = void 0;
+exports.handleHumanizerTool = handleHumanizerTool;
+exports.HUMANIZER_TOOLS = [
+    {
+        name: "humanize_text",
+        description: "Remove AI writing patterns from text — makes it sound natural, direct, and human. " +
+            "Fixes 29 common AI tells: significance inflation, em dash overuse, filler phrases, " +
+            "sycophantic openers, passive voice, elegant variation, chatbot artifacts, and more. " +
+            "Optionally provide a writing sample to match your personal voice.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                text: {
+                    type: "string",
+                    description: "The text to humanize",
+                },
+                voice_sample: {
+                    type: "string",
+                    description: "Optional: a sample of your own writing so the output matches your voice",
+                },
+            },
+            required: ["text"],
+        },
+    },
+];
+const HUMANIZER_SYSTEM = `You are a text editor that removes signs of AI-generated writing.
+
+Your job: rewrite the input so it sounds natural, direct, and human — without changing the meaning.
+
+Fix these patterns when present:
+
+CONTENT
+1. Significance inflation — remove phrases like "in today's rapidly evolving landscape", "in an era of", "now more than ever"
+2. Notability emphasis — cut "notably", "it is worth noting", "it is important to note"
+3. Superficial -ing openers — rewrite "By leveraging X, you can Y" → just say "X lets you Y"
+4. Promotional language — cut "revolutionary", "game-changing", "cutting-edge", "innovative solution"
+5. Vague attribution — replace "experts say", "studies show" with specific sources or cut entirely
+6. Formulaic challenges sections — remove "Of course, challenges remain" boilerplate
+
+LANGUAGE
+7. AI vocabulary — replace: landscape → field/market/space, pivotal → key/critical, testament → proof/sign, delve → explore/look at, utilize → use, leverage → use
+8. Copula avoidance — "serves as", "stands as", "acts as" → just use "is"
+9. Negative parallelisms — "not only X but also Y" → just say the thing directly
+10. Rule of three — "fast, reliable, and scalable" padding — cut to what matters
+11. Elegant variation — don't use synonyms to avoid repeating a word; repeat it or restructure
+12. False ranges — "anywhere from X to Y" → just say the number you know
+13. Passive voice — rewrite to active where it feels evasive
+14. Em dash overuse — max one per paragraph; replace others with commas or rewrite
+15. Bullet point padding — remove bullets that just restate the intro sentence
+
+COMMUNICATION
+16. Chatbot artifacts — cut "Certainly!", "Of course!", "Great question!", "I hope this helps"
+17. Knowledge disclaimers — cut "As of my last update", "Based on my training data"
+18. Sycophancy — cut "That's a fascinating perspective", "You raise an excellent point"
+
+FILLER
+19. Filler phrases — cut "It is worth mentioning that", "It goes without saying", "Needless to say"
+20. Excessive hedging — cut "it could be argued", "one might say", "in some ways"
+21. Generic conclusions — rewrite "In conclusion, X is important" → just end on substance
+22. Hyphenated padding — "user-friendly", "game-changing", "thought-provoking" → be specific
+23. Signposting — cut "In this article, I will explain" — just explain it
+24. Fragmented headers — avoid turning every sentence into a bold header
+
+PROCESS:
+1. Read the full text
+2. Identify which patterns are present
+3. Rewrite — fix all patterns found
+4. Self-audit: scan the rewrite for any remaining AI tells
+5. Final revision if needed
+6. Output ONLY the final humanized text — no commentary, no explanation, no "Here is your text:"
+
+If a voice sample is provided, match its tone, rhythm, and vocabulary. Otherwise use direct, opinionated, natural prose.`;
+async function handleHumanizerTool(name, args) {
+    if (name !== "humanize_text")
+        return null;
+    const a = (args ?? {});
+    if (!a.text?.trim()) {
+        return { content: [{ type: "text", text: "text is required" }], isError: true };
+    }
+    const apiKey = process.env.MINIMAX_API_KEY;
+    if (!apiKey) {
+        return { content: [{ type: "text", text: "MINIMAX_API_KEY not set — humanizer requires MiniMax API access" }], isError: true };
+    }
+    const userMsg = a.voice_sample
+        ? `VOICE SAMPLE (match this style):\n${a.voice_sample}\n\n---\n\nTEXT TO HUMANIZE:\n${a.text}`
+        : a.text;
+    try {
+        const res = await fetch("https://api.minimaxi.chat/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model: "MiniMax-Text-01",
+                messages: [
+                    { role: "system", content: HUMANIZER_SYSTEM },
+                    { role: "user", content: userMsg },
+                ],
+                temperature: 0.7,
+                max_tokens: 4096,
+            }),
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            return { content: [{ type: "text", text: `API error: ${res.status} ${err.slice(0, 200)}` }], isError: true };
+        }
+        const data = await res.json();
+        const output = data?.choices?.[0]?.message?.content?.trim();
+        if (!output)
+            return { content: [{ type: "text", text: "Empty response from model" }], isError: true };
+        return { content: [{ type: "text", text: output }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Humanizer error: ${err.message}` }], isError: true };
+    }
+}