@spencerbeggs/claude-coordinator-server 0.1.0 → 0.1.1

package/bin/claude-coordinator-server.js

@@ -1,15 +1,19 @@
 #!/usr/bin/env node
-import { DEFAULT_PORT, createServer, DEFAULT_HOST } from "../36.js";
-const port = Number(process.env.PORT) || DEFAULT_PORT;
-const host = process.env.HOST ?? DEFAULT_HOST;
+import { createServer } from "../server.js";
+import { DEFAULT_HOST, DEFAULT_PORT } from "@spencerbeggs/claude-coordinator-core";
+
+//#region src/bin/cli.ts
 const server = createServer({
-    port: port,
-    host: host
+	port: Number(process.env.PORT) || DEFAULT_PORT,
+	host: process.env.HOST ?? DEFAULT_HOST
 });
-const shutdown = ()=>{
-    server.close();
-    process.exit(0);
+const shutdown = () => {
+	server.close();
+	process.exit(0);
 };
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
-console.error("[coordinator] Server started. Press Ctrl+C to stop.");
+console.error(`[coordinator] Server started. Press Ctrl+C to stop.`);
+
+//#endregion
+export {  };

package/index.d.ts

@@ -1,129 +1,106 @@
-/**
- * \@spencerbeggs/claude-coordinator-server
- *
- * tRPC WebSocket server for the Claude Coordinator system.
- * Provides real-time communication between Claude Code instances.
- *
- * @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 { EventEmitter } from 'node:events';
-import type { Question } from '@spencerbeggs/claude-coordinator-core';
-import { TRPCDefaultErrorShape } from '@trpc/server';
-import { TRPCRootObject } from '@trpc/server';
-import { TRPCRuntimeConfigOptions } from '@trpc/server';
-import { WebSocketServer } from 'ws';
-
-/**
- * Type exports for clients
- */
-export declare type AppRouter = typeof appRouter;
-
-/**
- * Main application router
- */
-export declare const appRouter: typeof t.router extends (...args: any) => infer R ? R : unknown;
-
-/**
- * Context passed to each tRPC procedure
- */
-export declare interface Context {
-    state: CoordinatorState;
-    agentId?: string;
-}
-
-/**
- * Server instance with cleanup method
- */
-export declare interface CoordinatorServer {
-    wss: WebSocketServer;
-    close: () => void;
-}
-
-/**
- * EventEmitter-based state manager for the coordinator
- */
-export declare class CoordinatorState extends EventEmitter<CoordinatorStateEvents> {
-    private sessionId;
-    private agents;
-    private context;
-    private questions;
-    private decisions;
-    constructor(sessionId: string);
-    getSessionId(): string;
-    addAgent(agent: Agent): void;
-    removeAgent(agentId: string): boolean;
-    getAgent(agentId: string): Agent | undefined;
-    listAgents(): Agent[];
-    setContext(entry: ContextEntry): void;
-    getContext(key: string): ContextEntry | undefined;
-    listContext(filters?: {
-        tags?: string[];
-        createdBy?: string;
-    }): ContextEntry[];
-    addQuestion(question: Question): void;
-    answerQuestion(questionId: string, answer: string, answeredBy: string): Question | undefined;
-    getQuestion(questionId: string): Question | undefined;
-    listPendingQuestions(forAgentId?: string): Question[];
-    addDecision(decision: Decision): void;
-    listDecisions(): Decision[];
-}
-
-/**
- * Events emitted by the coordinator state
- */
-export declare interface CoordinatorStateEvents {
-    agentChange: [agents: Agent[]];
-    contextChange: [entry: ContextEntry];
-    question: [question: Question];
-    answer: [question: Question];
-}
-
-/**
- * Create context for a request
- */
-export declare function createContext(): Context;
-
-/**
- * Create and start the coordinator WebSocket server
- */
-export declare function createServer(options?: ServerOptions): CoordinatorServer;
-
-export declare function getOrCreateState(sessionId?: string): CoordinatorState;
-
-/**
- * Resets the global coordinator state singleton to null.
- *
- * @remarks
- * Call this in test teardown (e.g., `afterEach` or `afterAll`) to ensure clean
- * state between test suites. This prevents state from leaking across tests when
- * using the singleton pattern.
- *
- * @example
- * ```ts
- * afterEach(() => {
- *   resetState();
- * });
- * ```
- */
-export declare function resetState(): void;
-
-/**
- * Options for creating the coordinator server
- */
-export declare interface ServerOptions {
-    port?: number;
-    host?: string;
-}
-
-declare const t: TRPCRootObject<Context, object, TRPCRuntimeConfigOptions<Context, object>, {
-ctx: Context;
-meta: object;
-errorShape: TRPCDefaultErrorShape;
-transformer: false;
-}>;
-
-export { }
+import { EventEmitter } from "node:events";
+import { Agent, ContextEntry, Decision, ListContextInput, Question } from "@spencerbeggs/claude-coordinator-core";
+import { WebSocketServer } from "ws";
+
+//#region src/state.d.ts
+/**
+ * Events emitted by the coordinator state
+ */
+interface CoordinatorStateEvents {
+  agentChange: [agents: Agent[]];
+  contextChange: [entry: ContextEntry];
+  question: [question: Question];
+  answer: [question: Question];
+}
+/**
+ * EventEmitter-based state manager for the coordinator
+ */
+declare class CoordinatorState extends EventEmitter<CoordinatorStateEvents> {
+  private sessionId;
+  private agents;
+  private context;
+  private questions;
+  private decisions;
+  constructor(sessionId: string);
+  getSessionId(): string;
+  addAgent(agent: Agent): void;
+  removeAgent(agentId: string): boolean;
+  getAgent(agentId: string): Agent | undefined;
+  listAgents(): Agent[];
+  setContext(entry: ContextEntry): void;
+  getContext(key: string): ContextEntry | undefined;
+  listContext(filters?: ListContextInput): ContextEntry[];
+  addQuestion(question: Question): void;
+  answerQuestion(questionId: string, answer: string, answeredBy: string): Question | undefined;
+  getQuestion(questionId: string): Question | undefined;
+  listPendingQuestions(forAgentId?: string): Question[];
+  addDecision(decision: Decision): void;
+  listDecisions(): Decision[];
+}
+declare function getOrCreateState(sessionId?: string): CoordinatorState;
+/**
+ * Resets the global coordinator state singleton to null.
+ *
+ * @remarks
+ * Call this in test teardown (e.g., `afterEach` or `afterAll`) to ensure clean
+ * state between test suites. This prevents state from leaking across tests when
+ * using the singleton pattern.
+ *
+ * @example
+ * ```ts
+ * afterEach(() => {
+ *   resetState();
+ * });
+ * ```
+ */
+declare function resetState(): void;
+//#endregion
+//#region src/router.d.ts
+/**
+ * Context passed to each tRPC procedure
+ */
+interface Context {
+  state: CoordinatorState;
+  agentId?: string;
+}
+declare const t: import("@trpc/server").TRPCRootObject<Context, object, import("@trpc/server").TRPCRuntimeConfigOptions<Context, object>, {
+  ctx: Context;
+  meta: object;
+  errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+  transformer: false;
+}>;
+/**
+ * Main application router
+ */
+declare const appRouter: typeof t.router extends ((...args: any) => infer R) ? R : unknown;
+/**
+ * Type exports for clients
+ */
+type AppRouter = typeof appRouter;
+/**
+ * Create context for a request
+ */
+declare function createContext(): Context;
+//#endregion
+//#region src/server.d.ts
+/**
+ * Options for creating the coordinator server
+ */
+interface ServerOptions {
+  port?: number;
+  host?: string;
+}
+/**
+ * Server instance with cleanup method
+ */
+interface CoordinatorServer {
+  wss: WebSocketServer;
+  close: () => void;
+}
+/**
+ * Create and start the coordinator WebSocket server
+ */
+declare function createServer(options?: ServerOptions): CoordinatorServer;
+//#endregion
+export { type AppRouter, type Context, type CoordinatorServer, CoordinatorState, type CoordinatorStateEvents, type ServerOptions, appRouter, createContext, createServer, getOrCreateState, resetState };
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1 +1,5 @@
-export { CoordinatorState, appRouter, createContext, createServer, getOrCreateState, resetState } from "./36.js";
+import { CoordinatorState, getOrCreateState, resetState } from "./state.js";
+import { appRouter, createContext } from "./router.js";
+import { createServer } from "./server.js";
+
+export { CoordinatorState, appRouter, createContext, createServer, getOrCreateState, resetState };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@spencerbeggs/claude-coordinator-server",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"private": false,
 	"description": "tRPC WebSocket server for Claude Coordinator",
 	"keywords": [
@@ -21,32 +21,25 @@
 		"email": "spencer@beggs.codes",
 		"url": "https://spencerbeg.gs"
 	},
+	"sideEffects": false,
 	"type": "module",
 	"exports": {
 		".": {
 			"types": "./index.d.ts",
 			"import": "./index.js"
-		}
+		},
+		"./package.json": "./package.json"
 	},
 	"bin": {
-		"claude-coordinator-server": "./bin/claude-coordinator-server.js"
+		"claude-coordinator-server": "bin/claude-coordinator-server.js"
 	},
 	"dependencies": {
 		"@spencerbeggs/claude-coordinator-core": "0.1.0",
-		"@trpc/server": "^11.8.1",
-		"ws": "^8.19.0",
-		"zod": "^4.3.5"
+		"@trpc/server": "^11.18.0",
+		"ws": "^8.21.0",
+		"zod": "^4.4.3"
 	},
 	"engines": {
-		"node": ">=20.0.0"
-	},
-	"files": [
-		"36.js",
-		"LICENSE",
-		"README.md",
-		"bin/claude-coordinator-server.js",
-		"index.d.ts",
-		"index.js",
-		"package.json"
-	]
-}
+		"node": ">=24.11.0"
+	}
+}

