@brainfile/cli 0.13.2 → 0.15.0

package/dist/commands/mcp.js

@@ -42,12 +42,46 @@ const path = __importStar(require("path"));
 const core_1 = require("@brainfile/core");
 const errorHandler_1 = require("../utils/errorHandler");
 const contractSpec_1 = require("../utils/contractSpec");
+const strict_validation_1 = require("../utils/strict-validation");
 const config_1 = require("../utils/config");
 const github_auth_1 = require("../utils/github-auth");
 const linear_auth_1 = require("../utils/linear-auth");
 const core_2 = require("@brainfile/core");
 const contractRunner_1 = require("../lib/contractRunner");
 const archive_1 = require("../utils/archive");
+const core_3 = require("@brainfile/core");
+const v2_detect_1 = require("../utils/v2-detect");
+function sanitizeTypesConfig(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        return {};
+    }
+    const out = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            continue;
+        }
+        const entry = value;
+        const idPrefix = typeof entry.idPrefix === 'string' && entry.idPrefix.trim()
+            ? entry.idPrefix.trim()
+            : name;
+        const normalized = { idPrefix };
+        if (typeof entry.completable === 'boolean')
+            normalized.completable = entry.completable;
+        if (typeof entry.schema === 'string' && entry.schema.trim())
+            normalized.schema = entry.schema.trim();
+        out[name] = normalized;
+    }
+    return out;
+}
+function isTaskCompletable(taskType, rawTypes) {
+    const resolvedType = taskType || 'task';
+    if (resolvedType === 'task') {
+        return true;
+    }
+    const types = sanitizeTypesConfig(rawTypes);
+    const typeConfig = types[resolvedType];
+    return typeConfig?.completable !== false;
+}
 function resolveBrainfile(filePath) {
     return path.resolve(filePath);
 }
@@ -68,6 +102,15 @@ function writeBoard(filePath, board) {
     const content = core_1.Brainfile.serialize(board);
     fs.writeFileSync(resolvedPath, content, 'utf-8');
 }
+function mcpStructuredError(message, field, value) {
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ error: { code: 'VALIDATION_ERROR', message, field, value } }, null, 2)
+            }],
+        isError: true
+    };
+}
 /**
  * Find git repository root by walking up directory tree
  */
