@dalmasonto/taskflow-mcp 1.0.33 → 2.0.0

package/dist/tools/agent.js

@@ -1,168 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { logActivity, successResponse, broadcastChange } from '../helpers.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function getAgentInstructions() {
-    const db = getDb();
-    // Gather live context to include in the instructions
-    const projectCount = db.prepare('SELECT COUNT(*) AS c FROM projects').get().c;
-    const taskCount = db.prepare('SELECT COUNT(*) AS c FROM tasks').get().c;
-    const inProgressCount = db.prepare("SELECT COUNT(*) AS c FROM tasks WHERE status = 'in_progress'").get().c;
-    const blockedCount = db.prepare("SELECT COUNT(*) AS c FROM tasks WHERE status = 'blocked'").get().c;
-    const unreadNotifs = db.prepare('SELECT COUNT(*) AS c FROM notifications WHERE read = 0').get().c;
-    const instructions = {
-        role: 'TaskFlow — local-first task & time tracker with MCP integration. Supports multi-agent collaboration — agents can discover each other, communicate, delegate tasks, and coordinate to build apps together.',
-        startup: [
-            'Derive the project name from the **folder name** of the current working directory (e.g. `/home/user/projects/my-app` → search for "my-app"). Use search_projects with that name. If 2–3 results match, **ask the user** which project to use — never guess.',
-            'list_tasks status="in_progress" and status="blocked" for the confirmed project.',
-            'list_notifications unread_only=true',
-            'register_agent with a descriptive name for your role (e.g. "backend", "frontend", "lead"). Then list_agents to see who else is online. If 2+ disconnected agents exist for the same project path, ask the user which name to register as — the name preserves message history from previous sessions. If other agents are active on the same project, check_messages for any pending messages addressed to you.',
-        ],
-        state: {
-            projects: projectCount,
-            tasks: taskCount,
-            in_progress: inProgressCount,
-            blocked: blockedCount,
-            unread: unreadNotifs,
-        },
-        rules: [
-            // Project discovery
-            'The project name should be derived from the working directory folder name. Always search_projects first. If no match, create the project using create_project with the folder name. If multiple matches, present them to the user and ask which one to use.',
-            // Task tracking
-            'Proactively create tasks for ALL substantial work — features, bugs, refactors, AND debugging/investigation. Debugging is real work: create a task for it (e.g. "Debug: SSE connection dropping"), start a timer, and track it the same way you would a feature. search_tasks first to avoid duplicates. Link tasks to the confirmed project.',
-            'Timer lifecycle: start_timer → work → stop_timer(final_status). Use "done"/"partial_done"/"blocked". pause_timer when waiting for input. This applies equally to debugging tasks — start a timer before investigating, stop it when resolved or blocked.',
-            'MUST stop_timer with "done" when work is complete. Never leave finished tasks in "in_progress" or "paused". This includes debugging tasks — when the bug is fixed or the investigation concludes, stop the timer.',
-            // Bugs & post-build debugging
-            'When a user reports a bug or you discover one while testing/building: FIRST search_tasks for an existing related task. If found (even if "done"), move it back to in_progress (update_task_status) — this reopens the task and auto-starts a timer. Then log_debug on that task to document the new bug. If no related task exists, create a new one (e.g. "Bug: sidebar not rendering in light mode") with tag "bug", start the timer, and begin debugging.',
-            'This also applies to post-build issues: after running a build/test and seeing failures, do NOT silently fix them. Open or reopen a task first, log what failed, then fix. The task becomes the paper trail — the user and future agents can see what broke, what was tried, and how it was resolved.',
-            // Dependencies
-            'Check task dependencies before starting. If any dep is incomplete, set task to "blocked".',
-            'After completing a task, check if blocked tasks depending on it can be unblocked.',
-            // Prioritization
-            'When user is unsure what to work on: list_tasks priority="critical"/"high" status="not_started".',
-            // Transparency — CRITICAL
-            'ALWAYS tell the user what commands you are running and why. Before executing a shell command, state: "Running: `<command>`". After significant actions (file edits, installs, config changes), summarize what changed. The user must be able to reconstruct what happened from your messages alone — they should never wonder "what did the agent do?".',
-            'When starting work, briefly state the approach: what you plan to do, which files you expect to touch, and what commands you will run. This gives the user a chance to course-correct before you act.',
-            // Debug logging — comprehensive
-            'ALWAYS log your work using log_debug. Log with a task_id when working on a specific task, or with project_id for project-level observations. Use log_debug as a running journal — it shows up in the Activity Pulse and on the project page so the user (and future agents) can follow your reasoning.',
-            'What to log: **every stage** of your process. When you start investigating, when you form a hypothesis, when you read/edit a file, the exact commands you run (with output snippets), errors encountered, fixes attempted, and the resolution. Log the **path you took**, not just the destination.',
-            'Log early and often — not just at the end. A debug log entry per significant step (e.g. "Read `sse.ts:57` — found the healthz route exists but is unreachable because..."). Use Markdown: `## headings` for stages, `` `code blocks` `` for errors/paths/commands, **bold** for key findings.',
-            'For project-level notes (architecture decisions, setup gotchas, "how to run the app"), use log_debug with project_id instead of task_id. These appear on the project page and serve as living documentation.',
-            // Formatting
-            'Use Markdown in descriptions — headings, bullets, code blocks, bold. The UI renders it.',
-            // Agent Inbox — remote communication
-            'When you need user input (choices, confirmations, clarifications), ALWAYS do BOTH: (1) ask the question normally in the terminal conversation, AND (2) call ask_user to post it to the Agent Inbox. This lets the user respond from either the terminal or the TaskFlow UI remotely. If the user explicitly tells you not to use the inbox (e.g. "don\'t post to inbox"), skip the ask_user call.',
-            'After calling ask_user, continue your work if possible. The user may respond from the UI, and the response will be delivered to your terminal automatically (if running in tmux). You can also call check_response to poll for the answer.',
-            // Agent Inbox — formatting
-            'When calling ask_user, write **proper titles** for the question field — clear, concise, well-formed sentences (not random fragments or debug-style text). The question is the headline the user sees first.',
-            'The `context` field in ask_user is rendered as Markdown in the UI. Format it well: use `## headings` to organize sections, `**bold**` for key terms, bullet lists for options/trade-offs, and `\\`code\\`` for file paths or commands. Use real newlines (not literal \\\\n). The context should read like a well-written message, not raw debug output.',
-            // ── Multi-Agent Collaboration ──────────────────────────────────────
-            // Identity & discovery
-            'On startup, call register_agent with a descriptive name that reflects your role (e.g. "backend", "frontend", "designer", "qa"). If the user assigns you a role, use that. This name is how other agents address you and how your message history is preserved across sessions.',
-            'Call list_agents to discover who else is online. If you see 2+ disconnected agents on the same project path, ask the user which name to register as — registering with an existing name resumes that agent\'s full message history. Before starting work, check if another agent is already working on the same project — coordinate instead of duplicating effort.',
-            // Communication
-            'Use send_to_agent for fire-and-forget updates — status changes, "I finished task X", "file Y is ready for you". Use ask_agent when you need a response before proceeding — "Should I use REST or GraphQL for this endpoint?", "Is the auth middleware ready?".',
-            'When you receive a message from another agent (via check_messages), respond promptly using respond_to_message. Treat agent messages with the same priority as user messages.',
-            'Check for incoming messages (check_messages) periodically — at minimum: (1) when you finish a task, (2) before starting a new task, and (3) when you\'ve been working for a while without checking. Other agents may be blocked waiting for your response.',
-            // Collaborative app building — the coordination pattern
-            'When multiple agents collaborate on building an app, follow this coordination pattern:\n' +
-                '  1. **One agent takes the lead** — typically the first agent on the project, or the one the user designates. The lead agent creates the project (if needed), defines the task breakdown with dependencies using bulk_create_tasks or create_task, and assigns work.\n' +
-                '  2. **Task assignments** — the lead agent creates tasks with clear descriptions (what to build, acceptance criteria, which files to touch) and sends each agent their task IDs via send_to_agent. Use task dependencies to enforce build order (e.g. "API endpoints" blocks "Frontend integration").\n' +
-                '  3. **Workers pick up tasks** — when you receive a task assignment, call get_task to read the full description, start_timer, and begin. Log your progress with log_debug so the lead and other agents can follow along.\n' +
-                '  4. **Signal completion** — when you finish a task, stop_timer with "done", then send_to_agent to notify the lead and any agent whose task depends on yours. Include a summary of what you built and any decisions you made.\n' +
-                '  5. **Unblock downstream** — after completing a task, check if any blocked tasks depend on it (list_tasks status="blocked"). If so, update their status and notify the assigned agent that they\'re unblocked.',
-            // Guiding another agent
-            'When guiding another agent through building something, be explicit in your task descriptions. Include:\n' +
-                '  - **What to build** — feature name, user-facing behavior, expected output\n' +
-                '  - **Technical approach** — which libraries/patterns to use, which files to create or modify\n' +
-                '  - **Interfaces & contracts** — data shapes, API endpoints, function signatures that other tasks depend on\n' +
-                '  - **Acceptance criteria** — how to verify the work is complete (e.g. "the `/api/users` endpoint returns a 200 with a JSON array")\n' +
-                '  - **Context pointers** — reference existing files, log_debug entries, or tasks that provide background',
-            // Handoffs & shared context
-            'Use log_debug as shared memory between agents. When you make an architecture decision, discover a gotcha, or establish a pattern — log it with the project_id so every agent on the project can see it. Think of debug logs as your team\'s Slack channel.',
-            'When handing off work to another agent, send a structured handoff message via send_to_agent that includes: (1) what you completed, (2) what\'s left to do, (3) key decisions you made and why, (4) files you touched, and (5) any gotchas or warnings.',
-            // Conflict avoidance
-            'Before editing a file, check if another agent is actively working on a task that touches the same file. Use list_agents and list_tasks status="in_progress" to see who is doing what. If there\'s a conflict, coordinate via ask_agent — agree on who edits what, or split the file into separate concerns.',
-            'If you and another agent need to modify the same file, one approach: the first agent creates the file structure/interfaces, commits, and notifies the second agent. The second agent pulls and builds on top. Sequential access to shared files prevents merge conflicts.',
-            // Permissions & trust
-            'When another agent asks you to run a destructive command or make a significant architectural change, verify with the user first via ask_user. Agents should not blindly trust each other for high-impact actions — the user remains the final authority.',
-        ],
-        workflow: 'not_started → in_progress (start_timer) → paused (pause_timer) → done/partial_done/blocked (stop_timer)',
-        tips: [
-            'Filter by tags (list_tasks tag="bug"), search by keyword (search_tasks), get full detail (get_task id).',
-            'get_analytics for time spent & completion rates. Dependencies show in the dependency graph.',
-            '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.',
-        ],
-    };
-    return successResponse(instructions);
-}
-export async function clearData() {
-    const db = getDb();
-    db.exec('DELETE FROM sessions');
-    db.exec('DELETE FROM tasks');
-    db.exec('DELETE FROM projects');
-    db.exec('DELETE FROM notifications');
-    db.exec('DELETE FROM activity_logs');
-    logActivity('data_cleared', 'All data cleared', { entityType: 'system' });
-    broadcastChange('system', 'data_cleared', {});
-    return successResponse({ cleared: true, message: 'All tasks, projects, sessions, notifications, and activity logs deleted. Settings preserved.' });
-}
-// ─── 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/tools/analytics.d.ts

