@clawnet/template-minimal 0.0.1

package/tests/agent/prompts.test.ts

@@ -0,0 +1,172 @@
+import { describe, expect, it } from "vitest";
+import { buildSystemPrompt, buildUserMessage } from "../../src/agent/prompts";
+
+describe("buildSystemPrompt", () => {
+	it("includes Clawbook identity", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).toContain("Clawbook");
+		expect(prompt).toContain("on-chain social network");
+	});
+
+	it("includes behavioral rules", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).toContain("read the feed");
+		expect(prompt).toContain("Max");
+	});
+
+	it("includes bot identity when provided", () => {
+		const prompt = buildSystemPrompt({
+			idKey: "abc123idkey",
+			name: "TestBot",
+		});
+		expect(prompt).toContain("abc123idkey");
+		expect(prompt).toContain("TestBot");
+	});
+
+	it("includes current UTC timestamp", () => {
+		const before = new Date().toISOString().slice(0, 13);
+		const prompt = buildSystemPrompt();
+		const after = new Date().toISOString().slice(0, 13);
+		expect(prompt.includes(before) || prompt.includes(after)).toBe(true);
+	});
+
+	it("mentions MCP server tools without listing them individually", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).toContain("15 tools");
+		expect(prompt).toContain("clawbook MCP server");
+		expect(prompt).not.toContain("## Available Tools");
+	});
+
+	it("mentions registration tool", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).toContain("register_agent");
+	});
+
+	it("includes engagement behavior in system prompt", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).toContain("Engagement");
+		expect(prompt).toContain("mention");
+	});
+
+	it("includes personality section", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).toContain("Personality");
+		expect(prompt).toContain("Thoughtful");
+	});
+
+	it("is concise without Moltbook (under 400 tokens rough estimate)", () => {
+		const prompt = buildSystemPrompt();
+		const roughTokens = prompt.length / 4;
+		expect(roughTokens).toBeLessThan(400);
+	});
+
+	it("includes Moltbook section when networks.moltbook is true", () => {
+		const prompt = buildSystemPrompt(undefined, { moltbook: true });
+		expect(prompt).toContain("Moltbook");
+		expect(prompt).toContain("submolts");
+		expect(prompt).toContain("39 tools");
+		expect(prompt).toContain("moltbook MCP server");
+		expect(prompt).toContain("Cross-Network Strategy");
+		expect(prompt).toContain("Check DMs");
+	});
+
+	it("does NOT include Moltbook when networks is undefined", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).not.toContain("Moltbook");
+		expect(prompt).not.toContain("submolts");
+	});
+
+	it("does NOT include Moltbook when networks.moltbook is false", () => {
+		const prompt = buildSystemPrompt(undefined, { moltbook: false });
+		expect(prompt).not.toContain("Moltbook");
+	});
+});
+
+describe("buildUserMessage", () => {
+	it("scheduled_post biases toward creating content", () => {
+		const msg = buildUserMessage("scheduled_post");
+		expect(msg).toContain("post");
+	});
+
+	it("heartbeat biases toward engagement", () => {
+		const msg = buildUserMessage("heartbeat");
+		expect(msg).toContain("engage");
+	});
+
+	it("heartbeat mentions scanning for mentions", () => {
+		const msg = buildUserMessage("heartbeat");
+		expect(msg).toContain("Scan");
+		expect(msg).toContain("mention");
+	});
+
+	it("heartbeat includes bot name when identity provided", () => {
+		const msg = buildUserMessage("heartbeat", {
+			idKey: "abc123",
+			name: "Clark",
+		});
+		expect(msg).toContain("Clark");
+	});
+
+	it("heartbeat includes engagement guidelines content", () => {
+		const msg = buildUserMessage("heartbeat");
+		expect(msg).toContain("channels");
+		expect(msg).toContain("conversations");
+	});
+
+	it("manual gives free choice", () => {
+		const msg = buildUserMessage("manual");
+		expect(msg.length).toBeGreaterThan(0);
+	});
+
+	it("all non-conversation triggers instruct reading the feed first", () => {
+		for (const trigger of ["scheduled_post", "heartbeat", "manual"] as const) {
+			const msg = buildUserMessage(trigger);
+			expect(msg).toContain("feed");
+		}
+	});
+
+	it("user message with moltbook includes Moltbook hint", () => {
+		for (const trigger of ["scheduled_post", "heartbeat", "manual"] as const) {
+			const msg = buildUserMessage(trigger, undefined, { moltbook: true });
+			expect(msg).toContain("Moltbook");
+		}
+	});
+
+	it("user message without moltbook does NOT include Moltbook hint", () => {
+		const msg = buildUserMessage("scheduled_post");
+		expect(msg).not.toContain("Moltbook");
+	});
+
+	it("conversation trigger returns custom message when provided", () => {
+		const msg = buildUserMessage("conversation", undefined, undefined, "hello");
+		expect(msg).toBe("hello");
+	});
+
+	it("conversation trigger returns fallback when no custom message", () => {
+		const msg = buildUserMessage("conversation");
+		expect(msg).toContain("feed");
+	});
+
+	it("conversation trigger ignores moltbook hint", () => {
+		const msg = buildUserMessage(
+			"conversation",
+			undefined,
+			{ moltbook: true },
+			"do something",
+		);
+		expect(msg).toBe("do something");
+	});
+});
+
+describe("buildSystemPrompt conversation mode", () => {
+	it("includes direct message preamble when isConversation is true", () => {
+		const prompt = buildSystemPrompt(undefined, undefined, true);
+		expect(prompt).toContain("direct message");
+		expect(prompt).toContain("owner");
+	});
+
+	it("does NOT include conversation preamble by default", () => {
+		const prompt = buildSystemPrompt();
+		expect(prompt).not.toContain("direct message");
+	});
+});

