@nookplot/runtime 0.5.70 → 0.5.72

package/dist/__tests__/autonomous.actionDispatch.test.js

@@ -1,563 +1,287 @@
 /**
- * Action dispatch tests for AutonomousAgent.handleActionRequest.
+ * Action dispatch tests for AutonomousAgent — unified dispatch via gateway.
  *
- * Tests that each action type calls the correct runtime manager method
- * with the right arguments. Uses mock runtime + mock prepareSignRelay.
+ * After the thin dispatch refactor, all actions go through
+ * `POST /v1/actions/execute { toolName, payload }`. These tests verify:
+ *  - Correct toolName + payload are sent to the gateway
+ *  - `completed` results are handled
+ *  - `sign_required` results trigger local signing + relay
+ *  - `client_side_required` results are handled locally
+ *  - `error` results reject delegated actions
+ *  - Approval gate still works for on-chain actions
+ *  - actionId lifecycle (completeAction / rejectDelegatedAction)
  */
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { createMockRuntime } from "./helpers/mockRuntime.js";
 import { AutonomousAgent } from "../autonomous.js";
-// Mock prepareSignRelay at module level
+// Mock the signing module
 vi.mock("../signing.js", () => ({
     prepareSignRelay: vi.fn().mockResolvedValue({ txHash: "0xRELAY_TX" }),
-    signForwardRequest: vi.fn(),
+    signForwardRequest: vi.fn().mockResolvedValue("0xSIGNATURE"),
 }));
-import { prepareSignRelay } from "../signing.js";
-const mockPrepareSignRelay = vi.mocked(prepareSignRelay);
 let runtime;
 let callbacks;
 let agent;
+let requestMock;
 beforeEach(() => {
     vi.clearAllMocks();
     const mock = createMockRuntime();
     runtime = mock.runtime;
     callbacks = mock.callbacks;
+    // Default mock: return `completed` for POST /v1/actions/execute
+    requestMock = runtime.connection.request;
+    requestMock.mockImplementation(async (method, path) => {
+        if (method === "POST" && path === "/v1/actions/execute") {
+            return { status: "completed", result: { success: true } };
+        }
+        return { success: true };
+    });
     agent = new AutonomousAgent(runtime, { verbose: false });
     agent.start();
 });
 /** Helper: dispatch an action request and wait for processing */
 async function dispatchAction(actionType, payload, suggestedContent, actionId) {
-    const event = { agentId: "agent_1", actionType, payload, suggestedContent, actionId };
-    callbacks.actionCb(event);
-    // Allow async handler to settle
-    await new Promise((r) => setTimeout(r, 10));
+    callbacks.actionCb({ agentId: "agent_1", actionType, payload, suggestedContent, actionId });
+    await new Promise((r) => setTimeout(r, 20));
 }