@@ -159,10 +202,37 @@ async function mcpCommand(options) {
         inputSchema: {
             file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
             column: zod_1.z.string().optional().describe('Filter by column ID or name'),
-            tag: zod_1.z.string().optional().describe('Filter by tag')
+            tag: zod_1.z.string().optional().describe('Filter by tag'),
+            type: zod_1.z.string().optional().describe('Filter by document type (e.g., epic, adr). Only returns tasks matching this type.'),
         }
-    }, async ({ file, column, tag }) => {
+    }, async ({ file, column, tag, type: filterType }) => {
         const filePath = file || defaultFile;
+        // V2: use per-task files
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const board = (0, v2_detect_1.buildBoardFromV2)(filePath);
+            let tasks = [];
+            for (const col of board.columns) {
+                if (column) {
+                    const matchesId = col.id === column;
+                    const matchesName = col.title.toLowerCase() === column.toLowerCase();
+                    if (!matchesId && !matchesName)
+                        continue;
+                }
+                for (const task of col.tasks) {
+                    if (tag && (!task.tags || !task.tags.includes(tag)))
+                        continue;
+                    // Filter by type: match explicit type field, or treat missing/undefined as "task"
+                    if (filterType) {
+                        const taskType = task.type || 'task';
+                        if (taskType !== filterType)
+                            continue;
+                    }
+                    tasks.push({ id: task.id, title: task.title, column: col.title, priority: task.priority, tags: task.tags, assignee: task.assignee });
+                }
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ tasks, count: tasks.length }, null, 2) }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -170,7 +240,6 @@ async function mcpCommand(options) {
         const { board } = result;
         let tasks = [];
         for (const col of board.columns) {
-            // Filter by column if specified
             if (column) {
                 const matchesId = col.id === column;
                 const matchesName = col.title.toLowerCase() === column.toLowerCase();
@@ -178,9 +247,14 @@ async function mcpCommand(options) {
                     continue;
             }
             for (const task of col.tasks) {
-                // Filter by tag if specified
                 if (tag && (!task.tags || !task.tags.includes(tag)))
                     continue;
+                // Filter by type: match explicit type field, or treat missing/undefined as "task"
+                if (filterType) {
+                    const taskType = task.type || 'task';
+                    if (taskType !== filterType)
+                        continue;
+                }
                 tasks.push({
                     id: task.id,
                     title: task.title,
@@ -206,6 +280,24 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task }) => {
         const filePath = file || defaultFile;
+        // V2: use per-task files
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task, true);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const { doc, isLog } = found;
+            const description = (0, v2_detect_1.extractDescription)(doc.body);
+            const output = {
+                ...doc.task,
+                ...(description && !doc.task.description && { description }),
+                column: isLog ? 'Completed' : (doc.task.column || 'unknown'),
+                ...(isLog && { archived: true }),
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -237,6 +329,66 @@ async function mcpCommand(options) {
         }
     }, async ({ file, query, column, priority, assignee }) => {
         const filePath = file || defaultFile;
+        // V2: search per-task files
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const queryLower = query.toLowerCase();
+            let matches = [];
+            const taskDocs = (0, core_3.readTasksDir)(dirs.boardDir);
+            for (const doc of taskDocs) {
+                const task = doc.task;
+                if (column && task.column !== column)
+                    continue;
+                if (priority && task.priority !== priority)
+                    continue;
+                if (assignee && task.assignee !== assignee)
+                    continue;
+                let score = 0;
+                if (task.title.toLowerCase().includes(queryLower)) {
+                    score += 10;
+                    if (task.title.toLowerCase().startsWith(queryLower))
+                        score += 5;
+                }
+                if (task.description?.toLowerCase().includes(queryLower))
+                    score += 5;
+                if (task.tags?.some(t => t.toLowerCase().includes(queryLower)))
+                    score += 3;
+                if (task.id.toLowerCase() === queryLower)
+                    score += 20;
+                if (score > 0) {
+                    matches.push({ id: task.id, title: task.title, column: task.column, priority: task.priority, tags: task.tags, assignee: task.assignee, score });
+                }
+            }
+            // Also search logs
+            if (!column) {
+                const logDocs = (0, core_3.readTasksDir)(dirs.logsDir);
+                for (const doc of logDocs) {
+                    const task = doc.task;
+                    if (priority && task.priority !== priority)
+                        continue;
+                    if (assignee && task.assignee !== assignee)
+                        continue;
+                    let score = 0;
+                    if (task.title.toLowerCase().includes(queryLower)) {
+                        score += 10;
+                        if (task.title.toLowerCase().startsWith(queryLower))
+                            score += 5;
+                    }
+                    if (task.description?.toLowerCase().includes(queryLower))
+                        score += 5;
+                    if (task.tags?.some(t => t.toLowerCase().includes(queryLower)))
+                        score += 3;
+                    if (task.id.toLowerCase() === queryLower)
+                        score += 20;
+                    if (score > 0) {
+                        matches.push({ id: task.id, title: task.title, column: 'Completed', priority: task.priority, tags: task.tags, assignee: task.assignee, score, isLog: true });
+                    }
+                }
+            }
+            matches.sort((a, b) => b.score - a.score);
+            return { content: [{ type: 'text', text: JSON.stringify({ results: matches, count: matches.length }, null, 2) }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -245,7 +397,6 @@ async function mcpCommand(options) {
         const queryLower = query.toLowerCase();
         let matches = [];
         for (const col of board.columns) {
-            // Filter by column if specified
             if (column) {
                 const matchesId = col.id === column;
                 const matchesName = col.title.toLowerCase() === column.toLowerCase();
@@ -253,51 +404,30 @@ async function mcpCommand(options) {
                     continue;
             }
             for (const task of col.tasks) {
-                // Filter by priority if specified
                 if (priority && task.priority !== priority)
                     continue;
-                // Filter by assignee if specified
                 if (assignee && task.assignee !== assignee)
                     continue;
-                // Calculate search score
                 let score = 0;
-                // Title match (highest weight)
                 if (task.title.toLowerCase().includes(queryLower)) {
                     score += 10;
                     if (task.title.toLowerCase().startsWith(queryLower))
                         score += 5;
                 }
-                // Description match
-                if (task.description?.toLowerCase().includes(queryLower)) {
+                if (task.description?.toLowerCase().includes(queryLower))
                     score += 5;
-                }
-                // Tag match
-                if (task.tags?.some(t => t.toLowerCase().includes(queryLower))) {
+                if (task.tags?.some(t => t.toLowerCase().includes(queryLower)))
                     score += 3;
-                }
-                // ID exact match
-                if (task.id.toLowerCase() === queryLower) {
+                if (task.id.toLowerCase() === queryLower)
                     score += 20;
-                }
                 if (score > 0) {
-                    matches.push({
-                        id: task.id,
-                        title: task.title,
-                        column: col.title,
-                        priority: task.priority,
-                        tags: task.tags,
-                        assignee: task.assignee,
-                        score
-                    });
+                    matches.push({ id: task.id, title: task.title, column: col.title, priority: task.priority, tags: task.tags, assignee: task.assignee, score });
                 }
             }
         }
-        // Sort by score descending
         matches.sort((a, b) => b.score - a.score);
         const output = { results: matches, count: matches.length };
-        return {
-            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }]
-        };
+        return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
     });
     // Add task tool
     server.registerTool('add_task', {
@@ -314,6 +444,7 @@ async function mcpCommand(options) {
             dueDate: zod_1.z.string().optional().describe('Due date (YYYY-MM-DD)'),
             subtasks: zod_1.z.array(zod_1.z.string()).optional().describe('Subtask titles (IDs auto-generated)'),
             relatedFiles: zod_1.z.array(zod_1.z.string()).optional().describe('Related file paths'),
+            type: zod_1.z.string().optional().describe('Document type (e.g., epic, adr). Determines ID prefix. Default: task'),
             // Contract creation (optional)
             with_contract: zod_1.z.boolean().optional().describe('Attach a contract to the new task (status=ready)'),
             deliverables: zod_1.z.array(zod_1.z.string()).optional().describe('Contract deliverables: type:path:description'),
@@ -323,14 +454,75 @@ async function mcpCommand(options) {
             withContract: zod_1.z.boolean().optional().describe('Alias of with_contract'),
             validationCommands: zod_1.z.array(zod_1.z.string()).optional().describe('Alias of validation_commands'),
         }
-    }, async ({ file, column, title, description, priority, tags, assignee, dueDate, subtasks, relatedFiles, with_contract, deliverables, validation_commands, constraints, withContract, validationCommands, }) => {
+    }, async ({ file, column, title, description, priority, tags, assignee, dueDate, subtasks, relatedFiles, type: docType, with_contract, deliverables, validation_commands, constraints, withContract, validationCommands, }) => {
         const filePath = file || defaultFile;
+        // V2: add task as individual file
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            try {
+                const dirs = (0, v2_detect_1.ensureV2Dirs)(filePath);
+                const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
+                const typePrefix = docType || 'task';
+                const typeValidation = (0, strict_validation_1.validateType)(board, typePrefix);
+                if (!typeValidation.valid) {
+                    return mcpStructuredError(typeValidation.error || `Invalid type: ${typePrefix}`, 'type', typePrefix);
+                }
+                let targetColumn = board.columns.find(c => c.id === column);
+                if (!targetColumn)
+                    targetColumn = board.columns.find(c => c.title.toLowerCase() === column.toLowerCase());
+                if (!targetColumn) {
+                    const available = board.columns.map(c => `${c.id} (${c.title})`).join(', ');
+                    return { content: [{ type: 'text', text: `Error: Column not found: ${column}. Available: ${available}` }], isError: true };
+                }
+                const taskId = (0, core_3.generateNextFileTaskId)(dirs.boardDir, dirs.logsDir, typePrefix);
+                const existingTasks = (0, core_3.readTasksDir)(dirs.boardDir).filter(t => t.task.column === targetColumn.id);
+                const position = existingTasks.length;
+                const builtSubtasks = subtasks && subtasks.length > 0
+                    ? subtasks.map((st, i) => ({ id: `${taskId}-${i + 1}`, title: st.trim(), completed: false }))
+                    : undefined;
+                const task = {
+                    id: taskId,
+                    title,
+                    ...(docType && docType !== 'task' && { type: docType }),
+                    column: targetColumn.id,
+                    position,
+                    ...(description && { description }),
+                    ...(priority && { priority }),
+                    ...(tags && tags.length > 0 && { tags }),
+                    ...(assignee && { assignee }),
+                    ...(dueDate && { dueDate }),
+                    ...(relatedFiles && relatedFiles.length > 0 && { relatedFiles }),
+                    ...(builtSubtasks && { subtasks: builtSubtasks }),
+                    createdAt: new Date().toISOString(),
+                };
+                // Optionally attach contract
+                const wantsContract = Boolean(with_contract ?? withContract) ||
+                    Boolean(deliverables && deliverables.length > 0) ||
+                    Boolean(validation_commands && validation_commands.length > 0) ||
+                    Boolean(validationCommands && validationCommands.length > 0) ||
+                    Boolean(constraints && constraints.length > 0);
+                if (wantsContract) {
+                    const contract = (0, contractSpec_1.buildContract)({
+                        deliverableSpecs: deliverables,
+                        validationCommands: validation_commands ?? validationCommands,
+                        constraints,
+                    });
+                    task.contract = contract;
+                }
+                const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(taskId));
+                const body = description ? (0, v2_detect_1.composeBody)(description) : '';
+                (0, core_3.writeTaskFile)(taskPath, task, body);
+                return { content: [{ type: 'text', text: `Task added successfully: ${taskId} - ${title}` }] };
+            }
+            catch (e) {
+                return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+            }
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
         }
         let { board } = result;
-        // Find target column
         let targetColumn = (0, core_1.findColumnById)(board, column);
         if (!targetColumn) {
             targetColumn = (0, core_1.findColumnByName)(board, column);
@@ -353,11 +545,9 @@ async function mcpCommand(options) {
         if (!addResult.success) {
             return { content: [{ type: 'text', text: `Error: ${addResult.error}` }], isError: true };
         }
-        // Get the new task
         const newTask = addResult.board.columns
             .find(c => c.id === targetColumn.id)
             .tasks.slice(-1)[0];
-        // Optionally attach a contract (status=ready)
         const wantsContract = Boolean(with_contract ?? withContract) ||
             Boolean(deliverables && deliverables.length > 0) ||
             Boolean(validation_commands && validation_commands.length > 0) ||
@@ -405,6 +595,29 @@ async function mcpCommand(options) {
         if (!resolvedTaskId) {
             return { content: [{ type: 'text', text: 'Error: task is required' }], isError: true };
         }
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, resolvedTaskId);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${resolvedTaskId}` }], isError: true };
+            }
+            try {
+                const contract = (0, contractSpec_1.buildContract)({
+                    deliverableSpecs: deliverables,
+                    validationCommands: validation_commands ?? validationCommands,
+                    constraints,
+                });
+                found.doc.task.contract = contract;
+                found.doc.task.updatedAt = new Date().toISOString();
+                (0, core_3.writeTaskFile)(found.filePath, found.doc.task, found.doc.body);
+                return { content: [{ type: 'text', text: `Contract attached: ${resolvedTaskId}` }] };
+            }
+            catch (e) {
+                return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+            }
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -442,17 +655,56 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, column }) => {
         const filePath = file || defaultFile;
+        // V2: update task file
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(task));
+            const doc = (0, core_3.readTaskFile)(taskPath);
+            if (!doc) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
+            let targetColumn = board.columns.find(c => c.id === column);
+            if (!targetColumn)
+                targetColumn = board.columns.find(c => c.title.toLowerCase() === column.toLowerCase());
+            const targetColumnId = targetColumn?.id || column;
+            const columnValidation = (0, strict_validation_1.validateColumn)(board, targetColumnId);
+            if (!columnValidation.valid) {
+                return mcpStructuredError(columnValidation.error || `Invalid column: ${targetColumnId}`, 'column', targetColumnId);
+            }
+            const resolvedTargetColumn = targetColumn || { id: column, title: column, tasks: [] };
+            const sourceColumn = doc.task.column || '';
+            const targetTasks = (0, core_3.readTasksDir)(dirs.boardDir).filter(t => t.task.column === resolvedTargetColumn.id);
+            doc.task.column = resolvedTargetColumn.id;
+            doc.task.position = targetTasks.length;
+            doc.task.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(taskPath, doc.task, doc.body);
+            const shouldAutoComplete = resolvedTargetColumn.completionColumn === true && isTaskCompletable(doc.task.type, board.types);
+            if (shouldAutoComplete) {
+                const completeResult = (0, core_3.completeTaskFile)(taskPath, dirs.logsDir);
+                if (!completeResult.success) {
+                    return { content: [{ type: 'text', text: `Error: ${completeResult.error || `Failed to complete task: ${task}`}` }], isError: true };
+                }
+            }
+            const warning = (0, errorHandler_1.mcpCheckIncompleteSubtasks)(doc.task, resolvedTargetColumn);
+            let message = `Task ${task} moved from "${sourceColumn}" to "${resolvedTargetColumn.title}"`;
+            if (shouldAutoComplete) {
+                message += '\nTask auto-completed and moved to logs/.';
+            }
+            if (warning)
+                message += `\n\n${warning.warning}`;
+            return { content: [{ type: 'text', text: message }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
         }
         let { board } = result;
-        // Find the task
         const taskInfo = (0, core_1.findTaskById)(board, task);
         if (!taskInfo) {
             return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
         }
-        // Find target column
         let targetColumn = (0, core_1.findColumnById)(board, column);
         if (!targetColumn) {
             targetColumn = (0, core_1.findColumnByName)(board, column);
@@ -465,7 +717,6 @@ async function mcpCommand(options) {
             return { content: [{ type: 'text', text: `Error: ${moveResult.error}` }], isError: true };
         }
         writeBoard(filePath, moveResult.board);
-        // Check for incomplete subtasks warning when moving to done-like column
         const warning = (0, errorHandler_1.mcpCheckIncompleteSubtasks)(taskInfo.task, targetColumn);
         let message = `Task ${task} moved from "${taskInfo.column.title}" to "${targetColumn.title}"`;
         if (warning) {
@@ -492,13 +743,64 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, title, description, priority, tags, assignee, dueDate, relatedFiles }) => {
         const filePath = file || defaultFile;
+        const isNull = (v) => v === null || v === 'null';
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(task));
+            const doc = (0, core_3.readTaskFile)(taskPath);
+            if (!doc) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const t = doc.task;
+            if (title !== undefined)
+                t.title = title;
+            if (description !== undefined) {
+                if (isNull(description))
+                    delete t.description;
+                else
+                    t.description = description;
+            }
+            if (priority !== undefined) {
+                if (isNull(priority))
+                    delete t.priority;
+                else
+                    t.priority = priority;
+            }
+            if (tags !== undefined) {
+                if (isNull(tags))
+                    delete t.tags;
+                else
+                    t.tags = tags;
+            }
+            if (assignee !== undefined) {
+                if (isNull(assignee))
+                    delete t.assignee;
+                else
+                    t.assignee = assignee;
+            }
+            if (dueDate !== undefined) {
+                if (isNull(dueDate))
+                    delete t.dueDate;
+                else
+                    t.dueDate = dueDate;
+            }
+            if (relatedFiles !== undefined) {
+                if (isNull(relatedFiles))
+                    delete t.relatedFiles;
+                else
+                    t.relatedFiles = relatedFiles;
+            }
+            t.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(taskPath, t, doc.body);
+            return { content: [{ type: 'text', text: `Task ${task} updated successfully` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
         }
         let { board } = result;
-        // Helper to check for null or "null" string (MCP clients may send either)
-        const isNull = (v) => v === null || v === 'null';
         const patch = {};
         if (title !== undefined)
             patch.title = title;
@@ -533,6 +835,22 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task }) => {
         const filePath = file || defaultFile;
+        // V2: delete task file
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task, true);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            try {
+                fs.unlinkSync(found.filePath);
+                return { content: [{ type: 'text', text: `Task ${task} deleted successfully` }] };
+            }
+            catch (e) {
+                return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+            }
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -563,6 +881,78 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, destination }) => {
         const filePath = file || defaultFile;
+        // V2: archive means move task from board/ to logs/
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            // Determine effective destination
+            const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
+            const brainfileDestination = board.archive?.destination;
+            const effectiveDestination = destination || (0, config_1.getEffectiveArchiveDestination)(brainfileDestination);
+            // For GitHub/Linear, format and send before removing
+            if (effectiveDestination === 'github') {
+                if (!(await (0, github_auth_1.isGitHubAuthenticated)())) {
+                    return { content: [{ type: 'text', text: `Error: Not authenticated with GitHub.\n\nTo authenticate, run:\n  npx @brainfile/cli auth github\n\nOr fall back to local archive:\n  Use destination: "local"` }], isError: true };
+                }
+                const config = (0, config_1.getArchiveConfig)();
+                if (!config.github?.owner || !config.github?.repo) {
+                    return { content: [{ type: 'text', text: `Error: GitHub repository not configured.\n\nTo configure, run:\n  npx @brainfile/cli config set archive.github.owner <owner>\n  npx @brainfile/cli config set archive.github.repo <repo>` }], isError: true };
+                }
+                const payload = (0, core_2.formatTaskForGitHub)(found.doc.task, {
+                    includeMeta: true, includeSubtasks: true, includeRelatedFiles: true,
+                    boardTitle: board.title, fromColumn: found.doc.task.column || 'unknown',
+                    extraLabels: config.github.labels,
+                });
+                const ghResult = await (0, github_auth_1.createGitHubIssue)({ owner: config.github.owner, repo: config.github.repo, title: payload.title, body: payload.body, labels: payload.labels, state: 'closed' });
+                if (!ghResult.success) {
+                    return { content: [{ type: 'text', text: `Error creating GitHub issue: ${ghResult.error}` }], isError: true };
+                }
+                fs.unlinkSync(found.filePath);
+                return { content: [{ type: 'text', text: `Task ${task} archived to GitHub Issue #${ghResult.issueNumber} (closed)\n\nView: ${ghResult.issueUrl}` }] };
+            }
+            if (effectiveDestination === 'linear') {
+                if (!(await (0, linear_auth_1.isLinearAuthenticated)())) {
+                    return { content: [{ type: 'text', text: `Error: Not authenticated with Linear.\n\nTo authenticate, run:\n  npx @brainfile/cli auth linear --token <api-key>` }], isError: true };
+                }
+                const config = (0, config_1.getArchiveConfig)();
+                let teamId = config.linear?.teamId;
+                if (!teamId) {
+                    const teams = await (0, linear_auth_1.getLinearTeams)();
+                    if (teams.length === 0) {
+                        return { content: [{ type: 'text', text: `Error: No Linear teams found.` }], isError: true };
+                    }
+                    if (teams.length === 1) {
+                        teamId = teams[0].id;
+                    }
+                    else {
+                        const teamList = teams.map(t => `  ${t.key}: ${t.name} (${t.id})`).join('\n');
+                        return { content: [{ type: 'text', text: `Error: Multiple Linear teams found. Please configure a default.\n\nAvailable teams:\n${teamList}` }], isError: true };
+                    }
+                }
+                const payload = (0, core_2.formatTaskForLinear)(found.doc.task, {
+                    includeMeta: true, includeSubtasks: true, includeRelatedFiles: true,
+                    boardTitle: board.title, fromColumn: found.doc.task.column || 'unknown', stateName: 'Done',
+                });
+                const linearResult = await (0, linear_auth_1.createLinearIssue)({ teamId, title: payload.title, description: payload.description, priority: payload.priority, labelNames: payload.labelNames, stateName: 'Done' });
+                if (!linearResult.success) {
+                    return { content: [{ type: 'text', text: `Error creating Linear issue: ${linearResult.error}` }], isError: true };
+                }
+                fs.unlinkSync(found.filePath);
+                return { content: [{ type: 'text', text: `Task ${task} archived to Linear Issue ${linearResult.issueId} (Done)\n\nView: ${linearResult.issueUrl}` }] };
+            }
+            // Local archive: move from board/ to logs/
+            const logPath = path.join(dirs.logsDir, (0, core_3.taskFileName)(task));
+            found.doc.task.completedAt = found.doc.task.completedAt || new Date().toISOString();
+            delete found.doc.task.column;
+            delete found.doc.task.position;
+            (0, core_3.writeTaskFile)(logPath, found.doc.task, found.doc.body);
+            fs.unlinkSync(found.filePath);
+            return { content: [{ type: 'text', text: `Task ${task} archived to logs/` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -736,6 +1126,34 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, column }) => {
         const filePath = file || defaultFile;
+        // V2: restore means move from logs/ to board/
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
+            let targetColumn = board.columns.find(c => c.id === column);
+            if (!targetColumn)
+                targetColumn = board.columns.find(c => c.title.toLowerCase() === column.toLowerCase());
+            if (!targetColumn) {
+                return { content: [{ type: 'text', text: `Error: Column not found: ${column}` }], isError: true };
+            }
+            // Look in logs
+            const logPath = path.join(dirs.logsDir, (0, core_3.taskFileName)(task));
+            const doc = (0, core_3.readTaskFile)(logPath);
+            if (!doc) {
+                return { content: [{ type: 'text', text: `Error: Task not found in logs: ${task}` }], isError: true };
+            }
+            // Move to board/ with column info
+            const targetTasks = (0, core_3.readTasksDir)(dirs.boardDir).filter(t => t.task.column === targetColumn.id);
+            doc.task.column = targetColumn.id;
+            doc.task.position = targetTasks.length;
+            delete doc.task.completedAt;
+            doc.task.updatedAt = new Date().toISOString();
+            const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(task));
+            (0, core_3.writeTaskFile)(taskPath, doc.task, doc.body);
+            fs.unlinkSync(logPath);
+            return { content: [{ type: 'text', text: `Task ${task} restored to "${targetColumn.title}"` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -777,6 +1195,26 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, title }) => {
         const filePath = file || defaultFile;
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const t = found.doc.task;
+            if (!t.subtasks)
+                t.subtasks = [];
+            const nextId = t.subtasks.length > 0
+                ? `${task}-${Math.max(...t.subtasks.map(s => parseInt(s.id.split('-').pop() || '0', 10))) + 1}`
+                : `${task}-1`;
+            const newSubtask = { id: nextId, title, completed: false };
+            t.subtasks.push(newSubtask);
+            t.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(found.filePath, t, found.doc.body);
+            return { content: [{ type: 'text', text: `Subtask added: ${newSubtask.id} - ${newSubtask.title}` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -805,6 +1243,23 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, subtask }) => {
         const filePath = file || defaultFile;
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const t = found.doc.task;
+            if (!t.subtasks || !t.subtasks.some(s => s.id === subtask)) {
+                return { content: [{ type: 'text', text: `Error: Subtask not found: ${subtask}` }], isError: true };
+            }
+            t.subtasks = t.subtasks.filter(s => s.id !== subtask);
+            t.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(found.filePath, t, found.doc.body);
+            return { content: [{ type: 'text', text: `Subtask ${subtask} deleted successfully` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -830,6 +1285,26 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, subtask }) => {
         const filePath = file || defaultFile;
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const t = found.doc.task;
+            const st = t.subtasks?.find(s => s.id === subtask);
+            if (!st) {
+                return { content: [{ type: 'text', text: `Error: Subtask not found: ${subtask}` }], isError: true };
+            }
+            const wasCompleted = st.completed;
+            st.completed = !st.completed;
+            t.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(found.filePath, t, found.doc.body);
+            const newStatus = wasCompleted ? 'incomplete' : 'completed';
+            return { content: [{ type: 'text', text: `Subtask ${subtask} marked as ${newStatus}` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -861,6 +1336,24 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, subtask, title }) => {
         const filePath = file || defaultFile;
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const t = found.doc.task;
+            const st = t.subtasks?.find(s => s.id === subtask);
+            if (!st) {
+                return { content: [{ type: 'text', text: `Error: Subtask not found: ${subtask}` }], isError: true };
+            }
+            st.title = title;
+            t.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(found.filePath, t, found.doc.body);
+            return { content: [{ type: 'text', text: `Subtask ${subtask} updated to "${title}"` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -887,6 +1380,29 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, subtasks, completed }) => {
         const filePath = file || defaultFile;
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const t = found.doc.task;
+            if (!t.subtasks) {
+                return { content: [{ type: 'text', text: `Error: Task has no subtasks` }], isError: true };
+            }
+            const subtaskSet = new Set(subtasks);
+            for (const st of t.subtasks) {
+                if (subtaskSet.has(st.id)) {
+                    st.completed = completed;
+                }
+            }
+            t.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(found.filePath, t, found.doc.body);
+            const status = completed ? 'completed' : 'incomplete';
+            return { content: [{ type: 'text', text: `${subtasks.length} subtasks marked as ${status}` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -913,13 +1429,32 @@ async function mcpCommand(options) {
         }
     }, async ({ file, task, completed }) => {
         const filePath = file || defaultFile;
+        const markCompleted = completed ?? true;
+        // V2: update task file directly
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, task);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const t = found.doc.task;
+            const count = t.subtasks?.length || 0;
+            if (t.subtasks) {
+                for (const st of t.subtasks) {
+                    st.completed = markCompleted;
+                }
+            }
+            t.updatedAt = new Date().toISOString();
+            (0, core_3.writeTaskFile)(found.filePath, t, found.doc.body);
+            const status = markCompleted ? 'completed' : 'incomplete';
+            return { content: [{ type: 'text', text: `All ${count} subtasks in ${task} marked as ${status}` }] };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
         }
         let { board } = result;
-        // Default to true if not specified
-        const markCompleted = completed ?? true;
         const bulkResult = (0, core_1.setAllSubtasksCompleted)(board, task, markCompleted);
         if (!bulkResult.success) {
             return { content: [{ type: 'text', text: `Error: ${bulkResult.error}` }], isError: true };
@@ -947,6 +1482,37 @@ async function mcpCommand(options) {
         }
     }, async ({ file, tasks, column }) => {
         const filePath = file || defaultFile;
+        // V2: update each task file
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
+            let targetColumn = board.columns.find(c => c.id === column);
+            if (!targetColumn)
+                targetColumn = board.columns.find(c => c.title.toLowerCase() === column.toLowerCase());
+            if (!targetColumn) {
+                return { content: [{ type: 'text', text: `Error: Column not found: ${column}` }], isError: true };
+            }
+            const results = [];
+            let successCount = 0;
+            let failureCount = 0;
+            for (const taskId of tasks) {
+                const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(taskId));
+                const doc = (0, core_3.readTaskFile)(taskPath);
+                if (!doc) {
+                    results.push({ taskId, success: false, error: 'Task not found' });
+                    failureCount++;
+                    continue;
+                }
+                doc.task.column = targetColumn.id;
+                doc.task.updatedAt = new Date().toISOString();
+                (0, core_3.writeTaskFile)(taskPath, doc.task, doc.body);
+                results.push({ taskId, success: true });
+                successCount++;
+            }
+            const output = { success: failureCount === 0, successCount, failureCount, results };
+            return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }], isError: failureCount > 0 && successCount === 0 };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -1008,13 +1574,54 @@ async function mcpCommand(options) {
         }
     }, async ({ file, tasks, priority, tags, assignee }) => {
         const filePath = file || defaultFile;
+        const isNull = (v) => v === null || v === 'null';
+        // V2: update each task file
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const results = [];
+            let successCount = 0;
+            let failureCount = 0;
+            for (const taskId of tasks) {
+                const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(taskId));
+                const doc = (0, core_3.readTaskFile)(taskPath);
+                if (!doc) {
+                    results.push({ taskId, success: false, error: 'Task not found' });
+                    failureCount++;
+                    continue;
+                }
+                const t = doc.task;
+                if (priority !== undefined) {
+                    if (isNull(priority))
+                        delete t.priority;
+                    else
+                        t.priority = priority;
+                }
+                if (tags !== undefined) {
+                    if (isNull(tags))
+                        delete t.tags;
+                    else
+                        t.tags = tags;
+                }
+                if (assignee !== undefined) {
+                    if (isNull(assignee))
+                        delete t.assignee;
+                    else
+                        t.assignee = assignee;
+                }
+                t.updatedAt = new Date().toISOString();
+                (0, core_3.writeTaskFile)(taskPath, t, doc.body);
+                results.push({ taskId, success: true });
+                successCount++;
+            }
+            const output = { success: failureCount === 0, successCount, failureCount, results };
+            return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }], isError: failureCount > 0 && successCount === 0 };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
         }
         let { board } = result;
-        // Helper to check for null or "null" string
-        const isNull = (v) => v === null || v === 'null';
         const patch = {};
         if (priority !== undefined)
             patch.priority = isNull(priority) ? undefined : priority;
@@ -1047,6 +1654,33 @@ async function mcpCommand(options) {
         }
     }, async ({ file, tasks }) => {
         const filePath = file || defaultFile;
+        // V2: delete task files
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const results = [];
+            let successCount = 0;
+            let failureCount = 0;
+            for (const taskId of tasks) {
+                const found = (0, v2_detect_1.findV2Task)(dirs, taskId, true);
+                if (!found) {
+                    results.push({ taskId, success: false, error: 'Task not found' });
+                    failureCount++;
+                    continue;
+                }
+                try {
+                    fs.unlinkSync(found.filePath);
+                    results.push({ taskId, success: true });
+                    successCount++;
+                }
+                catch (e) {
+                    results.push({ taskId, success: false, error: e.message });
+                    failureCount++;
+                }
+            }
+            const output = { success: failureCount === 0, successCount, failureCount, results };
+            return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }], isError: failureCount > 0 && successCount === 0 };
+        }
+        // V1: use board
         const result = readBoard(filePath);
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
@@ -1077,6 +1711,39 @@ async function mcpCommand(options) {
         }
     }, async ({ file, tasks }) => {
         const filePath = file || defaultFile;
+        // V2: move task files from board/ to logs/
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const results = [];
+            let successCount = 0;
+            let failureCount = 0;
+            for (const taskId of tasks) {
+                const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(taskId));
+                const doc = (0, core_3.readTaskFile)(taskPath);
+                if (!doc) {
+                    results.push({ taskId, success: false, error: 'Task not found' });
+                    failureCount++;
+                    continue;
+                }
+                try {
+                    const logPath = path.join(dirs.logsDir, (0, core_3.taskFileName)(taskId));
+                    doc.task.completedAt = doc.task.completedAt || new Date().toISOString();
+                    delete doc.task.column;
+                    delete doc.task.position;
+                    (0, core_3.writeTaskFile)(logPath, doc.task, doc.body);
+                    fs.unlinkSync(taskPath);
+                    results.push({ taskId, success: true });
+                    successCount++;
+                }
+                catch (e) {
+                    results.push({ taskId, success: false, error: e.message });
+                    failureCount++;
+                }
+            }
+            const output = { success: failureCount === 0, successCount, failureCount, results };
+            return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }], isError: failureCount > 0 && successCount === 0 };
+        }
+        // V1: use board
         const results = [];
         let successCount = 0;
         let failureCount = 0;
@@ -1175,6 +1842,274 @@ async function mcpCommand(options) {
             isError: !result.ok
         };
     });
