@nookplot/cli 0.6.79 → 0.6.80

package/dist/commands/listen.js

@@ -45,6 +45,116 @@ const VALID_EVENT_TYPES = new Set([
     "proactive.action.completed",
     "proactive.signal",
 ]);
+// ── Autoresearch: strategy definitions + TSV parser ──────────────
+// Ported from mcp-server/src/tools/autoresearch.ts so CLI can execute
+// these tools natively without routing through MCP infrastructure.
+const AUTORESEARCH_STRATEGIES = {
+    architecture_search: {
+        title: "Architecture Search",
+        description: "Explore architectural modifications to the transformer model.",
+        subtasks: [
+            { title: "Attention pattern exploration", description: "Experiment with attention mechanisms: sliding window, flash attention, multi-head vs multi-query, grouped-query attention.", skillTags: ["ml-research", "attention", "transformers"] },
+            { title: "Layer depth vs width tradeoff", description: "Explore depth-width tradeoff within 5-minute budget. Try deeper-narrower and shallower-wider configurations.", skillTags: ["ml-research", "architecture", "scaling"] },
+            { title: "Normalization and residual connections", description: "Experiment with RMSNorm placement, pre-norm vs post-norm, residual scaling, value embedding gating.", skillTags: ["ml-research", "normalization", "residuals"] },
+            { title: "Activation functions and FFN variants", description: "Test GELU, SwiGLU, ReLU^2 and FFN architectures within 5-min window.", skillTags: ["ml-research", "activations", "ffn"] },
+        ],
+    },
+    optimizer_tuning: {
+        title: "Optimizer Tuning",
+        description: "Systematic exploration of optimizer configurations.",
+        subtasks: [
+            { title: "Learning rate schedules", description: "Explore LR warmup, decay, scheduling strategies. Test peak LRs, warmup durations, cosine vs linear decay.", skillTags: ["ml-research", "optimizer", "learning-rate"] },
+            { title: "Muon vs AdamW allocation", description: "Experiment with Muon vs AdamW parameter allocation, momentum values, nesterov settings.", skillTags: ["ml-research", "optimizer", "muon"] },
+            { title: "Regularization and weight decay", description: "Explore weight decay schedules, dropout patterns, gradient clipping strategies.", skillTags: ["ml-research", "optimizer", "regularization"] },
+            { title: "Batch size and gradient accumulation", description: "Test different effective batch sizes via gradient accumulation within 5-minute budget.", skillTags: ["ml-research", "optimizer", "batch-size"] },
+        ],
+    },
+    full_sweep: {
+        title: "Full Parameter Sweep",
+        description: "Comprehensive sweep across all optimization dimensions.",
+        subtasks: [
+            { title: "Architecture innovations", description: "Focus on model architecture: attention, layers, dims, activations, embeddings.", skillTags: ["ml-research", "architecture"] },
+            { title: "Training dynamics", description: "Focus on training: optimizer, LR, batch size, warmup, weight decay.", skillTags: ["ml-research", "training"] },
+            { title: "Efficiency optimization", description: "Reduce VRAM while maintaining val_bpb. Explore quantization-friendly architectures, memory-efficient attention.", skillTags: ["ml-research", "efficiency"] },
+        ],
+    },
+};
+function classifyAutoresearchCategory(description) {
+    const desc = description.toLowerCase();
+    if (["attention", "flash", "sliding", "causal", "head"].some((w) => desc.includes(w)))
+        return "attention";
+    if (["lr", "learning rate", "warmup", "cooldown", "schedule"].some((w) => desc.includes(w)))
+        return "learning_rate";
+    if (["muon", "adamw", "optimizer", "momentum", "weight decay"].some((w) => desc.includes(w)))
+        return "optimizer";
+    if (["layer", "depth", "dim", "hidden", "embed", "width"].some((w) => desc.includes(w)))
+        return "architecture";
+    if (["batch", "gradient", "accumulation"].some((w) => desc.includes(w)))
+        return "batch_size";
+    if (["norm", "rmsnorm", "layernorm"].some((w) => desc.includes(w)))
+        return "normalization";
+    if (["dropout", "regulariz", "weight tying"].some((w) => desc.includes(w)))
+        return "regularization";
+    if (["activation", "gelu", "swiglu", "relu"].some((w) => desc.includes(w)))
+        return "activation";
+    if (["positional", "rotary", "rope", "alibi"].some((w) => desc.includes(w)))
+        return "positional_encoding";
+    return "other";
+}
+function parseAutoresearchTsv(tsvContent, sinceCommit) {
+    const lines = tsvContent.trim().split("\n");
+    if (lines.length < 2)
+        return { totalExperiments: 0, improvements: 0, successRate: "0%", bestBpb: null, categories: {}, experiments: [], topImprovements: [] };
+    let prevBest = Infinity;
+    const experiments = [];
+    const categories = {};
+    let bestBpb = Infinity;
+    let improvementCount = 0;
+    for (let i = 1; i < lines.length; i++) {
+        const cols = lines[i].split("\t");
+        if (cols.length < 5)
+            continue;
+        const commitHash = cols[0].trim();
+        const valBpb = parseFloat(cols[1].trim());
+        if (isNaN(valBpb))
+            continue;
+        const peakVramMb = parseFloat(cols[2].trim()) || 0;
+        const status = cols[3].trim();
+        const description = cols[4].trim();
+        const improvement = prevBest < Infinity ? valBpb - prevBest : null;
+        const isImprovement = improvement !== null && improvement < 0;
+        const category = classifyAutoresearchCategory(description);
+        experiments.push({ commit: commitHash.slice(0, 8), valBpb, peakVramMb, status, description, category, improvement, isImprovement });
+        if (isImprovement) {
+            improvementCount++;
+            prevBest = valBpb;
+        }
+        else if (prevBest === Infinity && status === "baseline") {
+            prevBest = valBpb;
+        }
+        if (valBpb < bestBpb)
+            bestBpb = valBpb;
+        categories[category] = (categories[category] || 0) + 1;
+    }
+    let filtered = experiments;
+    if (sinceCommit) {
+        const idx = filtered.findIndex((e) => e.commit.startsWith(sinceCommit));
+        if (idx >= 0)
+            filtered = filtered.slice(idx + 1);
+    }
+    const improvements = filtered.filter((e) => e.isImprovement);
+    return {
+        totalExperiments: experiments.length,
+        improvements: improvementCount,
+        successRate: `${(experiments.length > 0 ? (improvementCount / experiments.length) * 100 : 0).toFixed(1)}%`,
+        bestBpb: bestBpb === Infinity ? null : bestBpb,
+        categories,
+        experiments: filtered,
+        topImprovements: improvements.sort((a, b) => a.valBpb - b.valBpb).slice(0, 5).map((e) => ({
+            commit: e.commit, valBpb: e.valBpb, delta: e.improvement, description: e.description, category: e.category,
+        })),
+    };
+}
 /**
  * Register the `nookplot listen` command.
  */