-// ── On-chain via runtime managers ──────────────────────────────
-describe("on-chain actions via runtime managers", () => {
-    it("create_post / publish calls memory.publishKnowledge", async () => {
-        await dispatchAction("create_post", { community: "general", title: "Test" }, "Post body");
-        expect(runtime.memory.publishKnowledge).toHaveBeenCalledWith(expect.objectContaining({ title: "Test", body: "Post body", community: "general" }));
-    });
-    it("publish is alias for create_post", async () => {
-        await dispatchAction("publish", { community: "sci" }, "My insight");
-        expect(runtime.memory.publishKnowledge).toHaveBeenCalled();
-    });
-    it("post_reply calls memory.publishComment", async () => {
-        await dispatchAction("post_reply", { parentCid: "Qm_parent", community: "general" }, "Nice post!");
-        expect(runtime.memory.publishComment).toHaveBeenCalledWith(expect.objectContaining({ parentCid: "Qm_parent", body: "Nice post!", community: "general" }));
-    });
-    it("vote calls memory.vote", async () => {
-        await dispatchAction("vote", { cid: "Qm_cid", voteType: "up" });
-        expect(runtime.memory.vote).toHaveBeenCalledWith(expect.objectContaining({ cid: "Qm_cid", type: "up" }));
-    });
-    it("follow_agent calls social.follow", async () => {
-        await dispatchAction("follow_agent", { targetAddress: "0xTARGET" });
-        expect(runtime.social.follow).toHaveBeenCalledWith("0xTARGET");
-    });
-    it("attest_agent calls social.attest", async () => {
-        await dispatchAction("attest_agent", { targetAddress: "0xTARGET" }, "Great work!");
-        expect(runtime.social.attest).toHaveBeenCalledWith("0xTARGET", "Great work!");
-    });
-    it("list_service calls marketplace.createListing", async () => {
-        await dispatchAction("list_service", { category: "dev" }, "Build APIs");
-        expect(runtime.marketplace.createListing).toHaveBeenCalledWith(expect.objectContaining({ title: "Build APIs", category: "dev" }));
-    });
-    it("create_agreement calls marketplace.createAgreement", async () => {
-        await dispatchAction("create_agreement", { listingId: 42 }, "Build me an API");
-        expect(runtime.marketplace.createAgreement).toHaveBeenCalledWith(expect.objectContaining({ listingId: 42, terms: "Build me an API" }));
-    });
-    it("deliver_work calls marketplace.deliver", async () => {
-        await dispatchAction("deliver_work", { agreementId: 5 }, "Qm_delivery_cid");
-        expect(runtime.marketplace.deliver).toHaveBeenCalledWith(5, "Qm_delivery_cid");
-    });
-    it("settle_agreement calls marketplace.settle", async () => {
-        await dispatchAction("settle_agreement", { agreementId: 5 });
-        expect(runtime.marketplace.settle).toHaveBeenCalledWith(5);
-    });
-    it("dispute_agreement calls marketplace.dispute", async () => {
-        await dispatchAction("dispute_agreement", { agreementId: 5 });
-        expect(runtime.marketplace.dispute).toHaveBeenCalledWith(5);
-    });
-    it("cancel_agreement calls marketplace.cancel", async () => {
-        await dispatchAction("cancel_agreement", { agreementId: 5 });
-        expect(runtime.marketplace.cancel).toHaveBeenCalledWith(5);
-    });
-    it("expire_dispute calls marketplace.expireDispute", async () => {
-        await dispatchAction("expire_dispute", { agreementId: 5 });
-        expect(runtime.marketplace.expireDispute).toHaveBeenCalledWith(5);
-    });
-    it("expire_delivered calls marketplace.expireDelivered", async () => {
-        await dispatchAction("expire_delivered", { agreementId: 5 });
-        expect(runtime.marketplace.expireDelivered).toHaveBeenCalledWith(5);
-    });
-});
-// ── On-chain via prepareSignRelay ────────────────────────────
-describe("on-chain actions via prepareSignRelay", () => {
-    it("create_community calls prepareSignRelay with /v1/prepare/community", async () => {
-        await dispatchAction("create_community", { slug: "ai", name: "AI Agents" }, "An AI community");
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/community", expect.objectContaining({ slug: "ai", name: "AI Agents" }));
-    });
-    it("propose_guild calls prepareSignRelay with /v1/prepare/guild", async () => {
-        await dispatchAction("propose_guild", { name: "BuilderGuild", members: ["0xA", "0xB", "0xC"] }, "A builder guild");
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild", expect.objectContaining({ name: "BuilderGuild", members: ["0xA", "0xB", "0xC"] }));
-    });
-    it("propose_clique is alias for propose_guild", async () => {
-        await dispatchAction("propose_clique", { name: "Clique", members: ["0xA", "0xB"] }, "desc");
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild", expect.anything());
-    });
-    it("create_project does 2-step discover + prepare", async () => {
-        vi.mocked(runtime.connection.request).mockResolvedValueOnce({ discoveryId: "disc_1" });
-        await dispatchAction("create_project", { projectId: "proj_1", name: "My Project" }, "Project desc");
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/projects/discover", expect.anything());
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/project", expect.objectContaining({ discoveryId: "disc_1", projectId: "proj_1" }));
-    });
-    it("claim_bounty calls prepareSignRelay with /v1/prepare/bounty/:id/claim", async () => {
-        await dispatchAction("claim_bounty", { bountyId: "42" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/42/claim", {});
-    });
-    it("claim is alias for claim_bounty", async () => {
-        await dispatchAction("claim", { bountyId: "99" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/99/claim", {});
-    });
-    it("create_bounty calls prepareSignRelay with /v1/prepare/bounty", async () => {
-        await dispatchAction("create_bounty", { tokenRewardAmount: "100" }, "Fix the bug");
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty", expect.objectContaining({ title: "Fix the bug", tokenRewardAmount: "100" }));
-    });
-    it("create_bundle calls prepareSignRelay with /v1/prepare/bundle", async () => {
-        await dispatchAction("create_bundle", { name: "Research Bundle" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bundle", expect.objectContaining({ name: "Research Bundle" }));
-    });
-    it("approve_bounty_claimer calls prepareSignRelay with /v1/prepare/bounty/:id/approve-claimer", async () => {
-        await dispatchAction("approve_bounty_claimer", { bountyId: "10", claimer: "0xCLAIMER" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/approve-claimer", { claimer: "0xCLAIMER" });
-    });
-    it("approve_bounty_work calls prepareSignRelay with /v1/prepare/bounty/:id/approve", async () => {
-        await dispatchAction("approve_bounty_work", { bountyId: "10" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/approve", {});
-    });
-    it("dispute_bounty_work calls prepareSignRelay with /v1/prepare/bounty/:id/dispute", async () => {
-        await dispatchAction("dispute_bounty_work", { bountyId: "10" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/dispute", {});
-    });
-    it("cancel_bounty calls prepareSignRelay with /v1/prepare/bounty/:id/cancel", async () => {
-        await dispatchAction("cancel_bounty", { bountyId: "10" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/cancel", {});
-    });
-    it("unclaim_bounty calls prepareSignRelay with /v1/prepare/bounty/:id/unclaim", async () => {
-        await dispatchAction("unclaim_bounty", { bountyId: "10" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/unclaim", {});
-    });
-    it("deploy_preview calls prepareSignRelay with /v1/prepare/project/:id/deployment", async () => {
-        await dispatchAction("deploy_preview", { projectId: "proj_1" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/project/proj_1/deployment", expect.objectContaining({ prepaidHours: 2 }));
-    });
-    it("join_guild / approve_guild calls prepareSignRelay with /v1/prepare/guild/:id/approve", async () => {
-        await dispatchAction("join_guild", { guildId: 5 });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild/5/approve", {});
-    });
-    it("reject_guild calls prepareSignRelay with /v1/prepare/guild/:id/reject", async () => {
-        await dispatchAction("reject_guild", { guildId: 5 });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild/5/reject", {});
-    });
-    it("leave_guild calls prepareSignRelay with /v1/prepare/guild/:id/leave", async () => {
-        await dispatchAction("leave_guild", { guildId: 5 });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild/5/leave", {});
-    });
-    it("update_service calls prepareSignRelay with /v1/prepare/service/update", async () => {
-        await dispatchAction("update_service", { listingId: "list_1", title: "Updated" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/service/update", expect.objectContaining({ listingId: "list_1" }));
-    });
-    it("create_listing calls prepareSignRelay with /v1/prepare/service/list", async () => {
-        await dispatchAction("create_listing", { title: "Service", category: "dev" });
-        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/service/list", expect.anything());
-    });
-});
-// ── Off-chain messaging ──────────────────────────────────────
-describe("off-chain messaging actions", () => {
-    it("reply with channelId sends to channel", async () => {
-        await dispatchAction("reply", { channelId: "ch_1" }, "Hello channel!");
-        expect(runtime.channels.send).toHaveBeenCalledWith("ch_1", "Hello channel!");
-    });
-    it("reply with to sends DM", async () => {
-        await dispatchAction("reply", { to: "0xTARGET" }, "Hello DM!");
-        expect(runtime.inbox.send).toHaveBeenCalledWith(expect.objectContaining({ to: "0xTARGET", content: "Hello DM!" }));
-    });
-    it("send_dm calls inbox.send", async () => {
-        await dispatchAction("send_dm", { recipientAddress: "0xTARGET" }, "Hey!");
-        expect(runtime.inbox.send).toHaveBeenCalledWith(expect.objectContaining({ to: "0xTARGET", content: "Hey!" }));
-    });
-    it("send_message with to sends DM", async () => {
-        await dispatchAction("send_message", { to: "0xTARGET" }, "Collaboration time!");
-        expect(runtime.inbox.send).toHaveBeenCalled();
-    });
-    it("send_message with channelId sends to channel", async () => {
-        await dispatchAction("send_message", { channelId: "ch_2" }, "Hi team!");
-        expect(runtime.channels.send).toHaveBeenCalledWith("ch_2", "Hi team!");
-    });
-    it("acknowledge sends to project channel", async () => {
-        await dispatchAction("acknowledge", { projectId: "proj_1" });
-        expect(runtime.channels.sendToProject).toHaveBeenCalledWith("proj_1", expect.any(String));
-    });
-    it("accept sends to project channel", async () => {
-        await dispatchAction("accept", { projectId: "proj_1" });
-        expect(runtime.channels.sendToProject).toHaveBeenCalledWith("proj_1", expect.any(String));
-    });
-    it("execute with channelId sends to channel", async () => {
-        await dispatchAction("execute", { channelId: "ch_1" }, "Executing task...");
-        expect(runtime.channels.send).toHaveBeenCalledWith("ch_1", "Executing task...");
-    });
-    it("execute with to sends DM", async () => {
-        await dispatchAction("execute", { to: "0xTARGET" }, "Done!");
-        expect(runtime.inbox.send).toHaveBeenCalled();
-    });
-    it("propose_collab sends DM", async () => {
-        await dispatchAction("propose_collab", { targetAddress: "0xTARGET" }, "Let's work together!");
-        expect(runtime.inbox.send).toHaveBeenCalledWith(expect.objectContaining({ to: "0xTARGET", content: "Let's work together!" }));
-    });
-});
-// ── Off-chain social ─────────────────────────────────────────
-describe("off-chain social actions", () => {
-    it("follow calls social.follow", async () => {
+// ── Unified dispatch to gateway ──────────────────────────────
+describe("unified dispatch via POST /v1/actions/execute", () => {
+    it("dispatches action with correct toolName and payload", async () => {
+        await dispatchAction("send_message", { to: "0xTARGET", content: "Hello!" });
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({
+            toolName: "nookplot_send_message",
+            payload: expect.objectContaining({ to: "0xTARGET", content: "Hello!" }),
+        }));
+    });
+    it("includes suggestedContent in payload when present", async () => {
+        await dispatchAction("create_post", { community: "general", title: "Test" }, "Post body here");
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({
+            toolName: "nookplot_create_post",
+            payload: expect.objectContaining({
+                community: "general",
+                title: "Test",
+                suggestedContent: "Post body here",
+            }),
+        }));
+    });
+    it("follows dispatches as nookplot_follow", async () => {
         await dispatchAction("follow", { targetAddress: "0xTARGET" });
-        expect(runtime.social.follow).toHaveBeenCalledWith("0xTARGET");
-    });
-    it("follow_back calls social.follow", async () => {
-        await dispatchAction("follow_back", { senderAddress: "0xFOLLOWER" });
-        expect(runtime.social.follow).toHaveBeenCalledWith("0xFOLLOWER");
-    });
-    it("attest calls social.attest", async () => {
-        await dispatchAction("attest", { targetAddress: "0xTARGET" }, "Excellent contributor");
-        expect(runtime.social.attest).toHaveBeenCalledWith("0xTARGET", "Excellent contributor");
-    });
-    it("attest_back calls social.attest", async () => {
-        await dispatchAction("attest_back", { senderAddress: "0xATTESTER" });
-        expect(runtime.social.attest).toHaveBeenCalledWith("0xATTESTER", "Valued collaborator");
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({ toolName: "nookplot_follow" }));
+    });
+    it("vote dispatches as nookplot_vote", async () => {
+        await dispatchAction("vote", { contentCid: "Qm_cid", isUpvote: true });
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({
+            toolName: "nookplot_vote",
+            payload: expect.objectContaining({ contentCid: "Qm_cid", isUpvote: true }),
+        }));
+    });
+    it("reply action dispatches correctly", async () => {
+        await dispatchAction("reply", { channelId: "ch_1" }, "My reply");
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({
+            toolName: "nookplot_reply",
+            payload: expect.objectContaining({ channelId: "ch_1", suggestedContent: "My reply" }),
+        }));
     });
 });
-// ── Off-chain project actions ────────────────────────────────
-describe("off-chain project actions", () => {
-    it("review calls projects.submitReview", async () => {
-        await dispatchAction("review", { projectId: "proj_1", commitId: "abc", verdict: "approve" }, "LGTM");
-        expect(runtime.projects.submitReview).toHaveBeenCalledWith("proj_1", "abc", "approve", "LGTM");
-    });
-    it("comment calls projects.submitReview with verdict=comment", async () => {
-        await dispatchAction("comment", { projectId: "proj_1", commitId: "abc" }, "Looks fine");
-        expect(runtime.projects.submitReview).toHaveBeenCalledWith("proj_1", "abc", "comment", "Looks fine");
-    });
-    it("request_ai_review calls projects.requestAIReview", async () => {
-        await dispatchAction("request_ai_review", { projectId: "proj_1", commitId: "abc" });
-        expect(runtime.projects.requestAIReview).toHaveBeenCalledWith("proj_1", "abc");
-    });
-    it("commit_files calls projects.commitFiles", async () => {
-        const files = [{ path: "src/main.ts", content: "console.log('hi')" }];
-        await dispatchAction("commit_files", { projectId: "proj_1", files }, "Initial commit");
-        expect(runtime.projects.commitFiles).toHaveBeenCalledWith("proj_1", files, "Initial commit");
-    });
-    it("gateway_commit is alias for commit_files", async () => {
-        const files = [{ path: "index.ts", content: "export {}" }];
-        await dispatchAction("gateway_commit", { projectId: "proj_1", files });
-        expect(runtime.projects.commitFiles).toHaveBeenCalled();
-    });
-    it("add_collaborator calls projects.addCollaborator", async () => {
-        await dispatchAction("add_collaborator", { projectId: "proj_1", collaboratorAddress: "0xCOLLAB", role: "editor" });
-        expect(runtime.projects.addCollaborator).toHaveBeenCalledWith("proj_1", "0xCOLLAB", "editor");
-    });
-    it("create_task calls projects.createTask", async () => {
-        await dispatchAction("create_task", { projectId: "proj_1" }, "Implement feature X");
-        expect(runtime.projects.createTask).toHaveBeenCalledWith("proj_1", expect.objectContaining({ title: "Implement feature X" }));
-    });
-    it("assign_task calls projects.assignTask", async () => {
-        await dispatchAction("assign_task", { projectId: "proj_1", taskId: "task_1", assigneeAddress: "0xWORKER" });
-        expect(runtime.projects.assignTask).toHaveBeenCalledWith("proj_1", "task_1", "0xWORKER");
-    });
-    it("complete_task calls projects.updateTask with status=completed", async () => {
-        await dispatchAction("complete_task", { projectId: "proj_1", taskId: "task_1" });
-        expect(runtime.projects.updateTask).toHaveBeenCalledWith("proj_1", "task_1", expect.objectContaining({ status: "completed" }));
-    });
-    it("update_task calls projects.updateTask with provided updates", async () => {
-        await dispatchAction("update_task", { projectId: "proj_1", taskId: "task_1", status: "in_progress", priority: "high" });
-        expect(runtime.projects.updateTask).toHaveBeenCalledWith("proj_1", "task_1", expect.objectContaining({ status: "in_progress", priority: "high" }));
-    });
-    it("link_project_to_guild performs 3-step linking", async () => {
-        vi.mocked(runtime.guilds.get).mockResolvedValueOnce({ members: [{ address: "0xMEMBER", status: 2 }] });
-        await dispatchAction("link_project_to_guild", { projectId: "proj_1", guildId: 5 });
-        expect(runtime.guilds.linkProject).toHaveBeenCalledWith(5, "proj_1");
-        expect(runtime.projects.setGuildAttribution).toHaveBeenCalledWith("proj_1", "5");
-        expect(runtime.projects.addCollaborator).toHaveBeenCalledWith("proj_1", "0xMEMBER", "editor");
+// ── sign_required handling ──────────────────────────────
+describe("sign_required response handling", () => {
+    it("signs and relays when gateway returns sign_required", async () => {
+        // Provide a private key for signing
+        Object.defineProperty(runtime.connection, "privateKey", { value: "0xPRIVATE_KEY", writable: true });
+        requestMock.mockImplementation(async (method, path) => {
+            if (method === "POST" && path === "/v1/actions/execute") {
+                return {
+                    status: "sign_required",
+                    forwardRequest: { from: "0xAGENT", to: "0xCONTRACT", data: "0x..." },
+                    domain: { name: "Nookplot" },
+                    types: { ForwardRequest: [] },
+                };
+            }
+            if (method === "POST" && path === "/v1/relay") {
+                return { txHash: "0xRELAY_TX_HASH" };
+            }
+            return { success: true };
+        });
+        await dispatchAction("create_community", { slug: "test", name: "Test" }, undefined, "act_1");
+        // Should have called relay with the signed request
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/relay", expect.objectContaining({ signature: "0xSIGNATURE" }));
+        // Should complete the action with txHash
+        expect(runtime.proactive.completeAction).toHaveBeenCalledWith("act_1", "0xRELAY_TX_HASH", { txHash: "0xRELAY_TX_HASH" });
+    });
+    it("throws when sign_required but no private key", async () => {
+        Object.defineProperty(runtime.connection, "privateKey", { value: null, writable: true });
+        requestMock.mockImplementation(async (method, path) => {
+            if (method === "POST" && path === "/v1/actions/execute") {
+                return {
+                    status: "sign_required",
+                    forwardRequest: { from: "0xAGENT" },
+                    domain: { name: "Nookplot" },
+                    types: {},
+                };
+            }
+            return { success: true };
+        });
+        await dispatchAction("vote", { contentCid: "Qm_cid" }, undefined, "act_2");
+        // Should reject the delegated action
+        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("act_2", expect.stringContaining("Private key not configured"));
     });
 });
-// ── Off-chain HTTP actions ───────────────────────────────────
-describe("off-chain HTTP actions", () => {
-    it("apply_bounty calls connection.request POST", async () => {
-        const applyMsg = "I can do this! I have extensive experience with this type of work and will deliver high quality results.";
-        await dispatchAction("apply_bounty", { bountyId: "42" }, applyMsg);
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/apply", expect.objectContaining({ message: applyMsg }));
-    });
-    it("submit_bounty_work calls connection.request POST", async () => {
-        await dispatchAction("submit_bounty_work", { bountyId: "42" }, "Here is my work");
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/submissions", expect.anything());
-    });
-    it("approve_bounty_application calls connection.request POST", async () => {
-        await dispatchAction("approve_bounty_application", { bountyId: "42", applicationId: "app_1" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/applications/app_1/approve", {});
-    });
-    it("reject_bounty_application calls connection.request POST", async () => {
-        await dispatchAction("reject_bounty_application", { bountyId: "42", applicationId: "app_1" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/applications/app_1/reject", {});
-    });
-    it("select_bounty_submission calls connection.request POST", async () => {
-        await dispatchAction("select_bounty_submission", { bountyId: "42", submissionId: "sub_1" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/submissions/sub_1/select", {});
-    });
-    it("accept_invitation calls connection.request POST", async () => {
-        await dispatchAction("accept_invitation", { invitationId: "inv_1" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/teams/invitations/inv_1/accept", {});
-    });
-    it("decline_invitation calls connection.request POST", async () => {
-        await dispatchAction("decline_invitation", { invitationId: "inv_1" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/teams/invitations/inv_1/decline", {});
-    });
-    it("grant calls connection.request POST with grant-access", async () => {
-        await dispatchAction("grant", { projectId: "proj_1", bountyId: "42", requestId: "req_1" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/projects/proj_1/bounties/42/grant-access", { requestId: "req_1" });
-    });
-    it("deny calls connection.request POST with deny-access", async () => {
-        await dispatchAction("deny", { projectId: "proj_1", bountyId: "42", requestId: "req_1" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/projects/proj_1/bounties/42/deny-access", { requestId: "req_1" });
+// ── completed response handling ──────────────────────────────
+describe("completed response handling", () => {
+    it("completes delegated action with result", async () => {
+        requestMock.mockImplementation(async (method, path) => {
+            if (method === "POST" && path === "/v1/actions/execute") {
+                return { status: "completed", result: { messageId: "msg_1", sent: true } };
+            }
+            return { success: true };
+        });
+        await dispatchAction("send_message", { to: "0xTARGET", content: "Hi" }, undefined, "act_3");
+        expect(runtime.proactive.completeAction).toHaveBeenCalledWith("act_3", undefined, // no txHash for off-chain
+        { messageId: "msg_1", sent: true });
     });
 });
-// ── Real-world actions ───────────────────────────────────────
-describe("real-world actions", () => {
-    it("egress_request calls tools.httpRequest", async () => {
-        await dispatchAction("egress_request", { url: "https://api.example.com/data", method: "GET" });
-        expect(runtime.tools.httpRequest).toHaveBeenCalledWith("https://api.example.com/data", "GET", expect.anything());
-    });
-    it("http_request is alias for egress_request", async () => {
-        await dispatchAction("http_request", { url: "https://example.com", method: "POST" });
-        expect(runtime.tools.httpRequest).toHaveBeenCalled();
-    });
-    it("execute_tool calls tools.executeTool", async () => {
-        await dispatchAction("execute_tool", { toolName: "my_tool", args: { key: "val" } });
-        expect(runtime.tools.executeTool).toHaveBeenCalledWith("my_tool", { key: "val" });
-    });
-    it("connect_mcp_server calls tools.connectMcpServer", async () => {
-        await dispatchAction("connect_mcp_server", { serverUrl: "https://mcp.example.com", serverName: "test" });
-        expect(runtime.tools.connectMcpServer).toHaveBeenCalledWith("https://mcp.example.com", "test");
-    });
-    it("disconnect_mcp_server calls tools.disconnectMcpServer", async () => {
-        await dispatchAction("disconnect_mcp_server", { serverId: "mcp_1" });
-        expect(runtime.tools.disconnectMcpServer).toHaveBeenCalledWith("mcp_1");
-    });
-    it("call_mcp_tool calls tools.executeTool", async () => {
-        await dispatchAction("call_mcp_tool", { toolName: "mcp_tool_1", args: { x: 1 } });
-        expect(runtime.tools.executeTool).toHaveBeenCalledWith("mcp_tool_1", { x: 1 });
-    });
-    it("register_webhook calls tools.registerWebhook", async () => {
-        await dispatchAction("register_webhook", { source: "github" });
-        expect(runtime.tools.registerWebhook).toHaveBeenCalledWith("github", expect.anything());
+// ── error response handling ──────────────────────────────
+describe("error response handling", () => {
+    it("rejects delegated action when gateway returns error", async () => {
+        requestMock.mockImplementation(async (method, path) => {
+            if (method === "POST" && path === "/v1/actions/execute") {
+                return { status: "error", error: "Rate limited" };
+            }
+            return { success: true };
+        });
+        await dispatchAction("send_message", { to: "0xTARGET" }, "Hi", "act_4");
+        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("act_4", "Rate limited");
+    });
+    it("rejects delegated action when request throws", async () => {
+        requestMock.mockImplementation(async (method, path) => {
+            if (method === "POST" && path === "/v1/actions/execute") {
+                throw new Error("Network failure");
+            }
+            return { success: true };
+        });
+        await dispatchAction("vote", { contentCid: "Qm_cid" }, undefined, "act_5");
+        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("act_5", "Network failure");
     });
 });
-// ── Strategy / knowledge actions ─────────────────────────────
-describe("strategy and knowledge actions", () => {
-    it("publish_insight calls insights.publish", async () => {
-        await dispatchAction("publish_insight", { title: "Insight", body: "Content" });
-        expect(runtime.insights.publish).toHaveBeenCalledWith(expect.objectContaining({ title: "Insight", body: "Content" }));
-    });
-    it("cite_insight calls insights.cite", async () => {
-        await dispatchAction("cite_insight", { insightId: "ins_1" });
-        expect(runtime.insights.cite).toHaveBeenCalledWith("ins_1", undefined, undefined);
-    });
-    it("apply_insight calls insights.apply", async () => {
-        await dispatchAction("apply_insight", { insightId: "ins_1" });
-        expect(runtime.insights.apply).toHaveBeenCalledWith("ins_1", undefined, undefined);
-    });
-    it("workspace_create calls workspaces.create", async () => {
-        await dispatchAction("workspace_create", { name: "My Workspace" });
-        expect(runtime.workspaces.create).toHaveBeenCalledWith(expect.objectContaining({ name: "My Workspace" }));
-    });
-    it("workspace_set calls workspaces.setState", async () => {
-        await dispatchAction("workspace_set", { workspaceId: "ws_1", key: "status", value: "active" });
-        expect(runtime.workspaces.setState).toHaveBeenCalledWith("ws_1", "status", "active");
-    });
-    it("workspace_snapshot calls workspaces.createSnapshot", async () => {
-        await dispatchAction("workspace_snapshot", { workspaceId: "ws_1" });
-        expect(runtime.workspaces.createSnapshot).toHaveBeenCalledWith("ws_1", undefined);
-    });
-    it("propose_action calls workspaces.createProposal", async () => {
-        await dispatchAction("propose_action", { workspaceId: "ws_1", title: "Upgrade deps" });
-        expect(runtime.workspaces.createProposal).toHaveBeenCalledWith("ws_1", expect.objectContaining({ title: "Upgrade deps" }));
-    });
-    it("vote_proposal calls workspaces.vote", async () => {
-        await dispatchAction("vote_proposal", { workspaceId: "ws_1", proposalId: "prop_1", vote: true });
-        expect(runtime.workspaces.vote).toHaveBeenCalledWith("ws_1", "prop_1", true, undefined);
-    });
-    it("cancel_proposal calls workspaces.cancelProposal", async () => {
-        await dispatchAction("cancel_proposal", { workspaceId: "ws_1", proposalId: "prop_1" });
-        expect(runtime.workspaces.cancelProposal).toHaveBeenCalledWith("ws_1", "prop_1");
+// ── approval gate ──────────────────────────────
+describe("approval gate for on-chain actions", () => {
+    it("blocks on-chain action when approval handler rejects", async () => {
+        const agentWithApproval = new AutonomousAgent(runtime, {
+            verbose: false,
+            onApproval: async () => false,
+        });
+        agentWithApproval.start();
+        callbacks.actionCb({
+            agentId: "a1",
+            actionType: "create_community",
+            actionId: "act_6",
+            payload: { slug: "x", name: "X" },
+        });
+        await new Promise((r) => setTimeout(r, 20));
+        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("act_6", "Rejected by approval handler");
+        // Should NOT call the gateway execute endpoint
+        expect(requestMock).not.toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.anything());
+    });
+    it("allows on-chain action when approval handler approves", async () => {
+        const agentWithApproval = new AutonomousAgent(runtime, {
+            verbose: false,
+            onApproval: async () => true,
+        });
+        agentWithApproval.start();
+        callbacks.actionCb({
+            agentId: "a1",
+            actionType: "follow",
+            payload: { targetAddress: "0xTARGET" },
+        });
+        await new Promise((r) => setTimeout(r, 20));
+        // Should have dispatched to gateway
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({ toolName: "nookplot_follow" }));
+    });
+    it("skips approval for off-chain actions", async () => {
+        const approvalFn = vi.fn().mockResolvedValue(false);
+        const agentWithApproval = new AutonomousAgent(runtime, {
+            verbose: false,
+            onApproval: approvalFn,
+        });
+        agentWithApproval.start();
+        callbacks.actionCb({
+            agentId: "a1",
+            actionType: "reply",
+            payload: { channelId: "ch1" },
+            suggestedContent: "hi",
+        });
+        await new Promise((r) => setTimeout(r, 20));
+        expect(approvalFn).not.toHaveBeenCalled();
+        // Should still dispatch to gateway
+        expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({ toolName: "nookplot_reply" }));
     });
 });
-// ── Treasury actions ─────────────────────────────────────────
-describe("treasury actions", () => {
-    it("deposit_treasury calls guilds.depositTreasury", async () => {
-        await dispatchAction("deposit_treasury", { guildId: "5", amount: 100 });
-        expect(runtime.guilds.depositTreasury).toHaveBeenCalledWith("5", 100, undefined);
-    });
-    it("withdraw_treasury calls guilds.withdrawTreasury", async () => {
-        await dispatchAction("withdraw_treasury", { guildId: "5", amount: 50 });
-        expect(runtime.guilds.withdrawTreasury).toHaveBeenCalledWith("5", 50, undefined);
-    });
-    it("fund_bounty_from_treasury calls guilds.fundBountyFromTreasury", async () => {
-        await dispatchAction("fund_bounty_from_treasury", { guildId: "5", bountyId: "10", amount: 25 });
-        expect(runtime.guilds.fundBountyFromTreasury).toHaveBeenCalledWith("5", "10", 25, undefined);
-    });
-    it("distribute_revenue calls guilds.distributeRevenue", async () => {
-        await dispatchAction("distribute_revenue", { guildId: "5" });
-        expect(runtime.guilds.distributeRevenue).toHaveBeenCalledWith("5", undefined);
+// ── action lifecycle ──────────────────────────────
+describe("action lifecycle (completeAction / rejectDelegatedAction)", () => {
+    it("completes action on success (no actionId = no completeAction call)", async () => {
+        await dispatchAction("send_message", { to: "0xA", content: "hi" });
+        // No actionId → no completeAction call
+        expect(runtime.proactive.completeAction).not.toHaveBeenCalled();
+    });
+    it("completes action with actionId on success", async () => {
+        await dispatchAction("send_message", { to: "0xA", content: "hi" }, undefined, "act_7");
+        expect(runtime.proactive.completeAction).toHaveBeenCalledWith("act_7", undefined, { success: true });
+    });
+    it("rejects action with actionId on failure", async () => {
+        requestMock.mockImplementation(async (method, path) => {
+            if (method === "POST" && path === "/v1/actions/execute") {
+                return { status: "error", error: "Tool not found" };
+            }
+            return { success: true };
+        });
+        await dispatchAction("nonexistent_tool", {}, undefined, "act_8");
+        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("act_8", "Tool not found");
     });
 });
-// ── Swarm actions ────────────────────────────────────────────
-describe("swarm actions", () => {
-    it("create_swarm calls swarms.create", async () => {
-        await dispatchAction("create_swarm", { title: "Data Collection", subtasks: [{ title: "Collect A" }] });
-        expect(runtime.swarms.create).toHaveBeenCalledWith(expect.objectContaining({ title: "Data Collection" }));
-    });
-    it("claim_subtask calls swarms.claimSubtask", async () => {
-        await dispatchAction("claim_subtask", { subtaskId: "st_1" });
-        expect(runtime.swarms.claimSubtask).toHaveBeenCalledWith("st_1");
-    });
-    it("submit_swarm_result calls swarms.submitResult", async () => {
-        await dispatchAction("submit_swarm_result", { subtaskId: "st_1" });
-        expect(runtime.swarms.submitResult).toHaveBeenCalledWith("st_1", undefined, undefined);
-    });
-    it("aggregate_swarm calls swarms.aggregate", async () => {
-        await dispatchAction("aggregate_swarm", { swarmId: "swarm_1" });
-        expect(runtime.swarms.aggregate).toHaveBeenCalledWith("swarm_1", undefined);
-    });
+// ── various action types dispatch correctly ──────────────────────────────
+describe("action type → toolName mapping", () => {
+    const cases = [
+        ["create_post", { community: "general", title: "T" }],
+        ["post_reply", { parentCid: "Qm_p" }],
+        ["vote", { contentCid: "Qm_c", isUpvote: true }],
+        ["follow", { targetAddress: "0xT" }],
+        ["follow_agent", { targetAddress: "0xT" }],
+        ["attest", { targetAddress: "0xT" }],
+        ["attest_agent", { targetAddress: "0xT" }],
+        ["send_message", { to: "0xT", content: "hi" }],
+        ["send_dm", { to: "0xT", content: "hi" }],
+        ["send_channel_message", { channelId: "ch_1", content: "hi" }],
+        ["create_community", { slug: "test", name: "Test", description: "A test" }],
+        ["propose_guild", { name: "G1", description: "Guild" }],
+        ["create_bounty", { title: "B1", description: "bounty", community: "gen", rewardCredits: 100 }],
+        ["claim_bounty", { bountyId: "b_1" }],
+        ["create_bundle", { name: "Bundle", cids: ["Qm_1"] }],
+        ["create_project", { projectId: "my-proj", name: "My Project", description: "desc" }],
+        ["commit_files", { projectId: "p1", message: "init", files: [] }],
+        ["create_task", { projectId: "p1", title: "T1" }],
+        ["publish_insight", { title: "Insight", body: "text" }],
+        ["create_swarm", { title: "S1", subtasks: [] }],
+        ["create_intent", { title: "I1", description: "intent" }],
+        ["apply_bounty", { bountyId: "b_1", message: "applying" }],
+        ["egress_request", { url: "https://example.com" }],
+    ];
+    for (const [actionType, payload] of cases) {
+        it(`${actionType} → nookplot_${actionType}`, async () => {
+            await dispatchAction(actionType, payload);
+            expect(requestMock).toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.objectContaining({
+                toolName: `nookplot_${actionType}`,
+                payload: expect.objectContaining(payload),
+            }));
+        });
+    }
 });
-// ── Specialization actions ───────────────────────────────────
-describe("specialization actions", () => {
-    it("record_gap calls specialization.recordGap", async () => {
-        await dispatchAction("record_gap", { queryText: "How to deploy to k8s?" });
-        expect(runtime.specialization.recordGap).toHaveBeenCalledWith(expect.objectContaining({ queryText: "How to deploy to k8s?" }));
-    });
-    it("update_proficiency calls specialization.updateProficiency", async () => {
-        await dispatchAction("update_proficiency", { skillDomain: "typescript", proficiency: 85 });
-        expect(runtime.specialization.updateProficiency).toHaveBeenCalledWith("typescript", 85);
-    });
-    it("generate_recommendations calls specialization.generateRecommendations", async () => {
-        await dispatchAction("generate_recommendations", {});
-        expect(runtime.specialization.generateRecommendations).toHaveBeenCalled();
-    });
-    it("dismiss_recommendation calls specialization.dismissRecommendation", async () => {
-        await dispatchAction("dismiss_recommendation", { recommendationId: "rec_1" });
-        expect(runtime.specialization.dismissRecommendation).toHaveBeenCalledWith("rec_1");
-    });
-});
-// ── Intent actions ───────────────────────────────────────────
-describe("intent actions", () => {
-    it("create_intent calls intents.create", async () => {
-        await dispatchAction("create_intent", { title: "Need a logo" });
-        expect(runtime.intents.create).toHaveBeenCalledWith(expect.objectContaining({ title: "Need a logo" }));
-    });
-    it("browse_intents calls intents.list", async () => {
-        await dispatchAction("browse_intents", { status: "open" });
-        expect(runtime.intents.list).toHaveBeenCalledWith(expect.objectContaining({ status: "open", limit: 20 }));
-    });
-    it("submit_proposal calls intents.submitProposal", async () => {
-        await dispatchAction("submit_proposal", { intentId: "intent_1" }, "I can help");
-        expect(runtime.intents.submitProposal).toHaveBeenCalledWith("intent_1", expect.objectContaining({ description: "I can help" }));
-    });
-    it("accept_proposal calls intents.acceptProposal", async () => {
-        await dispatchAction("accept_proposal", { intentId: "intent_1", proposalId: "prop_1" });
-        expect(runtime.intents.acceptProposal).toHaveBeenCalledWith("intent_1", "prop_1");
-    });
-    it("cancel_intent calls intents.cancel", async () => {
-        await dispatchAction("cancel_intent", { intentId: "intent_1" });
-        expect(runtime.intents.cancel).toHaveBeenCalledWith("intent_1");
-    });
-    it("complete_intent calls intents.complete", async () => {
-        await dispatchAction("complete_intent", { intentId: "intent_1" });
-        expect(runtime.intents.complete).toHaveBeenCalledWith("intent_1");
-    });
-    it("withdraw_proposal calls intents.withdrawProposal", async () => {
-        await dispatchAction("withdraw_proposal", { intentId: "intent_1", proposalId: "prop_1" });
-        expect(runtime.intents.withdrawProposal).toHaveBeenCalledWith("intent_1", "prop_1");
-    });
-});
-// ── Token launch actions ─────────────────────────────────────
-describe("token launch actions", () => {
-    it("report_clawnch_launch is not yet wired (clawnch not live)", async () => {
-        await dispatchAction("report_clawnch_launch", { tokenName: "MyCoin", tokenTicker: "MYC", tokenAddress: "0xTOKEN" });
-        expect(runtime.connection.request).not.toHaveBeenCalled();
-    });
-    it("get_token_analytics calls connection.request GET", async () => {
-        await dispatchAction("get_token_analytics", { tokenAddress: "0xTOKEN" });
-        expect(runtime.connection.request).toHaveBeenCalledWith("GET", "/v1/clawnch/analytics/token/0xTOKEN");
-    });
-});
-// ── Oracle actions ───────────────────────────────────────────
-describe("oracle actions", () => {
-    it("query_oracle project calls oracle.getProjectSignals", async () => {
-        await dispatchAction("query_oracle", { entityType: "project", entityId: "proj_1" });
-        expect(runtime.oracle.getProjectSignals).toHaveBeenCalledWith("proj_1");
-    });
-    it("query_oracle agent calls oracle.getAgentSignals", async () => {
-        await dispatchAction("query_oracle", { entityType: "agent", entityId: "0xAGENT" });
-        expect(runtime.oracle.getAgentSignals).toHaveBeenCalledWith("0xAGENT");
-    });
-    it("query_oracle intent calls oracle.getIntentSignals", async () => {
-        await dispatchAction("query_oracle", { entityType: "intent", entityId: "intent_1" });
-        expect(runtime.oracle.getIntentSignals).toHaveBeenCalledWith("intent_1");
-    });
-    it("query_oracle guild calls oracle.getGuildSignals", async () => {
-        await dispatchAction("query_oracle", { entityType: "guild", entityId: "guild_1" });
-        expect(runtime.oracle.getGuildSignals).toHaveBeenCalledWith("guild_1");
-    });
-});
-// ── Marketplace review + messages ────────────────────────────
-describe("marketplace review and messages", () => {
-    it("submit_review calls marketplace.submitReview", async () => {
-        await dispatchAction("submit_review", { agreementId: 5, rating: 4 }, "Good work!");
-        expect(runtime.marketplace.submitReview).toHaveBeenCalledWith(5, 4, "Good work!");
-    });
-    it("send_agreement_message calls marketplace.sendAgreementMessage", async () => {
-        await dispatchAction("send_agreement_message", { agreementId: 5, messageType: "revision_request" }, "Please fix X");
-        expect(runtime.marketplace.sendAgreementMessage).toHaveBeenCalledWith(5, "revision_request", "Please fix X", undefined);
-    });
-});
-// ── Matching actions ─────────────────────────────────────────
-describe("matching actions", () => {
-    it("find_agents calls matching.findAgents", async () => {
-        await dispatchAction("find_agents", { skills: ["typescript", "react"] });
-        expect(runtime.matching.findAgents).toHaveBeenCalledWith(["typescript", "react"], expect.anything());
-    });
-    it("assemble_team calls matching.assembleTeam", async () => {
-        await dispatchAction("assemble_team", {}, "Build a web3 dashboard");
-        expect(runtime.matching.assembleTeam).toHaveBeenCalledWith(expect.objectContaining({ description: "Build a web3 dashboard" }));
-    });
-});
-// ── Error cases and lifecycle ────────────────────────────────
-describe("error cases and action lifecycle", () => {
-    it("unknown action rejects delegated action", async () => {
-        await dispatchAction("totally_unknown_action", {}, undefined, "action_42");
-        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("action_42", expect.stringContaining("Unknown"));
-    });
-    it("actionId triggers proactive.completeAction on success", async () => {
-        await dispatchAction("follow", { targetAddress: "0xTARGET" }, undefined, "action_99");
-        expect(runtime.proactive.completeAction).toHaveBeenCalledWith("action_99", "0xMOCK_TX", expect.anything());
-    });
-    it("missing required field throws and rejects delegated action", async () => {
-        await dispatchAction("send_dm", {}, undefined, "action_fail");
-        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("action_fail", expect.stringContaining("requires"));
-    });
-    it("custom onAction handler bypasses default dispatch", async () => {
-        const customHandler = vi.fn().mockResolvedValue(undefined);
-        const customAgent = new AutonomousAgent(runtime, { onAction: customHandler, verbose: false });
-        customAgent.start();
-        callbacks.actionCb({ agentId: "a1", actionType: "follow", payload: { targetAddress: "0x1" } });
-        await new Promise((r) => setTimeout(r, 10));
-        expect(customHandler).toHaveBeenCalled();
-        expect(runtime.social.follow).not.toHaveBeenCalled();
+// ── stop prevents dispatch ──────────────────────────────
+describe("stop prevents action dispatch", () => {
+    it("stopped agent does not dispatch actions", async () => {
+        agent.stop();
+        callbacks.actionCb({ agentId: "a1", actionType: "follow", payload: { targetAddress: "0xA" } });
+        await new Promise((r) => setTimeout(r, 20));
+        expect(requestMock).not.toHaveBeenCalledWith("POST", "/v1/actions/execute", expect.anything());
     });
 });
 //# sourceMappingURL=autonomous.actionDispatch.test.js.map