+    // ==========================================================================
+    // TYPES
+    // ==========================================================================
+    server.registerTool('list_types', {
+        title: 'List Types',
+        description: 'List board strict mode and custom type configuration',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+        }
+    }, async ({ file }) => {
+        const filePath = file || defaultFile;
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            try {
+                const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
+                const boardConfig = board;
+                const output = {
+                    strict: boardConfig.strict === true,
+                    types: sanitizeTypesConfig(boardConfig.types),
+                };
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(output, null, 2) }]
+                };
+            }
+            catch (e) {
+                return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+            }
+        }
+        const result = readBoard(filePath);
+        if ('error' in result) {
+            return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
+        }
+        const boardConfig = result.board;
+        const strict = boardConfig.strict === true;
+        const types = sanitizeTypesConfig(boardConfig.types);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ strict, types }, null, 2)
+                }]
+        };
+    });
+    // ==========================================================================
+    // RULES
+    // ==========================================================================
+    // List rules tool
+    server.registerTool('list_rules', {
+        title: 'List Rules',
+        description: 'List all project rules (always, never, prefer, context) from the brainfile',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            category: zod_1.z.enum(['always', 'never', 'prefer', 'context']).optional().describe('Filter by rule category')
+        }
+    }, async ({ file, category }) => {
+        const filePath = file || defaultFile;
+        const result = readBoard(filePath);
+        if ('error' in result) {
+            return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
+        }
+        const { board } = result;
+        const rules = board.rules || {};
+        // Filter by category if specified
+        let outputRules = rules;
+        if (category) {
+            outputRules = { [category]: rules[category] || [] };
+        }
+        // Count total rules
+        const countRules = (r) => (r.always?.length || 0) +
+            (r.never?.length || 0) +
+            (r.prefer?.length || 0) +
+            (r.context?.length || 0);
+        const output = {
+            rules: outputRules,
+            totalCount: category
+                ? (outputRules[category]?.length || 0)
+                : countRules(rules),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }]
+        };
+    });
+    // Add rule tool
+    server.registerTool('add_rule', {
+        title: 'Add Rule',
+        description: 'Add a new project rule to the brainfile',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            category: zod_1.z.enum(['always', 'never', 'prefer', 'context']).describe('Rule category'),
+            text: zod_1.z.string().describe('Rule text/description')
+        }
+    }, async ({ file, category, text }) => {
+        const filePath = file || defaultFile;
+        const result = readBoard(filePath);
+        if ('error' in result) {
+            return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
+        }
+        let { board } = result;
+        const addResult = (0, core_1.addRule)(board, category, text);
+        if (!addResult.success || !addResult.board) {
+            return { content: [{ type: 'text', text: `Error: ${addResult.error}` }], isError: true };
+        }
+        writeBoard(filePath, addResult.board);
+        // Find the newly added rule (last one in the category)
+        const newRules = addResult.board.rules?.[category] || [];
+        const newRule = newRules[newRules.length - 1];
+        const output = {
+            success: true,
+            category,
+            rule: newRule,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }]
+        };
+    });
+    // Delete rule tool
+    server.registerTool('delete_rule', {
+        title: 'Delete Rule',
+        description: 'Delete a project rule from the brainfile by category and ID',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            category: zod_1.z.enum(['always', 'never', 'prefer', 'context']).describe('Rule category'),
+            id: zod_1.z.number().describe('Rule ID to delete')
+        }
+    }, async ({ file, category, id }) => {
+        const filePath = file || defaultFile;
+        const result = readBoard(filePath);
+        if ('error' in result) {
+            return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
+        }
+        let { board } = result;
+        // Find the rule being deleted for the response
+        const existingRules = board.rules?.[category] || [];
+        const ruleToDelete = existingRules.find((r) => r.id === id);
+        if (!ruleToDelete) {
+            const availableIds = existingRules.map((r) => r.id).join(', ');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error: Rule ${id} not found in ${category}. ${availableIds ? `Available IDs: ${availableIds}` : `No rules in ${category} category`}`
+                    }],
+                isError: true
+            };
+        }
+        const deleteResult = (0, core_1.deleteRule)(board, category, id);
+        if (!deleteResult.success || !deleteResult.board) {
+            return { content: [{ type: 'text', text: `Error: ${deleteResult.error}` }], isError: true };
+        }
+        writeBoard(filePath, deleteResult.board);
+        const output = {
+            success: true,
+            category,
+            deletedRule: ruleToDelete,
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(output, null, 2) }]
+        };
+    });
+    // ==========================================================================
+    // V2 NEW TOOLS: complete_task, search_logs, append_log
+    // ==========================================================================
+    // Complete task tool
+    server.registerTool('complete_task', {
+        title: 'Complete Task',
+        description: 'Complete a task - in v2, moves task file from board/ to logs/ with completedAt timestamp. In v1, moves to done column.',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            task: zod_1.z.string().describe('Task ID to complete'),
+        }
+    }, async ({ file, task }) => {
+        const filePath = file || defaultFile;
+        try {
+            const { completeCommand } = await Promise.resolve().then(() => __importStar(require('./complete')));
+            const result = completeCommand({ file: filePath, task }, { log: () => { }, warn: () => { }, error: () => { }, info: () => { } });
+            return {
+                content: [{ type: 'text', text: `Task ${task} completed at ${result.completedAt}` }]
+            };
+        }
+        catch (e) {
+            return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+        }
+    });
+    // Search logs tool
+    server.registerTool('search_logs', {
+        title: 'Search Logs',
+        description: 'Search across completed task logs. Requires v2 per-task file architecture.',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            query: zod_1.z.string().optional().describe('Search query to match against log content'),
+            recent: zod_1.z.boolean().optional().describe('List recently completed tasks'),
+            task: zod_1.z.string().optional().describe('View a specific task log'),
+        }
+    }, async ({ file, query, recent, task: taskId }) => {
+        const filePath = file || defaultFile;
+        if (!(0, v2_detect_1.isV2)(filePath)) {
+            return { content: [{ type: 'text', text: 'Error: search_logs requires v2 per-task file architecture. Run: brainfile migrate --v2' }], isError: true };
+        }
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        // View specific task log
+        if (taskId) {
+            const found = (0, v2_detect_1.findV2Task)(dirs, taskId, true);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${taskId}` }], isError: true };
+            }
+            const output = {
+                id: found.doc.task.id,
+                title: found.doc.task.title,
+                completedAt: found.doc.task.completedAt,
+                description: (0, v2_detect_1.extractDescription)(found.doc.body),
+                log: (0, v2_detect_1.extractLog)(found.doc.body),
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+        }
+        // Search logs
+        if (query) {
+            const logDocs = (0, core_3.readTasksDir)(dirs.logsDir);
+            const queryLower = query.toLowerCase();
+            const matches = [];
+            for (const doc of logDocs) {
+                const task = doc.task;
+                const desc = (0, v2_detect_1.extractDescription)(doc.body) || '';
+                const log = (0, v2_detect_1.extractLog)(doc.body) || '';
+                const fullText = [task.title, task.description || '', desc, log].join(' ').toLowerCase();
+                if (fullText.includes(queryLower)) {
+                    matches.push({ id: task.id, title: task.title, completedAt: task.completedAt });
+                }
+            }
+            return { content: [{ type: 'text', text: JSON.stringify({ results: matches, count: matches.length }, null, 2) }] };
+        }
+        // Recent logs (default)
+        const logDocs = (0, core_3.readTasksDir)(dirs.logsDir);
+        logDocs.sort((a, b) => (b.task.completedAt || '').localeCompare(a.task.completedAt || ''));
+        const recent20 = logDocs.slice(0, 20).map(doc => ({
+            id: doc.task.id,
+            title: doc.task.title,
+            completedAt: doc.task.completedAt,
+        }));
+        return { content: [{ type: 'text', text: JSON.stringify({ logs: recent20, count: recent20.length }, null, 2) }] };
+    });
+    // Append log tool
+    server.registerTool('append_log', {
+        title: 'Append Log',
+        description: 'Append a timestamped entry to a task log section. Works on both active tasks and completed logs. Requires v2 per-task file architecture.',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            task: zod_1.z.string().describe('Task ID to append log to'),
+            message: zod_1.z.string().describe('Log message to append'),
+            agent: zod_1.z.string().optional().describe('Agent name for attribution'),
+        }
+    }, async ({ file, task: taskId, message, agent }) => {
+        const filePath = file || defaultFile;
+        if (!(0, v2_detect_1.isV2)(filePath)) {
+            return { content: [{ type: 'text', text: 'Error: append_log requires v2 per-task file architecture. Run: brainfile migrate --v2' }], isError: true };
+        }
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        const found = (0, v2_detect_1.findV2Task)(dirs, taskId, true);
+        if (!found) {
+            return { content: [{ type: 'text', text: `Error: Task not found: ${taskId}` }], isError: true };
+        }
+        const { doc, filePath: taskFilePath } = found;
+        const timestamp = new Date().toISOString();
+        const agentPrefix = agent ? `[${agent}] ` : '';
+        const entry = `- ${timestamp}: ${agentPrefix}${message}`;
+        const existingDescription = (0, v2_detect_1.extractDescription)(doc.body);
+        const existingLog = (0, v2_detect_1.extractLog)(doc.body) || '';
+        const newLog = existingLog ? `${existingLog}\n${entry}` : entry;
+        const newBody = (0, v2_detect_1.composeBody)(existingDescription, newLog);
+        (0, core_3.writeTaskFile)(taskFilePath, doc.task, newBody);
+        return { content: [{ type: 'text', text: `Log entry added to ${taskId}: ${entry}` }] };
+    });
     // Connect via stdio
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);