@dalmasonto/taskflow-mcp 1.0.0 → 1.0.2

package/dist/tools/agent.js

@@ -10,59 +10,39 @@ export async function getAgentInstructions() {
     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: 'You are connected to TaskFlow, a local-first task and time tracking system. You have access to tools for managing projects, tasks, timers, analytics, activity logs, notifications, and settings.',
-        startup_checklist: [
-            'Call list_projects to see all projects and their task counts.',
-            'Identify which project is relevant to the current work. Use search_projects by name if unsure. If multiple projects match, ask the user to confirm which one before proceeding.',
-            'Call list_tasks with status "in_progress" to see what is actively being worked on.',
-            'Call list_tasks with status "blocked" to see what is stuck and might need your help.',
-            'Call list_notifications with unread_only=true to check for pending notifications.',
+        role: 'TaskFlow — local-first task & time tracker with MCP integration.',
+        startup: [
+            'search_projects to find the current project (try name variants; confirm with user if ambiguous)',
+            'list_tasks status="in_progress" and status="blocked"',
+            'list_notifications unread_only=true',
         ],
-        current_state: {
+        state: {
             projects: projectCount,
-            total_tasks: taskCount,
+            tasks: taskCount,
             in_progress: inProgressCount,
             blocked: blockedCount,
-            unread_notifications: unreadNotifs,
+            unread: unreadNotifs,
         },
-        behavioral_rules: [
-            'At the start of a conversation, search for the current project by name using search_projects. Try multiple name variants if needed. If multiple projects match or you are unsure, ask the user to confirm which project to work on before creating or updating tasks. Always link new tasks to the confirmed project.',
-            'Before starting any coding work, check if a matching task exists in TaskFlow. If one exists, call start_timer on it to track time.',
-            'When you finish a piece of work, call stop_timer with the appropriate final_status: "done" if complete, "partial_done" if more work remains, "blocked" if you hit a blocker.',
-            'If you pause to wait for user input or switch context, call pause_timer on the active task.',
-            'If you encounter a blocker (missing dependency, unclear requirement, failing test you cannot fix), call stop_timer with final_status "blocked". This closes the active session and marks the task as blocked in one step. Update the task description to explain what is blocking it.',
-            'Before starting work on a task, check its dependencies array. If any dependency task is still "not_started" or "in_progress", set the task to "blocked" — do not start working on it until its dependencies are complete.',
-            'When the user asks "what should I work on?" or seems unsure what to do next, call list_tasks filtered by priority "critical" or "high" and status "not_started" to surface the most important unblocked work.',
-            'After completing a task, check if any blocked tasks had a dependency on it and might now be unblocked.',
-            'Periodically check list_notifications with unread_only=true and surface important ones to the user.',
-            'Before creating a new task, call list_tasks (or search_tasks) to check if a similar task already exists. Avoid creating duplicates — if a matching task exists, update it or start working on it instead of creating a new one.',
-            'When you finish work on a task, you MUST mark it as done. Call stop_timer with final_status "done" — this closes the session and sets the task to done in one step. Never leave a completed task in "in_progress" or "paused" status.',
-            'When you create new work items (files, features, fixes), create corresponding tasks in TaskFlow to keep the tracker in sync.',
-            'Proactively create tasks on the fly for any work you are doing — bug fixes, improvements, feature implementations, refactors. Create the task, start a timer, do the work, then stop the timer with the final status. Every meaningful unit of work should be tracked, even if the user did not explicitly ask you to create a task for it.',
-            'Use Markdown in description fields — headings, bullet lists, code blocks, bold/italic. Task and project descriptions render Markdown in the UI, so well-formatted descriptions are more readable for the user.',
-            'When debugging, use the log_debug tool to record your process — what you are investigating, what you tried, error messages, hypotheses, and findings. Link it to the relevant task with task_id. This creates a visible breadcrumb trail in the Activity Pulse that helps the user understand your reasoning.',
+        rules: [
+            // Task tracking
+            'Proactively create tasks for ALL substantial work (features, bugs, refactors). 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.',
+            'MUST stop_timer with "done" when work is complete. Never leave finished tasks in "in_progress" or "paused".',
+            // 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".',
+            // Logging
+            'Use log_debug with task_id to record debugging steps, hypotheses, findings, decisions. Use Markdown formatting.',
+            // Formatting
+            'Use Markdown in descriptions — headings, bullets, code blocks, bold. The UI renders it.',
         ],
-        task_workflow: {
-            description: 'The standard lifecycle of a task through the system',
-            flow: 'not_started → in_progress (start_timer) → paused (pause_timer) → in_progress (start_timer) → done/partial_done/blocked (stop_timer)',
-            valid_transitions: {
-                not_started: ['in_progress', 'blocked'],
-                in_progress: ['paused', 'blocked', 'partial_done', 'done'],
-                paused: ['in_progress', 'blocked', 'partial_done', 'done'],
-                blocked: ['not_started', 'in_progress'],
-                partial_done: ['in_progress', 'done'],
-                done: ['in_progress'],
-            },
-        },
+        workflow: 'not_started → in_progress (start_timer) → paused (pause_timer) → done/partial_done/blocked (stop_timer)',
         tips: [
-            'Tasks have tags — use them to find related work (e.g. list_tasks with tag "bug" or "frontend").',
-            'Tasks can have dependencies — check the dependencies array to understand task ordering.',
-            'Use get_analytics for a high-level overview of time spent and task completion rates.',
-            'Use search_tasks to find tasks by keyword when you are not sure of the exact task ID.',
-            'Use search_projects to find a project by name. Try the repo name, directory name, or common abbreviations.',
-            'Read task descriptions carefully — they often contain implementation details, acceptance criteria, or context that will help you do better work.',
-            'Write task descriptions in Markdown: use ## headings for sections, - bullet lists for steps, ```code blocks``` for snippets, and **bold** for emphasis. The UI renders Markdown natively.',
-            'When creating tasks that depend on others, set dependencies and use the "blocked" status to indicate the blocking relationship. This shows up in the dependency graph.',
+            '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.',
         ],
     };
     return successResponse(instructions);

package/dist/tools/tasks.js

@@ -10,6 +10,28 @@ function parseTask(row) {
         tags: JSON.parse(row.tags),
     };
 }
+/** Compact task for list/search responses — omits description, null fields, and empty arrays */
+function parseTaskCompact(row) {
+    const tags = JSON.parse(row.tags);
+    const deps = JSON.parse(row.dependencies);
+    const result = {
+        id: row.id,
+        title: row.title,
+        status: row.status,
+        priority: row.priority,
+    };
+    if (row.project_id != null)
+        result.project_id = row.project_id;
+    if (tags.length > 0)
+        result.tags = tags;
+    if (deps.length > 0)
+        result.dependencies = deps;
+    if (row.due_date != null)
+        result.due_date = row.due_date;
+    if (row.estimated_time != null)
+        result.estimated_time = row.estimated_time;
+    return result;
+}
 function detectCycle(taskId, proposedDeps) {
     const db = getDb();
     const allTasks = db.prepare('SELECT id, dependencies FROM tasks').all();
@@ -116,7 +138,7 @@ export async function listTasks(params) {
             return tags.includes(params.tag);
         });
     }
-    return successResponse(rows.map(parseTask));
+    return successResponse(rows.map(parseTaskCompact));
 }
 export async function getTask(params) {
     const db = getDb();
@@ -236,6 +258,31 @@ export async function updateTaskStatus(params) {
         return errorResponse(`Cannot transition from "${currentStatus}" to "${params.status}"`, 'INVALID_TRANSITION');
     }
     const ts = now();
+    // Auto-start a timer session when entering in_progress
+    if (params.status === 'in_progress') {
+        const existingOpen = db.prepare('SELECT id FROM sessions WHERE task_id = ? AND end IS NULL').get(params.id);
+        if (!existingOpen) {
+            const result = db.prepare('INSERT INTO sessions (task_id, start, end) VALUES (?, ?, ?)').run(params.id, ts, null);
+            const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(result.lastInsertRowid);
+            logActivity('timer_started', row.title, { entityType: 'task', entityId: params.id });
+            broadcastChange('timer', 'timer_started', { task_id: params.id, session, task_status: 'in_progress' });
+        }
+    }
+    // Auto-close any active timer session when leaving an active state
+    const terminalStatuses = ['done', 'partial_done', 'blocked', 'paused'];
+    if (terminalStatuses.includes(params.status)) {
+        const openSession = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.id);
+        if (openSession) {
+            db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(ts, openSession.id);
+            const duration = new Date(ts).getTime() - new Date(openSession.start).getTime();
+            logActivity('timer_stopped', row.title, {
+                detail: `Auto-stopped: duration ${duration}ms, status → ${params.status}`,
+                entityType: 'task',
+                entityId: params.id,
+            });
+            broadcastChange('timer', 'timer_stopped', { task_id: params.id, session: { ...openSession, end: ts, duration }, task_status: params.status });
+        }
+    }
     db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(params.status, ts, params.id);
     // Log appropriate action
     let statusAction;