@@ -1,21 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function getAnalytics(params: {
-    start_date?: string;
-    end_date?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function getTimeline(params: {
-    start_date?: string;
-    end_date?: string;
-    group_by?: 'day' | 'week';
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerAnalyticsTools(server: McpServer): void;

package/dist/tools/analytics.js

@@ -1,191 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { successResponse, errorResponse } from '../helpers.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function getAnalytics(params) {
-    const db = getDb();
-    const { start_date, end_date } = params;
-    // Build date filter for sessions
-    const sessionConditions = [];
-    const sessionValues = [];
-    if (start_date) {
-        sessionConditions.push('start >= ?');
-        sessionValues.push(start_date);
-    }
-    if (end_date) {
-        sessionConditions.push('start <= ?');
-        sessionValues.push(end_date);
-    }
-    const sessionWhere = sessionConditions.length > 0
-        ? `WHERE ${sessionConditions.join(' AND ')}`
-        : '';
-    // Total focused time (sum of all session durations in ms)
-    const durationFormula = `(julianday(COALESCE(end, datetime('now'))) - julianday(start)) * 86400000`;
-    const timeRow = db.prepare(`SELECT COALESCE(SUM(${durationFormula}), 0) AS total_focused_time FROM sessions ${sessionWhere}`).get(...sessionValues);
-    const total_focused_time = Math.round(timeRow.total_focused_time);
-    // Task counts by status
-    const taskRows = db.prepare('SELECT status, COUNT(*) AS count FROM tasks GROUP BY status').all();
-    const status_distribution = {};
-    let tasks_completed = 0;
-    let tasks_in_progress = 0;
-    let total_tasks = 0;
-    for (const row of taskRows) {
-        status_distribution[row.status] = row.count;
-        total_tasks += row.count;
-        if (row.status === 'done')
-            tasks_completed = row.count;
-        if (row.status === 'in_progress')
-            tasks_in_progress = row.count;
-    }
-    // Time per project (only tasks that belong to a project)
-    const projectTimeRows = db.prepare(`SELECT
-       t.project_id,
-       p.name AS project_name,
-       COALESCE(SUM(${durationFormula.replace(/start/g, 's.start').replace(/end/g, 's.end')}), 0) AS total_time
-     FROM sessions s
-     JOIN tasks t ON s.task_id = t.id
-     JOIN projects p ON t.project_id = p.id
-     ${sessionWhere.replace(/start/g, 's.start')}
-     GROUP BY t.project_id, p.name`).all(...sessionValues);
-    const time_per_project = projectTimeRows.map(row => ({
-        project_id: row.project_id,
-        project_name: row.project_name,
-        total_time: Math.round(row.total_time),
-    }));
-    return successResponse({
-        total_focused_time,
-        tasks_completed,
-        tasks_in_progress,
-        total_tasks,
-        status_distribution,
-        time_per_project,
-    });
-}
-export async function getTimeline(params) {
-    const db = getDb();
-    const { start_date, end_date, group_by = 'day' } = params;
-    const periodExpr = group_by === 'week'
-        ? `strftime('%Y-W%W', start)`
-        : `strftime('%Y-%m-%d', start)`;
-    const durationFormula = `(julianday(COALESCE(end, datetime('now'))) - julianday(start)) * 86400000`;
-    const conditions = [];
-    const values = [];
-    if (start_date) {
-        conditions.push('start >= ?');
-        values.push(start_date);
-    }
-    if (end_date) {
-        conditions.push('start <= ?');
-        values.push(end_date);
-    }
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-    const rows = db.prepare(`SELECT
-       ${periodExpr} AS period,
-       COALESCE(SUM(${durationFormula}), 0) AS total_time,
-       COUNT(*) AS session_count
-     FROM sessions
-     ${where}
-     GROUP BY period
-     ORDER BY period ASC`).all(...values);
-    const timeline = rows.map(row => ({
-        period: row.period,
-        total_time: Math.round(row.total_time),
-        session_count: row.session_count,
-    }));
-    return successResponse(timeline);
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerAnalyticsTools(server) {
-    server.tool('get_analytics', 'Get a high-level analytics summary: total focused time, task completion rates, status distribution, and time per project. Useful for standup reports or understanding workload.', {
-        start_date: z.string().optional(),
-        end_date: z.string().optional(),
-    }, { readOnlyHint: true }, async (params) => getAnalytics(params));
-    server.tool('get_timeline', 'Get focused time grouped by day or week. Use for visualizing work patterns over time.', {
-        start_date: z.string().optional(),
-        end_date: z.string().optional(),
-        group_by: z.enum(['day', 'week']).optional(),
-    }, { readOnlyHint: true }, async (params) => getTimeline(params));
-    server.tool('get_tool_stats', 'Get tool execution statistics: call count, success rate, average duration per tool. Shows which tools are used most and which are slow or failing.', {
-        since: z.string().optional().describe('ISO date to filter from (e.g. "2026-04-01"). Defaults to all time.'),
-        tool_name: z.string().optional().describe('Filter to a specific tool name'),
-    }, { readOnlyHint: true }, async (params) => {
-        const db = getDb();
-        const conditions = [];
-        const values = [];
-        if (params.since) {
-            conditions.push('created_at >= ?');
-            values.push(params.since);
-        }
-        if (params.tool_name) {
-            conditions.push('tool_name = ?');
-            values.push(params.tool_name);
-        }
-        const where = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
-        const stats = db.prepare(`
-        SELECT
-          tool_name,
-          COUNT(*) as call_count,
-          SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count,
-          SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failure_count,
-          ROUND(AVG(duration_ms)) as avg_duration_ms,
-          MAX(duration_ms) as max_duration_ms,
-          MIN(created_at) as first_call,
-          MAX(created_at) as last_call
-        FROM tool_executions${where}
-        GROUP BY tool_name
-        ORDER BY call_count DESC
-      `).all(...values);
-        const total = db.prepare(`SELECT COUNT(*) as count FROM tool_executions${where}`).get(...values);
-        return successResponse({ total_executions: total.count, tools: stats });
-    });
-    server.tool('get_task_cost', 'Get per-task cost metrics: tool calls made during active timer sessions, total execution time, and tool breakdown. Useful for understanding which tasks consume the most resources.', {
-        task_id: z.number().optional().describe('Get cost for a specific task. Omit for all tasks.'),
-        project_id: z.number().optional().describe('Get cost for all tasks in a project'),
-    }, { readOnlyHint: true }, async (params) => {
-        const db = getDb();
-        if (params.task_id) {
-            // Cost for a single task — use subqueries to avoid cross-join inflation
-            const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
-            if (!task)
-                return errorResponse(`Task ${params.task_id} not found`, 'NOT_FOUND');
-            const sessionTime = db.prepare('SELECT COALESCE(SUM(CASE WHEN end IS NOT NULL THEN (julianday(end) - julianday(start)) * 86400000 ELSE 0 END), 0) as total FROM sessions WHERE task_id = ?').get(params.task_id);
-            // Tool calls that occurred during any session for this task
-            const toolCalls = db.prepare(`
-          SELECT COUNT(*) as total, COALESCE(SUM(te.duration_ms), 0) as duration_ms,
-            SUM(CASE WHEN te.success = 0 THEN 1 ELSE 0 END) as failed
-          FROM tool_executions te
-          WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = ? AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))
-        `).get(params.task_id);
-            // Tool breakdown for this task
-            const tools = db.prepare(`
-          SELECT te.tool_name, COUNT(*) as call_count, ROUND(AVG(te.duration_ms)) as avg_ms
-          FROM tool_executions te
-          WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = ? AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))
-          GROUP BY te.tool_name
-          ORDER BY call_count DESC
-        `).all(params.task_id);
-            return successResponse({
-                task: { task_id: task.id, title: task.title, status: task.status, tool_calls: toolCalls.total, total_tool_duration_ms: toolCalls.duration_ms, failed_calls: toolCalls.failed, total_session_time_ms: sessionTime.total },
-                tool_breakdown: tools,
-            });
-        }
-        // All tasks (optionally filtered by project) — use subqueries to avoid cross-join
-        const projectFilter = params.project_id ? 'WHERE t.project_id = ?' : '';
-        const filterValues = params.project_id ? [params.project_id] : [];
-        const tasks = db.prepare(`
-        SELECT
-          t.id as task_id,
-          t.title,
-          t.status,
-          (SELECT COUNT(*) FROM tool_executions te WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = t.id AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))) as tool_calls,
-          (SELECT COALESCE(SUM(te.duration_ms), 0) FROM tool_executions te WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = t.id AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))) as total_tool_duration_ms,
-          (SELECT COALESCE(SUM(CASE WHEN end IS NOT NULL THEN (julianday(end) - julianday(start)) * 86400000 ELSE 0 END), 0) FROM sessions WHERE task_id = t.id) as total_session_time_ms
-        FROM tasks t
-        ${projectFilter}
-        HAVING tool_calls > 0
-        ORDER BY tool_calls DESC
-        LIMIT 30
-      `).all(...filterValues);
-        return successResponse({ tasks });
-    });
-}

package/dist/tools/checkpoint.d.ts

@@ -1,27 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function createCheckpoint(params: {
-    task_id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function getCheckpoint(params: {
-    task_id: number;
-    latest?: boolean;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function listCheckpoints(params: {
-    task_id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerCheckpointTools(server: McpServer): void;

package/dist/tools/checkpoint.js

@@ -1,105 +0,0 @@
-import { z } from 'zod';
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
-import { resolve } from 'path';
-import { homedir } from 'os';
-import { getDb } from '../db.js';
-import { successResponse, errorResponse } from '../helpers.js';
-const CHECKPOINTS_DIR = resolve(homedir(), '.taskflow/checkpoints');
-const MAX_CHECKPOINTS_PER_TASK = 10;
-function getTaskDir(taskId) {
-    const dir = resolve(CHECKPOINTS_DIR, String(taskId));
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-export async function createCheckpoint(params) {
-    const db = getDb();
-    const task = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.task_id);
-    if (!task)
-        return errorResponse(`Task ${params.task_id} not found`, 'NOT_FOUND');
-    // Gather task state
-    const deps = db.prepare('SELECT dependency_id FROM task_dependencies WHERE task_id = ?').all(params.task_id);
-    const recentActivity = db.prepare('SELECT * FROM activity_logs WHERE entity_id = ? AND entity_type = ? ORDER BY created_at DESC LIMIT 20').all(params.task_id, 'task');
-    const activeSession = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
-    const totalTime = db.prepare('SELECT SUM(CASE WHEN end IS NOT NULL THEN (julianday(end) - julianday(start)) * 86400000 ELSE 0 END) as total FROM sessions WHERE task_id = ?').get(params.task_id);
-    // Tool stats during this task's sessions
-    const toolStats = db.prepare(`
-    SELECT te.tool_name, COUNT(*) as calls, ROUND(AVG(te.duration_ms)) as avg_ms
-    FROM tool_executions te
-    JOIN sessions s ON s.task_id = ? AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end)
-    GROUP BY te.tool_name ORDER BY calls DESC LIMIT 10
-  `).all(params.task_id);
-    const checkpoint = {
-        task_id: params.task_id,
-        timestamp: new Date().toISOString(),
-        task,
-        dependencies: deps.map(d => d.dependency_id),
-        recent_activity: recentActivity,
-        active_session: activeSession,
-        total_time_ms: totalTime.total ?? 0,
-        tool_stats: toolStats,
-    };
-    // Write checkpoint file
-    const taskDir = getTaskDir(params.task_id);
-    const filename = `${checkpoint.timestamp.replace(/[:.]/g, '-')}.json`;
-    const filepath = resolve(taskDir, filename);
-    writeFileSync(filepath, JSON.stringify(checkpoint, null, 2), 'utf-8');
-    // Prune old checkpoints
-    const files = readdirSync(taskDir).filter(f => f.endsWith('.json')).sort();
-    while (files.length > MAX_CHECKPOINTS_PER_TASK) {
-        const oldest = files.shift();
-        try {
-            unlinkSync(resolve(taskDir, oldest));
-        }
-        catch { /* ignore */ }
-    }
-    return successResponse({
-        task_id: params.task_id,
-        checkpoint: filename,
-        path: filepath,
-        total_checkpoints: Math.min(files.length, MAX_CHECKPOINTS_PER_TASK),
-    });
-}
-export async function getCheckpoint(params) {
-    const taskDir = resolve(CHECKPOINTS_DIR, String(params.task_id));
-    let files;
-    try {
-        files = readdirSync(taskDir).filter(f => f.endsWith('.json')).sort();
-    }
-    catch {
-        return errorResponse(`No checkpoints found for task ${params.task_id}`, 'NOT_FOUND');
-    }
-    if (files.length === 0) {
-        return errorResponse(`No checkpoints found for task ${params.task_id}`, 'NOT_FOUND');
-    }
-    // Return latest by default
-    const file = files[files.length - 1];
-    const data = JSON.parse(readFileSync(resolve(taskDir, file), 'utf-8'));
-    return successResponse({
-        checkpoint: file,
-        data,
-        available_checkpoints: files.length,
-    });
-}
-export async function listCheckpoints(params) {
-    const taskDir = resolve(CHECKPOINTS_DIR, String(params.task_id));
-    let files;
-    try {
-        files = readdirSync(taskDir).filter(f => f.endsWith('.json')).sort();
-    }
-    catch {
-        return successResponse({ task_id: params.task_id, checkpoints: [] });
-    }
-    return successResponse({
-        task_id: params.task_id,
-        checkpoints: files.map(f => ({
-            filename: f,
-            timestamp: f.replace('.json', '').replace(/-/g, (m, offset) => offset <= 9 ? '-' : offset <= 15 ? ':' : '.'),
-        })),
-    });
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerCheckpointTools(server) {
-    server.tool('create_checkpoint', 'Create a checkpoint snapshot of a task\'s current state. Captures: task data, dependencies, recent activity, active timer, tool stats. Useful before context switches or at key milestones.', { task_id: z.number().describe('The task ID to checkpoint') }, { readOnlyHint: false }, async (params) => createCheckpoint(params));
-    server.tool('get_checkpoint', 'Get the latest checkpoint for a task. Returns the full task snapshot — useful for resuming work after an interruption.', { task_id: z.number().describe('The task ID to get checkpoint for') }, { readOnlyHint: true }, async (params) => getCheckpoint(params));
-    server.tool('list_checkpoints', 'List all available checkpoints for a task.', { task_id: z.number().describe('The task ID to list checkpoints for') }, { readOnlyHint: true }, async (params) => listCheckpoints(params));
-}

package/dist/tools/notifications.d.ts

@@ -1,31 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function listNotifications(params: {
-    limit?: number;
-    unread_only?: boolean;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function markNotificationRead(params: {
-    id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function markAllNotificationsRead(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function clearNotifications(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerNotificationTools(server: McpServer): void;

package/dist/tools/notifications.js

@@ -1,59 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { errorResponse, successResponse, broadcastChange } from '../helpers.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function listNotifications(params) {
-    const db = getDb();
-    const limit = params.limit ?? 50;
-    let sql = 'SELECT * FROM notifications';
-    const values = [];
-    if (params.unread_only) {
-        sql += ' WHERE read = 0';
-    }
-    sql += ' ORDER BY created_at DESC LIMIT ?';
-    values.push(limit);
-    const rows = db.prepare(sql).all(...values);
-    return successResponse(rows);
-}
-export async function markNotificationRead(params) {
-    const db = getDb();
-    const result = db
-        .prepare('UPDATE notifications SET read = 1 WHERE id = ?')
-        .run(params.id);
-    if (result.changes === 0) {
-        return errorResponse('Notification not found', 'NOT_FOUND');
-    }
-    const row = db
-        .prepare('SELECT * FROM notifications WHERE id = ?')
-        .get(params.id);
-    const notification = row;
-    broadcastChange('notification', 'notification_updated', notification);
-    return successResponse(notification);
-}
-export async function markAllNotificationsRead() {
-    const db = getDb();
-    const result = db
-        .prepare('UPDATE notifications SET read = 1 WHERE read = 0')
-        .run();
-    broadcastChange('notification', 'notifications_all_read', {});
-    return successResponse({ updated: result.changes });
-}
-export async function clearNotifications() {
-    const db = getDb();
-    const countRow = db
-        .prepare('SELECT COUNT(*) AS count FROM notifications')
-        .get();
-    db.prepare('DELETE FROM notifications').run();
-    broadcastChange('notification', 'notifications_cleared', {});
-    return successResponse({ deleted: countRow.count, message: 'Notifications cleared' });
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerNotificationTools(server) {
-    server.tool('list_notifications', 'List notifications. Check with unread_only=true at conversation start to surface important updates for the user.', {
-        limit: z.number().optional(),
-        unread_only: z.boolean().optional(),
-    }, { readOnlyHint: true }, async (params) => listNotifications(params));
-    server.tool('mark_notification_read', 'Mark a notification as read after surfacing it to the user.', { id: z.number() }, { readOnlyHint: false }, async (params) => markNotificationRead(params));
-    server.tool('mark_all_notifications_read', 'Mark all unread notifications as read. Call after the user has been briefed on pending notifications.', {}, { readOnlyHint: false }, async () => markAllNotificationsRead());
-    server.tool('clear_notifications', 'Delete all notifications. Use with caution — this is irreversible.', {}, { destructiveHint: true }, async () => clearNotifications());
-}