package/router.js

@@ -0,0 +1,149 @@
+import { getOrCreateState } from "./state.js";
+import { AnswerInputSchema, AskInputSchema, GetContextInputSchema, JoinInputSchema, ListContextInputSchema, LogDecisionInputSchema, ShareContextInputSchema } from "@spencerbeggs/claude-coordinator-core";
+import { initTRPC } from "@trpc/server";
+import { observable } from "@trpc/server/observable";
+import { z } from "zod";
+
+//#region src/router.ts
+const t = initTRPC.context().create();
+const publicProcedure = t.procedure;
+const sessionRouter = t.router({
+	join: publicProcedure.input(JoinInputSchema).mutation(({ input, ctx }) => {
+		const agent = {
+			id: crypto.randomUUID(),
+			name: input.name,
+			role: input.role,
+			repoPath: input.repoPath,
+			connectedAt: /* @__PURE__ */ new Date()
+		};
+		ctx.state.addAgent(agent);
+		return {
+			agent,
+			sessionId: ctx.state.getSessionId()
+		};
+	}),
+	leave: publicProcedure.input(z.object({ agentId: z.string().uuid() })).mutation(({ input, ctx }) => {
+		return { success: ctx.state.removeAgent(input.agentId) };
+	}),
+	list: publicProcedure.query(({ ctx }) => {
+		return ctx.state.listAgents();
+	}),
+	onAgentChange: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const handler = (agents) => {
+				emit.next(agents);
+			};
+			ctx.state.on("agentChange", handler);
+			emit.next(ctx.state.listAgents());
+			return () => {
+				ctx.state.off("agentChange", handler);
+			};
+		});
+	})
+});
+const contextRouter = t.router({
+	share: publicProcedure.input(ShareContextInputSchema.extend({ agentId: z.string().uuid() })).mutation(({ input, ctx }) => {
+		const now = /* @__PURE__ */ new Date();
+		const existing = ctx.state.getContext(input.key);
+		const entry = {
+			id: existing?.id ?? crypto.randomUUID(),
+			key: input.key,
+			value: input.value,
+			tags: input.tags ?? [],
+			createdBy: existing?.createdBy ?? input.agentId,
+			createdAt: existing?.createdAt ?? now,
+			updatedAt: now
+		};
+		ctx.state.setContext(entry);
+		return entry;
+	}),
+	get: publicProcedure.input(GetContextInputSchema).query(({ input, ctx }) => {
+		return ctx.state.getContext(input.key) ?? null;
+	}),
+	list: publicProcedure.input(ListContextInputSchema.optional()).query(({ input, ctx }) => {
+		return ctx.state.listContext(input);
+	}),
+	onContextChange: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const handler = (entry) => {
+				emit.next(entry);
+			};
+			ctx.state.on("contextChange", handler);
+			return () => {
+				ctx.state.off("contextChange", handler);
+			};
+		});
+	})
+});
+const questionsRouter = t.router({
+	ask: publicProcedure.input(AskInputSchema.extend({ agentId: z.string().uuid() })).mutation(({ input, ctx }) => {
+		const question = {
+			id: crypto.randomUUID(),
+			question: input.question,
+			from: input.agentId,
+			to: input.to,
+			status: "pending",
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		ctx.state.addQuestion(question);
+		return question;
+	}),
+	answer: publicProcedure.input(AnswerInputSchema.extend({ agentId: z.string().uuid() })).mutation(({ input, ctx }) => {
+		const answered = ctx.state.answerQuestion(input.questionId, input.answer, input.agentId);
+		if (!answered) throw new Error(`Question not found: ${input.questionId}`);
+		return answered;
+	}),
+	listPending: publicProcedure.input(z.object({ agentId: z.string().uuid().optional() }).optional()).query(({ input, ctx }) => {
+		return ctx.state.listPendingQuestions(input?.agentId);
+	}),
+	onQuestion: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const questionHandler = (question) => {
+				emit.next(question);
+			};
+			const answerHandler = (question) => {
+				emit.next(question);
+			};
+			ctx.state.on("question", questionHandler);
+			ctx.state.on("answer", answerHandler);
+			return () => {
+				ctx.state.off("question", questionHandler);
+				ctx.state.off("answer", answerHandler);
+			};
+		});
+	})
+});
+const decisionsRouter = t.router({
+	log: publicProcedure.input(LogDecisionInputSchema.extend({ agentId: z.string().uuid() })).mutation(({ input, ctx }) => {
+		const decision = {
+			id: crypto.randomUUID(),
+			decision: input.decision,
+			rationale: input.rationale,
+			by: input.agentId,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		ctx.state.addDecision(decision);
+		return decision;
+	}),
+	list: publicProcedure.query(({ ctx }) => {
+		return ctx.state.listDecisions();
+	})
+});
+/**
+* Main application router
+*/
+const appRouter = t.router({
+	session: sessionRouter,
+	context: contextRouter,
+	questions: questionsRouter,
+	decisions: decisionsRouter
+});
+/**
+* Create context for a request
+*/
+function createContext() {
+	return { state: getOrCreateState() };
+}
+
+//#endregion
+export { appRouter, createContext };

package/server.js

@@ -0,0 +1,45 @@
+import { appRouter, createContext } from "./router.js";
+import { applyWSSHandler } from "@trpc/server/adapters/ws";
+import { WebSocketServer } from "ws";
+
+//#region src/server.ts
+/**
+* Create and start the coordinator WebSocket server
+*/
+function createServer(options = {}) {
+	const port = options.port ?? 3030;
+	const host = options.host ?? "localhost";
+	const wss = new WebSocketServer({
+		port,
+		host
+	});
+	const handler = applyWSSHandler({
+		wss,
+		router: appRouter,
+		createContext,
+		keepAlive: {
+			enabled: true,
+			pingMs: 3e4,
+			pongWaitMs: 5e3
+		}
+	});
+	console.error(`[coordinator] WebSocket server listening on ws://${host}:${port}`);
+	wss.on("connection", (ws) => {
+		console.error(`[coordinator] Client connected (${wss.clients.size} total)`);
+		ws.on("close", () => {
+			console.error(`[coordinator] Client disconnected (${wss.clients.size} total)`);
+		});
+	});
+	const close = () => {
+		console.error("[coordinator] Shutting down server...");
+		handler.broadcastReconnectNotification();
+		wss.close();
+	};
+	return {
+		wss,
+		close
+	};
+}
+
+//#endregion
+export { createServer };

package/state.js

@@ -0,0 +1,112 @@
+import { EventEmitter } from "node:events";
+
+//#region src/state.ts
+/**
+* EventEmitter-based state manager for the coordinator
+*/
+var CoordinatorState = class extends EventEmitter {
+	sessionId;
+	agents = /* @__PURE__ */ new Map();
+	context = /* @__PURE__ */ new Map();
+	questions = /* @__PURE__ */ new Map();
+	decisions = [];
+	constructor(sessionId) {
+		super();
+		this.sessionId = sessionId;
+	}
+	getSessionId() {
+		return this.sessionId;
+	}
+	addAgent(agent) {
+		this.agents.set(agent.id, agent);
+		this.emit("agentChange", this.listAgents());
+	}
+	removeAgent(agentId) {
+		const removed = this.agents.delete(agentId);
+		if (removed) this.emit("agentChange", this.listAgents());
+		return removed;
+	}
+	getAgent(agentId) {
+		return this.agents.get(agentId);
+	}
+	listAgents() {
+		return Array.from(this.agents.values());
+	}
+	setContext(entry) {
+		this.context.set(entry.key, entry);
+		this.emit("contextChange", entry);
+	}
+	getContext(key) {
+		return this.context.get(key);
+	}
+	listContext(filters) {
+		let entries = Array.from(this.context.values());
+		const filterTags = filters?.tags;
+		if (filterTags && filterTags.length > 0) entries = entries.filter((entry) => filterTags.every((tag) => entry.tags.includes(tag)));
+		if (filters?.createdBy) entries = entries.filter((entry) => entry.createdBy === filters.createdBy);
+		return entries;
+	}
+	addQuestion(question) {
+		this.questions.set(question.id, question);
+		this.emit("question", question);
+	}
+	answerQuestion(questionId, answer, answeredBy) {
+		const question = this.questions.get(questionId);
+		if (!question) return;
+		const answered = {
+			...question,
+			answer,
+			answeredBy,
+			status: "answered",
+			answeredAt: /* @__PURE__ */ new Date()
+		};
+		this.questions.set(questionId, answered);
+		this.emit("answer", answered);
+		return answered;
+	}
+	getQuestion(questionId) {
+		return this.questions.get(questionId);
+	}
+	listPendingQuestions(forAgentId) {
+		return Array.from(this.questions.values()).filter((q) => {
+			if (q.status !== "pending") return false;
+			if (forAgentId && q.to && q.to !== forAgentId) return false;
+			return true;
+		});
+	}
+	addDecision(decision) {
+		this.decisions.push(decision);
+	}
+	listDecisions() {
+		return [...this.decisions];
+	}
+};
+/**
+* Global state instance (singleton per server)
+*/
+let globalState = null;
+function getOrCreateState(sessionId) {
+	if (!globalState) globalState = new CoordinatorState(sessionId ?? crypto.randomUUID());
+	return globalState;
+}
+/**
+* Resets the global coordinator state singleton to null.
+*
+* @remarks
+* Call this in test teardown (e.g., `afterEach` or `afterAll`) to ensure clean
+* state between test suites. This prevents state from leaking across tests when
+* using the singleton pattern.
+*
+* @example
+* ```ts
+* afterEach(() => {
+*   resetState();
+* });
+* ```
+*/
+function resetState() {
+	globalState = null;
+}
+
+//#endregion
+export { CoordinatorState, getOrCreateState, resetState };

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.9"
+    }
+  ]
+}