@@ -295,7 +342,7 @@ export async function searchTasks(params) {
     const db = getDb();
     const like = `%${params.query}%`;
     const rows = db.prepare(`SELECT * FROM tasks WHERE title LIKE ? COLLATE NOCASE OR description LIKE ? COLLATE NOCASE`).all(like, like);
-    return successResponse(rows.map(parseTask));
+    return successResponse(rows.map(parseTaskCompact));
 }
 // ─── MCP registration ─────────────────────────────────────────────────
 export function registerTaskTools(server) {

package/dist/tools/timer.js

@@ -59,13 +59,25 @@ export async function stopTimer(params) {
         return errorResponse('Task not found', 'NOT_FOUND');
     // Find open session
     const session = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
-    if (!session)
-        return errorResponse('No active timer session for this task', 'NO_ACTIVE_SESSION');
     const finalStatus = params.final_status ?? 'done';
     const endTime = now();
-    const duration = new Date(endTime).getTime() - new Date(session.start).getTime();
-    // Close session
-    db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(endTime, session.id);
+    let duration;
+    let closedSession;
+    if (session) {
+        // Normal path — close the active session
+        duration = new Date(endTime).getTime() - new Date(session.start).getTime();
+        db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(endTime, session.id);
+        closedSession = { ...session, end: endTime };
+    }
+    else {
+        // Fallback — session was already closed (e.g. by orphan cleanup or update_task_status)
+        // Still update the task status so the caller's intent is honored
+        const lastSession = db.prepare('SELECT * FROM sessions WHERE task_id = ? ORDER BY start DESC LIMIT 1').get(params.task_id);
+        if (!lastSession)
+            return errorResponse('No timer sessions found for this task', 'NO_ACTIVE_SESSION');
+        duration = new Date(lastSession.end).getTime() - new Date(lastSession.start).getTime();
+        closedSession = lastSession;
+    }
     // Update task to final_status
     db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(finalStatus, endTime, params.task_id);
     logActivity('timer_stopped', task.title, {
@@ -80,7 +92,7 @@ export async function stopTimer(params) {
     else if (finalStatus === 'partial_done') {
         logActivity('task_partial_done', task.title, { entityType: 'task', entityId: params.task_id });
     }
-    const stoppedSession = { ...session, end: endTime, duration };
+    const stoppedSession = { ...closedSession, duration };
     broadcastChange('timer', 'timer_stopped', { task_id: params.task_id, session: stoppedSession, task_status: finalStatus });
     return successResponse(stoppedSession);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmasonto/taskflow-mcp",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "MCP server for TaskFlow — manage projects, tasks, timers, analytics via AI agents",
   "type": "module",
   "main": "dist/index.js",