@spencerbeggs/claude-coordinator-mcp 0.1.0 → 0.1.2

package/bin/claude-coordinator-mcp.js

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
-import { DEFAULT_URL, createMcpServer } from "../433.js";
+import { createMcpServer } from "../mcp-server.js";
+import { DEFAULT_URL } from "@spencerbeggs/claude-coordinator-core";
+
+//#region src/bin/cli.ts
 const args = process.argv.slice(2);
 let url = DEFAULT_URL;
-for(let i = 0; i < args.length; i++){
-    const arg = args[i];
-    if ("--url" === arg && args[i + 1]) {
-        url = args[i + 1];
-        i++;
-    } else if (arg?.startsWith("--url=")) url = arg.slice(6);
+for (let i = 0; i < args.length; i++) {
+	const arg = args[i];
+	if (arg === "--url" && args[i + 1]) {
+		url = args[i + 1];
+		i++;
+	} else if (arg?.startsWith("--url=")) url = arg.slice(6);
 }
 console.error(`[coordinator-mcp] Connecting to coordinator at ${url}`);
-createMcpServer({
-    url: url
-}).catch((error)=>{
-    console.error("[coordinator-mcp] Failed to start:", error);
-    process.exit(1);
+createMcpServer({ url }).catch((error) => {
+	console.error("[coordinator-mcp] Failed to start:", error);
+	process.exit(1);
 });
+
+//#endregion
+export {  };

package/client.js

@@ -0,0 +1,27 @@
+import { DEFAULT_URL } from "@spencerbeggs/claude-coordinator-core";
+import { createTRPCClient, createWSClient, wsLink } from "@trpc/client";
+import WebSocket from "ws";
+
+//#region src/client.ts
+/**
+* Create a tRPC client that connects to the coordinator server
+*
+* @public
+*/
+function createCoordinatorClient(options = {}) {
+	const wsClient = createWSClient({
+		url: options.url ?? DEFAULT_URL,
+		WebSocket
+	});
+	const trpc = createTRPCClient({ links: [wsLink({ client: wsClient })] });
+	const close = () => {
+		wsClient.close();
+	};
+	return {
+		trpc,
+		close
+	};
+}
+
+//#endregion
+export { createCoordinatorClient };

package/index.d.ts

@@ -1,126 +1,121 @@
-/**
- * \@spencerbeggs/claude-coordinator-mcp
- *
- * MCP stdio bridge for the Claude Coordinator system.
- * Provides MCP tools that Claude Code can use to communicate
- * with other Claude Code instances through the coordinator server.
- *
- * @packageDocumentation
- */
-
-import type { Agent } from '@spencerbeggs/claude-coordinator-core';
-import type { ContextEntry } from '@spencerbeggs/claude-coordinator-core';
-import type { Decision } from '@spencerbeggs/claude-coordinator-core';
-import type { JoinInput } from '@spencerbeggs/claude-coordinator-core';
-import type { JoinResult } from '@spencerbeggs/claude-coordinator-core';
-import type { Question } from '@spencerbeggs/claude-coordinator-core';
-
-/**
- * Options for creating the coordinator client
- */
-export declare interface ClientOptions {
-    url?: string;
-}
-
-/**
- * Coordinator client instance
- */
-export declare interface CoordinatorClient {
-    trpc: TypedTRPCClient;
-    close: () => void;
-}
-
-/**
- * Create a tRPC client that connects to the coordinator server
- */
-export declare function createCoordinatorClient(options?: ClientOptions): CoordinatorClient;
-
-/**
- * Create and run the MCP server
- */
-export declare function createMcpServer(options?: McpServerOptions): Promise<void>;
-
-/**
- * MCP server options
- */
-export declare interface McpServerOptions {
-    url?: string;
-}
-
-/**
- * Typed tRPC client interface matching the coordinator server's router
- * This provides type safety without requiring cross-package type inference
- */
-declare interface TypedTRPCClient {
-    session: {
-        join: {
-            mutate: (input: JoinInput) => Promise<JoinResult>;
-        };
-        leave: {
-            mutate: (input: {
-                agentId: string;
-            }) => Promise<{
-                success: boolean;
-            }>;
-        };
-        list: {
-            query: () => Promise<Agent[]>;
-        };
-    };
-    context: {
-        share: {
-            mutate: (input: {
-                key: string;
-                value: string;
-                tags?: string[];
-                agentId: string;
-            }) => Promise<ContextEntry>;
-        };
-        get: {
-            query: (input: {
-                key: string;
-            }) => Promise<ContextEntry | null>;
-        };
-        list: {
-            query: (input?: {
-                prefix?: string;
-                tags?: string[];
-            }) => Promise<ContextEntry[]>;
-        };
-    };
-    questions: {
-        ask: {
-            mutate: (input: {
-                question: string;
-                to?: string;
-                agentId: string;
-            }) => Promise<Question>;
-        };
-        answer: {
-            mutate: (input: {
-                questionId: string;
-                answer: string;
-                agentId: string;
-            }) => Promise<Question>;
-        };
-        listPending: {
-            query: (input?: {
-                agentId?: string;
-            }) => Promise<Question[]>;
-        };
-    };
-    decisions: {
-        log: {
-            mutate: (input: {
-                decision: string;
-                rationale?: string;
-                agentId: string;
-            }) => Promise<Decision>;
-        };
-        list: {
-            query: () => Promise<Decision[]>;
-        };
-    };
-}
-
-export { }
+import { Agent, ContextEntry, Decision, JoinInput, JoinResult, Question } from "@spencerbeggs/claude-coordinator-core";
+//#region src/client.d.ts
+/**
+ * Options for creating the coordinator client
+ *
+ * @public
+ */
+interface ClientOptions {
+  url?: string;
+}
+/**
+ * Typed tRPC client interface matching the coordinator server's router
+ * This provides type safety without requiring cross-package type inference
+ *
+ * @public
+ */
+interface TypedTRPCClient {
+  session: {
+    join: {
+      mutate: (input: JoinInput) => Promise<JoinResult>;
+    };
+    leave: {
+      mutate: (input: {
+        agentId: string;
+      }) => Promise<{
+        success: boolean;
+      }>;
+    };
+    list: {
+      query: () => Promise<Agent[]>;
+    };
+  };
+  context: {
+    share: {
+      mutate: (input: {
+        key: string;
+        value: string;
+        tags?: string[];
+        agentId: string;
+      }) => Promise<ContextEntry>;
+    };
+    get: {
+      query: (input: {
+        key: string;
+      }) => Promise<ContextEntry | null>;
+    };
+    list: {
+      query: (input?: {
+        prefix?: string;
+        tags?: string[];
+      }) => Promise<ContextEntry[]>;
+    };
+  };
+  questions: {
+    ask: {
+      mutate: (input: {
+        question: string;
+        to?: string;
+        agentId: string;
+      }) => Promise<Question>;
+    };
+    answer: {
+      mutate: (input: {
+        questionId: string;
+        answer: string;
+        agentId: string;
+      }) => Promise<Question>;
+    };
+    listPending: {
+      query: (input?: {
+        agentId?: string;
+      }) => Promise<Question[]>;
+    };
+  };
+  decisions: {
+    log: {
+      mutate: (input: {
+        decision: string;
+        rationale?: string;
+        agentId: string;
+      }) => Promise<Decision>;
+    };
+    list: {
+      query: () => Promise<Decision[]>;
+    };
+  };
+}
+/**
+ * Coordinator client instance
+ *
+ * @public
+ */
+interface CoordinatorClient {
+  trpc: TypedTRPCClient;
+  close: () => void;
+}
+/**
+ * Create a tRPC client that connects to the coordinator server
+ *
+ * @public
+ */
+declare function createCoordinatorClient(options?: ClientOptions): CoordinatorClient;
+//#endregion
+//#region src/mcp-server.d.ts
+/**
+ * MCP server options
+ *
+ * @public
+ */
+interface McpServerOptions {
+  url?: string;
+}
+/**
+ * Create and run the MCP server
+ *
+ * @public
+ */
+declare function createMcpServer(options?: McpServerOptions): Promise<void>;
+//#endregion
+export { type ClientOptions, type CoordinatorClient, type McpServerOptions, type TypedTRPCClient, createCoordinatorClient, createMcpServer };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1 +1,4 @@
-export { createCoordinatorClient, createMcpServer } from "./433.js";
+import { createCoordinatorClient } from "./client.js";
+import { createMcpServer } from "./mcp-server.js";
+
+export { createCoordinatorClient, createMcpServer };

package/mcp-server.js

@@ -0,0 +1,327 @@
+import { createCoordinatorClient } from "./client.js";
+import { AnswerInputSchema, AskInputSchema, DEFAULT_URL, GetContextInputSchema, JoinInputSchema, ListContextInputSchema, LogDecisionInputSchema, ShareContextInputSchema } from "@spencerbeggs/claude-coordinator-core";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+//#region src/mcp-server.ts
+/**
+* Format connection errors with helpful guidance
+*/
+function formatConnectionError(error, url) {
+	const errorStr = String(error);
+	if (errorStr.includes("ECONNREFUSED") || errorStr.includes("ENOTFOUND") || errorStr.includes("WebSocket") || errorStr.includes("connect")) return `Could not connect to coordinator server at ${url}. Please start the server with: npx @spencerbeggs/claude-coordinator-server`;
+	return errorStr;
+}
+/**
+* Bridge the MCP SDK's tool-argument typing (optional fields surface as
+* required `prop: T | undefined`) to the tRPC input typing (`prop?: T`).
+* Under `exactOptionalPropertyTypes` the two are incompatible, so we drop
+* undefined-valued keys — an absent optional and an `undefined` optional are
+* equivalent for these schemas — and re-type the result to match.
+*/
+function exactOptional(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== void 0));
+}
+/**
+* Create and run the MCP server
+*
+* @public
+*/
+async function createMcpServer(options = {}) {
+	const serverUrl = options.url ?? DEFAULT_URL;
+	let client = null;
+	let agentId = null;
+	const server = new McpServer({
+		name: "claude-coordinator",
+		version: "0.1.0"
+	});
+	const getClient = () => {
+		if (!client) client = createCoordinatorClient({ url: serverUrl });
+		return client;
+	};
+	const formatError = (error) => formatConnectionError(error, serverUrl);
+	const requireAgentId = () => {
+		if (!agentId) throw new Error("Not joined to session. Call coordinator_join first.");
+		return agentId;
+	};
+	server.tool("coordinator_join", "Join the coordination session as an agent", JoinInputSchema.shape, async (params) => {
+		try {
+			const result = await getClient().trpc.session.join.mutate(params);
+			agentId = result.agent.id;
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					agent: result.agent,
+					sessionId: result.sessionId
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_leave", "Leave the coordination session", {}, async () => {
+		try {
+			const id = requireAgentId();
+			const result = await getClient().trpc.session.leave.mutate({ agentId: id });
+			if (result.success) agentId = null;
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({ success: result.success })
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_list_agents", "List all connected agents in the session", {}, async () => {
+		try {
+			const agents = await getClient().trpc.session.list.query();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					agents
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_share_context", "Share a context entry with other agents", ShareContextInputSchema.shape, async (params) => {
+		try {
+			const id = requireAgentId();
+			const entry = await getClient().trpc.context.share.mutate(exactOptional({
+				...params,
+				agentId: id
+			}));
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					entry
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_get_context", "Get a context entry by key", GetContextInputSchema.shape, async (params) => {
+		try {
+			const entry = await getClient().trpc.context.get.query(params);
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					entry
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_list_context", "List context entries with optional filters", { ...ListContextInputSchema.shape }, async (params) => {
+		try {
+			const entries = await getClient().trpc.context.list.query(exactOptional(params));
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					entries
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_ask", "Ask a question to other agents", AskInputSchema.shape, async (params) => {
+		try {
+			const id = requireAgentId();
+			const question = await getClient().trpc.questions.ask.mutate(exactOptional({
+				...params,
+				agentId: id
+			}));
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					question
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_answer", "Answer a pending question", AnswerInputSchema.shape, async (params) => {
+		try {
+			const id = requireAgentId();
+			const question = await getClient().trpc.questions.answer.mutate({
+				...params,
+				agentId: id
+			});
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					question
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_pending_questions", "List pending questions (optionally for a specific agent)", { agentId: z.string().uuid().optional().describe("Filter questions directed to this agent") }, async (params) => {
+		try {
+			const questions = await getClient().trpc.questions.listPending.query(exactOptional(params));
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					questions
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_log_decision", "Log a decision made during the session", LogDecisionInputSchema.shape, async (params) => {
+		try {
+			const id = requireAgentId();
+			const decision = await getClient().trpc.decisions.log.mutate(exactOptional({
+				...params,
+				agentId: id
+			}));
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					decision
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	server.tool("coordinator_list_decisions", "List all decisions made during the session", {}, async () => {
+		try {
+			const decisions = await getClient().trpc.decisions.list.query();
+			return { content: [{
+				type: "text",
+				text: JSON.stringify({
+					success: true,
+					decisions
+				})
+			}] };
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: formatError(error)
+					})
+				}],
+				isError: true
+			};
+		}
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	console.error("[coordinator-mcp] MCP server started");
+	process.on("exit", () => {
+		if (client) client.close();
+	});
+}
+
+//#endregion
+export { createMcpServer };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@spencerbeggs/claude-coordinator-mcp",
-	"version": "0.1.0",
+	"version": "0.1.2",
 	"private": false,
 	"description": "MCP stdio bridge for Claude Coordinator",
 	"keywords": [
@@ -20,35 +20,29 @@
 		"email": "spencer@beggs.codes",
 		"url": "https://spencerbeg.gs"
 	},
+	"sideEffects": false,
 	"type": "module",
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
-			"import": "./index.js"
-		}
+			"import": "./index.js",
+			"default": "./index.js"
+		},
+		"./package.json": "./package.json"
 	},
 	"bin": {
-		"claude-coordinator-mcp": "./bin/claude-coordinator-mcp.js"
+		"claude-coordinator-mcp": "bin/claude-coordinator-mcp.js"
 	},
 	"dependencies": {
-		"@modelcontextprotocol/sdk": "^1.25.3",
+		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@spencerbeggs/claude-coordinator-core": "0.1.0",
-		"@spencerbeggs/claude-coordinator-server": "0.1.0",
-		"@trpc/client": "^11.8.1",
-		"@trpc/server": "^11.8.1",
-		"ws": "^8.19.0",
-		"zod": "^4.3.5"
+		"@spencerbeggs/claude-coordinator-server": "0.1.2",
+		"@trpc/client": "^11.18.0",
+		"@trpc/server": "^11.18.0",
+		"ws": "^8.21.1",
+		"zod": "^4.4.3"
 	},
 	"engines": {
-		"node": ">=20.0.0"
-	},
-	"files": [
-		"433.js",
-		"LICENSE",
-		"README.md",
-		"bin/claude-coordinator-mcp.js",
-		"index.d.ts",
-		"index.js",
-		"package.json"
-	]
-}
+		"node": ">=24.11.0"
+	}
+}

package/tsdoc-metadata.json

@@ -0,0 +1,11 @@
+// This file is read by tools that parse documentation comments conforming to the TSDoc standard.
+// It should be published with your NPM package.  It should not be tracked by Git.
+{
+  "tsdocVersion": "0.12",
+  "toolPackages": [
+    {
+      "packageName": "@microsoft/api-extractor",
+      "packageVersion": "7.58.12"
+    }
+  ]
+}

package/433.js

@@ -1,403 +0,0 @@
-import { AnswerInputSchema, AskInputSchema, DEFAULT_URL, GetContextInputSchema, JoinInputSchema, ListContextInputSchema, LogDecisionInputSchema, ShareContextInputSchema } from "@spencerbeggs/claude-coordinator-core";
-import { createTRPCClient, createWSClient, wsLink } from "@trpc/client";
-import ws from "ws";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-function createCoordinatorClient(options = {}) {
-    const url = options.url ?? DEFAULT_URL;
-    const wsClient = createWSClient({
-        url,
-        WebSocket: ws
-    });
-    const trpc = createTRPCClient({
-        links: [
-            wsLink({
-                client: wsClient
-            })
-        ]
-    });
-    const close = ()=>{
-        wsClient.close();
-    };
-    return {
-        trpc,
-        close
-    };
-}
-function formatConnectionError(error, url) {
-    const errorStr = String(error);
-    if (errorStr.includes("ECONNREFUSED") || errorStr.includes("ENOTFOUND") || errorStr.includes("WebSocket") || errorStr.includes("connect")) return `Could not connect to coordinator server at ${url}. Please start the server with: npx @spencerbeggs/claude-coordinator-server`;
-    return errorStr;
-}
-async function createMcpServer(options = {}) {
-    const serverUrl = options.url ?? DEFAULT_URL;
-    let client = null;
-    let agentId = null;
-    const server = new McpServer({
-        name: "claude-coordinator",
-        version: "0.1.0"
-    });
-    const getClient = ()=>{
-        if (!client) client = createCoordinatorClient({
-            url: serverUrl
-        });
-        return client;
-    };
-    const formatError = (error)=>formatConnectionError(error, serverUrl);
-    const requireAgentId = ()=>{
-        if (!agentId) throw new Error("Not joined to session. Call coordinator_join first.");
-        return agentId;
-    };
-    server.tool("coordinator_join", "Join the coordination session as an agent", JoinInputSchema.shape, async (params)=>{
-        try {
-            const result = await getClient().trpc.session.join.mutate(params);
-            agentId = result.agent.id;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            agent: result.agent,
-                            sessionId: result.sessionId
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_leave", "Leave the coordination session", {}, async ()=>{
-        try {
-            const id = requireAgentId();
-            const result = await getClient().trpc.session.leave.mutate({
-                agentId: id
-            });
-            if (result.success) agentId = null;
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: result.success
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_list_agents", "List all connected agents in the session", {}, async ()=>{
-        try {
-            const agents = await getClient().trpc.session.list.query();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            agents
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_share_context", "Share a context entry with other agents", ShareContextInputSchema.shape, async (params)=>{
-        try {
-            const id = requireAgentId();
-            const entry = await getClient().trpc.context.share.mutate({
-                ...params,
-                agentId: id
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            entry
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_get_context", "Get a context entry by key", GetContextInputSchema.shape, async (params)=>{
-        try {
-            const entry = await getClient().trpc.context.get.query(params);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            entry
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_list_context", "List context entries with optional filters", {
-        ...ListContextInputSchema.shape
-    }, async (params)=>{
-        try {
-            const entries = await getClient().trpc.context.list.query(params);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            entries
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_ask", "Ask a question to other agents", AskInputSchema.shape, async (params)=>{
-        try {
-            const id = requireAgentId();
-            const question = await getClient().trpc.questions.ask.mutate({
-                ...params,
-                agentId: id
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            question
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_answer", "Answer a pending question", AnswerInputSchema.shape, async (params)=>{
-        try {
-            const id = requireAgentId();
-            const question = await getClient().trpc.questions.answer.mutate({
-                ...params,
-                agentId: id
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            question
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_pending_questions", "List pending questions (optionally for a specific agent)", {
-        agentId: z.string().uuid().optional().describe("Filter questions directed to this agent")
-    }, async (params)=>{
-        try {
-            const questions = await getClient().trpc.questions.listPending.query(params);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            questions
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_log_decision", "Log a decision made during the session", LogDecisionInputSchema.shape, async (params)=>{
-        try {
-            const id = requireAgentId();
-            const decision = await getClient().trpc.decisions.log.mutate({
-                ...params,
-                agentId: id
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            decision
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    server.tool("coordinator_list_decisions", "List all decisions made during the session", {}, async ()=>{
-        try {
-            const decisions = await getClient().trpc.decisions.list.query();
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: true,
-                            decisions
-                        })
-                    }
-                ]
-            };
-        } catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatError(error)
-                        })
-                    }
-                ],
-                isError: true
-            };
-        }
-    });
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("[coordinator-mcp] MCP server started");
-    process.on("exit", ()=>{
-        if (client) client.close();
-    });
-}
-export { DEFAULT_URL, createCoordinatorClient, createMcpServer };