package/36.js

@@ -1,263 +0,0 @@
-import { AnswerInputSchema, AskInputSchema, DEFAULT_HOST, DEFAULT_PORT, GetContextInputSchema, JoinInputSchema, ListContextInputSchema, LogDecisionInputSchema, ShareContextInputSchema } from "@spencerbeggs/claude-coordinator-core";
-import { initTRPC } from "@trpc/server";
-import { observable } from "@trpc/server/observable";
-import { z } from "zod";
-import { EventEmitter } from "node:events";
-import { applyWSSHandler } from "@trpc/server/adapters/ws";
-import { WebSocketServer } from "ws";
-class CoordinatorState extends EventEmitter {
-    sessionId;
-    agents = new Map();
-    context = new Map();
-    questions = new Map();
-    decisions = [];
-    constructor(sessionId){
-        super();
-        this.sessionId = sessionId;
-    }
-    getSessionId() {
-        return this.sessionId;
-    }
-    addAgent(agent) {
-        this.agents.set(agent.id, agent);
-        this.emit("agentChange", this.listAgents());
-    }
-    removeAgent(agentId) {
-        const removed = this.agents.delete(agentId);
-        if (removed) this.emit("agentChange", this.listAgents());
-        return removed;
-    }
-    getAgent(agentId) {
-        return this.agents.get(agentId);
-    }
-    listAgents() {
-        return Array.from(this.agents.values());
-    }
-    setContext(entry) {
-        this.context.set(entry.key, entry);
-        this.emit("contextChange", entry);
-    }
-    getContext(key) {
-        return this.context.get(key);
-    }
-    listContext(filters) {
-        let entries = Array.from(this.context.values());
-        const filterTags = filters?.tags;
-        if (filterTags && filterTags.length > 0) entries = entries.filter((entry)=>filterTags.every((tag)=>entry.tags.includes(tag)));
-        if (filters?.createdBy) entries = entries.filter((entry)=>entry.createdBy === filters.createdBy);
-        return entries;
-    }
-    addQuestion(question) {
-        this.questions.set(question.id, question);
-        this.emit("question", question);
-    }
-    answerQuestion(questionId, answer, answeredBy) {
-        const question = this.questions.get(questionId);
-        if (!question) return;
-        const answered = {
-            ...question,
-            answer,
-            answeredBy,
-            status: "answered",
-            answeredAt: new Date()
-        };
-        this.questions.set(questionId, answered);
-        this.emit("answer", answered);
-        return answered;
-    }
-    getQuestion(questionId) {
-        return this.questions.get(questionId);
-    }
-    listPendingQuestions(forAgentId) {
-        return Array.from(this.questions.values()).filter((q)=>{
-            if ("pending" !== q.status) return false;
-            if (forAgentId && q.to && q.to !== forAgentId) return false;
-            return true;
-        });
-    }
-    addDecision(decision) {
-        this.decisions.push(decision);
-    }
-    listDecisions() {
-        return [
-            ...this.decisions
-        ];
-    }
-}
-let globalState = null;
-function getOrCreateState(sessionId) {
-    if (!globalState) globalState = new CoordinatorState(sessionId ?? crypto.randomUUID());
-    return globalState;
-}
-function resetState() {
-    globalState = null;
-}
-const t = initTRPC.context().create();
-const publicProcedure = t.procedure;
-const sessionRouter = t.router({
-    join: publicProcedure.input(JoinInputSchema).mutation(({ input, ctx })=>{
-        const agent = {
-            id: crypto.randomUUID(),
-            name: input.name,
-            role: input.role,
-            repoPath: input.repoPath,
-            connectedAt: new Date()
-        };
-        ctx.state.addAgent(agent);
-        return {
-            agent,
-            sessionId: ctx.state.getSessionId()
-        };
-    }),
-    leave: publicProcedure.input(z.object({
-        agentId: z.string().uuid()
-    })).mutation(({ input, ctx })=>{
-        const removed = ctx.state.removeAgent(input.agentId);
-        return {
-            success: removed
-        };
-    }),
-    list: publicProcedure.query(({ ctx })=>ctx.state.listAgents()),
-    onAgentChange: publicProcedure.subscription(({ ctx })=>observable((emit)=>{
-            const handler = (agents)=>{
-                emit.next(agents);
-            };
-            ctx.state.on("agentChange", handler);
-            emit.next(ctx.state.listAgents());
-            return ()=>{
-                ctx.state.off("agentChange", handler);
-            };
-        }))
-});
-const contextRouter = t.router({
-    share: publicProcedure.input(ShareContextInputSchema.extend({
-        agentId: z.string().uuid()
-    })).mutation(({ input, ctx })=>{
-        const now = new Date();
-        const existing = ctx.state.getContext(input.key);
-        const entry = {
-            id: existing?.id ?? crypto.randomUUID(),
-            key: input.key,
-            value: input.value,
-            tags: input.tags ?? [],
-            createdBy: existing?.createdBy ?? input.agentId,
-            createdAt: existing?.createdAt ?? now,
-            updatedAt: now
-        };
-        ctx.state.setContext(entry);
-        return entry;
-    }),
-    get: publicProcedure.input(GetContextInputSchema).query(({ input, ctx })=>ctx.state.getContext(input.key) ?? null),
-    list: publicProcedure.input(ListContextInputSchema.optional()).query(({ input, ctx })=>ctx.state.listContext(input)),
-    onContextChange: publicProcedure.subscription(({ ctx })=>observable((emit)=>{
-            const handler = (entry)=>{
-                emit.next(entry);
-            };
-            ctx.state.on("contextChange", handler);
-            return ()=>{
-                ctx.state.off("contextChange", handler);
-            };
-        }))
-});
-const questionsRouter = t.router({
-    ask: publicProcedure.input(AskInputSchema.extend({
-        agentId: z.string().uuid()
-    })).mutation(({ input, ctx })=>{
-        const question = {
-            id: crypto.randomUUID(),
-            question: input.question,
-            from: input.agentId,
-            to: input.to,
-            status: "pending",
-            createdAt: new Date()
-        };
-        ctx.state.addQuestion(question);
-        return question;
-    }),
-    answer: publicProcedure.input(AnswerInputSchema.extend({
-        agentId: z.string().uuid()
-    })).mutation(({ input, ctx })=>{
-        const answered = ctx.state.answerQuestion(input.questionId, input.answer, input.agentId);
-        if (!answered) throw new Error(`Question not found: ${input.questionId}`);
-        return answered;
-    }),
-    listPending: publicProcedure.input(z.object({
-        agentId: z.string().uuid().optional()
-    }).optional()).query(({ input, ctx })=>ctx.state.listPendingQuestions(input?.agentId)),
-    onQuestion: publicProcedure.subscription(({ ctx })=>observable((emit)=>{
-            const questionHandler = (question)=>{
-                emit.next(question);
-            };
-            const answerHandler = (question)=>{
-                emit.next(question);
-            };
-            ctx.state.on("question", questionHandler);
-            ctx.state.on("answer", answerHandler);
-            return ()=>{
-                ctx.state.off("question", questionHandler);
-                ctx.state.off("answer", answerHandler);
-            };
-        }))
-});
-const decisionsRouter = t.router({
-    log: publicProcedure.input(LogDecisionInputSchema.extend({
-        agentId: z.string().uuid()
-    })).mutation(({ input, ctx })=>{
-        const decision = {
-            id: crypto.randomUUID(),
-            decision: input.decision,
-            rationale: input.rationale,
-            by: input.agentId,
-            createdAt: new Date()
-        };
-        ctx.state.addDecision(decision);
-        return decision;
-    }),
-    list: publicProcedure.query(({ ctx })=>ctx.state.listDecisions())
-});
-const appRouter = t.router({
-    session: sessionRouter,
-    context: contextRouter,
-    questions: questionsRouter,
-    decisions: decisionsRouter
-});
-function createContext() {
-    return {
-        state: getOrCreateState()
-    };
-}
-function createServer(options = {}) {
-    const port = options.port ?? 3030;
-    const host = options.host ?? "localhost";
-    const wss = new WebSocketServer({
-        port,
-        host
-    });
-    const handler = applyWSSHandler({
-        wss,
-        router: appRouter,
-        createContext: createContext,
-        keepAlive: {
-            enabled: true,
-            pingMs: 30000,
-            pongWaitMs: 5000
-        }
-    });
-    console.error(`[coordinator] WebSocket server listening on ws://${host}:${port}`);
-    wss.on("connection", (ws)=>{
-        console.error(`[coordinator] Client connected (${wss.clients.size} total)`);
-        ws.on("close", ()=>{
-            console.error(`[coordinator] Client disconnected (${wss.clients.size} total)`);
-        });
-    });
-    const close = ()=>{
-        console.error("[coordinator] Shutting down server...");
-        handler.broadcastReconnectNotification();
-        wss.close();
-    };
-    return {
-        wss,
-        close
-    };
-}
-export { CoordinatorState, DEFAULT_HOST, DEFAULT_PORT, appRouter, createContext, createServer, getOrCreateState, resetState };