@nookplot/cli 0.6.80 → 0.6.82

package/dist/commands/listen.js

@@ -14,9 +14,8 @@
 import chalk from "chalk";
 import ora from "ora";
 import { spawn } from "node:child_process";
-import { NookplotRuntime, AutonomousAgent, prepareSignRelay, ACTION_CATALOG } from "@nookplot/runtime";
+import { NookplotRuntime, AutonomousAgent, ACTION_CATALOG, getAvailableActionsFromMap, getCategoryListing, getToolsInCategory } from "@nookplot/runtime";
 import { loadConfig, validateConfig } from "../config.js";
-import { filterByProfile } from "../skillGenerator.js";
 // Valid event types from runtime/src/types.ts RuntimeEventType
 const VALID_EVENT_TYPES = new Set([
     "post.new",
@@ -413,2958 +412,77 @@ async function runListen(globalOpts, eventTypes, cmdOpts) {
         });
     }
 }
+/** Session state: dynamically loaded tool categories via browse_tools. */
+const loadedCategories = new Set();
 /**
  * Get available actions the agent can take in response to a signal type.
  * These are hints — the agent decides which (if any) to execute.
  */
 function getAvailableActions(signalType) {
-    return filterByProfile(_getAvailableActionsRaw(signalType));
-}
-function _getAvailableActionsRaw(signalType) {
-    switch (signalType) {
-        case "dm_received":
-            return [
-                "reply", "send_dm", "follow_back", "attest_back", "propose_collab",
-                "vote", "publish", "create_post", "create_bounty", "create_project",
-                "create_community", "create_listing", "commit_files", "create_task",
-                "link_project_to_guild", "propose_guild", "deploy_preview",
-                "egress_request", "execute_tool", "exec_code", "call_mcp_tool", "register_webhook",
-                "workspace_create", "publish_insight",
-                "create_intent", "browse_intents",
-                "launch_token", "preview_token_launch",
-                "search_skills", "install_skill", "store_memory", "recall_memory",
-                "propose_teaching", "search_teachers",
-                "credit_hire",
-                "ignore",
-            ];
-        case "channel_message":
-        case "channel_mention":
-        case "project_discussion":
-            return [
-                "reply", "publish", "vote", "follow", "attest", "propose_collab",
-                "create_post", "create_bounty", "create_project", "commit_files",
-                "create_task", "link_project_to_guild", "propose_guild",
-                "egress_request", "execute_tool", "exec_code", "call_mcp_tool",
-                "workspace_create", "publish_insight",
-                "create_intent", "browse_intents",
-                "search_skills", "install_skill", "store_memory",
-                "ignore",
-            ];
-        case "new_follower":
-            return ["follow_back", "send_dm", "ignore"];
-        case "attestation_received":
-            return ["attest_back", "endorse_agent", "send_dm", "ignore"];
-        case "endorsement_received":
-            return ["endorse_agent", "attest_back", "send_dm", "ignore"];
-        case "files_committed":
-        case "pending_review":
-            return ["review", "comment", "request_ai_review", "list_project_files", "read_project_file", "list_commits", "get_commit_detail", "list_merge_requests", "get_merge_request", "ignore"];
-        case "merge_request_created":
-            return ["get_merge_request", "merge_merge_request", "close_merge_request", "reply", "ignore"];
-        case "project_forked":
-            return ["acknowledge", "send_dm", "ignore"];
-        case "review_submitted":
-            return ["reply", "ignore"];
-        case "collaborator_added":
-            return ["send_message", "reply", "ignore"];
-        case "new_post_in_community":
-        case "post_reply":
-        case "reply_to_own_post":
-            return ["reply", "post_reply", "vote", "publish", "ignore"];
-        case "bounty":
-            return ["claim", "apply_bounty", "create_bounty", "reply", "ignore"];
-        case "community_gap":
-            return ["create_community", "ignore"];
-        case "potential_friend":
-            return ["follow", "send_dm", "attest", "endorse_agent", "ignore"];
-        case "attestation_opportunity":
-            return ["attest", "endorse_agent", "send_dm", "ignore"];
-        case "directive":
-            return [
-                "execute", "reply", "publish", "create_project", "commit_files",
-                "create_task", "assign_task", "complete_task", "update_task",
-                "link_project_to_guild", "propose_guild", "approve_guild", "reject_guild", "leave_guild",
-                "create_bounty", "create_bundle", "propose_collab", "assemble_team",
-                "find_agents", "deploy_preview", "add_collaborator",
-                "fork_project", "create_merge_request", "list_merge_requests", "get_merge_request", "merge_merge_request", "close_merge_request",
-                "create_listing", "create_agreement", "cancel_agreement",
-                "workspace_create", "workspace_set", "workspace_snapshot",
-                "propose_action", "vote_proposal", "cancel_proposal",
-                "egress_request", "execute_tool", "exec_code", "call_mcp_tool", "connect_mcp_server", "disconnect_mcp_server", "register_webhook",
-                "publish_insight", "cite_insight", "apply_insight",
-                "deposit_treasury", "withdraw_treasury", "fund_bounty_from_treasury", "distribute_revenue",
-                "create_swarm", "claim_subtask", "submit_swarm_result", "aggregate_swarm",
-                "record_gap", "update_proficiency", "generate_recommendations",
-                "create_intent", "browse_intents", "submit_proposal", "accept_proposal", "reject_proposal",
-                "cancel_intent", "complete_intent", "withdraw_proposal", "query_oracle",
-                "launch_token", "preview_token_launch", "claim_clawnch_fees", "get_token_analytics",
-                "create_search_subscription",
-                "send_email", "reply_email", "check_email", "create_email_inbox",
-                "search_skills", "publish_skill", "install_skill", "review_skill", "update_skill", "trending_skills",
-                "store_memory", "recall_memory", "list_memories", "memory_stats", "export_memories", "import_memories",
-                "forge_deploy", "forge_spawn", "forge_update_soul",
-                "propose_teaching", "accept_teaching", "deliver_teaching", "approve_teaching", "reject_teaching", "search_teachers",
-                "credit_hire", "accept_credit_agreement", "deliver_credit_work", "complete_credit_agreement", "cancel_credit_agreement",
-                "claim_reward",
-                "endorse_agent", "revoke_endorsement",
-                "block_agent", "unblock_agent",
-                "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":
-            return ["add_collaborator", "propose_collab", "reply", "ignore"];
-        case "team_assembly_suggested":
-            return ["assemble_team", "ignore"];
-        case "team_invitation":
-            return ["accept_invitation", "decline_invitation", "ignore"];
-        case "team_invitation_accepted":
-        case "team_invitation_declined":
-            return ["reply", "ignore"];
-        case "service":
-            return ["reply", "update_service", "create_listing", "create_agreement", "ignore"];
-        case "time_to_post":
-            return ["create_post", "create_bounty", "create_bundle", "publish_insight", "create_listing", "publish_skill", "ignore"];
-        case "time_to_create_project":
-            return ["create_project", "assemble_team", "ignore"];
-        case "task_assigned":
-            return ["accept", "update_task", "complete_task", "assign_task", "assemble_team", "reply", "ignore"];
-        case "task_completed":
-            return ["reply", "review", "create_task", "ignore"];
-        case "milestone_reached":
-            return ["reply", "ignore"];
-        case "review_comment_added":
-            return ["reply", "ignore"];
-        case "agent_mentioned":
-            return ["reply", "acknowledge", "ignore"];
-        case "project_status_update":
-            return ["reply", "ignore"];
-        case "file_shared":
-            return ["reply", "ignore"];
-        case "bounty_posted_to_project":
-            return ["reply", "claim", "ignore"];
-        case "bounty_access_requested":
-            return ["grant", "deny", "ignore"];
-        case "bounty_access_granted":
-            return ["reply", "claim", "ignore"];
-        case "project_bounty_claimed":
-            return ["reply", "ignore"];
-        case "project_bounty_completed":
-            return ["reply", "ignore"];
-        case "xmtp_message":
-            return ["reply", "ignore"];
-        case "guild_opportunity":
-            return ["join_guild", "approve_guild", "reject_guild", "leave_guild", "propose_guild", "link_project_to_guild", "reply", "ignore"];
-        // Marketplace signals
-        case "agreement_created":
-            return ["deliver_work", "cancel_agreement", "send_agreement_message", "ignore"];
-        case "work_delivered":
-            return ["settle_agreement", "dispute_agreement", "send_agreement_message", "expire_delivered", "ignore"];
-        case "agreement_settled":
-            return ["submit_review", "ignore"];
-        case "agreement_disputed":
-            return ["send_agreement_message", "expire_dispute", "ignore"];
-        case "agreement_cancelled":
-            return ["ignore"];
-        case "revision_requested":
-            return ["deliver_work", "send_agreement_message", "ignore"];
-        case "review_received":
-            return ["ignore"];
-        // Bounty application/submission signals
-        case "bounty_application_submitted":
-            return ["approve_bounty_claimer", "reject_bounty_application", "ignore"];
-        case "bounty_application_approved":
-            return ["claim_bounty", "ignore"];
-        case "bounty_application_rejected":
-            return ["ignore"];
-        case "bounty_work_submitted":
-            return ["select_bounty_submission", "ignore"];
-        case "bounty_submission_selected":
-            return ["claim_bounty", "ignore"];
-        case "bounty_submission_not_selected":
-            return ["ignore"];
-        // On-chain bounty lifecycle signals
-        case "bounty_claimed":
-            return ["approve_bounty_work", "approve_bounty_claimer", "dispute_bounty_work", "unclaim_bounty", "ignore"];
-        case "bounty_work_approved":
-            return ["ignore"];
-        case "bounty_disputed":
-            return ["cancel_bounty", "ignore"];
-        case "bounty_cancelled":
-            return ["ignore"];
-        case "bounty_claimer_approved":
-            return ["claim_bounty", "ignore"];
-        case "intent_matched":
-            return ["submit_proposal", "browse_intents", "reply", "ignore"];
-        case "proposal_received":
-            return ["accept_proposal", "reject_proposal", "reply", "ignore"];
-        case "intent_accepted":
-            return ["complete_intent", "reply", "ignore"];
-        case "email_received":
-            return ["reply_email", "send_email", "send_dm", "ignore"];
-        case "specialization_path":
-            return ["reply", "record_gap", "update_proficiency", "search_skills", "install_skill", "store_memory", "ignore"];
-        // Teaching signals
-        case "teaching_proposed":
-            return ["accept_teaching", "reject_teaching", "reply", "ignore"];
-        case "teaching_accepted":
-            return ["deliver_teaching", "reply", "ignore"];
-        case "teaching_delivered":
-            return ["approve_teaching", "reject_teaching", "reply", "ignore"];
-        case "teaching_opportunity":
-            return ["propose_teaching", "search_teachers", "reply", "ignore"];
-        // Credit agreement signals
-        case "credit_agreement_created":
-            return ["accept_credit_agreement", "cancel_credit_agreement", "reply", "ignore"];
-        case "credit_work_delivered":
-            return ["complete_credit_agreement", "cancel_credit_agreement", "reply", "ignore"];
-        case "credit_agreement_accepted":
-            return ["deliver_credit_work", "cancel_credit_agreement", "reply", "ignore"];
-        // Informational signals
-        case "new_project":
-        case "interesting_project":
-            return ["propose_collab", "reply", "ignore"];
-        case "bounty_access_denied":
-            return ["ignore"];
-        case "task_created":
-        case "task_deleted":
-        case "status_updated":
-            return ["reply", "ignore"];
-        case "welcome_guide":
-            return ["reply", "create_post", "ignore"];
-        case "onboarding_suggestion":
-            return ["reply", "ignore"];
-        case "new_bundle_in_domain":
-            return ["cite_insight", "reply", "ignore"];
-        case "bundle_cited":
-            return ["ignore"];
-        case "webhook_received":
-        case "webhook.received":
-            return ["reply", "egress_request", "execute_tool", "ignore"];
-        case "bounty_opportunity":
-            return ["apply_bounty", "send_dm", "reply", "ignore"];
-        default:
-            return ["reply", "ignore"];
-    }
+    return getAvailableActionsFromMap(signalType, loadedCategories);
 }
 /**
  * Execute an action the agent decided to take in response to a trigger.
  * The agent returns a JSON object with { action, ... } and we route it.
  */
-/** Validate an ID before URL interpolation — must be numeric or UUID. */
-function validateId(id, name) {
-    const s = String(id ?? "");
-    if (/^\d+$/.test(s) || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(s))
-        return s;
-    throw new Error(`Invalid ${name}: ${s}`);
-}
 async function executeAgentAction(runtime, action, signal, json) {
     const target = action.to || signal.senderAddress || "";
     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) {
-                    await runtime.channels.send(channelId, content);
-                }
-                else if (target) {
-                    await runtime.inbox.send({ to: target, content });
-                }
-                break;
-            case "send_dm":
-                if (target)
-                    await runtime.inbox.send({ to: target, content });
-                break;
-            case "follow_agent":
-            case "follow_back":
-            case "follow":
-                if (target)
-                    await runtime.social.follow(target);
-                break;
-            case "attest_agent":
-            case "attest_back":
-            case "attest":
-                if (target)
-                    await runtime.social.attest(target, action.reason || "Valued collaborator");
-                break;
-            case "endorse_agent":
-            case "endorse":
-                if (target && action.skill) {
-                    await runtime.social.endorse(target, action.skill, Number(action.rating ?? 3), action.context || "");
-                }
-                break;
-            case "revoke_endorsement":
-                if (target && action.skill) {
-                    await runtime.social.revokeEndorsement(target, action.skill);
-                }
-                break;
-            case "block_agent":
-                if (target) {
-                    await runtime.social.block(target);
-                }
-                break;
-            case "unblock_agent":
-                if (target) {
-                    await runtime.social.unblock(target);
-                }
-                break;
-            case "vote":
-                if (action.cid) {
-                    await runtime.memory.vote({ cid: action.cid, type: (action.voteType || "up") });
-                }
-                break;
-            case "review_commit":
-            case "review":
-            case "comment": {
-                const projectId = (action.projectId || signal.projectId);
-                const commitId = (action.commitId || signal.commitId);
-                const verdict = action.action === "comment" ? "comment" : action.verdict || "comment";
-                const body = content || "Reviewed";
-                if (projectId && commitId) {
-                    await runtime.projects.submitReview(projectId, commitId, verdict, body);
-                }
-                break;
-            }
-            case "request_ai_review": {
-                // AI-powered code review — costs 150 credits (1.50 cr).
-                // Requires the project to have a linked GitHub repo.
-                const projId2 = (action.projectId || signal.projectId);
-                const commitId2 = (action.commitId || signal.commitId);
-                if (projId2 && commitId2) {
-                    const aiResult = await runtime.projects.requestAIReview(projId2, commitId2);
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] AI review: ${aiResult.verdict} — ${aiResult.findingsCount} finding(s), cost ${aiResult.creditsCost} credits`));
-                }
-                break;
-            }
-            case "send_message":
-                if (target) {
-                    await runtime.inbox.send({ to: target, content: content || "Hey! Looking forward to collaborating." });
-                }
-                else if (channelId) {
-                    await runtime.channels.send(channelId, content || "Hey everyone! Excited to join.");
-                }
-                break;
-            case "apply_bounty": {
-                const bountyId = validateId(action.bountyId || signal.bountyId, "bountyId");
-                const applyMsg = action.message || content || "";
-                if (!applyMsg || applyMsg.length < 50)
-                    throw new Error("apply_bounty requires a work submission (minimum 50 characters)");
-                await runtime.connection.request("POST", `/v1/bounties/${bountyId}/apply`, { message: applyMsg });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Applied to bounty: ${bountyId}`));
-                break;
-            }
-            case "submit_bounty_work": {
-                const bountyId = validateId(action.bountyId || signal.bountyId, "bountyId");
-                const workContent = content || action.workContent || "";
-                const cids = action.deliverableCids || [];
-                const projectId = action.projectId;
-                const commitIds = action.commitIds || [];
-                await runtime.connection.request("POST", `/v1/bounties/${bountyId}/submissions`, {
-                    content: workContent,
-                    deliverableCids: cids,
-                    ...(projectId ? { projectId } : {}),
-                    ...(commitIds.length > 0 ? { commitIds } : {}),
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Work submitted for bounty: ${bountyId}`));
-                break;
-            }
-            case "claim":
-            case "claim_bounty": {
-                const rawBountyId = action.bountyId || signal.bountyId;
-                if (rawBountyId) {
-                    const bountyId = validateId(rawBountyId, "bountyId");
-                    const result = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/claim`, {});
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] Bounty claimed: ${bountyId} (tx: ${result.txHash})`));
-                }
-                else {
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] Bounty claim requested but no bountyId provided`));
-                }
-                break;
-            }
-            case "approve_bounty_claimer": {
-                const rawBountyId = action.bountyId || signal.bountyId;
-                const claimer = action.claimer;
-                if (rawBountyId && claimer) {
-                    const bountyId = validateId(rawBountyId, "bountyId");
-                    const result = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/approve-claimer`, { claimer });
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] Bounty claimer approved: ${bountyId} → ${claimer} (tx: ${result.txHash})`));
-                }
-                else {
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] approve_bounty_claimer requires bountyId and claimer`));
-                }
-                break;
-            }
-            case "approve_bounty_application": {
-                const bountyId = validateId(action.bountyId || signal.bountyId, "bountyId");
-                const applicationId = validateId(action.applicationId, "applicationId");
-                await runtime.connection.request("POST", `/v1/bounties/${bountyId}/applications/${applicationId}/approve`, {});
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Approved bounty application: ${applicationId} on bounty ${bountyId}`));
-                break;
-            }
-            case "reject_bounty_application": {
-                const bountyId = validateId(action.bountyId || signal.bountyId, "bountyId");
-                const applicationId = validateId(action.applicationId, "applicationId");
-                await runtime.connection.request("POST", `/v1/bounties/${bountyId}/applications/${applicationId}/reject`, {});
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Rejected bounty application: ${applicationId} on bounty ${bountyId}`));
-                break;
-            }
-            case "select_bounty_submission": {
-                const bountyId = validateId(action.bountyId || signal.bountyId, "bountyId");
-                const submissionId = validateId(action.submissionId, "submissionId");
-                const selectResult = await runtime.connection.request("POST", `/v1/bounties/${bountyId}/submissions/${submissionId}/select`, {});
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Selected bounty submission: ${submissionId} on bounty ${bountyId}`));
-                // Bridge: approve winner on-chain so they can claim
-                try {
-                    const winnerAddress = selectResult?.winner?.applicantAddress;
-                    if (winnerAddress) {
-                        const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/approve-claimer`, { claimer: winnerAddress });
-                        if (!json)
-                            console.log(chalk.dim(`  [reactive] Approved claimer on-chain: ${bountyId} → ${winnerAddress} (tx: ${relay.txHash})`));
-                    }
-                }
-                catch { /* non-fatal */ }
-                break;
-            }
-            case "create_community": {
-                const slug = action.slug;
-                const name = action.name || content;
-                const desc = action.description || content || "";
-                if (slug && name) {
-                    await prepareSignRelay(runtime.connection, "/v1/prepare/community", { slug, name, description: desc });
-                }
-                break;
-            }
-            case "create_project": {
-                const projName = action.name || content;
-                const projDesc = action.description || "";
-                const projId = action.projectId || projName?.toLowerCase().replace(/\s+/g, "-");
-                if (projId && projName) {
-                    // Discover similar projects first (gateway requires discoveryId)
-                    const discovery = await runtime.connection.request("POST", "/v1/projects/discover", { name: projName, description: projDesc });
-                    await prepareSignRelay(runtime.connection, "/v1/prepare/project", {
-                        discoveryId: discovery.discoveryId,
-                        projectId: projId, name: projName, description: projDesc,
-                    });
-                }
-                break;
-            }
-            case "commit_files":
-            case "gateway_commit": {
-                const projId = (action.projectId || signal.projectId);
-                const files = action.files;
-                const msg = content || "Automated commit";
-                if (projId && files?.length) {
-                    await runtime.projects.commitFiles(projId, files, msg);
-                }
-                break;
-            }
-            case "list_project_files": {
-                const projId = (action.projectId || signal.projectId);
-                if (projId) {
-                    await runtime.projects.listFiles(projId);
-                }
-                break;
-            }
-            case "read_project_file": {
-                const projId = (action.projectId || signal.projectId);
-                const filePath = action.filePath;
-                if (projId && filePath) {
-                    await runtime.projects.readFile(projId, filePath);
-                }
-                break;
-            }
-            case "list_commits": {
-                const projId = (action.projectId || signal.projectId);
-                if (projId) {
-                    const limit = action.limit ?? 20;
-                    const offset = action.offset ?? 0;
-                    await runtime.projects.listCommits(projId, limit, offset);
-                }
-                break;
-            }
-            case "get_commit_detail": {
-                const projId = (action.projectId || signal.projectId);
-                const commitId = action.commitId;
-                if (projId && commitId) {
-                    await runtime.projects.getCommit(projId, commitId);
-                }
-                break;
-            }
-            case "add_collaborator": {
-                const projId = (action.projectId || signal.projectId);
-                const collabAddr = (action.collaboratorAddress || target);
-                const role = action.role || "editor";
-                if (projId && collabAddr) {
-                    await runtime.projects.addCollaborator(projId, collabAddr, role);
-                }
-                break;
-            }
-            case "link_project_to_guild":
-            case "link_project_to_clique": {
-                const projId2 = (action.projectId || signal.projectId);
-                const gId = (action.guildId || action.cliqueId);
-                if (projId2 && gId != null) {
-                    // 1. Link project to guild
-                    await runtime.guilds.linkProject(Number(gId), projId2);
-                    // 2. Set guild attribution
-                    await runtime.projects.setGuildAttribution(projId2, String(gId));
-                    // 3. Add accepted guild members as editors
-                    // Gateway returns members as [{address, status}] objects where status=2 = accepted
-                    const guild = await runtime.guilds.get(Number(gId));
-                    const rawMembers = (guild?.members ?? []);
-                    const myAddr = runtime.connection.address?.toLowerCase();
-                    for (const m of rawMembers) {
-                        if (typeof m === "string")
-                            continue; // bare string — can't confirm accepted
-                        if (m.status === 2 && m.address?.toLowerCase() !== myAddr) {
-                            try {
-                                await runtime.projects.addCollaborator(projId2, m.address, "editor");
-                            }
-                            catch { /* best-effort */ }
-                        }
-                    }
-                }
-                break;
-            }
-            case "propose_guild":
-            case "propose_clique": {
-                const guildName = action.name || content;
-                const guildMembers2 = action.members;
-                const guildDesc = action.description || "";
-                if (guildName && guildMembers2 && guildMembers2.length >= 2) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/guild", { name: guildName, description: guildDesc, members: guildMembers2 });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Proposed guild "${guildName}" (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "join_guild":
-            case "approve_guild": {
-                const gId = action.guildId;
-                if (gId) {
-                    const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/guild/${gId}/approve`, {});
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Approved guild #${gId} membership (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "reject_guild": {
-                const gId = action.guildId;
-                if (gId) {
-                    const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/guild/${gId}/reject`, {});
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Rejected guild #${gId} membership (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "leave_guild": {
-                const gId = action.guildId;
-                if (gId) {
-                    const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/guild/${gId}/leave`, {});
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Left guild #${gId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "publish":
-            case "create_post": {
-                const community = action.community || "general";
-                const title = action.title || content?.slice(0, 100) || "Untitled";
-                const body = content || "";
-                if (body) {
-                    await runtime.memory.publishKnowledge({ title, body, community });
-                }
-                break;
-            }
-            case "execute":
-                if (channelId && content) {
-                    await runtime.channels.send(channelId, content);
-                }
-                else if (target && content) {
-                    await runtime.inbox.send({ to: target, content });
-                }
-                break;
-            case "accept": {
-                const ch = action.channelId || signal.channelId || "";
-                const msg = content || "Accepted — I'll get started.";
-                if (ch)
-                    await runtime.channels.send(ch, msg);
-                break;
-            }
-            case "acknowledge": {
-                const ch = action.channelId || signal.channelId || "";
-                const msg = content || "Got it, thanks for the mention!";
-                if (ch)
-                    await runtime.channels.send(ch, msg);
-                break;
-            }
-            case "deploy_preview": {
-                const projId = (action.projectId || signal.projectId);
-                if (projId) {
-                    const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/project/${projId}/deployment`, { prepaidHours: action.prepaidHours ?? 2 });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Deploy preview for ${projId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "fork_project": {
-                const projId = (action.projectId || signal.projectId);
-                if (projId) {
-                    const res = await runtime.projects.forkProject(projId, {
-                        name: action.name,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Forked project ${projId} → ${res.projectId}`));
-                }
-                break;
-            }
-            case "create_merge_request": {
-                const srcId = (action.sourceProjectId || signal.projectId);
-                const tgtId = action.targetProjectId;
-                const mrTitle = action.title;
-                const commitIds = action.commitIds;
-                if (srcId && tgtId && mrTitle && commitIds?.length) {
-                    const mr = await runtime.projects.createMergeRequest(srcId, tgtId, mrTitle, commitIds, action.description);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Created merge request "${mrTitle}" (${mr.id})`));
-                }
-                break;
-            }
-            case "list_merge_requests": {
-                const projId = (action.projectId || signal.projectId);
-                if (projId) {
-                    const res = await runtime.projects.listMergeRequests(projId, {
-                        status: action.status,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Listed ${res.mergeRequests.length} merge requests on ${projId}`));
-                }
-                break;
-            }
-            case "get_merge_request": {
-                const projId = (action.projectId || signal.projectId);
-                const mrId = action.mrId;
-                if (projId && mrId) {
-                    const mr = await runtime.projects.getMergeRequest(projId, mrId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Got merge request "${mr.title}" (${mr.status})`));
-                }
-                break;
-            }
-            case "merge_merge_request": {
-                const projId = (action.projectId || signal.projectId);
-                const mrId = action.mrId;
-                if (projId && mrId) {
-                    await runtime.projects.mergeMergeRequest(projId, mrId, action.comment);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Merged MR ${mrId} into ${projId}`));
-                }
-                break;
-            }
-            case "close_merge_request": {
-                const projId = (action.projectId || signal.projectId);
-                const mrId = action.mrId;
-                if (projId && mrId) {
-                    await runtime.projects.closeMergeRequest(projId, mrId, action.comment);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Closed MR ${mrId}`));
-                }
-                break;
-            }
-            case "claim_reward": {
-                const pool = action.pool || "nook";
-                const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/reward/claim", { pool });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Reward claimed from ${pool} pool (tx: ${relay.txHash})`));
-                break;
-            }
-            case "create_task": {
-                const projId = (action.projectId || signal.projectId);
-                const title = (content || action.title);
-                if (projId && title) {
-                    await runtime.connection.request("POST", `/v1/projects/${projId}/tasks`, {
-                        title,
-                        description: action.description,
-                        milestoneId: action.milestoneId,
-                        priority: action.priority ?? "medium",
-                        labels: action.labels,
-                        dueDate: action.dueDate,
-                    });
-                }
-                break;
-            }
-            case "assign_task": {
-                const projId = (action.projectId || signal.projectId);
-                const tid = action.taskId;
-                const assignee = (action.assigneeAddress || action.assignee);
-                if (projId && tid && assignee) {
-                    await runtime.projects.assignTask(projId, tid, assignee);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Assigned task ${tid} to ${assignee}`));
-                }
-                break;
-            }
-            case "complete_task":
-            case "update_task": {
-                const projId = (action.projectId || signal.projectId);
-                const tid = action.taskId;
-                if (projId && tid) {
-                    const updates = {};
-                    if (action.action === "complete_task") {
-                        updates.status = "completed";
-                    }
-                    else {
-                        if (action.status)
-                            updates.status = action.status;
-                        if (action.title)
-                            updates.title = action.title;
-                        if (action.description)
-                            updates.description = action.description;
-                        if (action.priority)
-                            updates.priority = action.priority;
-                        if (action.milestoneId !== undefined)
-                            updates.milestoneId = action.milestoneId;
-                        if (action.labels)
-                            updates.labels = action.labels;
-                        if (action.dueDate)
-                            updates.dueDate = action.dueDate;
-                    }
-                    await runtime.connection.request("PATCH", `/v1/projects/${projId}/tasks/${tid}`, updates);
-                }
-                break;
-            }
-            case "find_agents":
-            case "find_matching_agents": {
-                const skills = action.skills ?? [];
-                if (skills.length) {
-                    const matchResult = await runtime.matching.findAgents(skills, {
-                        count: action.count,
-                    });
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] Found ${matchResult.total} matching agents for [${skills.join(", ")}]`));
-                }
-                break;
-            }
-            case "assemble_team": {
-                const desc = content || action.description || "";
-                if (desc) {
-                    const teamResult = await runtime.matching.assembleTeam({
-                        description: desc,
-                        requiredSkills: action.requiredSkills,
-                        teamSize: action.teamSize,
-                    });
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] Team assembled: ${teamResult.members.length} members, ${Math.round(teamResult.coverageScore * 100)}% coverage`));
-                }
-                break;
-            }
-            case "accept_invitation":
-            case "decline_invitation": {
-                const invId = (action.invitationId || signal.invitationId);
-                if (invId) {
-                    const verb = action.action === "accept_invitation" ? "accept" : "decline";
-                    await runtime.connection.request("POST", `/v1/teams/invitations/${invId}/${verb}`, {});
-                    if (!json)
-                        console.log(chalk.dim(`  [reactive] Team invitation ${verb}ed: ${invId.slice(0, 8)}...`));
-                }
-                break;
-            }
-            // ── Marketplace actions ──
-            case "create_listing":
-            case "list_service": {
-                const title = (content || action.title);
-                const desc = action.description || "";
-                const category = action.category || "general";
-                if (title) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/list", {
-                        title, description: desc, category,
-                        pricingModel: action.pricingModel ?? 0,
-                        priceAmount: action.priceAmount ?? "0",
-                        tags: action.tags ?? [],
-                        ...(action.tokenAddress ? { tokenAddress: action.tokenAddress } : {}),
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Listed service "${title}" (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "create_agreement": {
-                const listingId = action.listingId;
-                const terms = (content || action.terms);
-                const deadline = (action.deadline ?? Math.floor(Date.now() / 1000) + 7 * 86400);
-                if (listingId != null && terms) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/agree", {
-                        listingId, terms, deadline,
-                        tokenAmount: action.tokenAmount ?? "0",
-                        ...(action.tokenAddress ? { tokenAddress: action.tokenAddress } : {}),
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Created agreement for listing #${listingId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "deliver_work": {
-                const agId = action.agreementId;
-                const deliveryCid = (content || action.deliveryCid);
-                if (agId != null && deliveryCid) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/deliver", {
-                        agreementId: agId, deliveryCid,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Delivered work for agreement #${agId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "settle_agreement": {
-                const agId = action.agreementId;
-                if (agId != null) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/settle", {
-                        agreementId: agId,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Settled agreement #${agId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "dispute_agreement": {
-                const agId = action.agreementId;
-                if (agId != null) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/dispute", {
-                        agreementId: agId,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Disputed agreement #${agId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "cancel_agreement": {
-                const agId = action.agreementId;
-                if (agId != null) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/cancel", {
-                        agreementId: agId,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Cancelled agreement #${agId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "expire_dispute": {
-                const agId = action.agreementId;
-                if (agId != null) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/expire-dispute", {
-                        agreementId: agId,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Expired dispute for agreement #${agId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "expire_delivered": {
-                const agId = action.agreementId;
-                if (agId != null) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/expire-delivered", {
-                        agreementId: agId,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Expired delivered for agreement #${agId} (tx: ${relay.txHash})`));
-                }
-                break;
-            }
-            case "submit_review": {
-                const agId = action.agreementId;
-                const rating = action.rating;
-                const comment = (content || action.comment || "");
-                if (agId != null && rating != null) {
-                    await runtime.marketplace.submitReview(agId, rating, comment);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Submitted review for agreement #${agId} (${rating}/5)`));
-                }
-                break;
-            }
-            case "send_agreement_message": {
-                const agId = action.agreementId;
-                const msgType = action.messageType || "general";
-                const msgContent = (content || action.content);
-                if (agId != null && msgContent) {
-                    const msgBody = { messageType: msgType, content: msgContent };
-                    if (action.attachmentCid)
-                        msgBody.attachmentCid = action.attachmentCid;
-                    await runtime.connection.request("POST", `/v1/marketplace/agreements/${agId}/messages`, msgBody);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Sent ${msgType} message for agreement #${agId}`));
-                }
-                break;
-            }
-            case "create_bounty": {
-                const payload = action;
-                const title = payload?.title;
-                const description = payload?.description ?? content ?? "";
-                const community = payload?.community ?? "";
-                const deadline = payload?.deadline ?? Math.floor(Date.now() / 1000) + 604800; // 7 days
-                const tokenRewardAmount = payload?.tokenRewardAmount ?? "0";
-                if (!title)
-                    throw new Error("create_bounty requires title");
-                const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/bounty", {
-                    title, description, community, deadline, tokenRewardAmount,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Created bounty "${title}" (tx: ${relay.txHash})`));
-                break;
-            }
-            case "post_reply": {
-                const parentCid = (action.parentCid ?? action.sourceId ?? "");
-                if (!parentCid)
-                    throw new Error("post_reply requires parentCid");
-                const replyContent = (content ?? action.body ?? "");
-                const replyCommunity = (action.community ?? "");
-                await runtime.memory.publishComment({ parentCid, body: replyContent, community: replyCommunity });
-                break;
-            }
-            case "propose_collab": {
-                const collabTarget = (action.targetAddress ?? action.recipientAddress ?? target);
-                if (!collabTarget)
-                    throw new Error("propose_collab requires targetAddress");
-                const msg = content || "I'd like to collaborate with you!";
-                await runtime.inbox.send({ to: collabTarget, content: msg });
-                break;
-            }
-            case "create_bundle": {
-                const bundleTitle = action.title;
-                if (!bundleTitle)
-                    throw new Error("create_bundle requires title");
-                const bundleDesc = content || action.description || "";
-                const domain = action.domain || "";
-                const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/bundle", {
-                    title: bundleTitle, description: bundleDesc, domain,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Created bundle "${bundleTitle}" (tx: ${relay.txHash})`));
-                break;
-            }
-            case "update_service": {
-                const listingId = action.listingId;
-                if (!listingId)
-                    throw new Error("update_service requires listingId");
-                const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/service/update", {
-                    listingId, ...action,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Updated service listing #${listingId} (tx: ${relay.txHash})`));
-                break;
-            }
-            case "approve_bounty_work": {
-                const bountyId = (action.bountyId || signal.bountyId);
-                if (!bountyId)
-                    throw new Error("approve_bounty_work requires bountyId");
-                const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/approve`, {});
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Approved bounty work: ${bountyId} (tx: ${relay.txHash})`));
-                break;
-            }
-            case "dispute_bounty_work": {
-                const bountyId = (action.bountyId || signal.bountyId);
-                if (!bountyId)
-                    throw new Error("dispute_bounty_work requires bountyId");
-                const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/dispute`, {});
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Disputed bounty work: ${bountyId} (tx: ${relay.txHash})`));
-                break;
-            }
-            case "cancel_bounty": {
-                const bountyId = (action.bountyId || signal.bountyId);
-                if (!bountyId)
-                    throw new Error("cancel_bounty requires bountyId");
-                const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/cancel`, {});
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Cancelled bounty: ${bountyId} (tx: ${relay.txHash})`));
-                break;
-            }
-            case "unclaim_bounty": {
-                const bountyId = (action.bountyId || signal.bountyId);
-                if (!bountyId)
-                    throw new Error("unclaim_bounty requires bountyId");
-                const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/unclaim`, {});
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Unclaimed bounty: ${bountyId} (tx: ${relay.txHash})`));
-                break;
-            }
-            case "grant": {
-                const projId = action.projectId;
-                const bountyId = (action.bountyId || signal.bountyId);
-                const reqId = action.requestId;
-                if (!projId || !bountyId || !reqId)
-                    throw new Error("grant requires projectId, bountyId, requestId");
-                await runtime.connection.request("POST", `/v1/projects/${projId}/bounties/${bountyId}/grant-access`, { requestId: reqId });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Granted bounty access: ${bountyId} request ${reqId}`));
-                break;
-            }
-            case "deny": {
-                const projId = action.projectId;
-                const bountyId = (action.bountyId || signal.bountyId);
-                const reqId = action.requestId;
-                if (!projId || !bountyId || !reqId)
-                    throw new Error("deny requires projectId, bountyId, requestId");
-                await runtime.connection.request("POST", `/v1/projects/${projId}/bounties/${bountyId}/deny-access`, { requestId: reqId });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Denied bounty access: ${bountyId} request ${reqId}`));
-                break;
-            }
-            case "workspace_create": {
-                const wsName = (action.name || content);
-                if (wsName) {
-                    const ws = await runtime.workspaces.create({ name: wsName, description: action.description });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Created workspace: ${ws.id}`));
-                }
-                break;
-            }
-            case "workspace_set": {
-                const wsId = action.workspaceId;
-                const wsKey = action.key;
-                const wsVal = action.value ?? content;
-                if (wsId && wsKey) {
-                    await runtime.workspaces.setState(wsId, wsKey, wsVal);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Set ${wsKey} in workspace ${wsId}`));
-                }
-                break;
-            }
-            case "workspace_snapshot": {
-                const snapWsId = action.workspaceId;
-                if (snapWsId) {
-                    await runtime.workspaces.createSnapshot(snapWsId, action.label);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Created snapshot in workspace ${snapWsId}`));
-                }
-                break;
-            }
-            case "propose_action": {
-                const wsId = action.workspaceId;
-                const title = (action.title || content);
-                if (wsId && title) {
-                    const prop = await runtime.workspaces.createProposal(wsId, {
-                        title,
-                        description: action.description,
-                        actionType: action.actionType ?? "custom",
-                        actionPayload: action.actionPayload,
-                        quorumType: action.quorumType,
-                        quorumThreshold: action.quorumThreshold,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Created proposal: ${prop.proposal?.id}`));
-                }
-                break;
-            }
-            case "vote_proposal": {
-                const wsId = action.workspaceId;
-                const proposalId = action.proposalId;
-                if (wsId && proposalId && action.vote !== undefined) {
-                    await runtime.workspaces.vote(wsId, proposalId, action.vote, action.reason);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Voted on proposal ${proposalId}`));
-                }
-                break;
-            }
-            case "cancel_proposal": {
-                const wsId = action.workspaceId;
-                const proposalId = action.proposalId;
-                if (wsId && proposalId) {
-                    await runtime.workspaces.cancelProposal(wsId, proposalId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Cancelled proposal ${proposalId}`));
-                }
-                break;
-            }
-            // ── Real World Actions ──
-            case "egress_request":
-            case "http_request": {
-                const targetUrl = action.url ?? "";
-                const httpMethod = (action.method ?? "GET").toUpperCase();
-                if (!targetUrl)
-                    throw new Error("egress_request requires url");
-                const httpResult = await runtime.tools.httpRequest(targetUrl, httpMethod, {
-                    headers: action.headers,
-                    body: action.body,
-                    timeout: action.timeout,
-                    credentialService: action.credentialService,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] HTTP ${httpMethod} ${targetUrl.slice(0, 60)} → ${httpResult?.status ?? "ok"}`));
-                break;
-            }
-            case "execute_tool": {
-                const toolName = action.toolName ?? "";
-                if (!toolName)
-                    throw new Error("execute_tool requires toolName");
-                const toolArgs = (action.args ?? action.arguments ?? {});
-                const toolResult = await runtime.tools.executeTool(toolName, toolArgs);
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Executed tool: ${toolName}`));
-                break;
-            }
-            case "exec_code": {
-                const cmd = action.command ?? "";
-                const img = (action.image ?? "node:20-slim");
-                const files = (action.files ?? {});
-                const timeout = action.timeout;
-                const projId = action.projectId;
-                if (!cmd)
-                    throw new Error("exec_code requires command");
-                const execResult = await runtime.tools.execCode(cmd, img, { files, timeout, projectId: projId });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Executed code (${img}): exit=${execResult.exitCode}`));
-                break;
-            }
-            case "connect_mcp_server": {
-                const serverUrl = (action.serverUrl ?? action.url);
-                const serverName = (action.serverName ?? action.name ?? "mcp-server");
-                if (!serverUrl)
-                    throw new Error("connect_mcp_server requires serverUrl");
-                await runtime.tools.connectMcpServer(serverUrl, serverName);
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Connected MCP server: ${serverUrl.slice(0, 60)}`));
-                break;
-            }
-            case "disconnect_mcp_server": {
-                const serverId = (action.serverId ?? action.serverUrl);
-                if (!serverId)
-                    throw new Error("disconnect_mcp_server requires serverId");
-                await runtime.tools.disconnectMcpServer(serverId);
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Disconnected MCP server: ${serverId.slice(0, 60)}`));
-                break;
-            }
-            case "call_mcp_tool":
-            case "use_mcp_tool": {
-                const mcpToolName = action.toolName ?? "";
-                if (!mcpToolName)
-                    throw new Error("call_mcp_tool requires toolName");
-                const mcpToolArgs = (action.args ?? action.arguments ?? {});
-                const mcpResult = await runtime.tools.executeTool(mcpToolName, mcpToolArgs);
-                if (!json)
-                    console.log(chalk.green(`  [reactive] MCP tool called: ${mcpToolName}`));
-                break;
-            }
-            case "register_webhook": {
-                const source = action.source ?? "";
-                if (!source)
-                    throw new Error("register_webhook requires source");
-                await runtime.connection.request("POST", "/v1/agents/me/webhooks", {
-                    source,
-                    description: action.description,
-                    secret: action.secret,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Registered webhook: ${source}`));
-                break;
-            }
-            case "publish_insight": {
-                const title = action.title;
-                const body = action.body;
-                if (title && body) {
-                    await runtime.insights?.publish({
-                        title,
-                        body,
-                        strategyType: action.strategyType,
-                        tags: action.tags,
-                        outcomeScore: action.outcomeScore,
-                        workspaceId: action.workspaceId,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Published insight: ${title}`));
-                }
-                break;
-            }
-            case "cite_insight": {
-                const insightId = action.insightId;
-                if (insightId) {
-                    await runtime.insights?.cite(insightId, action.context, action.outcomeScore);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Cited insight ${insightId}`));
-                }
-                break;
-            }
-            case "apply_insight": {
-                const insightId = action.insightId;
-                if (insightId) {
-                    await runtime.insights?.apply(insightId, action.context, action.outcomeScore);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Applied insight ${insightId}`));
-                }
-                break;
-            }
-            case "deposit_treasury": {
-                const guildId = action.guildId;
-                const amount = action.amount;
-                if (guildId && amount) {
-                    await runtime.guilds.depositTreasury(guildId, amount, action.memo);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Deposited ${amount} to guild ${guildId} treasury`));
-                }
-                break;
-            }
-            case "withdraw_treasury": {
-                const guildId = action.guildId;
-                const amount = action.amount;
-                if (guildId && amount) {
-                    await runtime.guilds.withdrawTreasury(guildId, amount, action.memo);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Withdrew ${amount} from guild ${guildId} treasury`));
-                }
-                break;
-            }
-            case "fund_bounty_from_treasury": {
-                const guildId = action.guildId;
-                const bountyId = action.bountyId;
-                const amount = action.amount;
-                if (guildId && bountyId && amount) {
-                    await runtime.guilds.fundBountyFromTreasury(guildId, bountyId, amount, action.proposalId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Funded bounty ${bountyId} with ${amount} from guild ${guildId}`));
-                }
-                break;
-            }
-            case "distribute_revenue": {
-                const guildId = action.guildId;
-                if (guildId) {
-                    await runtime.guilds.distributeRevenue(guildId, action.amount);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Distributed revenue for guild ${guildId}`));
-                }
-                break;
-            }
-            case "create_swarm": {
-                if (action.title && action.subtasks) {
-                    await runtime.swarms?.create({ title: action.title, description: action.description, workspaceId: action.workspaceId, subtasks: action.subtasks });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Created swarm: ${action.title}`));
-                }
-                break;
-            }
-            case "claim_subtask": {
-                const stId = action.subtaskId;
-                if (stId) {
-                    await runtime.swarms?.claimSubtask(stId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Claimed subtask ${stId}`));
-                }
-                break;
-            }
-            case "submit_swarm_result": {
-                const stId = action.subtaskId;
-                if (stId && action.content) {
-                    await runtime.swarms?.submitResult(stId, action.content, action.resultType);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Submitted result for subtask ${stId}`));
-                }
-                break;
-            }
-            case "aggregate_swarm": {
-                const swarmId = action.swarmId;
-                if (swarmId) {
-                    await runtime.swarms?.aggregate(swarmId, action.summary);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Aggregated swarm ${swarmId}`));
-                }
-                break;
-            }
-            case "record_gap": {
-                if (action.queryText) {
-                    await runtime.specialization?.recordGap({ queryText: action.queryText, queryTags: action.queryTags || [], communityId: action.communityId });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Recorded skill gap: ${action.queryText}`));
-                }
-                break;
-            }
-            case "update_proficiency": {
-                const domain = action.skillDomain;
-                if (domain) {
-                    await runtime.specialization?.updateProficiency(domain, Number(action.proficiency || 0));
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Updated proficiency: ${domain}`));
-                }
-                break;
-            }
-            case "generate_recommendations": {
-                await runtime.specialization?.generateRecommendations();
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Generated specialization recommendations`));
-                break;
-            }
-            case "dismiss_recommendation": {
-                const recId = action.recommendationId;
-                if (recId) {
-                    await runtime.specialization?.dismissRecommendation(recId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Dismissed recommendation ${recId}`));
-                }
-                break;
-            }
-            // ── Intents ──
-            case "create_intent": {
-                const intentRes = await runtime.intents.create({
-                    title: action.title || action.content || "Untitled intent",
-                    description: action.description || action.content || "",
-                    requiredSkills: action.requiredSkills,
-                    budgetAmount: action.budgetAmount,
-                    category: action.category,
-                    tags: action.tags,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Created intent ${intentRes.id}`));
-                break;
-            }
-            case "browse_intents": {
-                const browseRes = await runtime.intents.list({
-                    status: action.status || "open",
-                    category: action.category,
-                    q: action.q,
-                    limit: 20,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Found ${browseRes.total} intents`));
-                break;
-            }
-            case "submit_proposal": {
-                const spIntentId = action.intentId;
-                if (spIntentId) {
-                    const proposalRes = await runtime.intents.submitProposal(spIntentId, {
-                        description: action.description || action.content || "",
-                        approach: action.approach,
-                        estimatedCost: action.estimatedCost,
-                        estimatedDurationHours: action.estimatedDurationHours,
-                    });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Submitted proposal ${proposalRes.id}`));
-                }
-                break;
-            }
-            case "accept_proposal": {
-                const apIntentId = action.intentId;
-                const apProposalId = action.proposalId;
-                if (apIntentId && apProposalId) {
-                    await runtime.intents.acceptProposal(apIntentId, apProposalId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Accepted proposal ${apProposalId}`));
-                }
-                break;
-            }
-            case "reject_proposal": {
-                const rpIntentId = action.intentId;
-                const rpProposalId = action.proposalId;
-                if (rpIntentId && rpProposalId) {
-                    const rpReason = action.content || action.reason || "";
-                    await runtime.intents.rejectProposal(rpIntentId, rpProposalId, rpReason);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Rejected proposal ${rpProposalId}`));
-                }
-                break;
-            }
-            case "cancel_intent": {
-                const ciId = action.intentId;
-                if (ciId) {
-                    await runtime.intents.cancel(ciId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Cancelled intent ${ciId}`));
-                }
-                break;
-            }
-            case "complete_intent": {
-                const coiId = action.intentId;
-                if (coiId) {
-                    await runtime.intents.complete(coiId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Completed intent ${coiId}`));
-                }
-                break;
-            }
-            case "withdraw_proposal": {
-                const wpIntentId = action.intentId;
-                const wpProposalId = action.proposalId;
-                if (wpIntentId && wpProposalId) {
-                    await runtime.intents.withdrawProposal(wpIntentId, wpProposalId);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Withdrew proposal ${wpProposalId}`));
-                }
-                break;
-            }
-            case "query_oracle": {
-                const oEntityType = action.entityType;
-                const oEntityId = action.entityId;
-                if (oEntityType && oEntityId) {
-                    let oracleRes;
-                    switch (oEntityType) {
-                        case "project":
-                            oracleRes = await runtime.oracle.getProjectSignals(oEntityId);
-                            break;
-                        case "agent":
-                            oracleRes = await runtime.oracle.getAgentSignals(oEntityId);
-                            break;
-                        case "intent":
-                            oracleRes = await runtime.oracle.getIntentSignals(oEntityId);
-                            break;
-                        case "guild":
-                            oracleRes = await runtime.oracle.getGuildSignals(oEntityId);
-                            break;
-                    }
-                    if (!json && oracleRes)
-                        console.log(chalk.green(`  [reactive] Oracle ${oEntityType}/${oEntityId}: ${JSON.stringify(oracleRes.signals).slice(0, 100)}`));
-                }
-                break;
-            }
-            case "create_search_subscription": {
-                const subRes = await runtime.discovery.createSubscription({
-                    label: action.label || "Search subscription",
-                    query: action.query || action.content || "",
-                    types: action.types,
-                    frequencyMinutes: action.frequencyMinutes,
-                });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Created search subscription ${subRes.id}`));
-                break;
-            }
-            // ── Clawnch Token Launching ──
-            case "preview_token_launch": {
-                const prevRes = await runtime.connection.request("POST", "/v1/clawnch/preview", { tokenName: action.tokenName, tokenTicker: action.tokenTicker, description: action.description || action.content, imageUrl: action.imageUrl });
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Token preview: ${prevRes?.launch ? "OK" : "done"}`));
-                break;
-            }
-            case "launch_token": {
-                const launchRes = await runtime.connection.request("POST", "/v1/clawnch/launch", { tokenName: action.tokenName, tokenTicker: action.tokenTicker, description: action.description || action.content, imageUrl: action.imageUrl });
-                const tokenAddr = launchRes?.launch;
-                if (!json)
-                    console.log(chalk.green(`  [reactive] Launched token ${tokenAddr?.token_address ?? "pending"}`));
-                break;
-            }
-            case "claim_clawnch_fees": {
-                const claimAddr = action.tokenAddress;
-                if (claimAddr) {
-                    await runtime.connection.request("POST", "/v1/clawnch/claim-fees", { tokenAddress: claimAddr });
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Claimed fees for ${claimAddr.slice(0, 10)}...`));
-                }
-                break;
-            }
-            case "get_token_analytics": {
-                const analyticsAddr = action.tokenAddress;
-                if (analyticsAddr) {
-                    await runtime.connection.request("GET", `/v1/clawnch/analytics/token/${analyticsAddr}`);
-                    if (!json)
-                        console.log(chalk.green(`  [reactive] Token analytics for ${analyticsAddr.slice(0, 10)}...`));
-                }
-                break;
-            }
-            case "send_email": {
-                const emailTo = action.to;
-                const subject = (action.subject || content?.slice(0, 100));
-                const emailBody = (action.body || content);
-                if (!emailTo || !subject || !emailBody)
-                    throw new Error("send_email requires to, subject, body");
-                await runtime.connection.request("POST", "/v1/email/send", { to: emailTo, subject, bodyText: emailBody });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Email sent to ${emailTo.slice(0, 30)}`));
-                break;
-            }
-            case "reply_email": {
-                const msgId = action.messageId;
-                const replyBody = (action.body || content);
-                if (!msgId || !replyBody)
-                    throw new Error("reply_email requires messageId and body");
-                await runtime.connection.request("POST", `/v1/email/${msgId}/reply`, { bodyText: replyBody });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Replied to email ${msgId.slice(0, 10)}...`));
-                break;
-            }
-            case "check_email": {
-                await runtime.connection.request("GET", "/v1/email/messages?direction=inbound&limit=10");
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Checked email inbox`));
-                break;
-            }
-            case "create_email_inbox": {
-                const localPart = action.username;
-                if (!localPart)
-                    throw new Error("create_email_inbox requires username");
-                await runtime.connection.request("POST", "/v1/email/inbox", { username: localPart, displayName: action.displayName });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Created email inbox: ${localPart}`));
-                break;
-            }
-            // ── Skill Registry ──────────────────────────────────────────────
-            case "search_skills": {
-                const q = action.query || action.q || "";
-                const category = action.category;
-                const limit = action.limit || 20;
-                const params = new URLSearchParams();
-                if (q)
-                    params.set("q", String(q));
-                if (category)
-                    params.set("category", String(category));
-                params.set("limit", String(limit));
-                await runtime.connection.request("GET", `/v1/skills/registry?${params.toString()}`);
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Searched skills: "${q}"`));
-                break;
-            }
-            case "publish_skill": {
-                const name = action.name;
-                if (!name)
-                    throw new Error("publish_skill requires name");
-                await runtime.connection.request("POST", "/v1/skills/registry", {
-                    name,
-                    description: action.description,
-                    packageType: action.packageType || "skill_md",
-                    category: action.category || "other",
-                    tags: action.tags,
-                    content: action.content || content,
-                    githubUrl: action.githubUrl,
-                    npmPackage: action.npmPackage,
-                    version: action.version || "1.0.0",
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Published skill: ${name}`));
-                break;
-            }
-            case "install_skill": {
-                const skillId = action.skillId || action.skill_id;
-                if (!skillId)
-                    throw new Error("install_skill requires skillId");
-                await runtime.connection.request("POST", `/v1/skills/registry/${skillId}/install`);
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Installed skill: ${skillId}`));
-                break;
-            }
-            case "review_skill": {
-                const skillId = action.skillId || action.skill_id;
-                const rating = action.rating;
-                if (!skillId || !rating)
-                    throw new Error("review_skill requires skillId and rating");
-                await runtime.connection.request("POST", `/v1/skills/registry/${skillId}/review`, {
-                    rating, review: action.review || content,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Reviewed skill: ${skillId} (${rating}/5)`));
-                break;
-            }
-            case "trending_skills": {
-                const limit = action.limit || 20;
-                await runtime.connection.request("GET", `/v1/skills/registry/trending?limit=${limit}`);
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Fetched trending skills`));
-                break;
-            }
-            // ── Agent Memory ────────────────────────────────────────────────
-            case "store_memory": {
-                const memContent = action.body || content;
-                if (!memContent)
-                    throw new Error("store_memory requires content");
-                await runtime.connection.request("POST", "/v1/agent-memory/store", {
-                    type: action.memoryType || action.type || "semantic",
-                    content: memContent, importance: action.importance, tags: action.tags,
-                    source: action.source, metadata: action.metadata,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Stored memory`));
-                break;
-            }
-            case "recall_memory": {
-                const query = action.query || action.q;
-                if (!query)
-                    throw new Error("recall_memory requires query");
-                const rtypes = action.types
-                    || ((action.memoryType || action.type) ? [String(action.memoryType || action.type)] : undefined);
-                await runtime.connection.request("POST", "/v1/agent-memory/recall", {
-                    query, types: rtypes, limit: action.limit || 10,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Recalled memories for: "${query}"`));
-                break;
-            }
-            case "list_memories": {
-                const type = action.memoryType || action.type || "";
-                const limit = action.limit || 20;
-                const params = new URLSearchParams();
-                if (type)
-                    params.set("type", String(type));
-                params.set("limit", String(limit));
-                await runtime.connection.request("GET", `/v1/agent-memory/list?${params.toString()}`);
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Listed memories`));
-                break;
-            }
-            case "memory_stats": {
-                await runtime.connection.request("GET", "/v1/agent-memory/stats");
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Fetched memory stats`));
-                break;
-            }
-            case "export_memories": {
-                await runtime.connection.request("POST", "/v1/agent-memory/export");
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Exported memories`));
-                break;
-            }
-            case "import_memories": {
-                const pack = action.pack || action.memories;
-                if (!pack)
-                    throw new Error("import_memories requires pack data");
-                await runtime.connection.request("POST", "/v1/agent-memory/import", pack);
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Imported memories`));
-                break;
-            }
-            // ── Forge (Agent Deployment) ────────────────────────────────────
-            case "forge_deploy": {
-                const forgeBundleId = action.bundleId;
-                const forgeAgentAddr = action.agentAddress;
-                const forgeSoulCid = action.soulCid;
-                if (!forgeBundleId)
-                    throw new Error("forge_deploy requires bundleId (number)");
-                if (!forgeAgentAddr)
-                    throw new Error("forge_deploy requires agentAddress");
-                if (!forgeSoulCid)
-                    throw new Error("forge_deploy requires soulCid");
-                const relayResult = await prepareSignRelay(runtime.connection, "/v1/prepare/forge", {
-                    bundleId: forgeBundleId, agentAddress: forgeAgentAddr, soulCid: forgeSoulCid, deploymentFee: action.deploymentFee,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Forge deployed: ${forgeBundleId} (tx: ${relayResult.txHash})`));
-                break;
-            }
-            case "forge_spawn": {
-                const spawnBundleId = action.bundleId;
-                const childAddress = action.childAddress || action.parentAddress;
-                const spawnSoulCid = action.soulCid;
-                if (!spawnBundleId)
-                    throw new Error("forge_spawn requires bundleId (number)");
-                if (!childAddress)
-                    throw new Error("forge_spawn requires childAddress");
-                if (!spawnSoulCid)
-                    throw new Error("forge_spawn requires soulCid");
-                const relayResult = await prepareSignRelay(runtime.connection, "/v1/prepare/forge/spawn", {
-                    bundleId: spawnBundleId, childAddress, soulCid: spawnSoulCid, deploymentFee: action.deploymentFee,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Forge spawned child: ${childAddress} (tx: ${relayResult.txHash})`));
-                break;
-            }
-            case "forge_update_soul": {
-                const agentId = action.agentId || action.forgeId;
-                if (!agentId)
-                    throw new Error("forge_update_soul requires agentId");
-                const relayResult = await prepareSignRelay(runtime.connection, `/v1/prepare/forge/${agentId}/soul`, {
-                    soulCid: action.soulCid, metadata: action.metadata,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] Forge soul updated: ${agentId} (tx: ${relayResult.txHash})`));
-                break;
-            }
-            // ── Teaching Exchanges ──
-            case "propose_teaching": {
-                const learnerAddress = action.learnerAddress;
-                const goal = (action.goal ?? action.suggestedContent);
-                const offerings = action.offerings;
-                if (!learnerAddress || !goal || !offerings?.length)
-                    throw new Error("propose_teaching requires learnerAddress, goal, offerings[]");
-                await runtime.connection.request("POST", "/v1/teaching/propose", { learnerAddress, goal, offerings });
-                break;
-            }
-            case "accept_teaching": {
-                const exchangeId = action.exchangeId;
-                if (!exchangeId)
-                    throw new Error("accept_teaching requires exchangeId");
-                await runtime.connection.request("POST", `/v1/teaching/${exchangeId}/accept`, {});
-                break;
-            }
-            case "deliver_teaching": {
-                const exchangeId = action.exchangeId;
-                if (!exchangeId)
-                    throw new Error("deliver_teaching requires exchangeId");
-                await runtime.connection.request("POST", `/v1/teaching/${exchangeId}/deliver`, { notes: action.notes });
-                break;
-            }
-            case "approve_teaching": {
-                const exchangeId = action.exchangeId;
-                if (!exchangeId)
-                    throw new Error("approve_teaching requires exchangeId");
-                await runtime.connection.request("POST", `/v1/teaching/${exchangeId}/approve`, { feedback: action.feedback, rating: action.rating });
-                break;
-            }
-            case "reject_teaching": {
-                const exchangeId = action.exchangeId;
-                if (!exchangeId)
-                    throw new Error("reject_teaching requires exchangeId");
-                await runtime.connection.request("POST", `/v1/teaching/${exchangeId}/reject`, { feedback: action.feedback });
-                break;
-            }
-            case "search_teachers": {
-                const goal = (action.goal ?? action.query);
-                if (!goal)
-                    throw new Error("search_teachers requires goal");
-                await runtime.connection.request("GET", `/v1/teaching/search-teachers?goal=${encodeURIComponent(goal)}&limit=${action.limit || 10}`);
-                break;
-            }
-            // ── Credit Hire (off-chain marketplace) ──
-            case "credit_hire": {
-                const listingId = action.listingId;
-                const terms = (action.terms ?? action.suggestedContent);
-                const creditAmount = action.creditAmount;
-                if (!listingId || !terms || !creditAmount)
-                    throw new Error("credit_hire requires listingId, terms, creditAmount");
-                await runtime.connection.request("POST", "/v1/marketplace/credit-hire", { listingId, terms, creditAmount });
-                break;
-            }
-            case "accept_credit_agreement": {
-                const agreementId = action.agreementId;
-                if (!agreementId)
-                    throw new Error("accept_credit_agreement requires agreementId");
-                await runtime.connection.request("POST", `/v1/marketplace/credit-agreements/${agreementId}/accept`, {});
-                break;
-            }
-            case "deliver_credit_work": {
-                const agreementId = action.agreementId;
-                if (!agreementId)
-                    throw new Error("deliver_credit_work requires agreementId");
-                await runtime.connection.request("POST", `/v1/marketplace/credit-agreements/${agreementId}/deliver`, { deliveryNotes: action.deliveryNotes });
-                break;
-            }
-            case "complete_credit_agreement": {
-                const agreementId = action.agreementId;
-                if (!agreementId)
-                    throw new Error("complete_credit_agreement requires agreementId");
-                await runtime.connection.request("POST", `/v1/marketplace/credit-agreements/${agreementId}/complete`, { rating: action.rating, review: action.review });
-                break;
-            }
-            case "cancel_credit_agreement": {
-                const agreementId = action.agreementId;
-                if (!agreementId)
-                    throw new Error("cancel_credit_agreement requires agreementId");
-                await runtime.connection.request("POST", `/v1/marketplace/credit-agreements/${agreementId}/cancel`, {});
-                break;
-            }
-            // GPU marketplace actions
-            case "gpu_search": {
-                const result = await runtime.gpu.searchAvailable({
-                    gpuModel: action.gpuModel,
-                    minVram: action.minVram,
-                    status: action.status,
-                    limit: action.limit || 10,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] GPU search completed: ${JSON.stringify(result)}`));
-                break;
-            }
-            case "gpu_heartbeat": {
-                const listingId = Number(action.listingId);
-                if (!listingId)
-                    throw new Error("gpu_heartbeat requires listingId");
-                await runtime.gpu.heartbeat({
-                    listingId,
-                    status: action.status || "idle",
-                    gpuModel: action.gpuModel,
-                    vramGb: action.vramGb,
-                    gpuTempC: action.gpuTempC,
-                    gpuUtilization: action.gpuUtilization,
-                    vramUsedGb: action.vramUsedGb,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] GPU heartbeat sent for listing ${listingId}`));
-                break;
-            }
-            case "gpu_challenge": {
-                const listingId = Number(action.listingId);
-                const providerAddress = (action.providerAddress || target);
-                const challengeInputCid = action.challengeInputCid;
-                if (!listingId || !providerAddress || !challengeInputCid)
-                    throw new Error("gpu_challenge requires listingId, providerAddress, challengeInputCid");
-                await runtime.gpu.createChallenge({
-                    listingId,
-                    providerAddress,
-                    challengeInputCid,
-                    expectedMinTflops: action.expectedMinTflops,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] GPU challenge created for listing ${listingId}`));
-                break;
-            }
-            case "gpu_submit_challenge": {
-                const challengeId = action.challengeId;
-                const challengeOutputCid = action.challengeOutputCid;
-                if (!challengeId || !challengeOutputCid)
-                    throw new Error("gpu_submit_challenge requires challengeId, challengeOutputCid");
-                await runtime.gpu.submitChallengeResult({
-                    challengeId,
-                    challengeOutputCid,
-                    actualTflops: action.actualTflops,
-                    wallTimeMs: action.wallTimeMs,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] GPU challenge result submitted for ${challengeId}`));
-                break;
-            }
-            case "gpu_submit_attestation": {
-                const benchmarkHash = action.benchmarkHash;
-                const gpuModel = action.gpuModel;
-                const vramGb = action.vramGb;
-                if (!benchmarkHash || !gpuModel || !vramGb)
-                    throw new Error("gpu_submit_attestation requires benchmarkHash, gpuModel, vramGb");
-                const result = await runtime.gpu.submitAttestation({
-                    benchmarkHash,
-                    gpuModel,
-                    vramGb,
-                    computeCapability: action.computeCapability,
-                    cudaVersion: action.cudaVersion,
-                });
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] GPU attestation submitted (tx: ${result.txHash})`));
-                break;
-            }
-            case "gpu_update_attestation": {
-                const benchmarkHash = action.benchmarkHash;
-                if (!benchmarkHash)
-                    throw new Error("gpu_update_attestation requires benchmarkHash");
-                const result = await runtime.gpu.updateAttestation(benchmarkHash);
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] GPU attestation updated (tx: ${result.txHash})`));
-                break;
-            }
-            case "gpu_revoke_attestation": {
-                const result = await runtime.gpu.revokeAttestation();
-                if (!json)
-                    console.log(chalk.dim(`  [reactive] GPU attestation revoked (tx: ${result.txHash})`));
-                break;
-            }
-            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;
-            }
-            // ── 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 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 (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;
-            }
+        // ── Unified dispatch via POST /v1/actions/execute ──
+        if (action.action === "ignore") {
+            return;
+        }
+        // Intercept browse_tools (client-side, no gateway call needed)
+        if (action.action === "browse_tools") {
+            const category = action.category;
+            if (!category) {
+                const listing = getCategoryListing();
+                console.log(`[browse_tools] Categories: ${listing.map((c) => `${c.name} (${c.count})`).join(", ")}`);
+                return;
+            }
+            loadedCategories.add(category);
+            const tools = getToolsInCategory(category);
+            console.log(`[browse_tools] Loaded ${tools.length} tools from "${category}"`);
+            return;
+        }
+        const toolName = `nookplot_${action.action}`;
+        const payload = { ...action };
+        delete payload.action;
+        if (target && !payload.to)
+            payload.to = target;
+        if (content && !payload.content)
+            payload.content = content;
+        if (channelId && !payload.channelId)
+            payload.channelId = channelId;
+        const dispatchResult = await runtime.connection.request("POST", "/v1/actions/execute", { toolName, payload });
+        switch (dispatchResult.status) {
+            case "completed":
+                break;
+            case "sign_required": {
+                if (!dispatchResult.forwardRequest || !dispatchResult.domain || !dispatchResult.types) {
+                    throw new Error(`sign_required response missing forwardRequest/domain/types for ${action.action}`);
+                }
+                const { signForwardRequest } = await import("@nookplot/runtime");
+                const privateKey = runtime.connection.privateKey;
+                if (!privateKey)
+                    throw new Error("Private key not configured — cannot sign on-chain transactions.");
+                const signature = await signForwardRequest(privateKey, dispatchResult.domain, dispatchResult.types, dispatchResult.forwardRequest);
+                const relayResult = await runtime.connection.request("POST", "/v1/relay", { ...dispatchResult.forwardRequest, signature });
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] On-chain tx: ${relayResult.txHash}`));
+                break;
+            }
+            case "client_side_required":
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Client-side action required: ${dispatchResult.action}`));
+                break;
+            case "error":
+                throw new Error(dispatchResult.error ?? `Action failed: ${action.action}`);
+            default:
+                if (!json)
+                    console.log(chalk.dim(`  [reactive] Unexpected dispatch status: ${dispatchResult.status}`));
         }
         if (!json && action.action !== "ignore") {
             console.log(chalk.green(`  [reactive] ✓ ${action.action}${target ? ` → ${target.slice(0, 10)}...` : ""}`));