kitty-hive 0.1.1 → 0.3.0

package/dist/server.js

@@ -1,520 +1,19 @@
 import { randomUUID } from 'node:crypto';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
-import { createServer } from 'node:http';
-import { z } from 'zod';
-import { getAgentById, getAgentByName, touchAgent, initDB, getUnreadForAgent, setReadCursor, cleanupStaleTasks } from './db.js';
-import { handleStart } from './tools/start.js';
-import { handleDM, handleDMAsync } from './tools/dm.js';
-import { handleTaskCreate, handleTaskCreateAsync, handleTaskClaim, handleCheck, handleWorkflowPropose, handleWorkflowApprove, handleStepComplete, handleWorkflowReject } from './tools/task.js';
-import { handleEvents, handleList, handleInfo } from './tools/room.js';
-import { handleTeamCreate, handleTeamJoin, handleTeamList } from './tools/team.js';
-import * as db from './db.js';
-const LOG_PRIORITY = { error: 0, warn: 1, info: 2, debug: 3 };
-let logLevel = 'info';
-export function setLogLevel(level) { logLevel = level; }
-function log(level, msg) {
-    if (LOG_PRIORITY[level] <= LOG_PRIORITY[logLevel]) {
-        const prefix = level === 'info' ? '' : `[${level}] `;
-        console.log(`${prefix}${msg}`);
-    }
-}
-// sessionId → Session
-const sessions = {};
-// sessionId → agentId
-const sessionAgents = new Map();
-// agentId → Set<sessionId>
-const agentSessions = new Map();
-function bindSession(sessionId, agentId) {
-    // Clean up old binding if this session was previously bound to a different agent
-    const oldAgentId = sessionAgents.get(sessionId);
-    if (oldAgentId && oldAgentId !== agentId) {
-        const oldSet = agentSessions.get(oldAgentId);
-        if (oldSet) {
-            oldSet.delete(sessionId);
-            if (oldSet.size === 0)
-                agentSessions.delete(oldAgentId);
-        }
-    }
-    sessionAgents.set(sessionId, agentId);
-    let set = agentSessions.get(agentId);
-    if (!set) {
-        set = new Set();
-        agentSessions.set(agentId, set);
-    }
-    set.add(sessionId);
-    log("debug", `[bind] session=${sessionId} → agent=${agentId} (total sessions for agent: ${set.size})`);
-}
-function unbindSession(sessionId) {
-    const agentId = sessionAgents.get(sessionId);
-    if (agentId) {
-        const set = agentSessions.get(agentId);
-        if (set) {
-            set.delete(sessionId);
-            if (set.size === 0)
-                agentSessions.delete(agentId);
-        }
-        sessionAgents.delete(sessionId);
-    }
-}
-// --- Push notifications ---
-function notifyRoomMembers(roomId, excludeAgentId, message) {
-    const members = db.getRoomMembers(roomId);
-    log("debug", `[notify] room=${roomId} members=${members.join(',')} exclude=${excludeAgentId}`);
-    for (const memberId of members) {
-        if (memberId === excludeAgentId)
-            continue;
-        const sids = agentSessions.get(memberId);
-        log("debug", `[notify] agent=${memberId} sessions=${sids ? [...sids].join(',') : 'NONE'}`);
-        if (!sids)
-            continue;
-        for (const sid of sids) {
-            const session = sessions[sid];
-            if (!session) {
-                log("warn", `[notify] session ${sid} NOT FOUND in sessions map`);
-                continue;
-            }
-            try {
-                // Logging notification (generic)
-                session.server.sendLoggingMessage({
-                    level: 'info',
-                    data: message ?? `New event in room ${roomId}`,
-                }, sid);
-                // Resource updated notification (inbox changed)
-                session.server.server.sendResourceUpdated({ uri: 'hive://inbox' });
-                log("debug", `[notify] sent to session ${sid} OK (logging + resource updated)`);
-            }
-            catch (err) {
-                log("warn", `[notify] failed to send to session ${sid}: ${err}`);
-            }
-        }
-    }
-}
-function notifyAgents(agentIds, excludeAgentId, message) {
-    for (const agentId of agentIds) {
-        if (agentId === excludeAgentId)
-            continue;
-        const sids = agentSessions.get(agentId);
-        if (!sids)
-            continue;
-        for (const sid of sids) {
-            const session = sessions[sid];
-            if (!session)
-                continue;
-            try {
-                session.server.sendLoggingMessage({ level: 'info', data: message ?? 'New task event' }, sid);
-                session.server.server.sendResourceUpdated({ uri: 'hive://inbox' });
-            }
-            catch { /* ignore */ }
-        }
-    }
-}
-function notifyTaskParticipants(taskId, excludeAgentId, message) {
-    const task = db.getTaskById(taskId);
-    if (!task)
-        return;
-    const participants = new Set();
-    participants.add(task.creator_agent_id);
-    if (task.assignee_agent_id)
-        participants.add(task.assignee_agent_id);
-    // Also notify workflow step assignees
-    if (task.workflow_json) {
-        try {
-            const steps = JSON.parse(task.workflow_json);
-            for (const step of steps) {
-                for (const a of step.assignees || []) {
-                    if (a.startsWith('role:')) {
-                        const agent = db.findAgentByRole(a.slice(5));
-                        if (agent)
-                            participants.add(agent.id);
-                    }
-                    else {
-                        const agent = db.getAgentById(a) || db.getAgentByName(a);
-                        if (agent)
-                            participants.add(agent.id);
-                    }
-                }
-            }
-        }
-        catch { /* ignore */ }
-    }
-    notifyAgents([...participants], excludeAgentId, message);
-}
-// --- Agent resolution ---
-const asParam = z.string().optional().describe('Your agent name or ID (from hive.start)');
-function resolveAgent(extra, asValue) {
-    const sessionId = extra?.sessionId;
-    // Logged by caller, not here (too noisy from polling)
-    // 1) Session binding
-    if (sessionId) {
-        const agentId = sessionAgents.get(sessionId);
-        if (agentId) {
-            const agent = getAgentById(agentId);
-            if (agent) {
-                touchAgent(agent.id);
-                return agent;
-            }
-        }
-    }
-    // 2) `as` param fallback
-    if (asValue) {
-        const agent = getAgentById(asValue) || getAgentByName(asValue);
-        if (agent) {
-            touchAgent(agent.id);
-            return agent;
-        }
-    }
-    // silent — too noisy from polling/stateless requests
-    return null;
-}
-function authError() {
-    return {
-        content: [{ type: 'text', text: 'Error: Not authenticated. Call hive.start first, or pass `as` with your agent name.' }],
-        isError: true,
-    };
-}
-// --- MCP Server factory (one per session) ---
-function createMcpServer() {
-    const mcp = new McpServer({
-        name: 'kitty-hive',
-        version: '0.1.0',
-    }, {
-        capabilities: {
-            logging: {},
-            resources: { subscribe: true },
-        },
-        instructions: [
-            'kitty-hive is a multi-agent collaboration server.',
-            '',
-            '## Getting Started',
-            'Call hive.start with your name to register. All tools except hive.start and hive.check require `as` param.',
-            '',
-            '## Task Rules (IMPORTANT)',
-            'When you receive a task (via hive.task or task-assigned notification):',
-            '1. Analyze the task and propose a workflow using hive.workflow.propose',
-            '2. The workflow should have clear steps with assignees from your team',
-            '3. Wait for the creator to approve (hive.workflow.approve) before starting',
-            '4. Execute each step, call hive.workflow.step.complete when done',
-            '5. If you see an unassigned task, claim it with hive.task.claim',
-            '',
-            'When you CREATE a task:',
-            '- Always specify `to` (agent name or "role:xxx") to assign it',
-            '- Use `input.description` to describe what needs to be done',
-            '- The assignee will propose a workflow — you MUST show the proposal to the user and get explicit confirmation before calling hive.workflow.approve',
-            '- NEVER auto-approve a workflow without asking the user first',
-            '',
-            '## Rooms',
-            '- lobby: global, everyone auto-joins',
-            '- dm: private 1:1 messaging (auto-created by hive.dm)',
-            '- team: group collaboration (hive.team.create/join/list)',
-            '',
-            '## Shared Artifacts',
-            'Use ~/.kitty-hive/artifacts/<task_id>/ for cross-agent file exchange.',
-        ].join('\n'),
-    });
-    mcp.tool('hive.start', 'Register as an agent and join the lobby. Returns your agent_id. Session is auto-bound for push notifications.', {
-        name: z.string().optional().describe('Display name (random if omitted)'),
-        roles: z.string().optional().describe('Comma-separated roles: ux,frontend,backend'),
-        tool: z.string().optional().describe('Agent tool: claude, codex, shell'),
-        expertise: z.string().optional().describe('Free-text expertise description'),
-    }, async (params, extra) => {
-        const result = handleStart(params);
-        if (extra.sessionId)
-            bindSession(extra.sessionId, result.agent_id);
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.dm', 'Send a direct message. Use "agent@node" for cross-node DM (federation).', {
-        as: asParam,
-        to: z.string().describe('Target agent name, or "agent@node" for federation'),
-        content: z.string().describe('Message content'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = await handleDMAsync(agent.id, params);
-        if (!result.federated) {
-            notifyRoomMembers(result.room_id, agent.id, JSON.stringify({
-                type: 'dm', from: agent.display_name, room_id: result.room_id,
-                preview: params.content && params.content.length > 200 ? params.content.slice(0, 200) + ' [summary]' : params.content,
-            }));
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.task', 'Create a task and delegate. Use "agent@node" for cross-node delegation.', {
-        as: asParam,
-        to: z.string().optional().describe('Target: agent name, "role:ux", or "agent@node" for federation'),
-        title: z.string().describe('Task title'),
-        input: z.record(z.string(), z.unknown()).optional().describe('Structured task input (optional)'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = await handleTaskCreateAsync(agent.id, { to: params.to, title: params.title, input: params.input });
-        if (result.assignee) {
-            notifyAgents([result.assignee.id], agent.id, JSON.stringify({
-                type: 'task-assigned', from: agent.display_name,
-                task_id: result.task_id, title: params.title,
-            }));
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.task.claim', 'Claim an unassigned task. Only works on tasks with status "created" and no assignee.', {
-        as: asParam,
-        task_id: z.string().describe('Task ID to claim'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = handleTaskClaim(params.task_id, agent.id);
-        notifyTaskParticipants(params.task_id, agent.id, JSON.stringify({
-            type: 'task-claimed', from: agent.display_name,
-            task_id: params.task_id, preview: `${agent.display_name} claimed: ${result.title}`,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.tasks', 'List tasks. Shows all tasks you created or are assigned to, grouped by status.', {
-        as: asParam,
-        status: z.string().optional().describe('Filter by status: created, proposing, approved, in_progress, completed, failed, canceled'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const tasks = db.getAgentTasks(agent.id, params.status);
-        const board = tasks.map(t => ({
-            task_id: t.id,
-            title: t.title,
-            status: t.status,
-            creator: db.getAgentById(t.creator_agent_id)?.display_name ?? 'unknown',
-            assignee: t.assignee_agent_id ? (db.getAgentById(t.assignee_agent_id)?.display_name ?? 'unknown') : 'unassigned',
-            current_step: t.current_step,
-            has_workflow: !!t.workflow_json,
-            created_at: t.created_at,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify(board, null, 2) }] };
-    });
-    mcp.tool('hive.check', 'Check the current state of a task by task ID.', { task_id: z.string().describe('Task ID to check') }, async (params) => {
-        const result = handleCheck(params);
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.room.events', 'Fetch events from a room. Use "since" for incremental polling.', {
-        as: asParam,
-        room_id: z.string().describe('Room ID'),
-        since: z.number().optional().describe('Return events after this seq number'),
-        limit: z.number().optional().describe('Max events to return (default 50, max 200)'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = handleEvents(agent.id, {
-            room_id: params.room_id, since: params.since, limit: params.limit,
-        });
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.room.list', 'List rooms you are a member of.', {
-        as: asParam,
-        kind: z.string().optional().describe('Filter by room kind: dm, team, lobby'),
-        active_only: z.boolean().optional().describe('Only show active (non-closed) rooms (default true)'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = handleList(agent.id, { kind: params.kind, active_only: params.active_only });
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.room.info', 'Get detailed information about a room including members and recent events.', {
-        as: asParam,
-        room_id: z.string().describe('Room ID'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = handleInfo(agent.id, { room_id: params.room_id });
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.inbox', 'Check your inbox for unread messages and events across all rooms. Marks returned messages as read.', {
-        as: asParam,
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const unread = getUnreadForAgent(agent.id);
-        // Mark as read
-        for (const u of unread) {
-            if (u.latest.length > 0) {
-                if (u.type === 'room') {
-                    const events = db.getRoomEvents(u.id, 0, 10000);
-                    if (events.length > 0)
-                        setReadCursor(agent.id, 'room', u.id, events[events.length - 1].seq);
-                }
-                else {
-                    const events = db.getTaskEvents(u.id, 0, 100);
-                    if (events.length > 0)
-                        setReadCursor(agent.id, 'task', u.id, events[events.length - 1].seq);
-                }
-            }
-        }
-        if (unread.length === 0) {
-            return { content: [{ type: 'text', text: '[]' }] };
-        }
-        return { content: [{ type: 'text', text: JSON.stringify(unread) }] };
-    });
-    // --- Workflow tools ---
-    mcp.tool('hive.workflow.propose', 'Propose a workflow for a task. The task creator must approve before it starts.', {
-        as: asParam,
-        task_id: z.string().describe('Task ID'),
-        workflow: z.array(z.object({
-            step: z.number(),
-            title: z.string(),
-            assignees: z.array(z.string()).describe('Agent names or "role:xxx"'),
-            action: z.string(),
-            completion: z.enum(['all', 'any']).default('all'),
-            on_reject: z.string().optional().describe('"revise" or "back:N"'),
-        })).describe('Workflow steps'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        handleWorkflowPropose(params.task_id, agent.id, params.workflow);
-        notifyTaskParticipants(params.task_id, agent.id, JSON.stringify({
-            type: 'task-propose', from: agent.display_name,
-            task_id: params.task_id, preview: `Workflow proposed: ${params.workflow.length} steps`,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify({ task_id: params.task_id, status: 'proposing', steps: params.workflow.length }) }] };
-    });
-    mcp.tool('hive.workflow.approve', 'Approve a proposed workflow. Automatically starts step 1.', {
-        as: asParam,
-        task_id: z.string().describe('Task ID'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const action = handleWorkflowApprove(params.task_id, agent.id);
-        notifyTaskParticipants(params.task_id, agent.id, JSON.stringify({
-            type: 'step-start', from: agent.display_name,
-            task_id: params.task_id, preview: `Step 1 started, assignees: ${action.assignees?.join(', ')}`,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify({ task_id: params.task_id, status: 'approved', action }) }] };
-    });
-    mcp.tool('hive.workflow.step.complete', 'Mark your part of the current step as complete.', {
-        as: asParam,
-        task_id: z.string().describe('Task ID'),
-        step: z.number().describe('Step number'),
-        result: z.string().optional().describe('Result description'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const action = handleStepComplete(params.task_id, agent.id, params.step, params.result);
-        const resultPreview = params.result && params.result.length > 200 ? params.result.slice(0, 200) + ' [summary]' : params.result;
-        const msg = action?.type === 'task-complete' ? 'Task completed!'
-            : action?.type === 'step-start' ? `Step ${action.step} started. Previous step result: ${resultPreview || 'none'}`
-                : `Step ${params.step} progress recorded, waiting for others`;
-        notifyTaskParticipants(params.task_id, agent.id, JSON.stringify({
-            type: action?.type || 'step-complete', from: agent.display_name,
-            task_id: params.task_id, preview: msg,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify({ task_id: params.task_id, action: action || 'waiting' }) }] };
-    });
-    mcp.tool('hive.workflow.reject', 'Reject the current step output. Sends the task back to a previous step.', {
-        as: asParam,
-        task_id: z.string().describe('Task ID'),
-        step: z.number().describe('Step number being rejected'),
-        reason: z.string().optional().describe('Rejection reason'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const action = handleWorkflowReject(params.task_id, agent.id, params.step, params.reason);
-        notifyTaskParticipants(params.task_id, agent.id, JSON.stringify({
-            type: 'task-reject', from: agent.display_name,
-            task_id: params.task_id, preview: `Step ${params.step} rejected → back to step ${action.step}`,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify({ task_id: params.task_id, action }) }] };
-    });
-    // --- Team tools ---
-    mcp.tool('hive.team.create', 'Create a team room for group collaboration.', {
-        as: asParam,
-        name: z.string().describe('Team name'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = handleTeamCreate(agent.id, { name: params.name });
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.team.join', 'Join an existing team room by name or ID.', {
-        as: asParam,
-        room_id: z.string().optional().describe('Team room ID'),
-        name: z.string().optional().describe('Team name'),
-    }, async (params, extra) => {
-        const agent = resolveAgent(extra, params.as);
-        if (!agent)
-            return authError();
-        const result = handleTeamJoin(agent.id, { room_id: params.room_id, name: params.name });
-        notifyRoomMembers(result.room_id, agent.id, JSON.stringify({
-            type: 'join', from: agent.display_name, room_id: result.room_id,
-            preview: `${agent.display_name} joined the team`,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    mcp.tool('hive.team.list', 'List all available teams.', {}, async () => {
-        const result = handleTeamList();
-        return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    });
-    // --- Federation MCP tools ---
-    mcp.tool('hive.peers', 'List connected federation peers.', {}, async () => {
-        const peers = db.listPeers();
-        const result = peers.map(p => ({
-            name: p.name, url: p.url, status: p.status,
-            exposed: p.exposed, last_seen: p.last_seen,
-        }));
-        return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
-    });
-    mcp.tool('hive.remote.agents', 'List agents on a remote peer node.', {
-        peer: z.string().describe('Peer node name'),
-    }, async (params) => {
-        const peer = db.getPeerByName(params.peer);
-        if (!peer)
-            throw new Error(`Peer "${params.peer}" not found`);
-        const res = await fetch(peer.url.replace('/mcp', '/federation/agents'), {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${peer.secret}`,
-                'X-Hive-Peer': peer.name,
-            },
-        });
-        if (!res.ok)
-            throw new Error(`Failed to fetch agents from peer "${params.peer}"`);
-        const data = await res.json();
-        return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-    });
-    // --- Inbox resource ---
-    mcp.resource('inbox', 'hive://inbox', { mimeType: 'application/json', description: 'Your unread messages and events across all rooms' }, async (uri, extra) => {
-        const sessionId = extra?.sessionId;
-        let agentId;
-        if (sessionId)
-            agentId = sessionAgents.get(sessionId);
-        if (!agentId) {
-            return { contents: [{ uri: uri.href, text: '{"error":"Not authenticated. Call hive.start first."}' }] };
-        }
-        const unread = getUnreadForAgent(agentId);
-        return {
-            contents: [{
-                    uri: uri.href,
-                    text: JSON.stringify(unread.length > 0 ? unread : { message: 'No unread messages.' }),
-                }],
-        };
-    });
-    return mcp;
-}
-// --- HTTP server ---
+import { initDB, cleanupStaleTasks } from './db.js';
+import { log, setLogLevel } from './log.js';
+import { sessions, unbindSession, sessionAgents, activeSSE } from './sessions.js';
+import { createMcpServer } from './mcp/server.js';
+import { handleFederation, cleanupOldFiles, getNodeName } from './federation-http.js';
+import { startHeartbeat } from './federation-heartbeat.js';
+export { setLogLevel };
 export async function startServer(port, dbPath) {
     initDB(dbPath);
     const httpServer = createServer(async (req, res) => {
         const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
-        // --- Federation routes ---
+        // Federation routes
         if (url.pathname.startsWith('/federation/')) {
             await handleFederation(req, res, url);
             return;
@@ -524,9 +23,7 @@ export async function startServer(port, dbPath) {
             res.end(JSON.stringify({ error: 'Not found. MCP endpoint is at /mcp' }));
             return;
         }
-        // Don't log heartbeat/polling requests
-        const isQuiet = req.method === 'GET'; // SSE keepalive
-        // --- GET: SSE stream ---
+        // GET: SSE stream
         if (req.method === 'GET') {
             const sid = req.headers['mcp-session-id'];
             if (!sid || !sessions[sid]) {
@@ -534,11 +31,16 @@ export async function startServer(port, dbPath) {
                 res.end(JSON.stringify({ error: 'Invalid or missing session ID' }));
                 return;
             }
-            log("debug", `[sse] opening SSE stream for session=${sid} agent=${sessionAgents.get(sid) || 'unbound'}`);
+            log('info', `[sse] opening stream for session=${sid} agent=${sessionAgents.get(sid) || 'unbound'}`);
+            activeSSE.add(sid);
+            res.on('close', () => {
+                activeSSE.delete(sid);
+                log('info', `[sse] stream closed for session=${sid}`);
+            });
             await sessions[sid].transport.handleRequest(req, res);
             return;
         }
-        // --- DELETE: session termination ---
+        // DELETE: session termination
         if (req.method === 'DELETE') {
             const sid = req.headers['mcp-session-id'];
             if (!sid || !sessions[sid]) {
@@ -546,12 +48,12 @@ export async function startServer(port, dbPath) {
                 res.end(JSON.stringify({ error: 'Invalid or missing session ID' }));
                 return;
             }
-            log("info", `[session] DELETE session=${sid}`);
+            log('info', `[session] DELETE session=${sid}`);
             unbindSession(sid);
             await sessions[sid].transport.handleRequest(req, res);
             return;
         }
-        // --- POST: JSON-RPC ---
+        // POST: JSON-RPC
         try {
             const chunks = [];
             for await (const chunk of req)
@@ -562,26 +64,37 @@ export async function startServer(port, dbPath) {
             const tool = body?.params?.name || '';
             const isHeartbeat = tool === 'hive.inbox' || method === 'notifications/initialized';
             if (!isHeartbeat) {
-                log("info", `[rpc] method=${method} sid=${sid || 'none'} tool=${tool || '-'}`);
+                log('info', `[rpc] method=${method} sid=${sid || 'none'} tool=${tool || '-'}`);
             }
             if (sid && sessions[sid]) {
-                // Existing session
                 await sessions[sid].transport.handleRequest(req, res, body);
             }
+            else if (sid && !sessions[sid]) {
+                // Stale session id (e.g. after server restart) — reject with 404 so the client
+                // knows to re-initialize. Do NOT fall through to stateless: that would create
+                // a transport with no sessionId, breaking session binding for push notifications.
+                log('info', `[session] stale sid=${sid} method=${method} → 404 (client should re-init)`);
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    error: { code: -32001, message: 'Session not found. Re-initialize.' },
+                    id: body?.id ?? null,
+                }));
+                return;
+            }
             else if (!sid && isInitializeRequest(body)) {
-                // New session: create server + transport
                 const server = createMcpServer();
                 const transport = new StreamableHTTPServerTransport({
                     sessionIdGenerator: () => randomUUID(),
                     onsessioninitialized: (newSid) => {
-                        log("info", `[session] new session created: ${newSid}`);
+                        log('info', `[session] new session: ${newSid}`);
                         sessions[newSid] = { transport, server };
                     },
                 });
                 transport.onclose = () => {
                     const tSid = transport.sessionId;
                     if (tSid) {
-                        log("debug", `[session] transport closed: ${tSid}`);
+                        log('debug', `[session] transport closed: ${tSid}`);
                         unbindSession(tSid);
                         delete sessions[tSid];
                     }
@@ -590,10 +103,9 @@ export async function startServer(port, dbPath) {
                 await transport.handleRequest(req, res, body);
             }
             else {
-                // Stateless fallback: create temporary server + transport per request
-                // This supports clients that don't maintain sessions (e.g. HTTP adapters)
+                // Stateless fallback (per-request server, no session)
                 if (!isHeartbeat)
-                    log("debug", `[rpc] stateless request: method=${method} tool=${tool || '-'}`);
+                    log('debug', `[rpc] stateless: method=${method} tool=${tool || '-'}`);
                 const server = createMcpServer();
                 const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
                 await server.connect(transport);
@@ -602,7 +114,7 @@ export async function startServer(port, dbPath) {
             }
         }
         catch (error) {
-            console.error('[rpc] Error handling MCP request:', error);
+            console.error('[rpc] error:', error);
             if (!res.headersSent) {
                 res.writeHead(500, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
@@ -615,15 +127,31 @@ export async function startServer(port, dbPath) {
     });
     httpServer.listen(port, () => {
         console.log(`🐝 kitty-hive listening on http://localhost:${port}/mcp`);
+        console.log(`   Node: ${getNodeName()}`);
         console.log(`   Database: ${dbPath || '~/.kitty-hive/hive.db'}`);
         console.log(`   Mode: stateful (SSE push enabled)`);
     });
-    // Cleanup stale task rooms every hour
     setInterval(() => {
         const count = cleanupStaleTasks(7);
         if (count > 0)
-            log("info", `[cleanup] removed ${count} stale tasks`);
+            log('info', `[cleanup] removed ${count} stale tasks`);
     }, 60 * 60 * 1000);
+    // Sweep old federation files at boot, then daily
+    try {
+        const swept = cleanupOldFiles(7);
+        if (swept.removed > 0)
+            log('info', `[cleanup] removed ${swept.removed} old federation files (kept ${swept.kept})`);
+    }
+    catch (err) {
+        log('warn', `[cleanup] file sweep failed: ${err.message ?? err}`);
+    }
+    setInterval(() => {
+        try {
+            cleanupOldFiles(7);
+        }
+        catch { /* ignore */ }
+    }, 24 * 60 * 60 * 1000);
+    startHeartbeat(60 * 1000);
     process.on('SIGINT', async () => {
         for (const sid in sessions) {
             try {
@@ -635,237 +163,4 @@ export async function startServer(port, dbPath) {
         process.exit(0);
     });
 }
-// --- Federation handler ---
-import { mkdirSync as mkdirSyncFs, writeFileSync as writeFileSyncFs, readFileSync as readFileSyncFs, existsSync as existsSyncFs } from 'node:fs';
-import { join as joinPath } from 'node:path';
-import { homedir as homedirFn } from 'node:os';
-function authenticatePeer(req) {
-    const authHeader = req.headers.authorization;
-    if (!authHeader)
-        return null;
-    const match = authHeader.match(/^Bearer\s+(\S+)$/i);
-    if (!match)
-        return null;
-    const peer = db.getPeerBySecret(match[1]);
-    if (peer)
-        db.touchPeer(peer.name);
-    return peer ?? null;
-}
-async function readBody(req) {
-    const chunks = [];
-    for await (const chunk of req)
-        chunks.push(chunk);
-    return Buffer.concat(chunks).toString();
-}
-function filesDir() {
-    const dir = joinPath(homedirFn(), '.kitty-hive', 'files');
-    mkdirSyncFs(dir, { recursive: true });
-    return dir;
-}
-async function handleFederation(req, res, url) {
-    const peer = authenticatePeer(req);
-    if (!peer) {
-        res.writeHead(401, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Unauthorized' }));
-        return;
-    }
-    const peerName = req.headers['x-hive-peer'] || peer.name;
-    log("info", `[federation] ${req.method} ${url.pathname} from peer=${peerName}`);
-    // --- GET /federation/agents ---
-    if (url.pathname === '/federation/agents' && req.method === 'POST') {
-        const exposed = peer.exposed ? peer.exposed.split(',').map(s => s.trim()).filter(Boolean) : [];
-        const agents = exposed.map(name => {
-            const agent = db.getAgentByName(name);
-            return agent ? { name: agent.display_name, roles: agent.roles, status: agent.status } : null;
-        }).filter(Boolean);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ node: getNodeName(), agents }));
-        return;
-    }
-    // --- POST /federation/dm ---
-    if (url.pathname === '/federation/dm' && req.method === 'POST') {
-        const body = JSON.parse(await readBody(req));
-        const { from, to, content, file_id } = body;
-        if (!from || !to || !content) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Missing from, to, or content' }));
-            return;
-        }
-        // Check if target agent is exposed to this peer
-        if (!db.isPeerExposed(peer.name, to)) {
-            res.writeHead(403, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: `Agent "${to}" is not accessible` }));
-            return;
-        }
-        // Create or find remote agent placeholder
-        const remoteAgentName = `${from}`;
-        let remoteAgent = db.getAgentByName(remoteAgentName);
-        if (!remoteAgent) {
-            remoteAgent = db.createAgent(remoteAgentName, 'remote', `peer:${peerName}`, '');
-        }
-        // Deliver DM
-        const targetAgent = db.getAgentByName(to);
-        if (!targetAgent) {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: `Agent "${to}" not found` }));
-            return;
-        }
-        const msgContent = file_id ? `${content}\n\n[file: ${file_id}]` : content;
-        const result = handleDM(remoteAgent.id, { to, content: msgContent });
-        // Notify local agent
-        notifyRoomMembers(result.room_id, remoteAgent.id, JSON.stringify({
-            type: 'dm', from: remoteAgentName, room_id: result.room_id,
-            preview: content.length > 200 ? content.slice(0, 200) + ' [summary]' : content,
-        }));
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ delivered: true, event_id: result.event_id }));
-        return;
-    }
-    // --- POST /federation/file (upload) ---
-    if (url.pathname === '/federation/file' && req.method === 'POST') {
-        const chunks = [];
-        for await (const chunk of req)
-            chunks.push(chunk);
-        const data = Buffer.concat(chunks);
-        const filename = req.headers['x-filename'] || 'upload';
-        const fileId = 'f_' + Date.now().toString(36) + '_' + Math.random().toString(36).slice(2, 8);
-        const fileDir = joinPath(filesDir(), fileId);
-        mkdirSyncFs(fileDir, { recursive: true });
-        writeFileSyncFs(joinPath(fileDir, filename), data);
-        log("info", `[federation] file received: ${fileId}/${filename} (${data.length} bytes)`);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ file_id: fileId, filename, size: data.length }));
-        return;
-    }
-    // --- GET /federation/file/:id ---
-    if (url.pathname.startsWith('/federation/file/') && req.method === 'GET') {
-        const fileId = url.pathname.split('/').pop();
-        if (!fileId) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Missing file ID' }));
-            return;
-        }
-        const fileDir = joinPath(filesDir(), fileId);
-        if (!existsSyncFs(fileDir)) {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'File not found' }));
-            return;
-        }
-        // Read first file in directory
-        const { readdirSync } = await import('node:fs');
-        const files = readdirSync(fileDir);
-        if (files.length === 0) {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'File not found' }));
-            return;
-        }
-        const filePath = joinPath(fileDir, files[0]);
-        const fileData = readFileSyncFs(filePath);
-        res.writeHead(200, {
-            'Content-Type': 'application/octet-stream',
-            'Content-Disposition': `attachment; filename="${files[0]}"`,
-        });
-        res.end(fileData);
-        return;
-    }
-    // --- POST /federation/task ---
-    if (url.pathname === '/federation/task' && req.method === 'POST') {
-        const body = JSON.parse(await readBody(req));
-        const { from, to, title, input } = body;
-        if (!from || !to || !title) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Missing from, to, or title' }));
-            return;
-        }
-        if (!db.isPeerExposed(peer.name, to)) {
-            res.writeHead(403, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: `Agent "${to}" is not accessible` }));
-            return;
-        }
-        // Create remote agent placeholder
-        let remoteAgent = db.getAgentByName(from);
-        if (!remoteAgent) {
-            remoteAgent = db.createAgent(from, 'remote', `peer:${peerName}`, '');
-        }
-        const targetAgent = db.getAgentByName(to);
-        if (!targetAgent) {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: `Agent "${to}" not found` }));
-            return;
-        }
-        const result = handleTaskCreate(remoteAgent.id, { to, title, input });
-        // Notify assignee
-        notifyTaskParticipants(result.task_id, remoteAgent.id, JSON.stringify({
-            type: 'task-assigned', from, task_id: result.task_id, preview: title,
-        }));
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ task_id: result.task_id, status: result.status }));
-        return;
-    }
-    // --- POST /federation/task/event ---
-    if (url.pathname === '/federation/task/event' && req.method === 'POST') {
-        const body = JSON.parse(await readBody(req));
-        const { from, task_id, type, workflow, step, reason, result: stepResult } = body;
-        if (!from || !task_id || !type) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Missing from, task_id, or type' }));
-            return;
-        }
-        let remoteAgent = db.getAgentByName(from);
-        if (!remoteAgent) {
-            remoteAgent = db.createAgent(from, 'remote', `peer:${peerName}`, '');
-        }
-        const task = db.getTaskById(task_id);
-        if (!task) {
-            res.writeHead(404, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: `Task not found: ${task_id}` }));
-            return;
-        }
-        try {
-            let action = null;
-            switch (type) {
-                case 'task-propose':
-                    handleWorkflowPropose(task_id, remoteAgent.id, workflow);
-                    break;
-                case 'task-approve':
-                    action = handleWorkflowApprove(task_id, remoteAgent.id);
-                    break;
-                case 'step-complete':
-                    action = handleStepComplete(task_id, remoteAgent.id, step, stepResult);
-                    break;
-                case 'task-reject':
-                    action = handleWorkflowReject(task_id, remoteAgent.id, step, reason);
-                    break;
-                default:
-                    res.writeHead(400, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: `Unknown event type: ${type}` }));
-                    return;
-            }
-            notifyTaskParticipants(task_id, remoteAgent.id, JSON.stringify({
-                type, from, task_id, preview: `${type} from ${from}`,
-            }));
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ ok: true, action }));
-        }
-        catch (err) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: err.message }));
-        }
-        return;
-    }
-    res.writeHead(404, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: 'Unknown federation endpoint' }));
-}
-function getNodeName() {
-    try {
-        const configPath = joinPath(homedirFn(), '.kitty-hive', 'config.json');
-        if (existsSyncFs(configPath)) {
-            const config = JSON.parse(readFileSyncFs(configPath, 'utf8'));
-            if (config.name)
-                return config.name;
-        }
-    }
-    catch { /* ignore */ }
-    return require('os').hostname().split('.')[0];
-}
 //# sourceMappingURL=server.js.map