@dalmasonto/taskflow-mcp 1.0.20 → 1.0.23

package/dist/db.js

@@ -105,6 +105,7 @@ function initSchema(db) {
       status TEXT NOT NULL DEFAULT 'pending',
       source TEXT NOT NULL DEFAULT 'mcp',
       created_at TEXT NOT NULL,
+      broadcast_id TEXT,
       answered_at TEXT
     );
 
@@ -129,6 +130,7 @@ function initSchema(db) {
     CREATE INDEX IF NOT EXISTS idx_notifications_created_at ON notifications(created_at);
     CREATE INDEX IF NOT EXISTS idx_agent_messages_status ON agent_messages(status);
     CREATE INDEX IF NOT EXISTS idx_agent_messages_project_id ON agent_messages(project_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_messages_broadcast_id ON agent_messages(broadcast_id);
     CREATE INDEX IF NOT EXISTS idx_agent_registry_status ON agent_registry(status);
     CREATE INDEX IF NOT EXISTS idx_agent_registry_name ON agent_registry(name);
     CREATE INDEX IF NOT EXISTS idx_agent_registry_project_path ON agent_registry(project_path);
@@ -162,6 +164,10 @@ function initSchema(db) {
     if (!colNames.has('source')) {
         db.exec("ALTER TABLE agent_messages ADD COLUMN source TEXT NOT NULL DEFAULT 'mcp'");
     }
+    if (!colNames.has('broadcast_id')) {
+        db.exec('ALTER TABLE agent_messages ADD COLUMN broadcast_id TEXT');
+        db.exec('CREATE INDEX IF NOT EXISTS idx_agent_messages_broadcast_id ON agent_messages(broadcast_id)');
+    }
     // Migration: make agent_messages.project_id nullable if it was NOT NULL
     try {
         const tableInfo = db.prepare("SELECT sql FROM sqlite_master WHERE name = 'agent_messages'").get();

package/dist/index.js

@@ -60,9 +60,15 @@ if (!httpOnly) {
     const { registerTerminalTools } = await import('./tools/terminal.js');
     const { registerResources } = await import('./resources.js');
     const { registerCheckpointTools } = await import('./tools/checkpoint.js');
-    const server = new McpServer({
-        name: 'taskflow',
-        version: '1.0.0',
+    const server = new McpServer({ name: 'taskflow', version: '1.0.23' }, {
+        instructions: [
+            'You MUST call bootstrap (preferred) or get_agent_instructions before doing any work. This loads your task management rules and project context.',
+            'You MUST create a task in TaskFlow before editing files or running commands. search_tasks first to avoid duplicates.',
+            'You MUST call start_timer when beginning work and stop_timer when done. Timer lifecycle: start_timer → work → stop_timer(final_status).',
+            'Never silently fix bugs — always create or reopen a task first, then track the fix.',
+            'When you need user input, call ask_user to post it to the Agent Inbox so the user can respond remotely.',
+            'Use log_debug to document your work — it is shared memory visible to the user and other agents.',
+        ].join('\n'),
     });
     // Wrap server.tool() to track execution time and log failures
     const originalTool = server.tool.bind(server);

package/dist/resources.js

@@ -1,6 +1,19 @@
 import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { getDb } from './db.js';
+import { getAgentInstructions } from './tools/agent.js';
 export function registerResources(server) {
+    // ─── Agent Instructions Resource ────────────────────────────────────
+    // Auto-loaded by MCP clients on connection — ensures rules are always present
+    server.resource('agent-instructions', 'taskflow://instructions', { description: 'TaskFlow agent onboarding instructions — rules, workflow, and live project context', mimeType: 'application/json' }, async (uri) => {
+        const instructions = await getAgentInstructions();
+        return {
+            contents: [{
+                    uri: uri.href,
+                    text: JSON.stringify(instructions, null, 2),
+                    mimeType: 'application/json',
+                }],
+        };
+    });
     // ─── Projects Resource ──────────────────────────────────────────────
     server.resource('projects', new ResourceTemplate('taskflow://projects/{id}', {
         list: async () => {

package/dist/sse.js

@@ -666,17 +666,16 @@ export async function startSSEServer() {
                 // Relay command polling + state pushing (if relay is configured)
                 if (RELAY_URL && RELAY_PUSH_TOKEN) {
                     console.log(`[relay] command polling started → ${RELAY_URL}`);
-                    // Push state snapshot on startup and every 30s
+                    // Push lightweight sync state — only what the remote app needs
+                    // SSE events handle real-time updates after this initial load
                     const pushState = () => {
                         try {
                             const db = getDb();
                             const state = {
-                                tasks: db.prepare('SELECT * FROM tasks').all(),
-                                projects: db.prepare('SELECT * FROM projects').all(),
-                                sessions: db.prepare('SELECT * FROM sessions').all(),
-                                activityLogs: db.prepare('SELECT * FROM activity_logs ORDER BY id DESC LIMIT 100').all(),
-                                agentMessages: db.prepare('SELECT * FROM agent_messages ORDER BY id DESC LIMIT 200').all(),
                                 agentRegistry: db.prepare('SELECT * FROM agent_registry').all(),
+                                agentMessages: db.prepare('SELECT * FROM agent_messages ORDER BY id DESC LIMIT 100').all(),
+                                notifications: db.prepare('SELECT * FROM notifications ORDER BY id DESC LIMIT 50').all(),
+                                projects: db.prepare('SELECT * FROM projects').all(),
                             };
                             fetch(`${RELAY_URL}/push/state`, {
                                 method: 'POST',
@@ -687,7 +686,7 @@ export async function startSSEServer() {
                         catch { /* ignore */ }
                     };
                     pushState();
-                    setInterval(pushState, 30_000);
+                    setInterval(pushState, 60_000);
                     // Poll for commands every 2s
                     setInterval(async () => {
                         try {

package/dist/tools/agent-inbox.js

@@ -1,4 +1,5 @@
 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';
@@ -172,4 +173,81 @@ export function registerAgentInboxTools(server) {
         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.js

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { getDb } from '../db.js';
 import { logActivity, successResponse, broadcastChange } from '../helpers.js';
 // ─── exported handler functions ───────────────────────────────────────
@@ -93,6 +94,7 @@ export async function getAgentInstructions() {
             'list_tasks/search_tasks return compact summaries. Use get_task(id) to read full descriptions.',
             'log_debug accepts task_id OR project_id — use project_id for project-wide notes visible on the project page.',
             'Multi-agent: use register_agent to set your name, list_agents to see who is online, send_to_agent for updates, ask_agent for questions that need answers.',
+            'Multi-agent: use broadcast_agents to send a question to multiple agents at once (group chat). Omit the agents list to broadcast to ALL connected agents. Use check_broadcast(broadcast_id) to see all responses and their status.',
             'Multi-agent: task dependencies are the backbone of coordination — use them to enforce build order so agents don\'t step on each other.',
             'Multi-agent: log_debug with project_id is shared memory — other agents read it to understand decisions, gotchas, and architecture context.',
         ],
@@ -113,5 +115,54 @@ export async function clearData() {
 // ─── MCP registration ─────────────────────────────────────────────────
 export function registerAgentTools(server) {
     server.tool('get_agent_instructions', '**Call this at the start of every conversation.** Returns onboarding instructions, behavioral rules, and live project context for AI agents working with TaskFlow. This tool tells you how to proactively manage tasks, track time, and stay in sync with the project.', {}, { readOnlyHint: true }, async () => getAgentInstructions());
+    server.tool('bootstrap', '**CALL THIS FIRST.** One-shot startup: returns your agent instructions, active project (auto-detected from folder name), open/blocked tasks, unread notifications, and registered agents — all in one call. Replaces the need to call get_agent_instructions + search_projects + list_tasks + list_notifications + list_agents separately.', {
+        project_name: z.string().optional().describe('Override project name (default: auto-detected from working directory folder name)'),
+    }, { readOnlyHint: true }, async (params) => {
+        const db = getDb();
+        const { listAgents } = await import('../agent-registry.js');
+        // Get instructions
+        const instructionsResult = await getAgentInstructions();
+        const instructions = instructionsResult.content?.[0]?.text
+            ? JSON.parse(instructionsResult.content[0].text)
+            : null;
+        // Auto-detect project from folder name or use override
+        const { myAgentName } = await import('./agent-inbox.js');
+        const agentEntry = myAgentName
+            ? db.prepare('SELECT project_path FROM agent_registry WHERE name = ?').get(myAgentName)
+            : null;
+        const folderName = params.project_name
+            ?? (agentEntry?.project_path ? agentEntry.project_path.split('/').pop() : null);
+        let project = null;
+        let tasks = [];
+        if (folderName) {
+            const projects = db.prepare('SELECT * FROM projects WHERE LOWER(name) LIKE ?').all(`%${folderName.toLowerCase()}%`);
+            if (projects.length === 1) {
+                project = projects[0];
+                tasks = db.prepare("SELECT id, title, status, priority, tags, estimated_time FROM tasks WHERE project_id = ? AND status IN ('not_started', 'in_progress', 'paused', 'blocked') ORDER BY CASE priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 ELSE 3 END").all(project.id);
+            }
+            else if (projects.length > 1) {
+                project = { _ambiguous: true, matches: projects.map(p => ({ id: p.id, name: p.name })), message: 'Multiple projects match — ask the user which one to use.' };
+            }
+        }
+        // Unread notifications
+        const notifications = db.prepare("SELECT * FROM notifications WHERE read = 0 ORDER BY created_at DESC LIMIT 10").all();
+        // Active agents
+        const agents = listAgents('connected');
+        // Pending inbox messages for this agent
+        const agentName = myAgentName ?? 'unknown';
+        const pendingMessages = db.prepare("SELECT id, sender_name, question, created_at FROM agent_messages WHERE recipient_name = ? AND status = 'pending' ORDER BY created_at ASC").all(agentName);
+        return successResponse({
+            instructions,
+            project,
+            tasks,
+            taskCount: tasks.length,
+            notifications,
+            unreadCount: notifications.length,
+            agents,
+            pendingMessages,
+            pendingMessageCount: pendingMessages.length,
+            agentName,
+        });
+    });
     server.tool('clear_data', 'Delete ALL tasks, projects, sessions, notifications, and activity logs. Settings are preserved. Use with extreme caution — this is irreversible.', {}, { destructiveHint: true }, async () => clearData());
 }

package/dist/types.d.ts

@@ -64,6 +64,7 @@ export declare const ActivityAction: z.ZodEnum<{
     debug_log: "debug_log";
     agent_question: "agent_question";
     agent_question_answered: "agent_question_answered";
+    agent_broadcast: "agent_broadcast";
     agent_connected: "agent_connected";
     agent_disconnected: "agent_disconnected";
     terminal_send_keys: "terminal_send_keys";

package/dist/types.js

@@ -14,7 +14,7 @@ export const ActivityAction = z.enum([
     'tasks_bulk_created', 'settings_saved', 'data_seeded', 'data_cleared',
     'task_linked', 'task_unlinked', 'dependency_added', 'dependency_removed',
     'link_added', 'tag_added', 'tag_removed', 'debug_log',
-    'agent_question', 'agent_question_answered',
+    'agent_question', 'agent_question_answered', 'agent_broadcast',
     'agent_connected', 'agent_disconnected',
     'terminal_send_keys', 'terminal_captured',
     'compaction_summary', 'activity_compacted',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmasonto/taskflow-mcp",
-  "version": "1.0.20",
+  "version": "1.0.23",
   "description": "MCP server for TaskFlow — manage projects, tasks, timers, analytics via AI agents",
   "type": "module",
   "main": "dist/index.js",
@@ -36,7 +36,7 @@
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "latest",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "latest",
     "dotenv": "^17.4.1",
     "zod": "latest"