@nookplot/cli 0.6.80 → 0.6.82

package/dist/utils/agentLoop.js

@@ -11,116 +11,7 @@ import { existsSync, appendFileSync, statSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
-import { NookplotRuntime, AutonomousAgent, prepareSignRelay, formatActionsForPrompt } from "@nookplot/runtime";
-import { filterByProfile } from "../skillGenerator.js";
-// ── Autoresearch: strategy definitions + TSV parser ──────────
-// Ported from mcp-server/src/tools/autoresearch.ts so CLI can execute
-// these tools natively without routing through MCP infrastructure.
-const AUTORESEARCH_STRATEGIES = {
-    architecture_search: {
-        title: "Architecture Search",
-        description: "Explore architectural modifications to the transformer model.",
-        subtasks: [
-            { title: "Attention pattern exploration", description: "Experiment with attention mechanisms: sliding window, flash attention, multi-head vs multi-query, grouped-query attention.", skillTags: ["ml-research", "attention", "transformers"] },
-            { title: "Layer depth vs width tradeoff", description: "Explore depth-width tradeoff within 5-minute budget.", skillTags: ["ml-research", "architecture", "scaling"] },
-            { title: "Normalization and residual connections", description: "Experiment with RMSNorm placement, pre-norm vs post-norm, residual scaling.", skillTags: ["ml-research", "normalization", "residuals"] },
-            { title: "Activation functions and FFN variants", description: "Test GELU, SwiGLU, ReLU^2 and FFN architectures.", skillTags: ["ml-research", "activations", "ffn"] },
-        ],
-    },
-    optimizer_tuning: {
-        title: "Optimizer Tuning",
-        description: "Systematic exploration of optimizer configurations.",
-        subtasks: [
-            { title: "Learning rate schedules", description: "Explore LR warmup, decay, scheduling strategies.", skillTags: ["ml-research", "optimizer", "learning-rate"] },
-            { title: "Muon vs AdamW allocation", description: "Experiment with Muon vs AdamW parameter allocation.", skillTags: ["ml-research", "optimizer", "muon"] },
-            { title: "Regularization and weight decay", description: "Explore weight decay schedules, dropout patterns, gradient clipping.", skillTags: ["ml-research", "optimizer", "regularization"] },
-            { title: "Batch size and gradient accumulation", description: "Test different effective batch sizes via gradient accumulation.", skillTags: ["ml-research", "optimizer", "batch-size"] },
-        ],
-    },
-    full_sweep: {
-        title: "Full Parameter Sweep",
-        description: "Comprehensive sweep across all optimization dimensions.",
-        subtasks: [
-            { title: "Architecture innovations", description: "Focus on model architecture: attention, layers, dims, activations.", skillTags: ["ml-research", "architecture"] },
-            { title: "Training dynamics", description: "Focus on training: optimizer, LR, batch size, warmup, weight decay.", skillTags: ["ml-research", "training"] },
-            { title: "Efficiency optimization", description: "Reduce VRAM while maintaining val_bpb.", skillTags: ["ml-research", "efficiency"] },
-        ],
-    },
-};
-function classifyAutoresearchCategory(description) {
-    const desc = description.toLowerCase();
-    if (["attention", "flash", "sliding", "causal", "head"].some((w) => desc.includes(w)))
-        return "attention";
-    if (["lr", "learning rate", "warmup", "cooldown", "schedule"].some((w) => desc.includes(w)))
-        return "learning_rate";
-    if (["muon", "adamw", "optimizer", "momentum", "weight decay"].some((w) => desc.includes(w)))
-        return "optimizer";
-    if (["layer", "depth", "dim", "hidden", "embed", "width"].some((w) => desc.includes(w)))
-        return "architecture";
-    if (["batch", "gradient", "accumulation"].some((w) => desc.includes(w)))
-        return "batch_size";
-    if (["norm", "rmsnorm", "layernorm"].some((w) => desc.includes(w)))
-        return "normalization";
-    if (["dropout", "regulariz", "weight tying"].some((w) => desc.includes(w)))
-        return "regularization";
-    if (["activation", "gelu", "swiglu", "relu"].some((w) => desc.includes(w)))
-        return "activation";
-    if (["positional", "rotary", "rope", "alibi"].some((w) => desc.includes(w)))
-        return "positional_encoding";
-    return "other";
-}
-function parseAutoresearchTsv(tsvContent, sinceCommit) {
-    const lines = tsvContent.trim().split("\n");
-    if (lines.length < 2)
-        return { totalExperiments: 0, improvements: 0, successRate: "0%", bestBpb: null, categories: {}, experiments: [], topImprovements: [] };
-    let prevBest = Infinity;
-    const experiments = [];
-    const categories = {};
-    let bestBpb = Infinity;
-    let improvementCount = 0;
-    for (let i = 1; i < lines.length; i++) {
-        const cols = lines[i].split("\t");
-        if (cols.length < 5)
-            continue;
-        const commitHash = cols[0].trim();
-        const valBpb = parseFloat(cols[1].trim());
-        if (isNaN(valBpb))
-            continue;
-        const peakVramMb = parseFloat(cols[2].trim()) || 0;
-        const status = cols[3].trim();
-        const description = cols[4].trim();
-        const improvement = prevBest < Infinity ? valBpb - prevBest : null;
-        const isImprovement = improvement !== null && improvement < 0;
-        const category = classifyAutoresearchCategory(description);
-        experiments.push({ commit: commitHash.slice(0, 8), valBpb, peakVramMb, status, description, category, improvement, isImprovement });
-        if (isImprovement) {
-            improvementCount++;
-            prevBest = valBpb;
-        }
-        else if (prevBest === Infinity && status === "baseline") {
-            prevBest = valBpb;
-        }
-        if (valBpb < bestBpb)
-            bestBpb = valBpb;
-        categories[category] = (categories[category] || 0) + 1;
-    }
-    let filtered = experiments;
-    if (sinceCommit) {
-        const idx = filtered.findIndex((e) => e.commit.startsWith(sinceCommit));
-        if (idx >= 0)
-            filtered = filtered.slice(idx + 1);
-    }
-    const improvements = filtered.filter((e) => e.isImprovement);
-    return {
-        totalExperiments: experiments.length, improvements: improvementCount,
-        successRate: `${(experiments.length > 0 ? (improvementCount / experiments.length) * 100 : 0).toFixed(1)}%`,
-        bestBpb: bestBpb === Infinity ? null : bestBpb, categories,
-        experiments: filtered,
-        topImprovements: improvements.sort((a, b) => a.valBpb - b.valBpb).slice(0, 5).map((e) => ({
-            commit: e.commit, valBpb: e.valBpb, delta: e.improvement, description: e.description, category: e.category,
-        })),
-    };
-}
+import { NookplotRuntime, AutonomousAgent, formatActionsForPrompt, getAvailableActionsFromMap, getCategoryListing, getToolsInCategory } from "@nookplot/runtime";
 // ── Constants ─────────────────────────────────────────────────
 const NOOKPLOT_DIR = join(homedir(), ".nookplot");
 const EVENTS_FILE = join(NOOKPLOT_DIR, "events.jsonl");
@@ -482,2583 +373,71 @@ async function callAgentCli(cliBinary, trigger, log) {
     });
 }
 // ── Available actions ─────────────────────────────────────────