package/tests/agent/runner.test.ts

@@ -0,0 +1,353 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// Mock @vercel/sandbox
+const mockRunCommand = vi.fn();
+const mockWriteFiles = vi.fn();
+const mockStop = vi.fn();
+const mockCreate = vi.fn().mockResolvedValue({
+	runCommand: mockRunCommand,
+	writeFiles: mockWriteFiles,
+	stop: mockStop,
+});
+
+vi.mock("@vercel/sandbox", () => ({
+	Sandbox: { create: mockCreate },
+}));
+
+function cmdResult(exitCode: number, stdoutStr: string, stderrStr = "") {
+	return {
+		exitCode,
+		stdout: async () => stdoutStr,
+		stderr: async () => stderrStr,
+	};
+}
+
+async function loadRunner() {
+	return import("../../src/agent/runner");
+}
+
+describe("buildAgentScript", () => {
+	it("generates a script that uses the Claude Agent SDK", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "You are a bot",
+			userMessage: "Read the feed",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain('from "@anthropic-ai/claude-agent-sdk"');
+		expect(script).toContain("query(");
+		expect(script).toContain("You are a bot");
+		expect(script).toContain("Read the feed");
+		expect(script).toContain("https://clawbook.network");
+	});
+
+	it("does not import @anthropic-ai/sdk directly", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).not.toContain('from "@anthropic-ai/sdk"');
+	});
+
+	it("includes all 15 Clawbook tool definitions", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain("read_feed");
+		expect(script).toContain("read_replies");
+		expect(script).toContain("read_post");
+		expect(script).toContain("read_channel");
+		expect(script).toContain("list_channels");
+		expect(script).toContain("read_profile");
+		expect(script).toContain("create_post");
+		expect(script).toContain("reply_to_post");
+		expect(script).toContain("like_post");
+		expect(script).toContain("unlike_post");
+		expect(script).toContain("follow_user");
+		expect(script).toContain("unfollow_user");
+		expect(script).toContain("register_agent");
+		expect(script).toContain("create_channel");
+		expect(script).toContain("following_feed");
+	});
+
+	it("script with moltbookApiKey includes Moltbook server and tools", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+			moltbookApiUrl: "https://www.moltbook.com/api/v1",
+			moltbookApiKey: "test-key",
+		});
+		expect(script).toContain("moltbookRequest");
+		expect(script).toContain('name: "moltbook"');
+		expect(script).toContain("Authorization");
+		expect(script).toContain("Bearer");
+		expect(script).toContain("moltbook_read_feed");
+		expect(script).toContain("moltbook_create_post");
+	});
+
+	it("script without moltbookApiKey does not include Moltbook code", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).not.toContain("moltbookRequest");
+		expect(script).not.toContain('name: "moltbook"');
+	});
+
+	it("defines tools via createSdkMcpServer", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain("createSdkMcpServer");
+		expect(script).toContain('name: "clawbook"');
+	});
+
+	it("outputs JSON result to stdout", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain("console.log");
+		expect(script).toContain("JSON.stringify");
+	});
+
+	it("captures tool_use blocks into actions", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain('"tool_use"');
+		expect(script).toContain("actions.push");
+	});
+
+	it("imports getAuthToken from bitcoin-auth", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain('import { getAuthToken } from "bitcoin-auth"');
+	});
+
+	it("includes signRequest helper function", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain("function signRequest(path, bodyObj)");
+		expect(script).toContain("getAuthToken(");
+		expect(script).toContain("privateKeyWif: WIF");
+	});
+
+	it("uses X-Auth-Token header instead of Authorization Bearer", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain("X-Auth-Token");
+		expect(script).not.toContain("Authorization");
+		expect(script).not.toContain("Bearer");
+	});
+
+	it("uses query() with maxTurns and bypassPermissions", async () => {
+		const { buildAgentScript } = await loadRunner();
+		const script = buildAgentScript({
+			systemPrompt: "test",
+			userMessage: "test",
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+		});
+		expect(script).toContain("maxTurns: 10");
+		expect(script).toContain('permissionMode: "bypassPermissions"');
+		expect(script).toContain("allowDangerouslySkipPermissions: true");
+	});
+});
+
+describe("runAgentTurn", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockRunCommand.mockResolvedValue(cmdResult(0, ""));
+	});
+
+	it("creates a sandbox, writes files, installs CLI and deps, and runs script", async () => {
+		mockRunCommand.mockImplementation(({ cmd, args }) => {
+			if (cmd === "node" && args?.[0] === "agent.mjs") {
+				return cmdResult(
+					0,
+					JSON.stringify({
+						success: true,
+						summary: "Posted something",
+						actions: [{ tool: "create_post", input: { content: "Hello" } }],
+					}),
+				);
+			}
+			return cmdResult(0, "");
+		});
+
+		const { runAgentTurn } = await loadRunner();
+		const result = await runAgentTurn("scheduled_post", {
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+			anthropicAuthToken: "sk-ant-oat01-test",
+		});
+
+		expect(mockCreate).toHaveBeenCalled();
+		expect(mockWriteFiles).toHaveBeenCalled();
+		expect(mockRunCommand).toHaveBeenCalled();
+		expect(mockStop).toHaveBeenCalled();
+		expect(result.success).toBe(true);
+		expect(result.summary).toBe("Posted something");
+		expect(result.actions).toHaveLength(1);
+	});
+
+	it("returns error result when script fails", async () => {
+		mockRunCommand.mockImplementation(({ cmd, args }) => {
+			if (cmd === "node" && args?.[0] === "agent.mjs") {
+				return cmdResult(1, "", "Error: auth failed");
+			}
+			return cmdResult(0, "");
+		});
+
+		const { runAgentTurn } = await loadRunner();
+		const result = await runAgentTurn("scheduled_post", {
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+			anthropicAuthToken: "sk-ant-oat01-test",
+		});
+
+		expect(result.success).toBe(false);
+		expect(result.error).toContain("auth failed");
+		expect(mockStop).toHaveBeenCalled();
+	});
+
+	it("stops sandbox even on error", async () => {
+		mockWriteFiles.mockRejectedValueOnce(new Error("Write failed"));
+
+		const { runAgentTurn } = await loadRunner();
+		const result = await runAgentTurn("scheduled_post", {
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+			anthropicAuthToken: "sk-ant-oat01-test",
+		});
+
+		expect(result.success).toBe(false);
+		expect(mockStop).toHaveBeenCalled();
+	});
+
+	it("passes CLAUDE_CODE_OAUTH_TOKEN to sandbox runCommand env", async () => {
+		mockRunCommand.mockImplementation(({ cmd, args }) => {
+			if (cmd === "node" && args?.[0] === "agent.mjs") {
+				return cmdResult(
+					0,
+					JSON.stringify({ success: true, summary: "Done", actions: [] }),
+				);
+			}
+			return cmdResult(0, "");
+		});
+
+		const { runAgentTurn } = await loadRunner();
+		await runAgentTurn("scheduled_post", {
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+			anthropicAuthToken: "sk-ant-oat01-test",
+		});
+
+		expect(mockRunCommand).toHaveBeenCalledWith(
+			expect.objectContaining({
+				cmd: "node",
+				args: ["agent.mjs"],
+				env: expect.objectContaining({
+					CLAUDE_CODE_OAUTH_TOKEN: "sk-ant-oat01-test",
+				}),
+			}),
+		);
+	});
+
+	it("installs Claude Code CLI globally in sandbox", async () => {
+		mockRunCommand.mockImplementation(({ cmd, args }) => {
+			if (cmd === "node" && args?.[0] === "agent.mjs") {
+				return cmdResult(
+					0,
+					JSON.stringify({ success: true, summary: "Done", actions: [] }),
+				);
+			}
+			return cmdResult(0, "");
+		});
+
+		const { runAgentTurn } = await loadRunner();
+		await runAgentTurn("scheduled_post", {
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+			anthropicAuthToken: "sk-ant-oat01-test",
+		});
+
+		expect(mockRunCommand).toHaveBeenCalledWith(
+			expect.objectContaining({
+				cmd: "npm",
+				args: ["install", "-g", "@anthropic-ai/claude-code"],
+			}),
+		);
+	});
+
+	it("installs agent SDK and bitcoin-auth in sandbox", async () => {
+		mockRunCommand.mockImplementation(({ cmd, args }) => {
+			if (cmd === "node" && args?.[0] === "agent.mjs") {
+				return cmdResult(
+					0,
+					JSON.stringify({ success: true, summary: "Done", actions: [] }),
+				);
+			}
+			return cmdResult(0, "");
+		});
+
+		const { runAgentTurn } = await loadRunner();
+		await runAgentTurn("scheduled_post", {
+			clawbookApiUrl: "https://clawbook.network",
+			sigmaMemberWif: "L1test",
+			anthropicAuthToken: "sk-ant-oat01-test",
+		});
+
+		expect(mockRunCommand).toHaveBeenCalledWith(
+			expect.objectContaining({
+				cmd: "npm",
+				args: expect.arrayContaining([
+					"@anthropic-ai/claude-agent-sdk",
+					"bitcoin-auth",
+					"zod",
+				]),
+			}),
+		);
+	});
+});

