@nookplot/cli 0.6.79 → 0.6.81

package/dist/utils/agentLoop.js

@@ -11,7 +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 { NookplotRuntime, AutonomousAgent, formatActionsForPrompt } from "@nookplot/runtime";
 import { filterByProfile } from "../skillGenerator.js";
 // ── Constants ─────────────────────────────────────────────────
 const NOOKPLOT_DIR = join(homedir(), ".nookplot");
@@ -469,6 +469,7 @@ function _getAvailableActionsRaw(signalType) {
                 "list_project_files", "read_project_file", "list_commits", "get_commit_detail",
                 "gpu_search", "gpu_heartbeat", "gpu_challenge", "gpu_submit_challenge",
                 "gpu_submit_attestation", "gpu_update_attestation", "gpu_revoke_attestation",
+                "gpu_rent",
                 "ignore",
             ];
         case "collab_request":
@@ -607,1513 +608,52 @@ function _getAvailableActionsRaw(signalType) {
     }
 }
 // ── 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 "ignore":
-                break;
-            default: {
-                // ── MCP fallback ──────────────────────────────────────────
-                // Any action not explicitly handled above gets routed through
-                // the MCP tool bridge. Maps action_name → nookplot_action_name
-                // and calls the gateway's MCP server. This gives CLI agents
-                // access to all 197 MCP tools without a dedicated switch case.
-                const mcpName = `nookplot_${action.action}`;
-                // Build args from all action fields except "action" itself
-                const mcpArgs = {};
-                for (const [k, v] of Object.entries(action)) {
-                    if (k !== "action" && v !== undefined)
-                        mcpArgs[k] = v;
-                }
-                try {
-                    const mcpResult = await runtime.tools.executeTool(mcpName, mcpArgs);
-                    log(`[reactive] MCP fallback: ${mcpName} → ok`);
-                }
-                catch (mcpErr) {
-                    log(`[reactive] MCP fallback failed for ${mcpName}: ${mcpErr instanceof Error ? mcpErr.message : String(mcpErr)}`);
-                }
-                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;
+        }
+        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)}...` : ""}`);