mcp-coordinator 0.1.0

package/dist/src/server-setup.d.ts

@@ -0,0 +1,34 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { AgentRegistry } from "./agent-registry.js";
+import { Consultation } from "./consultation.js";
+import { ConflictDetector } from "./conflict-detector.js";
+import { DependencyMapper } from "./dependency-map.js";
+import { FileTracker } from "./file-tracker.js";
+import { ImpactScorer } from "./impact-scorer.js";
+import { SummaryContextProvider } from "./context-provider.js";
+import { IntrospectionManager } from "./introspection.js";
+import { SseEmitter } from "./sse-emitter.js";
+import { MqttBridge } from "./mqtt-bridge.js";
+import { AgentActivityTracker } from "./agent-activity.js";
+import { QuotaCache } from "./quota/quota-cache.js";
+import type { CoordinatorConfig } from "./types.js";
+import { type Logger } from "./logger.js";
+export interface CoordinatorServices {
+    logger: Logger;
+    registry: AgentRegistry;
+    activityTracker: AgentActivityTracker;
+    consultation: Consultation;
+    conflictDetector: ConflictDetector;
+    depMap: DependencyMapper;
+    fileTracker: FileTracker;
+    impactScorer: ImpactScorer;
+    introspection: IntrospectionManager;
+    contextProvider: SummaryContextProvider;
+    sseEmitter: SseEmitter;
+    mqttBridge: MqttBridge;
+    quotaCache: QuotaCache;
+}
+/** Create shared services (once at startup). */
+export declare function createServices(config: CoordinatorConfig): CoordinatorServices;
+/** Create a new McpServer bound to the shared services (one per MCP session). */
+export declare function createMcpServer(services: CoordinatorServices): McpServer;

package/dist/src/server-setup.js