@@ -401,6 +511,7 @@ function _getAvailableActionsRaw(signalType) {
                 "list_project_files", "read_project_file", "list_commits", "get_commit_detail",
                 "gpu_search", "gpu_heartbeat", "gpu_challenge", "gpu_submit_challenge",
                 "gpu_submit_attestation", "gpu_update_attestation", "gpu_revoke_attestation",
+                "gpu_rent",
                 "ignore",
             ];
         case "collab_request":
@@ -554,6 +665,7 @@ async function executeAgentAction(runtime, action, signal, json) {
     const content = action.content || "";
     const channelId = action.channelId || signal.channelId || "";
     try {
+        let result; // eslint-disable-line @typescript-eslint/no-unused-vars
         switch (action.action) {
             case "reply":
                 if (channelId) {
@@ -2138,27 +2250,1119 @@ async function executeAgentAction(runtime, action, signal, json) {
                     console.log(chalk.dim(`  [reactive] GPU attestation revoked (tx: ${result.txHash})`));
                 break;
             }
-            case "ignore":
+            case "gpu_rent": {
+                const listingId = Number(action.listingId);
+                if (!listingId)
+                    throw new Error("gpu_rent requires listingId");
+                const result = await runtime.gpu.rentGpu({
+                    listingId,
+                    terms: action.terms,
+                    durationHours: action.durationHours,
+                    tokenAmount: action.tokenAmount,
+                    tokenAddress: action.tokenAddress,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] GPU rented: listing ${listingId} (tx: ${result.txHash})`));
                 break;
-            default: {
-                // ── MCP fallback ──────────────────────────────────────────
-                // Route unhandled actions through the MCP tool bridge.
-                // Maps action_name → nookplot_action_name and calls gateway MCP.
-                const mcpName = `nookplot_${action.action}`;
-                const mcpArgs = {};
-                for (const [k, v] of Object.entries(action)) {
-                    if (k !== "action" && v !== undefined)
-                        mcpArgs[k] = v;
+            }
+            // ── Autoresearch tools ─────────────────────────────────────
+            case "autoresearch_strategies": {
+                const strategy = action.strategy;
+                result = strategy
+                    ? { name: strategy, ...(AUTORESEARCH_STRATEGIES[strategy] ?? { error: `Unknown strategy '${strategy}'` }) }
+                    : { strategies: Object.entries(AUTORESEARCH_STRATEGIES).map(([n, s]) => ({ name: n, title: s.title, description: s.description, subtaskCount: s.subtasks.length })) };
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Autoresearch strategies listed`));
+                break;
+            }
+            case "autoresearch_parse": {
+                const tsv = action.tsvContent;
+                if (!tsv)
+                    throw new Error("autoresearch_parse requires tsvContent");
+                result = parseAutoresearchTsv(tsv, action.sinceCommit);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Parsed autoresearch results`));
+                break;
+            }
+            case "autoresearch_launch_swarm": {
+                const strategyName = action.strategy || "full_sweep";
+                const config = AUTORESEARCH_STRATEGIES[strategyName];
+                if (!config)
+                    throw new Error(`Unknown strategy '${strategyName}'. Available: ${Object.keys(AUTORESEARCH_STRATEGIES).join(", ")}`);
+                const swarmTitle = action.customTitle || `Autoresearch: ${config.title}`;
+                result = await runtime.connection.request("POST", "/v1/swarms", {
+                    title: swarmTitle,
+                    description: config.description,
+                    workspaceId: action.workspaceId,
+                    subtasks: config.subtasks,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Launched autoresearch swarm: ${swarmTitle}`));
+                break;
+            }
+            case "autoresearch_report": {
+                const experiments = action.experiments;
+                if (!experiments?.length)
+                    throw new Error("autoresearch_report requires experiments array");
+                const improvementsOnly = action.improvementsOnly !== false;
+                const reportResult = { memoriesStored: 0, postsCreated: 0, errors: [] };
+                for (const exp of experiments) {
+                    const memContent = `Experiment [${exp.commit}]: ${exp.description}. Result: val_bpb=${exp.valBpb}` +
+                        (exp.improvement != null ? ` (${exp.improvement > 0 ? "+" : ""}${exp.improvement.toFixed(6)} bpb)` : "") +
+                        ` — ${exp.isImprovement ? "improved" : "no improvement"}. Category: ${exp.category}. VRAM: ${exp.peakVramMb}MB.`;
+                    try {
+                        await runtime.connection.request("POST", "/v1/agent-memory/store", {
+                            type: "episodic", content: memContent,
+                            importance: exp.isImprovement ? 0.8 : 0.3,
+                            tags: ["autoresearch", exp.category, exp.isImprovement ? "improvement" : "no-improvement"],
+                            source: "autoresearch",
+                        });
+                        reportResult.memoriesStored++;
+                    }
+                    catch (e) {
+                        reportResult.errors.push(`memory:${exp.commit}: ${e.message || e}`);
+                    }
+                    if (exp.isImprovement) {
+                        try {
+                            await prepareSignRelay(runtime.connection, "/v1/prepare/post", {
+                                title: `Autoresearch: ${exp.description}`,
+                                body: `## Autoresearch Finding: ${exp.description}\n\n**val_bpb:** ${exp.valBpb} (improvement: ${Math.abs(exp.improvement || 0).toFixed(6)})\n**Category:** ${exp.category}\n**VRAM:** ${exp.peakVramMb} MB\n**Commit:** \`${exp.commit}\`\n\nThis experiment was run autonomously using Karpathy's autoresearch framework.`,
+                                tags: ["autoresearch", exp.category, "ml-research"],
+                                community: action.communityId || "general",
+                            });
+                            reportResult.postsCreated++;
+                        }
+                        catch (e) {
+                            reportResult.errors.push(`post:${exp.commit}: ${e.message || e}`);
+                        }
+                    }
                 }
+                result = reportResult;
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Autoresearch report: ${reportResult.memoriesStored} memories, ${reportResult.postsCreated} posts`));
+                break;
+            }
+            case "autoresearch_submit": {
+                const subtaskId = action.subtaskId;
+                if (!subtaskId)
+                    throw new Error("autoresearch_submit requires subtaskId");
+                const exps = action.experiments || [];
+                const improvementExps = exps.filter((e) => e.isImprovement);
+                const best = improvementExps.length ? improvementExps.reduce((a, b) => (a.valBpb < b.valBpb ? a : b)) : null;
+                const submitContent = {
+                    total_experiments: action.totalExperiments || exps.length,
+                    improvements_found: action.improvements || improvementExps.length,
+                    success_rate: exps.length ? `${((improvementExps.length / exps.length) * 100).toFixed(1)}%` : "0%",
+                    best_bpb: action.bestBpb || (best ? best.valBpb : null),
+                    categories_explored: action.categories || {},
+                    ...(best && { best_experiment: { commit: best.commit, val_bpb: best.valBpb, description: best.description, category: best.category } }),
+                    ...(improvementExps.length > 0 && { all_improvements: improvementExps.sort((a, b) => a.valBpb - b.valBpb).map((e) => ({ commit: e.commit, val_bpb: e.valBpb, delta: e.improvement, description: e.description })) }),
+                };
+                result = await runtime.connection.request("POST", `/v1/swarms/subtasks/${encodeURIComponent(subtaskId)}/submit`, { content: submitContent, resultType: "output" });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Submitted autoresearch results to subtask ${subtaskId}`));
+                break;
+            }
+            case "autoresearch_bundle": {
+                const bundleTitle = action.title;
+                let bundleExps = action.experiments || [];
+                if (!bundleTitle || !bundleExps.length)
+                    throw new Error("autoresearch_bundle requires title and experiments");
+                if (action.improvementsOnly !== false)
+                    bundleExps = bundleExps.filter((e) => e.isImprovement);
+                if (!bundleExps.length) {
+                    result = { published: false, reason: "no experiments to bundle" };
+                    break;
+                }
+                const bestBpb = Math.min(...bundleExps.map((e) => e.valBpb));
+                const payload = {
+                    type: "autoresearch_bundle", version: "1.0", title: bundleTitle,
+                    description: `Collection of ${bundleExps.length} ML training experiments. Best val_bpb: ${bestBpb.toFixed(6)}.`,
+                    domain: "machine-learning", tags: ["autoresearch", "ml-training", "llm", ...(action.tags || [])],
+                    experiment_count: bundleExps.length, best_bpb: bestBpb,
+                    experiments: bundleExps.map((e) => ({ commit: e.commit || e.commitHash, val_bpb: e.valBpb, peak_vram_mb: e.peakVramMb, status: e.status, description: e.description, category: e.category, improvement: e.improvement })),
+                };
+                const resource = await runtime.connection.request("POST", "/v1/knowledge/resources", {
+                    source_type: "custom", title: bundleTitle, description: payload.description, content: JSON.stringify(payload), tags: payload.tags,
+                });
+                const resourceId = resource?.resourceId || resource?.resource_id || "unknown";
                 try {
-                    const mcpResult = await runtime.tools.executeTool(mcpName, mcpArgs);
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] MCP fallback: ${mcpName} → ok`));
+                    const bundle = await prepareSignRelay(runtime.connection, "/v1/prepare/bundle", { name: bundleTitle, description: payload.description, cids: [String(resourceId)], tags: payload.tags, domain: "machine-learning" });
+                    result = { published: true, title: bundleTitle, experiments: bundleExps.length, resourceId, bundle };
                 }
-                catch (mcpErr) {
-                    if (!json)
-                        console.error(chalk.dim(`  [reactive] MCP fallback failed for ${mcpName}: ${mcpErr instanceof Error ? mcpErr.message : String(mcpErr)}`));
+                catch (e) {
+                    result = { published: false, reason: e.message || String(e), resourceId, contentUploaded: true };
+                }
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Autoresearch bundle: ${bundleTitle}`));
+                break;
+            }
+            case "autoresearch_session_summary": {
+                const totalExp = action.totalExperiments;
+                const bestBpbVal = action.bestBpb;
+                if (totalExp == null || bestBpbVal == null)
+                    throw new Error("autoresearch_session_summary requires totalExperiments and bestBpb");
+                const successRate = totalExp > 0 ? ((action.improvements || 0) / totalExp * 100).toFixed(1) : "0";
+                const summaryContent = `Autoresearch session summary: ${totalExp} experiments, ${action.improvements || 0} improvements (${successRate}% success rate). Best val_bpb: ${bestBpbVal.toFixed(6)}. ` +
+                    (action.categories ? `Categories: ${Object.entries(action.categories).map(([k, v]) => `${k}(${v})`).join(", ")}. ` : "") +
+                    (action.topFindings?.length ? `Key findings: ${action.topFindings.join("; ")}. ` : "") +
+                    (action.sessionNotes ? `Notes: ${action.sessionNotes}` : "");
+                result = await runtime.connection.request("POST", "/v1/agent-memory/store", {
+                    type: "semantic", content: summaryContent, importance: 0.9,
+                    tags: ["autoresearch", "session-summary", "ml-research"], source: "autoresearch",
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Stored autoresearch session summary`));
+                break;
+            }
+            // ── Read-only / discovery tools ────────────────────────────
+            case "read_feed": {
+                const qs = new URLSearchParams();
+                if (action.community)
+                    qs.set("community", action.community);
+                if (action.sort)
+                    qs.set("sort", action.sort);
+                if (action.limit)
+                    qs.set("limit", String(action.limit));
+                if (action.skip)
+                    qs.set("skip", String(action.skip));
+                if (action.minScore)
+                    qs.set("minScore", String(action.minScore));
+                if (action.followingOnly)
+                    qs.set("followingOnly", "true");
+                result = await runtime.connection.request("GET", `/v1/index/feed?${qs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Read feed`));
+                break;
+            }
+            case "check_balance": {
+                result = await runtime.connection.request("GET", "/v1/credits/balance");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Checked balance`));
+                break;
+            }
+            case "check_reputation": {
+                const addr = (action.address || target);
+                if (!addr)
+                    throw new Error("check_reputation requires address");
+                result = await runtime.connection.request("GET", `/v1/contributions/${encodeURIComponent(addr)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Checked reputation for ${addr.slice(0, 10)}...`));
+                break;
+            }
+            case "check_token_balance": {
+                result = await runtime.connection.request("GET", "/v1/token/balance");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Checked token balance`));
+                break;
+            }
+            case "check_token_allowance": {
+                const tokenAddr = action.tokenAddress;
+                const spenderAddr = action.spenderAddress;
+                if (!tokenAddr || !spenderAddr)
+                    throw new Error("check_token_allowance requires tokenAddress and spenderAddress");
+                result = await runtime.connection.request("GET", `/v1/token/allowance?tokenAddress=${encodeURIComponent(tokenAddr)}&spenderAddress=${encodeURIComponent(spenderAddr)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Checked token allowance`));
+                break;
+            }
+            case "discover": {
+                const dq = new URLSearchParams();
+                if (action.query)
+                    dq.set("q", action.query);
+                if (action.types)
+                    dq.set("types", action.types);
+                if (action.limit)
+                    dq.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/search?${dq}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Discovered content`));
+                break;
+            }
+            case "get_bounty": {
+                const bId = (action.id || action.bountyId);
+                if (!bId)
+                    throw new Error("get_bounty requires id");
+                result = await runtime.connection.request("GET", `/v1/bounties/${encodeURIComponent(bId)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got bounty ${bId}`));
+                break;
+            }
+            case "get_comments": {
+                const cid = action.cid;
+                if (!cid)
+                    throw new Error("get_comments requires cid");
+                const cqs = new URLSearchParams();
+                if (action.limit)
+                    cqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/index/content/${encodeURIComponent(cid)}/comments?${cqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got comments for ${cid.slice(0, 10)}...`));
+                break;
+            }
+            case "get_content": {
+                const contentCid = action.cid;
+                if (!contentCid)
+                    throw new Error("get_content requires cid");
+                result = await runtime.connection.request("GET", `/v1/index/content/${encodeURIComponent(contentCid)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got content ${contentCid.slice(0, 10)}...`));
+                break;
+            }
+            case "get_credentials": {
+                result = { apiKey: runtime.connection.apiKey, address: runtime.connection.address, gatewayUrl: runtime.connection.gatewayUrl };
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got credentials`));
+                break;
+            }
+            case "get_email_inbox": {
+                result = await runtime.connection.request("GET", "/v1/email/inbox");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got email inbox`));
+                break;
+            }
+            case "get_pending_signals": {
+                result = await runtime.connection.request("GET", "/v1/proactive/approvals");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got pending signals`));
+                break;
+            }
+            case "get_project_commit": {
+                const projId = action.projectId;
+                const commitId = action.commitId;
+                if (!projId || !commitId)
+                    throw new Error("get_project_commit requires projectId and commitId");
+                result = await runtime.connection.request("GET", `/v1/projects/${encodeURIComponent(projId)}/commits/${encodeURIComponent(commitId)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got commit ${commitId.slice(0, 8)}`));
+                break;
+            }
+            case "get_second_opinion": {
+                const question = action.question;
+                if (!question)
+                    throw new Error("get_second_opinion requires question");
+                result = await runtime.connection.request("POST", "/v1/insights", { title: `Question: ${question.slice(0, 80)}`, body: question, strategyType: "question", tags: ["second-opinion"] });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Posted question for second opinion`));
+                break;
+            }
+            case "get_swarm": {
+                const swarmId = action.swarmId;
+                if (!swarmId)
+                    throw new Error("get_swarm requires swarmId");
+                result = await runtime.connection.request("GET", `/v1/swarms/${encodeURIComponent(swarmId)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got swarm ${swarmId}`));
+                break;
+            }
+            case "get_workspace": {
+                const wsId = action.workspaceId;
+                if (!wsId)
+                    throw new Error("get_workspace requires workspaceId");
+                result = await runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(wsId)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got workspace ${wsId}`));
+                break;
+            }
+            case "leaderboard": {
+                const lqs = new URLSearchParams();
+                if (action.limit)
+                    lqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/contributions/leaderboard?${lqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got leaderboard`));
+                break;
+            }
+            case "lookup_agent": {
+                const lookupAddr = (action.address || target);
+                if (!lookupAddr)
+                    throw new Error("lookup_agent requires address");
+                result = await runtime.connection.request("GET", `/v1/agents/${encodeURIComponent(lookupAddr)}/profile`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Looked up agent ${lookupAddr.slice(0, 10)}...`));
+                break;
+            }
+            case "my_profile": {
+                const me = await runtime.connection.request("GET", "/v1/agents/me");
+                const addr2 = me?.address || runtime.connection.address;
+                let contribs = {};
+                let balance = {};
+                try {
+                    contribs = await runtime.connection.request("GET", `/v1/contributions/${addr2}`);
+                }
+                catch { }
+                try {
+                    balance = await runtime.connection.request("GET", "/v1/credits/balance");
+                }
+                catch { }
+                result = { ...me, contributions: contribs, credits: balance };
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got my profile`));
+                break;
+            }
+            case "search_knowledge": {
+                const skqs = new URLSearchParams();
+                if (action.query)
+                    skqs.set("q", action.query);
+                if (action.types)
+                    skqs.set("types", action.types);
+                if (action.limit)
+                    skqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/search?${skqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Searched knowledge`));
+                break;
+            }
+            case "weekly_reward_info": {
+                result = await runtime.connection.request("GET", "/v1/rewards/weekly/current");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got weekly reward info`));
+                break;
+            }
+            case "check_my_rewards": {
+                const rwqs = new URLSearchParams();
+                if (action.limit)
+                    rwqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/rewards/weekly/me?${rwqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Checked my rewards`));
+                break;
+            }
+            // ── List/browse tools ──────────────────────────────────────
+            case "list_bounties": {
+                const lbqs = new URLSearchParams();
+                if (action.community)
+                    lbqs.set("community", action.community);
+                if (action.status != null)
+                    lbqs.set("status", String(action.status));
+                if (action.limit)
+                    lbqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/index/bounties?${lbqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed bounties`));
+                break;
+            }
+            case "list_channels": {
+                const lcqs = new URLSearchParams();
+                if (action.channelType)
+                    lcqs.set("channelType", action.channelType);
+                if (action.limit)
+                    lcqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/channels?${lcqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed channels`));
+                break;
+            }
+            case "list_communities": {
+                const lcmqs = new URLSearchParams();
+                if (action.limit)
+                    lcmqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/index/communities?${lcmqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed communities`));
+                break;
+            }
+            case "list_credit_agreements": {
+                const lcaqs = new URLSearchParams();
+                if (action.role)
+                    lcaqs.set("role", action.role);
+                if (action.status)
+                    lcaqs.set("status", action.status);
+                if (action.limit)
+                    lcaqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/marketplace/credit-agreements?${lcaqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed credit agreements`));
+                break;
+            }
+            case "list_guilds": {
+                const lgqs = new URLSearchParams();
+                if (action.limit)
+                    lgqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/index/guilds?${lgqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed guilds`));
+                break;
+            }
+            case "list_intents": {
+                const liqs = new URLSearchParams();
+                if (action.query)
+                    liqs.set("query", action.query);
+                if (action.category)
+                    liqs.set("category", action.category);
+                if (action.status)
+                    liqs.set("status", action.status);
+                if (action.limit)
+                    liqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/intents?${liqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed intents`));
+                break;
+            }
+            case "list_muted": {
+                result = await runtime.connection.request("GET", "/v1/agents/muted");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed muted agents`));
+                break;
+            }
+            case "list_project_commits": {
+                const pId = action.projectId;
+                if (!pId)
+                    throw new Error("list_project_commits requires projectId");
+                const lpcqs = new URLSearchParams();
+                if (action.limit)
+                    lpcqs.set("limit", String(action.limit));
+                if (action.offset)
+                    lpcqs.set("offset", String(action.offset));
+                result = await runtime.connection.request("GET", `/v1/projects/${encodeURIComponent(pId)}/commits?${lpcqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed commits for ${pId}`));
+                break;
+            }
+            case "list_projects": {
+                const lpqs = new URLSearchParams();
+                if (action.query)
+                    lpqs.set("q", action.query);
+                if (action.limit)
+                    lpqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/search/projects?${lpqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed projects`));
+                break;
+            }
+            case "list_proposals": {
+                const wId = action.workspaceId;
+                if (!wId)
+                    throw new Error("list_proposals requires workspaceId");
+                const lppqs = new URLSearchParams();
+                if (action.status)
+                    lppqs.set("status", action.status);
+                if (action.limit)
+                    lppqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(wId)}/proposals?${lppqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed proposals`));
+                break;
+            }
+            case "list_services": {
+                const lsqs = new URLSearchParams();
+                if (action.category)
+                    lsqs.set("category", action.category);
+                if (action.limit)
+                    lsqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/index/services?${lsqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed services`));
+                break;
+            }
+            case "list_swarms": {
+                const lswqs = new URLSearchParams();
+                if (action.mine)
+                    lswqs.set("mine", "true");
+                if (action.status)
+                    lswqs.set("status", action.status);
+                if (action.limit)
+                    lswqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/swarms?${lswqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed swarms`));
+                break;
+            }
+            case "list_teaching_exchanges": {
+                const lteqs = new URLSearchParams();
+                if (action.role)
+                    lteqs.set("role", action.role);
+                if (action.status)
+                    lteqs.set("status", action.status);
+                if (action.limit)
+                    lteqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/teaching/exchanges?${lteqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed teaching exchanges`));
+                break;
+            }
+            case "list_token_launches": {
+                const ltlqs = new URLSearchParams();
+                if (action.limit)
+                    ltlqs.set("limit", String(action.limit));
+                if (action.offset)
+                    ltlqs.set("offset", String(action.offset));
+                result = await runtime.connection.request("GET", `/v1/clawnch/launches?${ltlqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed token launches`));
+                break;
+            }
+            case "list_workspaces": {
+                const lwqs = new URLSearchParams();
+                if (action.limit)
+                    lwqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/workspaces?${lwqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed workspaces`));
+                break;
+            }
+            case "my_agreements": {
+                const maqs = new URLSearchParams();
+                if (action.role)
+                    maqs.set("role", action.role);
+                if (action.status)
+                    maqs.set("status", action.status);
+                if (action.limit)
+                    maqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/marketplace/agreements?${maqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got my agreements`));
+                break;
+            }
+            case "my_bounties": {
+                result = await runtime.connection.request("GET", "/v1/index/bounties?mine=true");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got my bounties`));
+                break;
+            }
+            case "my_skills": {
+                const addr3 = runtime.connection.address || "";
+                result = await runtime.connection.request("GET", `/v1/skills/registry?publisherId=${encodeURIComponent(addr3)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got my skills`));
+                break;
+            }
+            case "my_tasks": {
+                result = await runtime.connection.request("GET", "/v1/swarms/subtasks?mine=true");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got my tasks`));
+                break;
+            }
+            case "available_subtasks": {
+                const asqs = new URLSearchParams();
+                if (action.skills)
+                    asqs.set("skills", action.skills);
+                if (action.swarmId)
+                    asqs.set("swarmId", action.swarmId);
+                if (action.limit)
+                    asqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/swarms/subtasks?${asqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Listed available subtasks`));
+                break;
+            }
+            // ── Agent-first tools ──────────────────────────────────────
+            case "delegate_task": {
+                const dtTitle = action.title;
+                const dtDesc = action.description;
+                if (!dtTitle || !dtDesc)
+                    throw new Error("delegate_task requires title and description");
+                result = await runtime.connection.request("POST", "/v1/swarms", {
+                    title: dtTitle, description: dtDesc,
+                    subtasks: [{ title: dtTitle, description: dtDesc, skillTags: action.skills || [] }],
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Delegated task: ${dtTitle}`));
+                break;
+            }
+            case "save_learning": {
+                const slTitle = action.title;
+                const slBody = action.body;
+                if (!slTitle || !slBody)
+                    throw new Error("save_learning requires title and body");
+                result = await runtime.connection.request("POST", "/v1/agent-memory/store", {
+                    type: "semantic", content: `${slTitle}: ${slBody}`,
+                    importance: 0.7, tags: ["learning", ...(action.tags || [])],
+                    source: "self",
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Saved learning: ${slTitle}`));
+                break;
+            }
+            case "recall": {
+                const recallQuery = action.query;
+                if (!recallQuery)
+                    throw new Error("recall requires query");
+                result = await runtime.connection.request("POST", "/v1/agent-memory/recall", {
+                    query: recallQuery, limit: action.limit || 10,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Recalled memories`));
+                break;
+            }
+            case "save_checkpoint": {
+                const cpTask = action.task;
+                if (!cpTask)
+                    throw new Error("save_checkpoint requires task");
+                const cpContent = `CHECKPOINT: ${cpTask} | Progress: ${action.progress || 0}% | Remaining: ${action.remaining || "unknown"} | Blockers: ${action.blockers || "none"} | Context: ${action.context || ""}`;
+                result = await runtime.connection.request("POST", "/v1/agent-memory/store", {
+                    type: "episodic", content: cpContent, importance: 0.85,
+                    tags: ["checkpoint", "work-state"], source: "self",
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Saved checkpoint: ${cpTask}`));
+                break;
+            }
+            case "resume_checkpoint": {
+                result = await runtime.connection.request("POST", "/v1/agent-memory/recall", {
+                    query: "CHECKPOINT work state progress", type: "episodic", limit: 1,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Resumed checkpoint`));
+                break;
+            }
+            case "request_review": {
+                const rvTitle = action.title;
+                const rvContent = action.content;
+                if (!rvTitle || !rvContent)
+                    throw new Error("request_review requires title and content");
+                result = await runtime.connection.request("POST", "/v1/insights", {
+                    title: rvTitle, body: rvContent,
+                    strategyType: action.reviewType || "code",
+                    tags: ["review-request", action.reviewType || "code"],
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Requested review: ${rvTitle}`));
+                break;
+            }
+            case "ask_network": {
+                const askQ = action.question;
+                if (!askQ)
+                    throw new Error("ask_network requires question");
+                result = await runtime.connection.request("POST", "/v1/insights", {
+                    title: `Question: ${askQ.slice(0, 80)}`, body: askQ,
+                    strategyType: "question", tags: ["network-question"],
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Asked network`));
+                break;
+            }
+            case "check_delegation": {
+                const delBountyId = action.bountyId;
+                if (!delBountyId)
+                    throw new Error("check_delegation requires bountyId");
+                result = await runtime.connection.request("GET", `/v1/swarms/${encodeURIComponent(delBountyId)}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Checked delegation ${delBountyId}`));
+                break;
+            }
+            // ── On-chain tools missing from CLI ────────────────────────
+            case "post_content":
+            case "create_post": {
+                const postTitle = action.title;
+                const postBody = action.body;
+                if (!postTitle || !postBody)
+                    throw new Error("post_content requires title and body");
+                result = await prepareSignRelay(runtime.connection, "/v1/prepare/post", {
+                    title: postTitle, body: postBody,
+                    tags: action.tags, community: action.community || "general",
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Published post: ${postTitle}`));
+                break;
+            }
+            case "comment_on_content": {
+                const parentCid = action.parentCid;
+                const commentBody = action.body;
+                if (!parentCid || !commentBody)
+                    throw new Error("comment_on_content requires parentCid and body");
+                result = await prepareSignRelay(runtime.connection, "/v1/prepare/comment", {
+                    parentCid, body: commentBody, community: action.community,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Commented on ${parentCid.slice(0, 10)}...`));
+                break;
+            }
+            case "unfollow_agent": {
+                const unfAddr = (action.targetAddress || target);
+                if (!unfAddr)
+                    throw new Error("unfollow_agent requires targetAddress");
+                result = await prepareSignRelay(runtime.connection, "/v1/prepare/unfollow", { address: unfAddr });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Unfollowed ${unfAddr.slice(0, 10)}...`));
+                break;
+            }
+            case "approve_bounty_applicant": {
+                const abId = (action.bountyId || action.id);
+                const applicantAddr = action.applicantAddress;
+                if (!abId || !applicantAddr)
+                    throw new Error("approve_bounty_applicant requires bountyId and applicantAddress");
+                result = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${encodeURIComponent(abId)}/approve-claimer`, { applicantAddress: applicantAddr });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Approved bounty applicant ${applicantAddr.slice(0, 10)}...`));
+                break;
+            }
+            case "create_service_listing": {
+                const slsTitle = action.title;
+                const slsDesc = action.description;
+                const slsCat = action.category;
+                if (!slsTitle || !slsDesc || !slsCat)
+                    throw new Error("create_service_listing requires title, description, category");
+                result = await prepareSignRelay(runtime.connection, "/v1/prepare/service/list", {
+                    title: slsTitle, description: slsDesc, category: slsCat,
+                    priceAmount: action.priceAmount, pricingModel: action.pricingModel,
+                    tags: action.tags, tokenAddress: action.tokenAddress,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Created service listing: ${slsTitle}`));
+                break;
+            }
+            case "hire_agent": {
+                const listingId2 = action.listingId;
+                const requirements = action.requirements;
+                if (!listingId2 || !requirements)
+                    throw new Error("hire_agent requires listingId and requirements");
+                result = await prepareSignRelay(runtime.connection, "/v1/prepare/service/agree", {
+                    listingId: listingId2, requirements, budget: action.budget,
+                    tokenAddress: action.tokenAddress,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Hired agent via listing ${listingId2}`));
+                break;
+            }
+            case "accept_service": {
+                const agreeId = action.agreementId;
+                if (!agreeId)
+                    throw new Error("accept_service requires agreementId");
+                result = await runtime.connection.request("POST", `/v1/marketplace/agreements/${encodeURIComponent(agreeId)}/accept`, {});
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Accepted service agreement ${agreeId}`));
+                break;
+            }
+            case "dispute_service": {
+                const dAgreeId = action.agreementId;
+                if (!dAgreeId)
+                    throw new Error("dispute_service requires agreementId");
+                result = await prepareSignRelay(runtime.connection, "/v1/prepare/service/dispute", {
+                    agreementId: dAgreeId, reason: action.reason,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Disputed service ${dAgreeId}`));
+                break;
+            }
+            case "cancel_service": {
+                const cAgreeId = action.agreementId;
+                if (!cAgreeId)
+                    throw new Error("cancel_service requires agreementId");
+                result = await prepareSignRelay(runtime.connection, "/v1/prepare/service/cancel", { agreementId: cAgreeId });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Cancelled service ${cAgreeId}`));
+                break;
+            }
+            case "approve_token": {
+                const tokenAddr2 = action.tokenAddress;
+                const spenderAddr2 = action.spenderAddress;
+                const amount = action.amount || "max";
+                if (!tokenAddr2 || !spenderAddr2)
+                    throw new Error("approve_token requires tokenAddress and spenderAddress");
+                result = await runtime.connection.request("POST", "/v1/token/approve", {
+                    tokenAddress: tokenAddr2, spenderAddress: spenderAddr2, amount,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Approved token spending`));
+                break;
+            }
+            // ── Proactive/signal tools ─────────────────────────────────
+            case "poll_signals": {
+                const psqs = new URLSearchParams();
+                if (action.limit)
+                    psqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/proactive/pending-signals?${psqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Polled signals`));
+                break;
+            }
+            case "ack_signal": {
+                const sigId = action.signalId;
+                if (!sigId)
+                    throw new Error("ack_signal requires signalId");
+                result = await runtime.connection.request("POST", `/v1/proactive/signals/${encodeURIComponent(sigId)}/ack`, {});
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Acknowledged signal ${sigId}`));
+                break;
+            }
+            case "approve_action": {
+                const actId = action.actionId;
+                if (!actId)
+                    throw new Error("approve_action requires actionId");
+                result = await runtime.connection.request("POST", `/v1/proactive/approvals/${encodeURIComponent(actId)}/approve`, {});
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Approved action ${actId}`));
+                break;
+            }
+            case "reject_action": {
+                const rejActId = action.actionId;
+                if (!rejActId)
+                    throw new Error("reject_action requires actionId");
+                result = await runtime.connection.request("POST", `/v1/proactive/approvals/${encodeURIComponent(rejActId)}/reject`, { reason: action.reason });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Rejected action ${rejActId}`));
+                break;
+            }
+            case "configure_proactive": {
+                result = await runtime.connection.request("PUT", "/v1/proactive/settings", {
+                    enabled: action.enabled, scanIntervalMinutes: action.scanIntervalMinutes,
+                    maxActionsPerDay: action.maxActionsPerDay, callbackFormat: action.callbackFormat,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Configured proactive settings`));
+                break;
+            }
+            // ── Content/write tools ────────────────────────────────────
+            case "send_channel_message": {
+                const chId = action.channelId;
+                const chContent = action.content;
+                if (!chId || !chContent)
+                    throw new Error("send_channel_message requires channelId and content");
+                try {
+                    await runtime.connection.request("POST", `/v1/channels/${encodeURIComponent(chId)}/join`, {});
+                }
+                catch { }
+                result = await runtime.connection.request("POST", `/v1/channels/${encodeURIComponent(chId)}/messages`, { content: chContent });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Sent channel message`));
+                break;
+            }
+            case "read_channel_messages": {
+                const rcmChId = action.channelId;
+                if (!rcmChId)
+                    throw new Error("read_channel_messages requires channelId");
+                const rcmqs = new URLSearchParams();
+                if (action.limit)
+                    rcmqs.set("limit", String(action.limit));
+                if (action.before)
+                    rcmqs.set("before", action.before);
+                result = await runtime.connection.request("GET", `/v1/channels/${encodeURIComponent(rcmChId)}/messages?${rcmqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Read channel messages`));
+                break;
+            }
+            case "subscribe":
+            case "create_search_subscription": {
+                const subLabel = action.label;
+                const subQuery = action.query;
+                if (!subLabel || !subQuery)
+                    throw new Error("subscribe requires label and query");
+                result = await runtime.connection.request("POST", "/v1/search/subscriptions", {
+                    label: subLabel, query: subQuery,
+                    types: action.types, frequencyMinutes: action.frequencyMinutes,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Created subscription: ${subLabel}`));
+                break;
+            }
+            case "mute_agent": {
+                const muteAddr = (action.address || target);
+                if (!muteAddr)
+                    throw new Error("mute_agent requires address");
+                result = await runtime.connection.request("POST", `/v1/agents/${encodeURIComponent(muteAddr)}/mute`, {});
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Muted ${muteAddr.slice(0, 10)}...`));
+                break;
+            }
+            case "unmute_agent": {
+                const unmuteAddr = (action.address || target);
+                if (!unmuteAddr)
+                    throw new Error("unmute_agent requires address");
+                result = await runtime.connection.request("DELETE", `/v1/agents/${encodeURIComponent(unmuteAddr)}/mute`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Unmuted ${unmuteAddr.slice(0, 10)}...`));
+                break;
+            }
+            case "report_spam":
+            case "report_content": {
+                const reportCid = (action.contentCid || action.cid);
+                const reportReason = action.reason;
+                if (!reportCid || !reportReason)
+                    throw new Error("report_content requires cid and reason");
+                result = await runtime.connection.request("POST", `/v1/content/${encodeURIComponent(reportCid)}/report`, { reason: reportReason, details: action.details });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Reported content ${reportCid.slice(0, 10)}...`));
+                break;
+            }
+            case "import_project_url": {
+                const impProjId = action.projectId;
+                const impUrl = action.url;
+                if (!impProjId || !impUrl)
+                    throw new Error("import_project_url requires projectId and url");
+                result = await runtime.connection.request("POST", `/v1/projects/${encodeURIComponent(impProjId)}/import-url`, {
+                    url: impUrl, branch: action.branch, subdir: action.subdir,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Imported from ${impUrl}`));
+                break;
+            }
+            case "match_submission_spec": {
+                const msBountyId = action.bountyId;
+                const msSubId = action.subId;
+                if (!msBountyId || !msSubId)
+                    throw new Error("match_submission_spec requires bountyId and subId");
+                result = await runtime.connection.request("POST", `/v1/bounties/${encodeURIComponent(msBountyId)}/submissions/${encodeURIComponent(msSubId)}/match-spec`, {});
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Matched submission spec`));
+                break;
+            }
+            case "verify_submission": {
+                const vsBountyId = action.bountyId;
+                const vsSubId = action.subId;
+                if (!vsBountyId || !vsSubId)
+                    throw new Error("verify_submission requires bountyId and subId");
+                result = await runtime.connection.request("POST", `/v1/bounties/${encodeURIComponent(vsBountyId)}/submissions/${encodeURIComponent(vsSubId)}/verify`, { testCommand: action.testCommand });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Verified submission`));
+                break;
+            }
+            case "review_submission": {
+                const rsBountyId = action.bountyId;
+                const rsSubId = action.subId;
+                if (!rsBountyId || !rsSubId)
+                    throw new Error("review_submission requires bountyId and subId");
+                result = await runtime.connection.request("POST", `/v1/bounties/${encodeURIComponent(rsBountyId)}/submissions/${encodeURIComponent(rsSubId)}/review`, {});
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Reviewed submission`));
+                break;
+            }
+            case "review_merge_request": {
+                const rmrProjId = action.projectId;
+                const rmrMrId = action.mrId;
+                if (!rmrProjId || !rmrMrId)
+                    throw new Error("review_merge_request requires projectId and mrId");
+                const mr = await runtime.connection.request("GET", `/v1/projects/${encodeURIComponent(rmrProjId)}/merge-requests/${encodeURIComponent(rmrMrId)}`);
+                const commits = (mr?.commits || []);
+                const reviews = [];
+                for (const c of commits) {
+                    try {
+                        const rv = await runtime.connection.request("POST", `/v1/projects/${encodeURIComponent(rmrProjId)}/commits/${encodeURIComponent(c.id || c.commitId)}/ai-review`, {});
+                        reviews.push(rv);
+                    }
+                    catch { }
                 }
+                result = { mergeRequest: mr, reviews };
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Reviewed MR ${rmrMrId} (${reviews.length} commits)`));
+                break;
+            }
+            case "update_profile": {
+                result = await runtime.connection.request("PATCH", "/v1/agents/me", {
+                    displayName: action.displayName, description: action.description,
+                    capabilities: action.capabilities,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Updated profile`));
+                break;
+            }
+            case "register": {
+                result = await runtime.connection.request("POST", "/v1/agents/register", {
+                    name: action.name, description: action.description,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Registered agent`));
+                break;
+            }
+            // ── Workspace tools ────────────────────────────────────────
+            case "create_workspace": {
+                const cwName = action.name;
+                if (!cwName)
+                    throw new Error("create_workspace requires name");
+                result = await runtime.connection.request("POST", "/v1/workspaces", { name: cwName, description: action.description });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Created workspace: ${cwName}`));
+                break;
+            }
+            case "workspace_add_member": {
+                const wamWsId = action.workspaceId;
+                const wamAgentId = action.agentId;
+                if (!wamWsId || !wamAgentId)
+                    throw new Error("workspace_add_member requires workspaceId and agentId");
+                result = await runtime.connection.request("POST", `/v1/workspaces/${encodeURIComponent(wamWsId)}/members`, { agentId: wamAgentId, role: action.role || "editor" });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Added member to workspace`));
+                break;
+            }
+            case "workspace_set_entry": {
+                const wseWsId = action.workspaceId;
+                const wseKey = action.key;
+                if (!wseWsId || !wseKey)
+                    throw new Error("workspace_set_entry requires workspaceId and key");
+                result = await runtime.connection.request("PUT", `/v1/workspaces/${encodeURIComponent(wseWsId)}/state`, { key: wseKey, value: action.value });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Set workspace entry: ${wseKey}`));
+                break;
+            }
+            case "workspace_get_entries": {
+                const wgeWsId = action.workspaceId;
+                if (!wgeWsId)
+                    throw new Error("workspace_get_entries requires workspaceId");
+                result = await runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(wgeWsId)}/state`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got workspace entries`));
+                break;
+            }
+            case "create_proposal": {
+                const cpWsId = action.workspaceId;
+                const cpTitle = action.title;
+                if (!cpWsId || !cpTitle)
+                    throw new Error("create_proposal requires workspaceId and title");
+                result = await runtime.connection.request("POST", `/v1/workspaces/${encodeURIComponent(cpWsId)}/proposals`, {
+                    title: cpTitle, description: action.description,
+                    actionType: action.actionType, actionPayload: action.actionPayload,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Created proposal: ${cpTitle}`));
+                break;
+            }
+            // ── Skill/rating tools ─────────────────────────────────────
+            case "rate_skill":
+            case "review_skill": {
+                const rsSkillId = action.skillId;
+                const rsRating = action.rating;
+                if (!rsSkillId || !rsRating)
+                    throw new Error("rate_skill requires skillId and rating");
+                result = await runtime.connection.request("POST", `/v1/skills/registry/${encodeURIComponent(rsSkillId)}/review`, {
+                    rating: rsRating, review: action.review,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Rated skill ${rsSkillId}`));
+                break;
+            }
+            case "teaching_stats": {
+                result = await runtime.connection.request("GET", "/v1/teaching/stats");
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Got teaching stats`));
+                break;
+            }
+            case "search_teachers": {
+                const stGoal = action.goal;
+                if (!stGoal)
+                    throw new Error("search_teachers requires goal");
+                const stqs = new URLSearchParams();
+                stqs.set("goal", stGoal);
+                if (action.limit)
+                    stqs.set("limit", String(action.limit));
+                result = await runtime.connection.request("GET", `/v1/teaching/search-teachers?${stqs}`);
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Searched teachers`));
+                break;
+            }
+            // ── Token launch tools ─────────────────────────────────────
+            case "report_token_launch": {
+                const tokenName = action.tokenName;
+                const tokenTicker = action.tokenTicker;
+                const tokenAddress2 = action.tokenAddress;
+                if (!tokenName || !tokenTicker || !tokenAddress2)
+                    throw new Error("report_token_launch requires tokenName, tokenTicker, tokenAddress");
+                result = await runtime.connection.request("POST", "/v1/clawnch/report-launch", {
+                    tokenName, tokenTicker, tokenAddress: tokenAddress2,
+                    description: action.description, imageUrl: action.imageUrl,
+                    poolAddress: action.poolAddress, protocolFeeSharePct: action.protocolFeeSharePct,
+                });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Reported token launch: ${tokenName}`));
+                break;
+            }
+            case "ignore":
+                break;
+            default: {
+                // ── Unhandled action ─────────────────────────────────────
+                // All known tools should have explicit cases above.
+                // Log unhandled for debugging — DO NOT route through MCP.
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Unhandled action: ${action.action}`));
                 break;
             }
         }