+/** Session state: dynamically loaded tool categories via browse_tools. */
+const loadedCategories = new Set();
 export function getAvailableActions(signalType) {
-    return filterByProfile(_getAvailableActionsRaw(signalType));
-}
-/** Raw action lists per signal type (before profile filtering). */
-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 "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 "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 "xmtp_message":
-            return ["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 "guild_opportunity":
-            return ["join_guild", "approve_guild", "reject_guild", "leave_guild", "propose_guild", "link_project_to_guild", "reply", "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 agent action ──────────────────────────────────────
-/** 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}`);
-}
 export async function executeAgentAction(runtime, action, signal, log) {
     const target = action.to || signal.senderAddress || "";
     const content = action.content || "";
     const channelId = action.channelId || signal.channelId || "";
     try {
-        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_back":
-            case "follow":
-            case "follow_agent":
-                if (target)
-                    await runtime.social.follow(target);
-                break;
-            case "attest_back":
-            case "attest":
-            case "attest_agent":
-                if (target)
-                    await runtime.social.attest(target, action.reason || "Valued collaborator");
-                break;
-            case "endorse_agent":
-            case "endorse":
-                if (target) {
-                    await runtime.social.endorse(target, action.skill || "collaboration", action.rating || 3, action.context || undefined);
-                }
-                break;
-            case "revoke_endorsement":
-                if (target) {
-                    await runtime.social.revokeEndorsement(target, action.skill || "collaboration");
-                }
-                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":
-            case "review_commit":
-            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": {
-                const projId2 = (action.projectId || signal.projectId);
-                const commitId2 = (action.commitId || signal.commitId);
-                if (projId2 && commitId2) {
-                    const aiResult = await runtime.projects.requestAIReview(projId2, commitId2);
-                    log(`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 "grant": {
-                const projId = (action.projectId || signal.projectId);
-                const bId = (action.bountyId || signal.bountyId);
-                const reqAddr = (signal.senderAddress || target);
-                if (projId && bId) {
-                    await runtime.connection.request("POST", `/v1/projects/${projId}/bounties/${bId}/grant-access`, { requesterAddress: reqAddr });
-                    log(`[reactive] Granted bounty access for ${reqAddr?.slice(0, 10)}... on ${projId}`);
-                }
-                break;
-            }
-            case "deny": {
-                const projId = (action.projectId || signal.projectId);
-                const bId = (action.bountyId || signal.bountyId);
-                const reqAddr = (signal.senderAddress || target);
-                if (projId && bId) {
-                    await runtime.connection.request("POST", `/v1/projects/${projId}/bounties/${bId}/deny-access`, { requesterAddress: reqAddr });
-                    log(`[reactive] Denied bounty access for ${reqAddr?.slice(0, 10)}... on ${projId}`);
-                }
-                break;
-            }
-            case "claim":
-            case "claim_bounty": {
-                const rawBountyId = action.bountyId || signal.bountyId;
-                if (rawBountyId) {
-                    const bountyId = validateId(rawBountyId, "bountyId");
-                    const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/claim`, {});
-                    log(`[reactive] Bounty claimed: ${bountyId} (tx: ${relay.txHash})`);
-                }
-                else {
-                    log(`[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 relay = await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${bountyId}/approve-claimer`, { claimer });
-                    log(`[reactive] Bounty claimer approved: ${bountyId} → ${claimer} (tx: ${relay.txHash})`);
-                }
-                else {
-                    log(`[reactive] approve_bounty_claimer requires bountyId and claimer`);
-                }
-                break;
-            }
-            case "apply_bounty": {
-                const bountyId = validateId(action.bountyId || signal.bountyId, "bountyId");
-                const applyMsg = content || action.message || "";
-                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 });
-                log(`[reactive] Applied to bounty: ${bountyId}`);
-                break;
-            }
-            case "submit_bounty_work": {
-                const bountyId = validateId(action.bountyId || signal.bountyId, "bountyId");
-                if (content) {
-                    const cids = (action.deliverableCids ?? []);
-                    await runtime.connection.request("POST", `/v1/bounties/${bountyId}/submissions`, { content, deliverableCids: cids });
-                    log(`[reactive] Submitted work for bounty: ${bountyId}`);
-                }
-                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`, {});
-                log(`[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`, {});
-                log(`[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`, {});
-                log(`[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 });
-                        log(`[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) {
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/community", { slug, name, description: desc });
-                    log(`[reactive] Community created: ${slug} (tx: ${relay.txHash})`);
-                }
-                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) {
-                    const discovery = await runtime.connection.request("POST", "/v1/projects/discover", { name: projName, description: projDesc });
-                    const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/project", {
-                        discoveryId: discovery.discoveryId,
-                        projectId: projId, name: projName, description: projDesc,
-                    });
-                    log(`[reactive] Project created: ${projId} (tx: ${relay.txHash})`);
-                }
-                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) {
-                    const files = await runtime.projects.listFiles(projId);
-                    log(`[reactive] Listed ${files.length} files in project ${projId}`);
-                }
-                break;
-            }
-            case "read_project_file": {
-                const projId = (action.projectId || signal.projectId);
-                const filePath = action.filePath;
-                if (projId && filePath) {
-                    const fileContent = await runtime.projects.readFile(projId, filePath);
-                    log(`[reactive] Read file ${filePath} from project ${projId}`);
-                }
-                break;
-            }
-            case "list_commits": {
-                const projId = (action.projectId || signal.projectId);
-                if (projId) {
-                    const limit = action.limit ?? 20;
-                    const offset = action.offset ?? 0;
-                    const commits = await runtime.projects.listCommits(projId, limit, offset);
-                    log(`[reactive] Listed ${commits.length} commits in project ${projId}`);
-                }
-                break;
-            }
-            case "get_commit_detail": {
-                const projId = (action.projectId || signal.projectId);
-                const commitId = action.commitId;
-                if (projId && commitId) {
-                    const commit = await runtime.projects.getCommit(projId, commitId);
-                    log(`[reactive] Got commit detail ${commitId} from project ${projId}`);
-                }
-                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) {
-                    await runtime.guilds.linkProject(Number(gId), projId2);
-                    await runtime.projects.setGuildAttribution(projId2, String(gId));
-                    // 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 */ }
-                        }
-                    }
-                    log(`[reactive] Linked project ${projId2} to guild ${gId}`);
-                }
-                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 });
-                    log(`[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`, {});
-                    log(`[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`, {});
-                    log(`[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`, {});
-                    log(`[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 projId = (action.projectId || signal.projectId);
-                const channelSlug = projId ? `project-${projId}` : "";
-                if (channelSlug) {
-                    await runtime.channels.send(channelSlug, content || "Accepted the task — I'll get started.");
-                }
-                break;
-            }
-            case "acknowledge": {
-                const projId = (action.projectId || signal.projectId);
-                const channelSlug = projId ? `project-${projId}` : "";
-                if (channelSlug) {
-                    await runtime.channels.send(channelSlug, content || "Got it, thanks for the mention!");
-                }
-                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 });
-                    log(`[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,
-                    });
-                    log(`[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);
-                    log(`[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,
-                    });
-                    log(`[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);
-                    log(`[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);
-                    log(`[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);
-                    log(`[reactive] Closed MR ${mrId}`);
-                }
-                break;
-            }
-            case "claim_reward": {
-                const pool = action.pool || "nook";
-                const relay = await prepareSignRelay(runtime.connection, "/v1/prepare/reward/claim", { pool });
-                log(`[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,
-                    });
-                    log(`[reactive] Task created in ${projId}: ${title}`);
-                }
-                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);
-                    log(`[reactive] Assigned task ${tid} in ${projId} 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);
-                    log(`[reactive] Task ${action.action === "complete_task" ? "completed" : "updated"}: ${tid}`);
-                }
-                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,
-                    });
-                    log(`[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,
-                    });
-                    log(`[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}`, {});
-                    log(`[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 } : {}),
-                    });
-                    log(`[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 } : {}),
-                    });
-                    log(`[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,
-                    });
-                    log(`[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,
-                    });
-                    log(`[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,
-                    });
-                    log(`[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,
-                    });
-                    log(`[reactive] Cancelled agreement #${agId} (tx: ${relay.txHash})`);
-                }
-                break;
-            }
-            case "submit_review": {
-                const agId = action.agreementId;
-                const rating = action.rating;
-                const reviewComment = (content || action.comment || "");
-                if (agId != null && rating != null) {
-                    await runtime.marketplace.submitReview(agId, rating, reviewComment);
-                    log(`[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);
-                    log(`[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,
-                });
-                log(`[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,
-                });
-                log(`[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,
-                });
-                log(`[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`, {});
-                log(`[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`, {});
-                log(`[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`, {});
-                log(`[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`, {});
-                log(`[reactive] Unclaimed bounty: ${bountyId} (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,
-                    });
-                    log(`[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,
-                    });
-                    log(`[reactive] Expired delivered for agreement #${agId} (tx: ${relay.txHash})`);
-                }
-                break;
-            }
-            case "workspace_create": {
-                const wsName = (action.name || content);
-                if (wsName) {
-                    const ws = await runtime.workspaces.create({ name: wsName, description: action.description });
-                    log(`[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);
-                    log(`[reactive] Set ${wsKey} in workspace ${wsId}`);
-                }
-                break;
-            }
-            case "workspace_snapshot": {
-                const wsId = action.workspaceId;
-                if (wsId) {
-                    await runtime.workspaces.createSnapshot(wsId, action.label);
-                    log(`[reactive] Created snapshot in workspace ${wsId}`);
-                }
-                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,
-                    });
-                    log(`[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);
-                    log(`[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);
-                    log(`[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,
-                });
-                log(`[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);
-                log(`[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 });
-                log(`[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);
-                log(`[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);
-                log(`[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);
-                log(`[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,
-                });
-                log(`[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,
-                    });
-                    log(`[reactive] Published insight: ${title}`);
-                }
-                break;
-            }
-            case "cite_insight": {
-                const insightId = action.insightId;
-                if (insightId) {
-                    await runtime.insights?.cite(insightId, action.context, action.outcomeScore);
-                    log(`[reactive] Cited insight ${insightId}`);
-                }
-                break;
-            }
-            case "apply_insight": {
-                const insightId = action.insightId;
-                if (insightId) {
-                    await runtime.insights?.apply(insightId, action.context, action.outcomeScore);
-                    log(`[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);
-                    log(`[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);
-                    log(`[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);
-                    log(`[reactive] Funded bounty ${bountyId} with ${amount} from guild ${guildId} treasury`);
-                }
-                break;
-            }
-            case "distribute_revenue": {
-                const guildId = action.guildId;
-                if (guildId) {
-                    await runtime.guilds.distributeRevenue(guildId, action.amount);
-                    log(`[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 });
-                    log(`[reactive] Created swarm: ${action.title}`);
-                }
-                break;
-            }
-            case "claim_subtask": {
-                const stId = action.subtaskId;
-                if (stId) {
-                    await runtime.swarms?.claimSubtask(stId);
-                    log(`[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);
-                    log(`[reactive] Submitted result for subtask ${stId}`);
-                }
-                break;
-            }
-            case "aggregate_swarm": {
-                const swarmId = action.swarmId;
-                if (swarmId) {
-                    await runtime.swarms?.aggregate(swarmId, action.summary);
-                    log(`[reactive] Aggregated swarm ${swarmId}`);
-                }
-                break;
-            }
-            case "record_gap": {
-                if (action.queryText) {
-                    await runtime.specialization?.recordGap({ queryText: action.queryText, queryTags: action.queryTags || [], communityId: action.communityId });
-                    log(`[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));
-                    log(`[reactive] Updated proficiency: ${domain}`);
-                }
-                break;
-            }
-            case "generate_recommendations": {
-                await runtime.specialization?.generateRecommendations();
-                log(`[reactive] Generated specialization recommendations`);
-                break;
-            }
-            case "dismiss_recommendation": {
-                const recId = action.recommendationId;
-                if (recId) {
-                    await runtime.specialization?.dismissRecommendation(recId);
-                    log(`[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,
-                });
-                log(`[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,
-                });
-                log(`[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,
-                    });
-                    log(`[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);
-                    log(`[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);
-                    log(`[reactive] Rejected proposal ${rpProposalId}`);
-                }
-                break;
-            }
-            case "cancel_intent": {
-                const ciId = action.intentId;
-                if (ciId) {
-                    await runtime.intents.cancel(ciId);
-                    log(`[reactive] Cancelled intent ${ciId}`);
-                }
-                break;
-            }
-            case "complete_intent": {
-                const coiId = action.intentId;
-                if (coiId) {
-                    await runtime.intents.complete(coiId);
-                    log(`[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);
-                    log(`[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 (oracleRes)
-                        log(`[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,
-                });
-                log(`[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 });
-                log(`[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;
-                log(`[reactive] Launched token ${tokenAddr?.token_address ?? "pending"}`);
-                break;
-            }
-            case "claim_clawnch_fees": {
-                const claimAddr = action.tokenAddress;
-                if (claimAddr) {
-                    const claimRes = await runtime.connection.request("POST", "/v1/clawnch/claim-fees", { tokenAddress: claimAddr });
-                    log(`[reactive] Claimed fees for ${claimAddr.slice(0, 10)}...`);
-                }
-                break;
-            }
-            case "get_token_analytics": {
-                const analyticsAddr = action.tokenAddress;
-                if (analyticsAddr) {
-                    const analyticsRes = await runtime.connection.request("GET", `/v1/clawnch/analytics/token/${analyticsAddr}`);
-                    log(`[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 });
-                log(`[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 });
-                log(`[reactive] Replied to email ${msgId.slice(0, 10)}...`);
-                break;
-            }
-            case "check_email": {
-                await runtime.connection.request("GET", "/v1/email/messages?direction=inbound&limit=10");
-                log(`[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 });
-                log(`[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()}`);
-                log(`[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",
-                });
-                log(`[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`);
-                log(`[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,
-                });
-                log(`[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}`);
-                log(`[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,
-                });
-                log(`[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,
-                });
-                log(`[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()}`);
-                log(`[reactive] Listed memories`);
-                break;
-            }
-            case "memory_stats": {
-                await runtime.connection.request("GET", "/v1/agent-memory/stats");
-                log(`[reactive] Fetched memory stats`);
-                break;
-            }
-            case "export_memories": {
-                await runtime.connection.request("POST", "/v1/agent-memory/export");
-                log(`[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);
-                log(`[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 relay = await prepareSignRelay(runtime.connection, "/v1/prepare/forge", {
-                    bundleId: forgeBundleId, agentAddress: forgeAgentAddr, soulCid: forgeSoulCid, deploymentFee: action.deploymentFee,
-                });
-                log(`[reactive] Forge deployed: ${forgeBundleId} (tx: ${relay.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 relay = await prepareSignRelay(runtime.connection, "/v1/prepare/forge/spawn", {
-                    bundleId: spawnBundleId, childAddress, soulCid: spawnSoulCid, deploymentFee: action.deploymentFee,
-                });
-                log(`[reactive] Forge spawned child: ${childAddress} (tx: ${relay.txHash})`);
-                break;
-            }
-            case "forge_update_soul": {
-                const agentId = action.agentId || action.forgeId;
-                if (!agentId)
-                    throw new Error("forge_update_soul requires agentId");
-                const relay = await prepareSignRelay(runtime.connection, `/v1/prepare/forge/${agentId}/soul`, {
-                    soulCid: action.soulCid, metadata: action.metadata,
-                });
-                log(`[reactive] Forge soul updated: ${agentId} (tx: ${relay.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,
-                });
-                log(`[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,
-                });
-                log(`[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,
-                });
-                log(`[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,
-                });
-                log(`[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,
-                });
-                log(`[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);
-                log(`[reactive] GPU attestation updated (tx: ${result.txHash})`);
-                break;
-            }
-            case "gpu_revoke_attestation": {
-                const result = await runtime.gpu.revokeAttestation();
-                log(`[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,
-                });
-                log(`[reactive] GPU rented: listing ${listingId} (tx: ${result.txHash})`);
-                break;
-            }
-            // ── Autoresearch tools ─────────────────────────────────────
-            case "autoresearch_strategies": {
-                const strategy = action.strategy;
-                if (strategy) {
-                    const s = AUTORESEARCH_STRATEGIES[strategy];
-                    if (!s)
-                        throw new Error(`Unknown strategy '${strategy}'. Available: ${Object.keys(AUTORESEARCH_STRATEGIES).join(", ")}`);
-                    log(`[reactive] Autoresearch strategy: ${s.title}`);
-                }
-                else {
-                    log(`[reactive] Listed ${Object.keys(AUTORESEARCH_STRATEGIES).length} autoresearch strategies`);
-                }
-                break;
-            }
-            case "autoresearch_parse": {
-                const tsv = action.tsvContent;
-                if (!tsv)
-                    throw new Error("autoresearch_parse requires tsvContent");
-                const parsed = parseAutoresearchTsv(tsv, action.sinceCommit);
-                log(`[reactive] Parsed autoresearch: ${parsed.totalExperiments} experiments`);
-                break;
-            }
-            case "autoresearch_launch_swarm": {
-                const strategyName = action.strategy || "full_sweep";
-                const config = AUTORESEARCH_STRATEGIES[strategyName];
-                if (!config)
-                    throw new Error(`Unknown strategy '${strategyName}'`);
-                const swarmTitle = action.customTitle || `Autoresearch: ${config.title}`;
-                await runtime.connection.request("POST", "/v1/swarms", {
-                    title: swarmTitle, description: config.description,
-                    workspaceId: action.workspaceId, subtasks: config.subtasks,
-                });
-                log(`[reactive] Launched autoresearch swarm: ${swarmTitle}`);
-                break;
-            }
-            case "autoresearch_report": {
-                const experiments = action.experiments;
-                if (!experiments?.length)
-                    throw new Error("autoresearch_report requires experiments");
-                let memoriesStored = 0;
-                let postsCreated = 0;
-                for (const exp of experiments) {
-                    const memContent = `Experiment [${exp.commit}]: ${exp.description}. val_bpb=${exp.valBpb}` +
-                        (exp.improvement != null ? ` (${exp.improvement > 0 ? "+" : ""}${exp.improvement.toFixed(6)})` : "") +
-                        ` — ${exp.isImprovement ? "improved" : "no improvement"}. ${exp.category}. ${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",
-                        });
-                        memoriesStored++;
-                    }
-                    catch { }
-                    if (exp.isImprovement) {
-                        try {
-                            await prepareSignRelay(runtime.connection, "/v1/prepare/post", {
-                                title: `Autoresearch: ${exp.description}`,
-                                body: `## Finding: ${exp.description}\n\n**val_bpb:** ${exp.valBpb}\n**Category:** ${exp.category}\n**VRAM:** ${exp.peakVramMb} MB`,
-                                tags: ["autoresearch", exp.category, "ml-research"],
-                                community: action.communityId || "general",
-                            });
-                            postsCreated++;
-                        }
-                        catch { }
-                    }
-                }
-                log(`[reactive] Autoresearch report: ${memoriesStored} memories, ${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;
-                await runtime.connection.request("POST", `/v1/swarms/subtasks/${encodeURIComponent(subtaskId)}/submit`, {
-                    content: {
-                        total_experiments: action.totalExperiments || exps.length,
-                        improvements_found: action.improvements || improvementExps.length,
-                        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 } }),
-                    },
-                    resultType: "output",
-                });
-                log(`[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) {
-                    log("[reactive] 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 experiments. Best val_bpb: ${bestBpb.toFixed(6)}.`,
-                    tags: ["autoresearch", "ml-training", "llm", ...(action.tags || [])],
-                    experiments: bundleExps.map((e) => ({ commit: e.commit, val_bpb: e.valBpb, description: e.description, category: e.category })),
-                };
-                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 {
-                    await prepareSignRelay(runtime.connection, "/v1/prepare/bundle", {
-                        name: bundleTitle, description: payload.description, cids: [String(resourceId)],
-                        tags: payload.tags, domain: "machine-learning",
-                    });
-                    log(`[reactive] Published autoresearch bundle: ${bundleTitle}`);
-                }
-                catch (e) {
-                    log(`[reactive] Bundle content uploaded but on-chain failed: ${e.message}`);
-                }
-                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: ${totalExp} experiments, ${action.improvements || 0} improvements (${successRate}%). Best val_bpb: ${bestBpbVal.toFixed(6)}.`;
-                await runtime.connection.request("POST", "/v1/agent-memory/store", {
-                    type: "semantic", content: summaryContent, importance: 0.9,
-                    tags: ["autoresearch", "session-summary", "ml-research"], source: "autoresearch",
-                });
-                log(`[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));
-                await runtime.connection.request("GET", `/v1/index/feed?${qs}`);
-                log("[reactive] Read feed");
-                break;
-            }
-            case "check_balance": {
-                await runtime.connection.request("GET", "/v1/credits/balance");
-                log("[reactive] Checked balance");
-                break;
-            }
-            case "check_reputation": {
-                const addr = (action.address || target);
-                if (!addr)
-                    throw new Error("check_reputation requires address");
-                await runtime.connection.request("GET", `/v1/contributions/${encodeURIComponent(addr)}`);
-                log("[reactive] Checked reputation");
-                break;
-            }
-            case "check_token_balance": {
-                await runtime.connection.request("GET", "/v1/token/balance");
-                log("[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");
-                await runtime.connection.request("GET", `/v1/token/allowance?tokenAddress=${encodeURIComponent(tokenAddr)}&spenderAddress=${encodeURIComponent(spenderAddr)}`);
-                log("[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));
-                await runtime.connection.request("GET", `/v1/search?${dq}`);
-                log("[reactive] Discovered content");
-                break;
-            }
-            case "get_bounty": {
-                const bId = (action.id || action.bountyId);
-                if (!bId)
-                    throw new Error("get_bounty requires id");
-                await runtime.connection.request("GET", `/v1/bounties/${encodeURIComponent(bId)}`);
-                log(`[reactive] Got bounty ${bId}`);
-                break;
-            }
-            case "get_comments": {
-                const cid = action.cid;
-                if (!cid)
-                    throw new Error("get_comments requires cid");
-                await runtime.connection.request("GET", `/v1/index/content/${encodeURIComponent(cid)}/comments`);
-                log("[reactive] Got comments");
-                break;
-            }
-            case "get_content": {
-                const contentCid = action.cid;
-                if (!contentCid)
-                    throw new Error("get_content requires cid");
-                await runtime.connection.request("GET", `/v1/index/content/${encodeURIComponent(contentCid)}`);
-                log("[reactive] Got content");
-                break;
-            }
-            case "get_credentials": {
-                log(`[reactive] Credentials: ${runtime.connection.address}`);
-                break;
-            }
-            case "get_email_inbox": {
-                await runtime.connection.request("GET", "/v1/email/inbox");
-                log("[reactive] Got email inbox");
-                break;
-            }
-            case "get_pending_signals": {
-                await runtime.connection.request("GET", "/v1/proactive/approvals");
-                log("[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");
-                await runtime.connection.request("GET", `/v1/projects/${encodeURIComponent(projId)}/commits/${encodeURIComponent(commitId)}`);
-                log(`[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");
-                await runtime.connection.request("POST", "/v1/insights", { title: `Question: ${question.slice(0, 80)}`, body: question, strategyType: "question", tags: ["second-opinion"] });
-                log("[reactive] Posted question");
-                break;
-            }
-            case "get_swarm": {
-                const swarmId = action.swarmId;
-                if (!swarmId)
-                    throw new Error("get_swarm requires swarmId");
-                await runtime.connection.request("GET", `/v1/swarms/${encodeURIComponent(swarmId)}`);
-                log(`[reactive] Got swarm ${swarmId}`);
-                break;
-            }
-            case "get_workspace": {
-                const wsId = action.workspaceId;
-                if (!wsId)
-                    throw new Error("get_workspace requires workspaceId");
-                await runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(wsId)}`);
-                log(`[reactive] Got workspace ${wsId}`);
-                break;
-            }
-            case "leaderboard": {
-                const lqs = new URLSearchParams();
-                if (action.limit)
-                    lqs.set("limit", String(action.limit));
-                await runtime.connection.request("GET", `/v1/contributions/leaderboard?${lqs}`);
-                log("[reactive] Got leaderboard");
-                break;
-            }
-            case "lookup_agent": {
-                const lookupAddr = (action.address || target);
-                if (!lookupAddr)
-                    throw new Error("lookup_agent requires address");
-                await runtime.connection.request("GET", `/v1/agents/${encodeURIComponent(lookupAddr)}/profile`);
-                log(`[reactive] Looked up agent`);
-                break;
-            }
-            case "my_profile": {
-                await runtime.connection.request("GET", "/v1/agents/me");
-                log("[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));
-                await runtime.connection.request("GET", `/v1/search?${skqs}`);
-                log("[reactive] Searched knowledge");
-                break;
-            }
-            case "weekly_reward_info": {
-                await runtime.connection.request("GET", "/v1/rewards/weekly/current");
-                log("[reactive] Got weekly reward info");
-                break;
-            }
-            case "check_my_rewards": {
-                await runtime.connection.request("GET", "/v1/rewards/weekly/me");
-                log("[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));
-                await runtime.connection.request("GET", `/v1/index/bounties?${lbqs}`);
-                log("[reactive] Listed bounties");
-                break;
-            }
-            case "list_channels": {
-                await runtime.connection.request("GET", "/v1/channels");
-                log("[reactive] Listed channels");
-                break;
-            }
-            case "list_communities": {
-                await runtime.connection.request("GET", "/v1/index/communities");
-                log("[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);
-                await runtime.connection.request("GET", `/v1/marketplace/credit-agreements?${lcaqs}`);
-                log("[reactive] Listed credit agreements");
-                break;
-            }
-            case "list_guilds": {
-                await runtime.connection.request("GET", "/v1/index/guilds");
-                log("[reactive] Listed guilds");
-                break;
-            }
-            case "list_intents": {
-                const liqs = new URLSearchParams();
-                if (action.query)
-                    liqs.set("query", action.query);
-                if (action.status)
-                    liqs.set("status", action.status);
-                await runtime.connection.request("GET", `/v1/intents?${liqs}`);
-                log("[reactive] Listed intents");
-                break;
-            }
-            case "list_muted": {
-                await runtime.connection.request("GET", "/v1/agents/muted");
-                log("[reactive] Listed muted agents");
-                break;
-            }
-            case "list_project_commits": {
-                const pId = action.projectId;
-                if (!pId)
-                    throw new Error("list_project_commits requires projectId");
-                await runtime.connection.request("GET", `/v1/projects/${encodeURIComponent(pId)}/commits`);
-                log(`[reactive] Listed commits for ${pId}`);
-                break;
-            }
-            case "list_projects": {
-                const lpqs = new URLSearchParams();
-                if (action.query)
-                    lpqs.set("q", action.query);
-                await runtime.connection.request("GET", `/v1/search/projects?${lpqs}`);
-                log("[reactive] Listed projects");
-                break;
-            }
-            case "list_proposals": {
-                const wId = action.workspaceId;
-                if (!wId)
-                    throw new Error("list_proposals requires workspaceId");
-                await runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(wId)}/proposals`);
-                log("[reactive] Listed proposals");
-                break;
-            }
-            case "list_services": {
-                await runtime.connection.request("GET", "/v1/index/services");
-                log("[reactive] Listed services");
-                break;
-            }
-            case "list_swarms": {
-                await runtime.connection.request("GET", "/v1/swarms");
-                log("[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);
-                await runtime.connection.request("GET", `/v1/teaching/exchanges?${lteqs}`);
-                log("[reactive] Listed teaching exchanges");
-                break;
-            }
-            case "list_token_launches": {
-                await runtime.connection.request("GET", "/v1/clawnch/launches");
-                log("[reactive] Listed token launches");
-                break;
-            }
-            case "list_workspaces": {
-                await runtime.connection.request("GET", "/v1/workspaces");
-                log("[reactive] Listed workspaces");
-                break;
-            }
-            case "my_agreements": {
-                await runtime.connection.request("GET", "/v1/marketplace/agreements");
-                log("[reactive] Got my agreements");
-                break;
-            }
-            case "my_bounties": {
-                await runtime.connection.request("GET", "/v1/index/bounties?mine=true");
-                log("[reactive] Got my bounties");
-                break;
-            }
-            case "my_skills": {
-                await runtime.connection.request("GET", `/v1/skills/registry?publisherId=${encodeURIComponent(runtime.connection.address || "")}`);
-                log("[reactive] Got my skills");
-                break;
-            }
-            case "my_tasks": {
-                await runtime.connection.request("GET", "/v1/swarms/subtasks?mine=true");
-                log("[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);
-                await runtime.connection.request("GET", `/v1/swarms/subtasks?${asqs}`);
-                log("[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");
-                await runtime.connection.request("POST", "/v1/swarms", {
-                    title: dtTitle, description: dtDesc,
-                    subtasks: [{ title: dtTitle, description: dtDesc, skillTags: action.skills || [] }],
-                });
-                log(`[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");
-                await runtime.connection.request("POST", "/v1/agent-memory/store", {
-                    type: "semantic", content: `${slTitle}: ${slBody}`, importance: 0.7,
-                    tags: ["learning", ...(action.tags || [])], source: "self",
-                });
-                log(`[reactive] Saved learning: ${slTitle}`);
-                break;
-            }
-            case "recall": {
-                const recallQuery = action.query;
-                if (!recallQuery)
-                    throw new Error("recall requires query");
-                await runtime.connection.request("POST", "/v1/agent-memory/recall", { query: recallQuery, limit: action.limit || 10 });
-                log("[reactive] Recalled memories");
-                break;
-            }
-            case "save_checkpoint": {
-                const cpTask = action.task;
-                if (!cpTask)
-                    throw new Error("save_checkpoint requires task");
-                await runtime.connection.request("POST", "/v1/agent-memory/store", {
-                    type: "episodic", content: `CHECKPOINT: ${cpTask} | Progress: ${action.progress || 0}%`,
-                    importance: 0.85, tags: ["checkpoint", "work-state"], source: "self",
-                });
-                log(`[reactive] Saved checkpoint: ${cpTask}`);
-                break;
-            }
-            case "resume_checkpoint": {
-                await runtime.connection.request("POST", "/v1/agent-memory/recall", { query: "CHECKPOINT work state progress", type: "episodic", limit: 1 });
-                log("[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");
-                await runtime.connection.request("POST", "/v1/insights", { title: rvTitle, body: rvContent, strategyType: action.reviewType || "code", tags: ["review-request"] });
-                log(`[reactive] Requested review: ${rvTitle}`);
-                break;
-            }
-            case "ask_network": {
-                const askQ = action.question;
-                if (!askQ)
-                    throw new Error("ask_network requires question");
-                await runtime.connection.request("POST", "/v1/insights", { title: `Question: ${askQ.slice(0, 80)}`, body: askQ, strategyType: "question", tags: ["network-question"] });
-                log("[reactive] Asked network");
-                break;
-            }
-            case "check_delegation": {
-                const delBountyId = action.bountyId;
-                if (!delBountyId)
-                    throw new Error("check_delegation requires bountyId");
-                await runtime.connection.request("GET", `/v1/swarms/${encodeURIComponent(delBountyId)}`);
-                log(`[reactive] Checked delegation ${delBountyId}`);
-                break;
-            }
-            // ── On-chain tools ─────────────────────────────────────────
-            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");
-                await prepareSignRelay(runtime.connection, "/v1/prepare/comment", { parentCid, body: commentBody, community: action.community });
-                log(`[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");
-                await prepareSignRelay(runtime.connection, "/v1/prepare/unfollow", { address: unfAddr });
-                log(`[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");
-                await prepareSignRelay(runtime.connection, `/v1/prepare/bounty/${encodeURIComponent(abId)}/approve-claimer`, { applicantAddress: applicantAddr });
-                log(`[reactive] Approved bounty applicant`);
-                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");
-                await prepareSignRelay(runtime.connection, "/v1/prepare/service/list", { title: slsTitle, description: slsDesc, category: slsCat, tags: action.tags });
-                log(`[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");
-                await prepareSignRelay(runtime.connection, "/v1/prepare/service/agree", { listingId: listingId2, requirements, budget: action.budget });
-                log(`[reactive] Hired agent via listing ${listingId2}`);
-                break;
-            }
-            case "accept_service": {
-                const agreeId = action.agreementId;
-                if (!agreeId)
-                    throw new Error("accept_service requires agreementId");
-                await runtime.connection.request("POST", `/v1/marketplace/agreements/${encodeURIComponent(agreeId)}/accept`, {});
-                log(`[reactive] Accepted service agreement`);
-                break;
-            }
-            case "dispute_service": {
-                const dAgreeId = action.agreementId;
-                if (!dAgreeId)
-                    throw new Error("dispute_service requires agreementId");
-                await prepareSignRelay(runtime.connection, "/v1/prepare/service/dispute", { agreementId: dAgreeId, reason: action.reason });
-                log(`[reactive] Disputed service ${dAgreeId}`);
-                break;
-            }
-            case "cancel_service": {
-                const cAgreeId = action.agreementId;
-                if (!cAgreeId)
-                    throw new Error("cancel_service requires agreementId");
-                await prepareSignRelay(runtime.connection, "/v1/prepare/service/cancel", { agreementId: cAgreeId });
-                log(`[reactive] Cancelled service ${cAgreeId}`);
-                break;
-            }
-            case "approve_token": {
-                const tokenAddr2 = action.tokenAddress;
-                const spenderAddr2 = action.spenderAddress;
-                if (!tokenAddr2 || !spenderAddr2)
-                    throw new Error("approve_token requires tokenAddress and spenderAddress");
-                await runtime.connection.request("POST", "/v1/token/approve", { tokenAddress: tokenAddr2, spenderAddress: spenderAddr2, amount: action.amount || "max" });
-                log("[reactive] Approved token spending");
-                break;
-            }
-            // ── Proactive/signal tools ─────────────────────────────────
-            case "poll_signals": {
-                await runtime.connection.request("GET", "/v1/proactive/pending-signals");
-                log("[reactive] Polled signals");
-                break;
-            }
-            case "ack_signal": {
-                const sigId = action.signalId;
-                if (!sigId)
-                    throw new Error("ack_signal requires signalId");
-                await runtime.connection.request("POST", `/v1/proactive/signals/${encodeURIComponent(sigId)}/ack`, {});
-                log(`[reactive] Acknowledged signal ${sigId}`);
-                break;
-            }
-            case "approve_action": {
-                const actId = action.actionId;
-                if (!actId)
-                    throw new Error("approve_action requires actionId");
-                await runtime.connection.request("POST", `/v1/proactive/approvals/${encodeURIComponent(actId)}/approve`, {});
-                log(`[reactive] Approved action ${actId}`);
-                break;
-            }
-            case "reject_action": {
-                const rejActId = action.actionId;
-                if (!rejActId)
-                    throw new Error("reject_action requires actionId");
-                await runtime.connection.request("POST", `/v1/proactive/approvals/${encodeURIComponent(rejActId)}/reject`, { reason: action.reason });
-                log(`[reactive] Rejected action ${rejActId}`);
-                break;
-            }
-            case "configure_proactive": {
-                await runtime.connection.request("PUT", "/v1/proactive/settings", {
-                    enabled: action.enabled, scanIntervalMinutes: action.scanIntervalMinutes,
-                    maxActionsPerDay: action.maxActionsPerDay, callbackFormat: action.callbackFormat,
-                });
-                log("[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 { }
-                await runtime.connection.request("POST", `/v1/channels/${encodeURIComponent(chId)}/messages`, { content: chContent });
-                log("[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);
-                await runtime.connection.request("GET", `/v1/channels/${encodeURIComponent(rcmChId)}/messages?${rcmqs}`);
-                log("[reactive] Read channel messages");
-                break;
-            }
-            case "mute_agent": {
-                const muteAddr = (action.address || target);
-                if (!muteAddr)
-                    throw new Error("mute_agent requires address");
-                await runtime.connection.request("POST", `/v1/agents/${encodeURIComponent(muteAddr)}/mute`, {});
-                log(`[reactive] Muted ${muteAddr.slice(0, 10)}...`);
-                break;
-            }
-            case "unmute_agent": {
-                const unmuteAddr = (action.address || target);
-                if (!unmuteAddr)
-                    throw new Error("unmute_agent requires address");
-                await runtime.connection.request("DELETE", `/v1/agents/${encodeURIComponent(unmuteAddr)}/mute`);
-                log(`[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");
-                await runtime.connection.request("POST", `/v1/content/${encodeURIComponent(reportCid)}/report`, { reason: reportReason, details: action.details });
-                log("[reactive] Reported content");
-                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");
-                await runtime.connection.request("POST", `/v1/projects/${encodeURIComponent(impProjId)}/import-url`, { url: impUrl, branch: action.branch, subdir: action.subdir });
-                log(`[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");
-                await runtime.connection.request("POST", `/v1/bounties/${encodeURIComponent(msBountyId)}/submissions/${encodeURIComponent(msSubId)}/match-spec`, {});
-                log("[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");
-                await runtime.connection.request("POST", `/v1/bounties/${encodeURIComponent(vsBountyId)}/submissions/${encodeURIComponent(vsSubId)}/verify`, { testCommand: action.testCommand });
-                log("[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");
-                await runtime.connection.request("POST", `/v1/bounties/${encodeURIComponent(rsBountyId)}/submissions/${encodeURIComponent(rsSubId)}/review`, {});
-                log("[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 || []);
-                for (const c of commits) {
-                    try {
-                        await runtime.connection.request("POST", `/v1/projects/${encodeURIComponent(rmrProjId)}/commits/${encodeURIComponent(c.id || c.commitId)}/ai-review`, {});
-                    }
-                    catch { }
-                }
-                log(`[reactive] Reviewed MR ${rmrMrId}`);
-                break;
-            }
-            case "update_profile": {
-                await runtime.connection.request("PATCH", "/v1/agents/me", { displayName: action.displayName, description: action.description, capabilities: action.capabilities });
-                log("[reactive] Updated profile");
-                break;
-            }
-            case "register": {
-                await runtime.connection.request("POST", "/v1/agents/register", { name: action.name, description: action.description });
-                log("[reactive] Registered agent");
-                break;
-            }
-            // ── Workspace tools ────────────────────────────────────────
-            case "create_workspace": {
-                const cwName = action.name;
-                if (!cwName)
-                    throw new Error("create_workspace requires name");
-                await runtime.connection.request("POST", "/v1/workspaces", { name: cwName, description: action.description });
-                log(`[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");
-                await runtime.connection.request("POST", `/v1/workspaces/${encodeURIComponent(wamWsId)}/members`, { agentId: wamAgentId, role: action.role || "editor" });
-                log("[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");
-                await runtime.connection.request("PUT", `/v1/workspaces/${encodeURIComponent(wseWsId)}/state`, { key: wseKey, value: action.value });
-                log(`[reactive] Set workspace entry: ${wseKey}`);
-                break;
-            }
-            case "workspace_get_entries": {
-                const wgeWsId = action.workspaceId;
-                if (!wgeWsId)
-                    throw new Error("workspace_get_entries requires workspaceId");
-                await runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(wgeWsId)}/state`);
-                log("[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");
-                await runtime.connection.request("POST", `/v1/workspaces/${encodeURIComponent(cpWsId)}/proposals`, { title: cpTitle, description: action.description, actionType: action.actionType, actionPayload: action.actionPayload });
-                log(`[reactive] Created proposal: ${cpTitle}`);
-                break;
-            }
-            // ── Skill/teaching/token 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");
-                await runtime.connection.request("POST", `/v1/skills/registry/${encodeURIComponent(rsSkillId)}/review`, { rating: rsRating, review: action.review });
-                log(`[reactive] Rated skill ${rsSkillId}`);
-                break;
-            }
-            case "teaching_stats": {
-                await runtime.connection.request("GET", "/v1/teaching/stats");
-                log("[reactive] Got teaching stats");
-                break;
-            }
-            case "search_teachers": {
-                const stGoal = action.goal;
-                if (!stGoal)
-                    throw new Error("search_teachers requires goal");
-                await runtime.connection.request("GET", `/v1/teaching/search-teachers?goal=${encodeURIComponent(stGoal)}`);
-                log("[reactive] Searched teachers");
-                break;
-            }
-            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");
-                await runtime.connection.request("POST", "/v1/clawnch/report-launch", { tokenName, tokenTicker, tokenAddress: tokenAddress2, description: action.description });
-                log(`[reactive] Reported token launch: ${tokenName}`);
-                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");
-                await runtime.connection.request("POST", "/v1/search/subscriptions", { label: subLabel, query: subQuery, types: action.types, frequencyMinutes: action.frequencyMinutes });
-                log(`[reactive] Created subscription: ${subLabel}`);
-                break;
-            }
-            case "ignore":
-                break;
-            default: {
-                // ── Unhandled action ─────────────────────────────────────
-                // All known tools should have explicit cases above.
-                // Log unhandled for debugging — DO NOT route through MCP.
-                log(`[reactive] Unhandled action: ${action.action}`);
-                break;
-            }
+        // ── Unified dispatch via POST /v1/actions/execute ──
+        // The gateway's ToolDispatcher routes the call to the correct internal
+        // endpoint, replacing the 2000+ line switch statement that was here before.
+        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();
+                log(`[browse_tools] Categories: ${listing.map((c) => `${c.name} (${c.count})`).join(", ")}`);
+                return;
+            }
+            loadedCategories.add(category);
+            const tools = getToolsInCategory(category);
+            log(`[browse_tools] Loaded ${tools.length} tools from "${category}"`);
+            return;
+        }
+        const toolName = `nookplot_${action.action}`;
+        const payload = { ...action };
+        delete payload.action; // toolName carries the action type
+        // Merge signal context (senderAddress, channelId) into payload
+        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": {
+                // On-chain action: sign locally + relay
+                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 });
+                log(`[reactive] On-chain tx: ${relayResult.txHash}`);
+                break;
+            }
+            case "client_side_required":
+                log(`[reactive] Client-side action required: ${dispatchResult.action}`);
+                break;
+            case "error":
+                throw new Error(dispatchResult.error ?? `Action failed: ${action.action}`);
+            default:
+                log(`[reactive] Unexpected dispatch status: ${dispatchResult.status}`);
         }
         if (action.action !== "ignore") {
             log(`[reactive] ${action.action}${target ? ` -> ${target.slice(0, 10)}...` : ""}`);