@@ -0,0 +1,453 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { initDatabase } from "./database.js";
+import { AgentRegistry } from "./agent-registry.js";
+import { Consultation } from "./consultation.js";
+import { ConflictDetector } from "./conflict-detector.js";
+import { DependencyMapper } from "./dependency-map.js";
+import { FileTracker } from "./file-tracker.js";
+import { ImpactScorer } from "./impact-scorer.js";
+import { SummaryContextProvider } from "./context-provider.js";
+import { IntrospectionManager } from "./introspection.js";
+import { SseEmitter } from "./sse-emitter.js";
+import { MqttBridge } from "./mqtt-bridge.js";
+import { assessPlanQuality } from "./plan-quality.js";
+import { AgentActivityTracker } from "./agent-activity.js";
+import { QuotaCache } from "./quota/quota-cache.js";
+import { createLogger } from "./logger.js";
+import { getVersion } from "../cli/version.js";
+const VERSION = getVersion();
+/** Create shared services (once at startup). */
+export function createServices(config) {
+    initDatabase(config.dataDir);
+    const logger = createLogger();
+    const registry = new AgentRegistry();
+    const activityTracker = new AgentActivityTracker(registry);
+    const consultation = new Consultation(logger.child({ component: "consultation" }));
+    const depMap = new DependencyMapper();
+    const fileTracker = new FileTracker();
+    const impactScorer = new ImpactScorer(registry, fileTracker, consultation);
+    const introspection = new IntrospectionManager();
+    const conflictDetector = new ConflictDetector(consultation, depMap, fileTracker, logger.child({ component: "conflict" }));
+    const contextProvider = new SummaryContextProvider(registry, consultation, fileTracker);
+    const sseEmitter = new SseEmitter();
+    const mqttBridge = new MqttBridge(logger.child({ component: "mqtt" }));
+    // Quota cache — macOS-only for now, Linux/Windows stubs return 503 via the
+    // /api/quota handler so raids keep running without a quota guardrail there.
+    // onRefresh fans the new data out to dashboard (SSE) + any live listener (MQTT)
+    // so the UI reflects quota moves without polling.
+    const quotaCache = new QuotaCache({
+        logger: logger.child({ component: "quota" }),
+        onRefresh: (info) => {
+            sseEmitter.emit("quota_update", {
+                five_hour: info.fiveHour,
+                seven_day: info.sevenDay,
+                seven_day_sonnet: info.sevenDaySonnet,
+                fetched_at: info.fetchedAt,
+            });
+            mqttBridge.publishQuotaUpdate(info);
+        },
+    });
+    // Hybrid refresh: keep the cache warm whenever agents are online. Tap into
+    // SSE events for agent_online/agent_offline since they're already emitted by
+    // the REST handler on /api/register and the offline hook. Avoids plumbing a
+    // dedicated observer through AgentRegistry.
+    sseEmitter.addListener((event) => {
+        if (event.type === "agent_online")
+            quotaCache.onAgentActive();
+        else if (event.type === "agent_offline")
+            quotaCache.onAgentInactive();
+    });
+    // Centralized resolution → SSE + MQTT
+    consultation.onResolve((event) => {
+        sseEmitter.emit("thread_resolved", {
+            thread_id: event.thread_id,
+            resolution_type: event.resolution_type,
+            resolution: event.resolution_summary,
+            approved_by: event.approved_by,
+            approved_by_name: event.approved_by_name,
+            created_at: event.created_at,
+            resolved_at: event.resolved_at,
+            had_messages: event.had_messages,
+        });
+        if (event.resolution_type !== "auto_resolved") {
+            mqttBridge.publishResolution(event.thread_id, "resolved", event.resolution_summary || "");
+        }
+    });
+    return {
+        logger, registry, activityTracker, consultation, conflictDetector,
+        depMap, fileTracker, impactScorer, introspection, contextProvider, sseEmitter, mqttBridge, quotaCache,
+    };
+}
+/** Create a new McpServer bound to the shared services (one per MCP session). */
+export function createMcpServer(services) {
+    const { registry, activityTracker, consultation, conflictDetector, depMap, fileTracker, impactScorer, introspection, contextProvider, sseEmitter, mqttBridge } = services;
+    const mcpLog = services.logger.child({ component: "mcp" });
+    const server = new McpServer({
+        name: "mcp-coordinator-v3",
+        version: VERSION,
+    });
+    // ── AGENT REGISTRY TOOLS ──
+    server.tool("register_agent", "Register agent as online with module list", {
+        agent_id: z.string(),
+        name: z.string(),
+        modules: z.array(z.string()),
+    }, async ({ agent_id, name, modules }) => {
+        mcpLog.info({ tool: "register_agent", agent_id, name, module_count: modules.length }, "Tool called");
+        const agent = registry.register(agent_id, name, modules);
+        sseEmitter.emit("agent_online", { agent_id, name, modules });
+        mqttBridge.registerAgent(agent_id, name);
+        return { content: [{ type: "text", text: JSON.stringify(agent) }] };
+    });
+    server.tool("list_agents", "List registered agents", {
+        online_only: z.boolean().optional(),
+    }, async ({ online_only }) => {
+        const agents = online_only ? registry.listOnline() : registry.listAll();
+        return { content: [{ type: "text", text: JSON.stringify(agents) }] };
+    });
+    server.tool("heartbeat", "Update agent activity status and last seen timestamp", {
+        agent_id: z.string(),
+        current_file: z.string().optional(),
+        current_thread: z.string().optional(),
+    }, async ({ agent_id, current_file, current_thread }) => {
+        registry.heartbeat(agent_id);
+        activityTracker.heartbeat(agent_id, {
+            currentFile: current_file || null,
+            currentThread: current_thread || null,
+        });
+        const activity = activityTracker.getActivity(agent_id);
+        sseEmitter.emit("agent_activity", {
+            agent_id, activity_status: activity.activity_status,
+            current_file: activity.current_file, current_thread: activity.current_thread,
+        });
+        return { content: [{ type: "text", text: JSON.stringify(activity) }] };
+    });
+    server.tool("agent_activity", "Get activity status for all online agents", {}, async () => {
+        const activities = activityTracker.listAll({ idleAfterMinutes: 5 });
+        return { content: [{ type: "text", text: JSON.stringify(activities) }] };
+    });
+    // ── CONSULTATION TOOLS ──
+    server.tool("announce_work", "Open a consultation thread before starting work", {
+        agent_id: z.string(),
+        subject: z.string(),
+        plan: z.string().optional(),
+        target_modules: z.array(z.string()),
+        target_files: z.array(z.string()),
+        depends_on_files: z.array(z.string()).optional(),
+        exports_affected: z.array(z.string()).optional(),
+        keep_open: z.boolean().optional().describe("Keep thread open even if no agents are concerned (for manual coordination like games or debates)"),
+        assigned_to: z.string().optional().describe("Directed-dispatch: only this agent_id will be allowed to claim the thread. Use for lead→worker handoffs in maitre/chaine/relais presets. Implies keep_open=true."),
+    }, async ({ agent_id, subject, plan, target_modules, target_files, depends_on_files, exports_affected, keep_open, assigned_to }) => {
+        mcpLog.info({ tool: "announce_work", agent_id, subject, target_modules, target_files, assigned_to }, "Tool called");
+        // Quality gate on plan
+        const planQuality = assessPlanQuality(plan);
+        const effectiveMode = planQuality.mode;
+        const conflicts = conflictDetector.detect({ agent_id, target_modules, target_files });
+        const thread = consultation.announceWork({
+            agent_id, subject, plan, target_modules, target_files, depends_on_files, exports_affected, keep_open, assigned_to,
+        });
+        // Store conflicts on thread
+        if (conflicts.length > 0) {
+            const db = (await import("./database.js")).getDb();
+            db.prepare("UPDATE threads SET conflicts = ? WHERE id = ?")
+                .run(JSON.stringify(conflicts), thread.id);
+        }
+        // Impact scoring: categorize all online agents
+        const categorized = impactScorer.categorize({
+            agent_id, target_modules, target_files, depends_on_files, exports_affected,
+        });
+        // Override expected_respondents with concerned agents from scorer
+        {
+            const db = (await import("./database.js")).getDb();
+            const concernedIds = categorized.concerned.map(s => s.agent_id);
+            db.prepare("UPDATE threads SET expected_respondents = ? WHERE id = ?")
+                .run(JSON.stringify(concernedIds), thread.id);
+            // Only auto-resolve when truly alone — no other online agents.
+            // If peers are online but not yet concerned, keep the thread open so
+            // a subsequent announce can still match via Layer 0. Thread timeouts
+            // naturally if no one joins.
+            const otherOnlineCount = registry.listOnline().filter((a) => a.id !== agent_id).length;
+            const shouldAutoResolve = concernedIds.length === 0 && otherOnlineCount === 0;
+            if (shouldAutoResolve && thread.status === "open" && !keep_open) {
+                db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?")
+                    .run(new Date().toISOString(), thread.id);
+                consultation.emitResolution(thread.id, "auto_resolved");
+            }
+        }
+        // Emit impact_scored SSE events for all agents
+        for (const s of [...categorized.concerned, ...categorized.gray_zone, ...categorized.pass]) {
+            sseEmitter.emit("impact_scored", {
+                thread_id: thread.id, agent_id: s.agent_id, agent_name: s.agent_name,
+                score: s.score, reasons: s.reasons, category: s.score >= 90 ? "concerned" : s.score >= 30 ? "gray_zone" : "pass",
+            });
+        }
+        // Create introspection records and emit introspection_requested for gray_zone agents
+        for (const s of categorized.gray_zone) {
+            introspection.create({ thread_id: thread.id, agent_id: s.agent_id, score: s.score, reasons: s.reasons });
+            sseEmitter.emit("introspection_requested", {
+                thread_id: thread.id, agent_id: s.agent_id, agent_name: s.agent_name, score: s.score, reasons: s.reasons,
+            });
+        }
+        // Emit downgrade event when plan is provided but quality is insufficient
+        if (plan && effectiveMode === "discovery") {
+            sseEmitter.emit("impact_scored", {
+                thread_id: thread.id,
+                agent_id: agent_id,
+                agent_name: registry.get(agent_id)?.name || agent_id,
+                score: planQuality.score,
+                reasons: [`plan downgraded: score ${planQuality.score}/3 — ${!planQuality.checks.mentions_files ? 'no files' : ''} ${!planQuality.checks.concrete_approach ? 'vague approach' : ''} ${!planQuality.checks.sufficient_detail ? 'too short' : ''}`.trim()],
+                category: "plan_quality",
+            });
+        }
+        const updated = consultation.getThread(thread.id);
+        const respondents = JSON.parse(updated.expected_respondents || "[]");
+        sseEmitter.emit("thread_opened", {
+            thread_id: thread.id, initiator: agent_id, subject, target_modules, conflicts,
+            expected_respondents: respondents,
+            mode: effectiveMode,
+            plan: plan || null,
+            plan_quality: planQuality,
+        });
+        mqttBridge.publishConsultation(thread.id, agent_id, subject, target_modules);
+        // Gather context from concerned agents for the initiator
+        const contextForInitiator = respondents.map((rid) => contextProvider.getRelevantContext(rid, { thread_id: updated.id, subject, target_modules, target_files })).filter((ctx) => ctx.modules.length > 0);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({ thread: updated, conflicts, context: contextForInitiator, impact: categorized }),
+                }],
+        };
+    });
+    server.tool("post_to_thread", "Post a message to a consultation thread", {
+        thread_id: z.string(),
+        agent_id: z.string(),
+        agent_name: z.string().optional(),
+        type: z.enum(["context", "suggestion", "warning"]),
+        content: z.string(),
+        context_snapshot: z.string().optional(),
+        in_reply_to: z.string().optional(),
+    }, async ({ thread_id, agent_id, agent_name, type, content, context_snapshot, in_reply_to }) => {
+        mcpLog.info({ tool: "post_to_thread", thread_id, agent_id, type }, "Tool called");
+        const msg = consultation.postToThread({
+            thread_id, agent_id, agent_name, type, content, context_snapshot, in_reply_to,
+        });
+        const thread = consultation.getThread(thread_id);
+        sseEmitter.emit("message_posted", {
+            thread_id, agent_id, agent_name: agent_name || agent_id,
+            type, content, round: thread?.round || 1,
+            token_estimate: msg.token_estimate || 0,
+        });
+        mqttBridge.publishMessage(thread_id, agent_id, type, content);
+        return { content: [{ type: "text", text: JSON.stringify(msg) }] };
+    });
+    server.tool("propose_resolution", "Propose a resolution for the consultation", {
+        thread_id: z.string(),
+        agent_id: z.string(),
+        summary: z.string(),
+        plan: z.string().optional(),
+    }, async ({ thread_id, agent_id, summary, plan }) => {
+        mcpLog.info({ tool: "propose_resolution", thread_id, agent_id }, "Tool called");
+        consultation.proposeResolution(thread_id, agent_id, summary);
+        sseEmitter.emit("resolution_proposed", { thread_id, agent_id, summary });
+        mqttBridge.publishResolution(thread_id, "resolving", summary);
+        const thread = consultation.getThread(thread_id);
+        return { content: [{ type: "text", text: JSON.stringify(thread) }] };
+    });
+    server.tool("approve_resolution", "Approve the proposed resolution", {
+        thread_id: z.string(),
+        agent_id: z.string(),
+    }, async ({ thread_id, agent_id }) => {
+        mcpLog.info({ tool: "approve_resolution", thread_id, agent_id }, "Tool called");
+        const agentInfo = registry.get(agent_id);
+        consultation.approveResolution(thread_id, agent_id, agentInfo?.name);
+        const thread = consultation.getThread(thread_id);
+        return { content: [{ type: "text", text: JSON.stringify(thread) }] };
+    });
+    server.tool("contest_resolution", "Contest the proposed resolution", {
+        thread_id: z.string(),
+        agent_id: z.string(),
+        reason: z.string(),
+    }, async ({ thread_id, agent_id, reason }) => {
+        mcpLog.info({ tool: "contest_resolution", thread_id, agent_id }, "Tool called");
+        consultation.contestResolution(thread_id, agent_id, reason);
+        const thread = consultation.getThread(thread_id);
+        return { content: [{ type: "text", text: JSON.stringify(thread) }] };
+    });
+    server.tool("close_thread", "Close a consultation thread", {
+        thread_id: z.string(),
+        agent_id: z.string(),
+        summary: z.string(),
+    }, async ({ thread_id, agent_id, summary }) => {
+        mcpLog.info({ tool: "close_thread", thread_id, agent_id }, "Tool called");
+        consultation.closeThread(thread_id, agent_id, summary);
+        return { content: [{ type: "text", text: "closed" }] };
+    });
+    server.tool("cancel_thread", "Cancel a consultation thread", {
+        thread_id: z.string(),
+        agent_id: z.string(),
+        reason: z.string().optional(),
+    }, async ({ thread_id, agent_id, reason }) => {
+        mcpLog.info({ tool: "cancel_thread", thread_id, agent_id }, "Tool called");
+        consultation.cancelThread(thread_id, agent_id, reason);
+        sseEmitter.emit("thread_cancelled", { thread_id, reason });
+        return { content: [{ type: "text", text: "cancelled" }] };
+    });
+    server.tool("get_thread", "Get a thread with all messages", {
+        thread_id: z.string(),
+    }, async ({ thread_id }) => {
+        const result = consultation.getThreadWithMessages(thread_id);
+        mcpLog.debug({ tool: "get_thread", thread_id, message_count: result?.messages.length }, "Tool called");
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    server.tool("get_thread_updates", "Get new messages since timestamp", {
+        agent_id: z.string(),
+        since: z.string().optional(),
+    }, async ({ agent_id, since }) => {
+        const updates = consultation.getThreadUpdates(agent_id, since);
+        return { content: [{ type: "text", text: JSON.stringify(updates) }] };
+    });
+    server.tool("list_threads", "List consultation threads", {
+        status: z.string().optional(),
+        agent_id: z.string().optional(),
+        module: z.string().optional(),
+        assigned_to_me: z.string().optional().describe("Filter to threads claimable by this agent_id: open pool (assigned_to NULL) OR directed to me. Use for worker agents receiving directed dispatches."),
+    }, async ({ status, agent_id, module, assigned_to_me }) => {
+        const threads = consultation.listThreads({ status, agent_id, module, assigned_to_me });
+        mcpLog.debug({ tool: "list_threads", status, agent_id, module, assigned_to_me, result_count: threads.length }, "Tool called");
+        return { content: [{ type: "text", text: JSON.stringify(threads) }] };
+    });
+    server.tool("log_action_summary", "Log a one-liner summary of an action", {
+        session_id: z.string(),
+        agent_id: z.string(),
+        file_path: z.string().optional(),
+        summary: z.string(),
+    }, async ({ session_id, agent_id, file_path, summary }) => {
+        const result = consultation.logActionSummary({ session_id, agent_id, file_path, summary });
+        sseEmitter.emit("action_summary", { agent_id, file_path, summary });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ── FILE TRACKING TOOLS ──
+    server.tool("hot_files", "List files modified by multiple agents", {
+        since_minutes: z.number().optional(),
+    }, async ({ since_minutes }) => {
+        const files = fileTracker.getHotFiles(since_minutes || 30);
+        return { content: [{ type: "text", text: JSON.stringify(files) }] };
+    });
+    server.tool("get_session_files", "Get files modified in a session", {
+        session_id: z.string(),
+    }, async ({ session_id }) => {
+        const files = fileTracker.getBySession(session_id);
+        return { content: [{ type: "text", text: JSON.stringify(files) }] };
+    });
+    server.tool("check_file_conflict", "Check if another agent is editing a file", {
+        file_path: z.string(),
+        agent_id: z.string(),
+        within_minutes: z.number().optional(),
+    }, async ({ file_path, agent_id, within_minutes }) => {
+        const result = fileTracker.checkFileConflict(file_path, agent_id, within_minutes || 30);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+    });
+    // ── DEPENDENCY MAP TOOLS ──
+    server.tool("set_dependency_map", "Load module dependency graph", {
+        modules: z.string(), // JSON DependencyMap
+    }, async ({ modules }) => {
+        const map = JSON.parse(modules);
+        depMap.setMap(map);
+        return { content: [{ type: "text", text: "ok" }] };
+    });
+    server.tool("get_blast_radius", "Calculate impact of changes to a module", {
+        module_id: z.string(),
+    }, async ({ module_id }) => {
+        const radius = depMap.getBlastRadius(module_id);
+        return { content: [{ type: "text", text: JSON.stringify(radius) }] };
+    });
+    server.tool("get_module_info", "Get module dependency info", {
+        module_id: z.string(),
+    }, async ({ module_id }) => {
+        const info = depMap.getModuleInfo(module_id);
+        return { content: [{ type: "text", text: JSON.stringify(info) }] };
+    });
+    // ── STATUS TOOL ──
+    server.tool("coordinator_status", "Full system status", {}, async () => {
+        const online = registry.listOnline();
+        const openThreads = consultation.listThreads({ status: "open" });
+        const resolvingThreads = consultation.listThreads({ status: "resolving" });
+        const hotFiles = fileTracker.getHotFiles(30);
+        const status = {
+            agents_online: online.length,
+            agents: online.map((a) => ({ id: a.id, name: a.name, modules: JSON.parse(a.modules) })),
+            open_threads: openThreads.length,
+            resolving_threads: resolvingThreads.length,
+            hot_files: hotFiles.length,
+            mqtt_connected: mqttBridge.isConnected(),
+        };
+        mcpLog.debug({ tool: "coordinator_status", agents_online: online.length, open_threads: openThreads.length }, "Tool called");
+        return { content: [{ type: "text", text: JSON.stringify(status) }] };
+    });
+    // ── COORDINATION HELPERS ──
+    server.tool("wait_for_peers", "Block until at least N other online agents are registered, or timeout. Use before the first announce_work to avoid the race where one agent announces before peers have booted.", {
+        agent_id: z.string(),
+        min_peers: z.number().optional(),
+        timeout_seconds: z.number().optional(),
+    }, async ({ agent_id, min_peers, timeout_seconds }) => {
+        const targetPeers = min_peers ?? 1;
+        const timeoutMs = (timeout_seconds ?? 30) * 1000;
+        const pollIntervalMs = 1000;
+        const startedAt = Date.now();
+        mcpLog.info({ tool: "wait_for_peers", agent_id, min_peers: targetPeers, timeout_seconds: timeoutMs / 1000 }, "Tool called");
+        while (Date.now() - startedAt < timeoutMs) {
+            const peers = registry.listOnline().filter((a) => a.id !== agent_id);
+            if (peers.length >= targetPeers) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                ready: true,
+                                online_peers: peers.map((p) => ({ id: p.id, name: p.name })),
+                                waited_ms: Date.now() - startedAt,
+                            }),
+                        }],
+                };
+            }
+            await new Promise((r) => setTimeout(r, pollIntervalMs));
+        }
+        const finalPeers = registry.listOnline().filter((a) => a.id !== agent_id);
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify({
+                        ready: false,
+                        timeout: true,
+                        online_peers: finalPeers.map((p) => ({ id: p.id, name: p.name })),
+                        waited_ms: Date.now() - startedAt,
+                    }),
+                }],
+        };
+    });
+    // ── MQTT LISTENER TOOLS (replaces standalone mqtt-mcp-bridge) ──
+    server.tool("wait_for_message", "Block until an MQTT consultation message arrives or timeout", {
+        agent_id: z.string(),
+        timeout_seconds: z.number().optional(),
+    }, async ({ agent_id, timeout_seconds }) => {
+        const timeoutMs = (timeout_seconds || 15) * 1000;
+        const msg = await mqttBridge.waitForMessage(agent_id, timeoutMs);
+        if (msg) {
+            return { content: [{ type: "text", text: JSON.stringify(msg) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ timeout: true }) }] };
+    });
+    server.tool("get_queued_messages", "Get all queued MQTT messages without blocking", {
+        agent_id: z.string(),
+    }, async ({ agent_id }) => {
+        const messages = mqttBridge.getQueuedMessages(agent_id);
+        return { content: [{ type: "text", text: JSON.stringify(messages) }] };
+    });
+    server.tool("mqtt_publish", "Publish a message to an MQTT topic", {
+        topic: z.string(),
+        payload: z.string(),
+    }, async ({ topic, payload }) => {
+        mqttBridge.mqttPublish(topic, payload);
+        return { content: [{ type: "text", text: "published" }] };
+    });
+    return server;
+}

