@dalmasonto/taskflow-mcp 1.0.33 → 2.0.0

package/dist/tmux-bridge.d.ts

@@ -1,12 +0,0 @@
-interface BridgeOptions {
-    /** Returns the current agent name — must be a getter so renames are picked up */
-    getAgentName: () => string;
-    agentPid: number;
-    tmuxPane: string;
-}
-/**
- * Start the tmux bridge: SSE listener for instant message delivery.
- * Returns a cleanup function for graceful shutdown.
- */
-export declare function startTmuxBridge(options: BridgeOptions): () => void;
-export {};

package/dist/tmux-bridge.js

@@ -1,157 +0,0 @@
-import { execFileSync } from 'child_process';
-import { getDb } from './db.js';
-import { getActivePort } from './sse.js';
-import http from 'http';
-// ─── SSE Listener (replaces the 3s poller) ───────────────────────────
-function startSSEListener(options) {
-    const port = getActivePort();
-    function connect() {
-        const req = http.get(`http://localhost:${port}/events`, (res) => {
-            let buffer = '';
-            let eventType = ''; // persists across chunks — SSE fields may split across TCP segments
-            res.on('data', (chunk) => {
-                buffer += chunk.toString();
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (line.startsWith('event: ')) {
-                        eventType = line.slice(7).trim();
-                    }
-                    else if (line.startsWith('data: ') && eventType) {
-                        try {
-                            const data = JSON.parse(line.slice(6));
-                            handleSSEEvent(eventType, data, options);
-                        }
-                        catch { /* malformed JSON */ }
-                        eventType = '';
-                    }
-                    else if (line === '') {
-                        // SSE event delimiter — reset state for next event
-                        eventType = '';
-                    }
-                }
-            });
-            res.on('end', () => {
-                console.error('[bridge] SSE connection closed, reconnecting in 3s...');
-                setTimeout(connect, 3000);
-            });
-            res.on('error', () => {
-                console.error('[bridge] SSE connection error, reconnecting in 3s...');
-                setTimeout(connect, 3000);
-            });
-        });
-        req.on('error', () => {
-            console.error('[bridge] SSE connect failed, retrying in 3s...');
-            setTimeout(connect, 3000);
-        });
-    }
-    // Initial sweep: deliver any undelivered messages from before SSE connected
-    deliverUndelivered(options);
-    connect();
-}
-function handleSSEEvent(event, data, options) {
-    const { getAgentName, agentPid, tmuxPane } = options;
-    const agentName = getAgentName();
-    const payload = data.payload;
-    if (!payload)
-        return;
-    if (event === 'agent_question') {
-        const recipient = payload.recipient_name;
-        const sender = payload.sender_name;
-        const status = payload.status;
-        const id = payload.id;
-        const delivered = payload.delivered;
-        if (recipient !== agentName || status !== 'pending' || delivered === 1)
-            return;
-        let text;
-        if (sender === 'user') {
-            text = `[Message from User]: ${payload.question}`;
-        }
-        else {
-            text = `[Message from ${sender}]: ${payload.question}`;
-        }
-        injectAndMarkDelivered(id, text, tmuxPane);
-    }
-    if (event === 'agent_question_answered') {
-        const sender = payload.sender_name;
-        const recipient = payload.recipient_name;
-        const status = payload.status;
-        const id = payload.id;
-        const delivered = payload.delivered;
-        const agentPidField = payload.agent_pid;
-        const isOurs = sender === agentName || agentPidField === agentPid;
-        if (!isOurs || status !== 'answered' || delivered === 1)
-            return;
-        const question = (payload.question || '').slice(0, 60);
-        const response = payload.response;
-        const text = `[Inbox Response] to "${question}": ${response}`;
-        injectAndMarkDelivered(id, text, tmuxPane);
-    }
-}
-function injectAndMarkDelivered(id, text, tmuxPane) {
-    const db = getDb();
-    db.prepare('UPDATE agent_messages SET delivered = 1 WHERE id = ?').run(id);
-    try {
-        // Send text literally (-l) so special chars are safe and tmux doesn't interpret them
-        execFileSync('tmux', ['send-keys', '-t', tmuxPane, '-l', text], { stdio: 'ignore', timeout: 5000 });
-        // Delay before Enter — gives the CLI time to fully process the bracketed paste.
-        // Without this, Codex (and similar TUIs) may only show partial text because
-        // the Enter arrives inside the paste bracket and gets swallowed.
-        setTimeout(() => {
-            try {
-                execFileSync('tmux', ['send-keys', '-t', tmuxPane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
-            }
-            catch { /* pane may have closed */ }
-            // Second Enter after another delay — catches CLIs that need an extra nudge
-            // after bracketed paste ends (e.g. long messages that trigger paste mode)
-            setTimeout(() => {
-                try {
-                    execFileSync('tmux', ['send-keys', '-t', tmuxPane, 'Enter'], { stdio: 'ignore', timeout: 5000 });
-                }
-                catch { /* pane may have closed */ }
-            }, 500);
-        }, 300);
-        console.error(`[bridge] delivered message ${id} to tmux pane ${tmuxPane}`);
-    }
-    catch (err) {
-        console.error(`[bridge] tmux send-keys failed for message ${id}:`, err);
-    }
-}
-function deliverUndelivered(options) {
-    const { getAgentName, agentPid, tmuxPane } = options;
-    const agentName = getAgentName();
-    const db = getDb();
-    const incoming = db.prepare(`SELECT * FROM agent_messages WHERE delivered IS NULL AND (
-      (recipient_name = ? AND status = 'pending') OR
-      (sender_name = ? AND status = 'answered') OR
-      (agent_pid = ? AND status = 'answered')
-    )`).all(agentName, agentName, agentPid);
-    for (const msg of incoming) {
-        let text;
-        if (msg.recipient_name === agentName && msg.sender_name === 'user') {
-            text = `[Message from User]: ${msg.question}`;
-        }
-        else if (msg.recipient_name === agentName && msg.sender_name !== 'user') {
-            text = `[Message from ${msg.sender_name}]: ${msg.question}`;
-        }
-        else if (msg.status === 'answered' && msg.response) {
-            text = `[Inbox Response] to "${msg.question.slice(0, 60)}": ${msg.response}`;
-        }
-        else {
-            continue;
-        }
-        injectAndMarkDelivered(msg.id, text, tmuxPane);
-    }
-}
-// ─── Public API ──────────────────────────────────────────────────────
-/**
- * Start the tmux bridge: SSE listener for instant message delivery.
- * Returns a cleanup function for graceful shutdown.
- */
-export function startTmuxBridge(options) {
-    startSSEListener(options);
-    console.error(`[bridge] tmux bridge active for agent "${options.getAgentName()}" on pane ${options.tmuxPane}`);
-    return () => {
-        // SSE connection will close when process exits
-    };
-}

package/dist/tools/activity.d.ts

@@ -1,39 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function getActivityLog(params: {
-    limit?: number;
-    action?: string;
-    entity_type?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function clearActivityLog(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function compactActivityLog(params: {
-    preserve_recent?: number;
-    max_entries?: number;
-    dry_run?: boolean;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function logDebug(params: {
-    message: string;
-    task_id?: number;
-    project_id?: number;
-    detail?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerActivityTools(server: McpServer): void;

package/dist/tools/activity.js

@@ -1,152 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { successResponse, broadcastChange } from '../helpers.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function getActivityLog(params) {
-    const db = getDb();
-    const limit = params.limit ?? 50;
-    const conditions = [];
-    const values = [];
-    if (params.action) {
-        conditions.push('action = ?');
-        values.push(params.action);
-    }
-    if (params.entity_type) {
-        conditions.push('entity_type = ?');
-        values.push(params.entity_type);
-    }
-    let sql = 'SELECT * FROM activity_logs';
-    if (conditions.length > 0) {
-        sql += ' WHERE ' + conditions.join(' AND ');
-    }
-    sql += ' ORDER BY created_at DESC LIMIT ?';
-    values.push(limit);
-    const rows = db.prepare(sql).all(...values);
-    return successResponse(rows);
-}
-export async function clearActivityLog() {
-    const db = getDb();
-    const countRow = db.prepare('SELECT COUNT(*) AS count FROM activity_logs').get();
-    db.prepare('DELETE FROM activity_logs').run();
-    broadcastChange('activity', 'activity_cleared', {});
-    return successResponse({ deleted: countRow.count, message: 'Activity log cleared' });
-}
-// ─── compaction ──────────────────────────────────────────────────────
-const DEFAULT_PRESERVE_RECENT = 50;
-const DEFAULT_MAX_LOG_ENTRIES = 500;
-/** Actions that are always preserved in full (never compacted) */
-const MILESTONE_ACTIONS = new Set([
-    'task_created', 'task_completed', 'task_partial_done',
-    'project_created', 'project_deleted',
-    'agent_connected', 'agent_disconnected', 'agent_renamed',
-]);
-export async function compactActivityLog(params) {
-    const db = getDb();
-    const preserveRecent = params.preserve_recent ?? DEFAULT_PRESERVE_RECENT;
-    const maxEntries = params.max_entries ?? DEFAULT_MAX_LOG_ENTRIES;
-    const totalCount = db.prepare('SELECT COUNT(*) AS count FROM activity_logs').get().count;
-    if (totalCount <= maxEntries) {
-        return successResponse({
-            compacted: false,
-            total_entries: totalCount,
-            message: `Log has ${totalCount} entries (threshold: ${maxEntries}) — no compaction needed.`,
-        });
-    }
-    // Get all entries sorted by date
-    const allEntries = db.prepare('SELECT * FROM activity_logs ORDER BY created_at ASC').all();
-    // Split into: entries to compact vs entries to preserve
-    const cutoffIndex = allEntries.length - preserveRecent;
-    const toCompact = allEntries.slice(0, cutoffIndex);
-    const toPreserve = allEntries.slice(cutoffIndex);
-    if (toCompact.length === 0) {
-        return successResponse({
-            compacted: false,
-            total_entries: totalCount,
-            message: 'All entries are within the preserve window — nothing to compact.',
-        });
-    }
-    // Generate summary of compacted entries
-    const actionCounts = {};
-    const milestones = [];
-    const timeRange = {
-        start: toCompact[0].created_at,
-        end: toCompact[toCompact.length - 1].created_at,
-    };
-    for (const entry of toCompact) {
-        actionCounts[entry.action] = (actionCounts[entry.action] || 0) + 1;
-        if (MILESTONE_ACTIONS.has(entry.action)) {
-            milestones.push(`[${entry.created_at.slice(0, 16)}] ${entry.action}: ${entry.title}`);
-        }
-    }
-    const summaryDetail = [
-        `## Compaction Summary`,
-        `**Period:** ${timeRange.start} → ${timeRange.end}`,
-        `**Entries compacted:** ${toCompact.length}`,
-        ``,
-        `### Action Counts`,
-        ...Object.entries(actionCounts)
-            .sort((a, b) => b[1] - a[1])
-            .map(([action, count]) => `- \`${action}\`: ${count}`),
-        ``,
-        `### Key Milestones`,
-        ...(milestones.length > 0
-            ? milestones.slice(-20).map(m => `- ${m}`)
-            : ['- (none)']),
-    ].join('\n');
-    if (params.dry_run) {
-        return successResponse({
-            compacted: false,
-            dry_run: true,
-            would_compact: toCompact.length,
-            would_preserve: toPreserve.length,
-            summary_preview: summaryDetail,
-        });
-    }
-    // Delete compacted entries and insert summary
-    const compactIds = toCompact.map(e => e.id);
-    const placeholders = compactIds.map(() => '?').join(',');
-    db.prepare(`DELETE FROM activity_logs WHERE id IN (${placeholders})`).run(...compactIds);
-    const now = new Date().toISOString();
-    db.prepare(`INSERT INTO activity_logs (action, title, detail, entity_type, entity_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`).run('compaction_summary', `Compacted ${toCompact.length} activity log entries (${timeRange.start.slice(0, 10)} → ${timeRange.end.slice(0, 10)})`, summaryDetail, null, null, now);
-    broadcastChange('activity', 'activity_compacted', { compacted: toCompact.length, preserved: toPreserve.length });
-    return successResponse({
-        compacted: true,
-        entries_removed: toCompact.length,
-        entries_preserved: toPreserve.length,
-        summary_inserted: true,
-        new_total: toPreserve.length + 1,
-    });
-}
-export async function logDebug(params) {
-    const db = getDb();
-    const now = new Date().toISOString();
-    // task_id takes priority; fall back to project_id
-    const entityType = params.task_id ? 'task' : params.project_id ? 'project' : null;
-    const entityId = params.task_id ?? params.project_id ?? null;
-    const result = db.prepare(`INSERT INTO activity_logs (action, title, detail, entity_type, entity_id, created_at)
-     VALUES (?, ?, ?, ?, ?, ?)`).run('debug_log', params.message, params.detail ?? null, entityType, entityId, now);
-    const entry = db.prepare('SELECT * FROM activity_logs WHERE id = ?').get(result.lastInsertRowid);
-    broadcastChange('activity', 'activity_logged', entry);
-    return successResponse({ id: result.lastInsertRowid, message: params.message });
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerActivityTools(server) {
-    server.tool('get_activity_log', 'Retrieve recent activity log entries. Shows what has changed — task completions, timer events, status transitions. Filter by action or entity type.', {
-        limit: z.number().optional(),
-        action: z.string().optional(),
-        entity_type: z.string().optional(),
-    }, { readOnlyHint: true }, async (params) => getActivityLog(params));
-    server.tool('clear_activity_log', 'Delete all activity log entries. Use with caution — this is irreversible.', {}, { destructiveHint: true }, async () => clearActivityLog());
-    server.tool('log_debug', 'Log a debug entry to the activity log. Use this to record your work process — what you investigated, commands you ran, decisions you made, and findings. Entries appear in the Activity Pulse and on the project page. Link to a task (task_id) or project (project_id) for context.', {
-        message: z.string().describe('Short summary of what you are doing or found'),
-        detail: z.string().optional().describe('Longer explanation — stack traces, error messages, hypotheses, commands run, what you tried'),
-        task_id: z.number().optional().describe('Link this debug log to a specific task'),
-        project_id: z.number().optional().describe('Link this debug log to a project (used when no specific task applies)'),
-    }, { readOnlyHint: false }, async (params) => logDebug(params));
-    server.tool('compact_activity_log', 'Compact old activity log entries into a summary. Keeps the most recent entries (default 50) and summarizes the rest. Use dry_run=true to preview what would be compacted. Runs automatically when log exceeds max_entries threshold.', {
-        preserve_recent: z.number().optional().describe('Number of recent entries to keep verbatim (default: 50)'),
-        max_entries: z.number().optional().describe('Only compact if log exceeds this count (default: 500)'),
-        dry_run: z.boolean().optional().describe('If true, show what would be compacted without doing it'),
-    }, { readOnlyHint: false }, async (params) => compactActivityLog(params));
-}

package/dist/tools/agent-inbox.d.ts

@@ -1,12 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-/** The name assigned to this agent after registration */
-declare let myAgentName: string | null;
-/** Set the agent name from external registration (index.ts).
- *  This prevents double-registration when index.ts registers at startup
- *  and ensureRegistered() would register again on first tool call.
- */
-export declare function setAgentName(name: string): void;
-export { myAgentName };
-/** Get the current agent name — used by tmux bridge to track renames */
-export declare function getAgentName(): string;
-export declare function registerAgentInboxTools(server: McpServer): void;

package/dist/tools/agent-inbox.js

@@ -1,257 +0,0 @@
-import { z } from 'zod';
-import crypto from 'crypto';
-import { getDb } from '../db.js';
-import { logActivity, errorResponse, successResponse, now, broadcastChange } from '../helpers.js';
-import { registerAgent as doRegister, getAgent, listAgents } from '../agent-registry.js';
-/** The name assigned to this agent after registration */
-let myAgentName = null;
-/** Set the agent name from external registration (index.ts).
- *  This prevents double-registration when index.ts registers at startup
- *  and ensureRegistered() would register again on first tool call.
- */
-export function setAgentName(name) {
-    myAgentName = name;
-}
-/** Get or auto-register the agent name.
- *  Verifies the cached registration is still valid — if the liveness
- *  checker disconnected us while sleeping, re-register to reclaim identity.
- */
-function ensureRegistered() {
-    if (myAgentName) {
-        // Verify our registration is still active
-        const agent = getAgent(myAgentName);
-        if (agent && agent.status === 'connected' && agent.pid === process.ppid) {
-            return myAgentName;
-        }
-        // Stale — re-register
-        myAgentName = null;
-    }
-    myAgentName = doRegister();
-    return myAgentName;
-}
-export { myAgentName };
-/** Get the current agent name — used by tmux bridge to track renames */
-export function getAgentName() {
-    return myAgentName || 'unknown';
-}
-export function registerAgentInboxTools(server) {
-    server.tool('register_agent', 'Register this agent with a custom name. Optional — agents auto-register on startup using the project folder name. Call this only if you want a specific name.', {
-        name: z.string().optional().describe('Custom agent name. If omitted, uses the project folder name.'),
-    }, { readOnlyHint: false, idempotentHint: true }, async (params) => {
-        myAgentName = doRegister({ customName: params.name });
-        return successResponse({ name: myAgentName, message: `Registered as "${myAgentName}"` });
-    });
-    server.tool('ask_user', 'Post a question to the TaskFlow Agent Inbox for the user to answer remotely. Returns immediately with the message ID. The question appears in the Agent Inbox UI with full context and optional quick-tap choices. After posting, use check_response to retrieve the user\'s answer. Always tell the user you posted a question so they know to check the inbox.', {
-        project_id: z.number().describe('Project ID to attach the question to'),
-        question: z.string().describe('The question to ask the user'),
-        context: z.string().optional().describe('Markdown context — proposals, trade-offs, code snippets shown before the question'),
-        choices: z.array(z.string()).optional().describe('Optional quick-tap choices, e.g. ["Yes", "No", "Skip"]'),
-    }, { readOnlyHint: false }, async (params) => {
-        const db = getDb();
-        const project = db.prepare('SELECT id FROM projects WHERE id = ?').get(params.project_id);
-        if (!project)
-            return errorResponse(`Project ${params.project_id} not found`, 'NOT_FOUND');
-        const senderName = ensureRegistered();
-        const ts = now();
-        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, choices, sender_name, recipient_name, agent_pid, source, status, created_at)
-         VALUES (?, ?, ?, ?, ?, 'user', ?, 'mcp', 'pending', ?)`).run(params.project_id, params.question, params.context ?? null, params.choices ? JSON.stringify(params.choices) : null, senderName, process.ppid, ts);
-        const id = result.lastInsertRowid;
-        const message = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
-        broadcastChange('agent_message', 'agent_question', message);
-        logActivity('agent_question', params.question, { entityType: 'agent_message', entityId: id });
-        return successResponse({
-            id,
-            status: 'pending',
-            sender: senderName,
-            message: `Question posted to Agent Inbox (id: ${id}). Use check_response(${id}) to retrieve the user's answer.`,
-        });
-    });
-    server.tool('check_response', 'Check if a previously posted question (via ask_user or ask_agent) has been answered. Returns the response if answered, or status "pending" if still waiting.', {
-        message_id: z.number().describe('The message ID returned by ask_user or ask_agent'),
-    }, { readOnlyHint: true }, async (params) => {
-        const db = getDb();
-        const message = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(params.message_id);
-        if (!message)
-            return errorResponse(`Message ${params.message_id} not found`, 'NOT_FOUND');
-        if (message.status === 'answered') {
-            return successResponse({
-                id: message.id, status: 'answered', response: message.response,
-                respondedBy: message.recipient_name,
-                question: message.question, answered_at: message.answered_at,
-            });
-        }
-        return successResponse({
-            id: message.id, status: 'pending', question: message.question,
-            recipient: message.recipient_name,
-            message: 'No response yet. Try again later or continue with other work.',
-        });
-    });
-    server.tool('send_to_agent', 'Send a message to another agent by name. Returns immediately. The recipient agent will receive the message in their terminal (if running in tmux).', {
-        recipient: z.string().describe('Name of the target agent (e.g. "backend", "task_flow:2")'),
-        message: z.string().describe('The message to send'),
-        context: z.string().optional().describe('Optional markdown context'),
-    }, { readOnlyHint: false }, async (params) => {
-        const db = getDb();
-        const senderName = ensureRegistered();
-        const recipient = getAgent(params.recipient);
-        if (!recipient)
-            return errorResponse(`Agent "${params.recipient}" not found`, 'NOT_FOUND');
-        const ts = now();
-        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, sender_name, recipient_name, source, status, created_at)
-         VALUES (NULL, ?, ?, ?, ?, 'mcp', 'pending', ?)`).run(params.message, params.context ?? null, senderName, params.recipient, ts);
-        const id = result.lastInsertRowid;
-        const msg = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
-        broadcastChange('agent_message', 'agent_question', msg);
-        return successResponse({ id, sender: senderName, recipient: params.recipient, status: 'pending' });
-    });
-    server.tool('ask_agent', 'Ask another agent a question and wait for their response. Like ask_user but targets an agent. Returns the message ID — use check_response to poll for the answer. The recipient agent receives the question in their terminal (if in tmux) and can respond with respond_to_message.', {
-        recipient: z.string().describe('Name of the target agent (e.g. "backend", "task_flow:2")'),
-        question: z.string().describe('The question to ask'),
-        context: z.string().optional().describe('Markdown context — background info, code snippets, proposals'),
-        choices: z.array(z.string()).optional().describe('Optional quick-tap choices, e.g. ["Yes", "No", "Skip"]'),
-        project_id: z.number().optional().describe('Optional project ID to attach the question to'),
-    }, { readOnlyHint: false }, async (params) => {
-        const db = getDb();
-        const senderName = ensureRegistered();
-        const recipient = getAgent(params.recipient);
-        if (!recipient)
-            return errorResponse(`Agent "${params.recipient}" not found or not connected`, 'NOT_FOUND');
-        const ts = now();
-        const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, choices, sender_name, recipient_name, agent_pid, source, status, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, 'mcp', 'pending', ?)`).run(params.project_id ?? null, params.question, params.context ?? null, params.choices ? JSON.stringify(params.choices) : null, senderName, params.recipient, process.ppid, ts);
-        const id = result.lastInsertRowid;
-        const msg = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
-        broadcastChange('agent_message', 'agent_question', msg);
-        logActivity('agent_question', `Asked ${params.recipient}: ${params.question}`, { entityType: 'agent_message', entityId: id });
-        return successResponse({
-            id,
-            status: 'pending',
-            sender: senderName,
-            recipient: params.recipient,
-            message: `Question sent to "${params.recipient}" (id: ${id}). Use check_response(${id}) to retrieve their answer.`,
-        });
-    });
-    server.tool('respond_to_message', 'Respond to a pending message addressed to this agent. Use check_messages to see incoming messages, then respond by message ID.', {
-        message_id: z.number().describe('The message ID to respond to (from check_messages)'),
-        response: z.string().describe('Your response text'),
-    }, { readOnlyHint: false }, async (params) => {
-        const db = getDb();
-        const name = ensureRegistered();
-        const message = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(params.message_id);
-        if (!message)
-            return errorResponse(`Message ${params.message_id} not found`, 'NOT_FOUND');
-        if (message.recipient_name !== name)
-            return errorResponse(`Message ${params.message_id} is not addressed to you`, 'VALIDATION_ERROR');
-        if (message.status !== 'pending')
-            return errorResponse(`Message ${params.message_id} is already ${message.status}`, 'VALIDATION_ERROR');
-        const ts = now();
-        db.prepare('UPDATE agent_messages SET response = ?, status = ?, answered_at = ?, delivered = NULL WHERE id = ?')
-            .run(params.response, 'answered', ts, params.message_id);
-        const updated = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(params.message_id);
-        broadcastChange('agent_message', 'agent_question_answered', updated);
-        logActivity('agent_question_answered', `Responded to ${message.sender_name}: ${params.response.slice(0, 80)}`, { entityType: 'agent_message', entityId: params.message_id });
-        return successResponse({
-            id: params.message_id,
-            status: 'answered',
-            sender: message.sender_name,
-            message: `Response sent to "${message.sender_name}".`,
-        });
-    });
-    server.tool('check_messages', 'Check for incoming messages from users or other agents addressed to this agent.', {}, { readOnlyHint: true }, async () => {
-        const db = getDb();
-        const name = ensureRegistered();
-        const messages = db.prepare(`SELECT * FROM agent_messages WHERE recipient_name = ? AND status = 'pending' ORDER BY created_at ASC`).all(name);
-        return successResponse({
-            agent: name,
-            count: messages.length,
-            messages: messages.map(m => ({
-                id: m.id, sender: m.sender_name, question: m.question,
-                context: m.context, choices: m.choices ? JSON.parse(m.choices) : null,
-                created_at: m.created_at,
-            })),
-        });
-    });
-    server.tool('list_agents', 'List registered agents with their status, project path, and connection info.', {
-        status: z.enum(['connected', 'disconnected']).optional().describe('Filter by status. Omit for all agents.'),
-    }, { readOnlyHint: true }, async (params) => {
-        const agents = listAgents(params.status);
-        return successResponse(agents);
-    });
-    server.tool('broadcast_agents', 'Send a question to multiple agents simultaneously. Creates a group message — each agent gets their own copy linked by a shared broadcast ID. Use check_broadcast to see all responses. Optional: omit agents list to broadcast to ALL connected agents.', {
-        question: z.string().describe('The question to broadcast'),
-        agents: z.array(z.string()).optional().describe('Agent names to send to. If omitted, sends to all connected agents.'),
-        context: z.string().optional().describe('Markdown context shown before the question'),
-        choices: z.array(z.string()).optional().describe('Optional quick-tap choices'),
-        project_id: z.number().optional().describe('Optional project ID to attach the messages to'),
-    }, { readOnlyHint: false }, async (params) => {
-        const db = getDb();
-        const senderName = ensureRegistered();
-        // Resolve recipients
-        let recipients;
-        if (params.agents && params.agents.length > 0) {
-            for (const name of params.agents) {
-                const agent = getAgent(name);
-                if (!agent)
-                    return errorResponse(`Agent "${name}" not found`, 'NOT_FOUND');
-            }
-            recipients = params.agents;
-        }
-        else {
-            const connected = listAgents('connected');
-            recipients = connected
-                .map((a) => a.name)
-                .filter((n) => n !== senderName);
-            if (recipients.length === 0)
-                return errorResponse('No other connected agents to broadcast to', 'VALIDATION_ERROR');
-        }
-        if (params.project_id) {
-            const project = db.prepare('SELECT id FROM projects WHERE id = ?').get(params.project_id);
-            if (!project)
-                return errorResponse(`Project ${params.project_id} not found`, 'NOT_FOUND');
-        }
-        const broadcastId = crypto.randomUUID();
-        const ts = now();
-        const messageIds = [];
-        for (const recipient of recipients) {
-            const result = db.prepare(`INSERT INTO agent_messages (project_id, question, context, choices, sender_name, recipient_name, agent_pid, source, status, broadcast_id, created_at)
-           VALUES (?, ?, ?, ?, ?, ?, ?, 'mcp', 'pending', ?, ?)`).run(params.project_id ?? null, params.question, params.context ?? null, params.choices ? JSON.stringify(params.choices) : null, senderName, recipient, process.ppid, broadcastId, ts);
-            const id = result.lastInsertRowid;
-            messageIds.push(id);
-            const msg = db.prepare('SELECT * FROM agent_messages WHERE id = ?').get(id);
-            broadcastChange('agent_message', 'agent_question', msg);
-        }
-        logActivity('agent_broadcast', `Broadcast to ${recipients.length} agents: ${params.question.slice(0, 80)}`, { entityType: 'agent_message' });
-        return successResponse({
-            broadcastId,
-            recipients,
-            messageIds,
-            count: recipients.length,
-            message: `Broadcast sent to ${recipients.length} agents. Use check_broadcast("${broadcastId}") to see responses.`,
-        });
-    });
-    server.tool('check_broadcast', 'Check the status of a broadcast message — shows which agents have responded and their answers.', {
-        broadcast_id: z.string().describe('The broadcast ID returned by broadcast_agents'),
-    }, { readOnlyHint: true }, async (params) => {
-        const db = getDb();
-        const messages = db.prepare('SELECT * FROM agent_messages WHERE broadcast_id = ? ORDER BY created_at ASC').all(params.broadcast_id);
-        if (messages.length === 0)
-            return errorResponse(`No messages found for broadcast ${params.broadcast_id}`, 'NOT_FOUND');
-        const total = messages.length;
-        const answered = messages.filter(m => m.status === 'answered').length;
-        const pending = messages.filter(m => m.status === 'pending').length;
-        return successResponse({
-            broadcastId: params.broadcast_id,
-            question: messages[0].question,
-            total,
-            answered,
-            pending,
-            responses: messages.map(m => ({
-                id: m.id,
-                recipient: m.recipient_name,
-                status: m.status,
-                response: m.response ?? null,
-                answered_at: m.answered_at ?? null,
-            })),
-        });
-    });
-}

package/dist/tools/agent.d.ts

@@ -1,14 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function getAgentInstructions(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function clearData(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerAgentTools(server: McpServer): void;