package/tests/agent/tool-definitions.test.ts

@@ -0,0 +1,171 @@
+import { describe, expect, it } from "vitest";
+import {
+	ALLOWED_TOOLS,
+	CLAWBOOK_TOOL_NAMES,
+	CLAWBOOK_TOOLS,
+	MOLTBOOK_TOOL_NAMES,
+	MOLTBOOK_TOOLS,
+	TOOL_DEFINITIONS,
+	TOOL_NAMES,
+} from "../../src/agent/tool-definitions";
+
+const EXPECTED_CLAWBOOK_TOOLS = [
+	"read_feed",
+	"read_replies",
+	"read_post",
+	"read_channel",
+	"list_channels",
+	"read_profile",
+	"create_post",
+	"reply_to_post",
+	"like_post",
+	"unlike_post",
+	"follow_user",
+	"unfollow_user",
+	"register_agent",
+	"create_channel",
+	"following_feed",
+];
+
+const EXPECTED_MOLTBOOK_TOOLS = [
+	"moltbook_read_feed",
+	"moltbook_read_post",
+	"moltbook_read_comments",
+	"moltbook_list_submolts",
+	"moltbook_read_submolt",
+	"moltbook_create_submolt",
+	"moltbook_subscribe",
+	"moltbook_unsubscribe",
+	"moltbook_submolt_feed",
+	"moltbook_update_submolt",
+	"moltbook_list_moderators",
+	"moltbook_create_post",
+	"moltbook_comment",
+	"moltbook_upvote",
+	"moltbook_downvote",
+	"moltbook_delete_post",
+	"moltbook_upvote_comment",
+	"moltbook_register",
+	"moltbook_follow_user",
+	"moltbook_unfollow_user",
+	"moltbook_personalized_feed",
+	"moltbook_check_status",
+	"moltbook_my_profile",
+	"moltbook_read_profile",
+	"moltbook_update_profile",
+	"moltbook_upload_avatar",
+	"moltbook_delete_avatar",
+	"moltbook_pin_post",
+	"moltbook_unpin_post",
+	"moltbook_add_moderator",
+	"moltbook_remove_moderator",
+	"moltbook_search",
+	"moltbook_dm_check",
+	"moltbook_dm_requests",
+	"moltbook_dm_approve",
+	"moltbook_dm_conversations",
+	"moltbook_dm_read",
+	"moltbook_dm_send",
+	"moltbook_dm_request",
+];
+
+describe("TOOL_DEFINITIONS", () => {
+	it("defines exactly 54 tools", () => {
+		expect(TOOL_DEFINITIONS).toHaveLength(54);
+	});
+
+	it("contains all expected Clawbook tool names", () => {
+		expect(TOOL_NAMES).toEqual(expect.arrayContaining(EXPECTED_CLAWBOOK_TOOLS));
+	});
+
+	it("contains all expected Moltbook tool names", () => {
+		expect(TOOL_NAMES).toEqual(expect.arrayContaining(EXPECTED_MOLTBOOK_TOOLS));
+	});
+
+	it("has no duplicate tool names", () => {
+		const unique = new Set(TOOL_NAMES);
+		expect(unique.size).toBe(TOOL_NAMES.length);
+	});
+
+	it("generates correct MCP-prefixed allowed tools", () => {
+		for (const name of EXPECTED_CLAWBOOK_TOOLS) {
+			expect(ALLOWED_TOOLS).toContain(`mcp__clawbook__${name}`);
+		}
+		for (const name of EXPECTED_MOLTBOOK_TOOLS) {
+			expect(ALLOWED_TOOLS).toContain(`mcp__moltbook__${name}`);
+		}
+		expect(ALLOWED_TOOLS).toHaveLength(54);
+	});
+
+	it("every tool has a non-empty description", () => {
+		for (const tool of TOOL_DEFINITIONS) {
+			expect(tool.description.length).toBeGreaterThan(0);
+		}
+	});
+
+	it("authed Clawbook POST/DELETE tools have bodyFields defined", () => {
+		for (const tool of CLAWBOOK_TOOLS) {
+			if (tool.auth && tool.method !== "GET") {
+				expect(tool.bodyFields).toBeDefined();
+				expect(tool.bodyFields?.length).toBeGreaterThan(0);
+			}
+		}
+	});
+
+	it("path param tools have pathParams defined", () => {
+		const pathParamTools = TOOL_DEFINITIONS.filter((t) => t.path.includes(":"));
+		for (const tool of pathParamTools) {
+			expect(tool.pathParams).toBeDefined();
+			expect(tool.pathParams?.length).toBeGreaterThan(0);
+		}
+	});
+
+	it("create_post and reply_to_post use POST /api/posts", () => {
+		const createPost = TOOL_DEFINITIONS.find((t) => t.name === "create_post");
+		const replyPost = TOOL_DEFINITIONS.find((t) => t.name === "reply_to_post");
+		expect(createPost?.method).toBe("POST");
+		expect(createPost?.path).toBe("/api/posts");
+		expect(replyPost?.method).toBe("POST");
+		expect(replyPost?.path).toBe("/api/posts");
+	});
+
+	it("all Clawbook tools have network: clawbook", () => {
+		for (const tool of CLAWBOOK_TOOLS) {
+			expect(tool.network).toBe("clawbook");
+		}
+	});
+
+	it("all Moltbook tools have network: moltbook", () => {
+		for (const tool of MOLTBOOK_TOOLS) {
+			expect(tool.network).toBe("moltbook");
+		}
+	});
+
+	it("authed Clawbook tools have authScheme: bitcoin-auth", () => {
+		for (const tool of CLAWBOOK_TOOLS) {
+			if (tool.auth) {
+				expect(tool.authScheme).toBe("bitcoin-auth");
+			}
+		}
+	});
+
+	it("authed Moltbook tools have authScheme: bearer", () => {
+		for (const tool of MOLTBOOK_TOOLS) {
+			if (tool.auth) {
+				expect(tool.authScheme).toBe("bearer");
+			}
+		}
+	});
+
+	it("Moltbook tool names are prefixed with mcp__moltbook__", () => {
+		for (const name of MOLTBOOK_TOOL_NAMES) {
+			expect(name).toMatch(/^mcp__moltbook__/);
+		}
+	});
+
+	it("Clawbook tool names are prefixed with mcp__clawbook__", () => {
+		for (const name of CLAWBOOK_TOOL_NAMES) {
+			expect(name).toMatch(/^mcp__clawbook__/);
+		}
+	});
+});