package/dist/src/sse-emitter.d.ts

@@ -0,0 +1,10 @@
+import type { CoordinatorEvent, EventType } from "./types.js";
+type EventListener = (event: CoordinatorEvent) => void;
+export declare class SseEmitter {
+    private listeners;
+    emit(type: EventType, payload: Record<string, unknown>): void;
+    getEventsSince(lastId: number): CoordinatorEvent[];
+    addListener(listener: EventListener): () => void;
+    removeAllListeners(): void;
+}
+export {};

package/dist/src/sse-emitter.js

@@ -0,0 +1,35 @@
+import { getDb } from "./database.js";
+export class SseEmitter {
+    listeners = [];
+    emit(type, payload) {
+        const db = getDb();
+        const payloadStr = JSON.stringify(payload);
+        const result = db
+            .prepare("INSERT INTO events (type, payload) VALUES (?, ?)")
+            .run(type, payloadStr);
+        const event = {
+            id: result.lastInsertRowid,
+            type,
+            payload: payloadStr,
+            created_at: new Date().toISOString(),
+        };
+        for (const listener of this.listeners) {
+            listener(event);
+        }
+    }
+    getEventsSince(lastId) {
+        const db = getDb();
+        return db
+            .prepare("SELECT * FROM events WHERE id > ? ORDER BY id")
+            .all(lastId);
+    }
+    addListener(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter((l) => l !== listener);
+        };
+    }
+    removeAllListeners() {
+        this.listeners = [];
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,121 @@
+export type AgentConnectionStatus = "online" | "offline";
+export type ActivityStatus = "working" | "idle" | "waiting" | "offline";
+export interface Agent {
+    id: string;
+    name: string;
+    modules: string;
+    status: AgentConnectionStatus;
+    registered_at: string;
+    last_seen_at: string;
+}
+export interface AgentActivity {
+    agent_id: string;
+    activity_status: ActivityStatus;
+    current_file: string | null;
+    current_thread: string | null;
+    last_activity_at: string;
+}
+export type ThreadStatus = "open" | "resolving" | "resolved" | "cancelled" | "poisoned";
+export type ResolutionType = "consensus" | "auto_resolved" | "timeout" | "closed" | "max_rounds" | "agent_departure";
+export interface Thread {
+    id: string;
+    initiator_id: string;
+    subject: string;
+    plan: string | null;
+    target_modules: string;
+    target_files: string;
+    status: ThreadStatus;
+    resolution_summary: string | null;
+    conflicts: string | null;
+    round: number;
+    max_rounds: number;
+    timeout_seconds: number;
+    created_at: string;
+    resolved_at: string | null;
+    expected_respondents: string | null;
+    depends_on_files: string | null;
+    exports_affected: string | null;
+    claimed_by: string | null;
+    claimed_at: string | null;
+    unclaim_count?: number | null;
+    assigned_to?: string | null;
+}
+export type MessageType = "context" | "suggestion" | "warning" | "resolution" | "approve" | "contest";
+export interface ThreadMessage {
+    id: string;
+    thread_id: string;
+    agent_id: string;
+    agent_name: string | null;
+    type: MessageType;
+    content: string;
+    context_snapshot: string | null;
+    in_reply_to: string | null;
+    round: number;
+    token_estimate: number;
+    created_at: string;
+}
+export interface ActionSummary {
+    id: string;
+    session_id: string;
+    agent_id: string;
+    file_path: string | null;
+    summary: string;
+    created_at: string;
+}
+export type EventType = "agent_online" | "agent_offline" | "thread_opened" | "message_posted" | "resolution_proposed" | "thread_resolved" | "thread_cancelled" | "file_edited" | "action_summary" | "impact_scored" | "introspection_requested" | "introspection_completed" | "agent_activity" | "task_claimed" | "token_usage" | "quota_update";
+export interface CoordinatorEvent {
+    id?: number;
+    type: EventType;
+    payload: string;
+    created_at?: string;
+}
+export interface ConflictReport {
+    type: "module_overlap" | "api_contract" | "file_overlap" | "dependency_chain";
+    severity: "warning" | "info";
+    agent_id: string;
+    agent_name: string;
+    description: string;
+    details: string;
+}
+export interface BlastRadius {
+    module_id: string;
+    direct_dependents: string[];
+    indirect_dependents: string[];
+    affected_exports: string[];
+    active_threads_in_radius: Thread[];
+}
+export interface ModuleInfo {
+    module_id: string;
+    depends_on: string[];
+    exports: string[];
+    owners: string[];
+}
+export type DependencyMap = Record<string, ModuleInfo>;
+export interface FileActivity {
+    id?: number;
+    session_id: string;
+    agent_id: string;
+    agent_name?: string;
+    tool_name: string;
+    file_path: string;
+    module: string;
+    created_at?: string;
+}
+export interface AgentContext {
+    agent_id: string;
+    modules: string[];
+    recent_files: string[];
+    action_summaries: ActionSummary[];
+}
+export interface ConsultationAnnounce {
+    thread_id: string;
+    subject: string;
+    target_modules: string[];
+    target_files: string[];
+}
+export interface CoordinatorConfig {
+    dataDir: string;
+    authEnabled?: boolean;
+    jwtSecret?: string;
+    jwtExpiry?: string;
+}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};