@brainfile/cli 0.13.3 → 0.15.1

package/dist/tui/actions.js

@@ -47,7 +47,7 @@ exports.copyToClipboard = copyToClipboard;
 exports.addRuleAction = addRuleAction;
 exports.updateRuleAction = updateRuleAction;
 exports.deleteRuleAction = deleteRuleAction;
-exports.loadArchive = loadArchive;
+exports.loadLogs = loadLogs;
 exports.restoreTaskAction = restoreTaskAction;
 exports.deleteArchivedTaskAction = deleteArchivedTaskAction;
 /**
@@ -62,6 +62,7 @@ const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
 const core_1 = require("@brainfile/core");
 const config_1 = require("../utils/config");
+const v2_detect_1 = require("../utils/v2-detect");
 const github_auth_1 = require("../utils/github-auth");
 const linear_auth_1 = require("../utils/linear-auth");
 /**
@@ -93,11 +94,53 @@ function writeBrainfile(filePath, board) {
         return { success: false, error: err instanceof Error ? err.message : String(err) };
     }
 }
+/**
+ * Read board with tasks populated (v1: embedded, v2: reconstructed from board/ files).
+ */
+function readBoardState(filePath) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const board = (0, v2_detect_1.buildBoardFromV2)(filePath);
+            return { board, content };
+        }
+        catch (err) {
+            return { board: null, content: '', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    return readBrainfile(filePath);
+}
+/**
+ * Read board config only (for rules/settings changes that should not touch task files).
+ */
+function readBoardConfigOnly(filePath) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        try {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
+            return { board, content };
+        }
+        catch (err) {
+            return { board: null, content: '', error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    return readBrainfile(filePath);
+}
+/**
+ * Resolve a task file path in v2 board directory.
+ */
+function resolveV2TaskPath(filePath, taskId) {
+    const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+    const doc = (0, core_1.findTask)(dirs.boardDir, taskId);
+    if (!doc || !doc.filePath)
+        return null;
+    return { taskPath: doc.filePath, task: doc.task };
+}
 /**
  * Move a task to a different column
  */
 function moveTaskAction(filePath, taskId, targetColumnId) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardState(filePath);
     if (!board)
         return { success: false, error };
     const taskInfo = (0, core_1.findTaskById)(board, taskId);
@@ -109,6 +152,15 @@ function moveTaskAction(filePath, taskId, targetColumnId) {
     if (taskInfo.column.id === targetColumn.id) {
         return { success: true, message: 'Task already in this column' };
     }
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const located = resolveV2TaskPath(filePath, taskId);
+        if (!located)
+            return { success: false, error: `Task ${taskId} not found` };
+        const moveResult = (0, core_1.moveTaskFile)(located.taskPath, targetColumn.id, targetColumn.tasks.length);
+        if (!moveResult.success)
+            return { success: false, error: moveResult.error };
+        return { success: true, message: `Moved to ${targetColumn.title}` };
+    }
     const result = (0, core_1.moveTask)(board, taskId, taskInfo.column.id, targetColumn.id, targetColumn.tasks.length);
     if (!result.success)
         return { success: false, error: result.error };
@@ -121,12 +173,21 @@ function moveTaskAction(filePath, taskId, targetColumnId) {
  * Delete a task permanently
  */
 function deleteTaskAction(filePath, taskId) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardState(filePath);
     if (!board)
         return { success: false, error };
     const taskInfo = (0, core_1.findTaskById)(board, taskId);
     if (!taskInfo)
         return { success: false, error: `Task ${taskId} not found` };
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const located = resolveV2TaskPath(filePath, taskId);
+        if (!located)
+            return { success: false, error: `Task ${taskId} not found` };
+        const result = (0, core_1.deleteTaskFile)(located.taskPath);
+        if (!result.success)
+            return { success: false, error: result.error };
+        return { success: true, message: `Deleted ${taskId}` };
+    }
     const result = (0, core_1.deleteTask)(board, taskInfo.column.id, taskId);
     if (!result.success)
         return { success: false, error: result.error };
@@ -150,7 +211,7 @@ function getArchivePath(filePath) {
  */
 function createEmptyArchiveBoard() {
     return {
-        title: 'Archive',
+        title: 'Logs',
         columns: [],
         archive: [],
     };
@@ -160,6 +221,16 @@ function createEmptyArchiveBoard() {
  * Per protocol spec, archived tasks go to a separate file, not inline archive array
  */
 function archiveTaskAction(filePath, taskId) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        const located = resolveV2TaskPath(filePath, taskId);
+        if (!located)
+            return { success: false, error: `Task ${taskId} not found` };
+        const result = (0, core_1.completeTaskFile)(located.taskPath, dirs.logsDir);
+        if (!result.success)
+            return { success: false, error: result.error };
+        return { success: true, message: `Moved ${taskId} to logs` };
+    }
     const { board, error } = readBrainfile(filePath);
     if (!board)
         return { success: false, error };
@@ -213,17 +284,17 @@ function archiveTaskAction(filePath, taskId) {
         // This is a partial failure state - log and report
         return {
             success: false,
-            error: `Task removed from board but failed to write archive: ${err instanceof Error ? err.message : String(err)}`,
+            error: `Task removed from board but failed to write logs: ${err instanceof Error ? err.message : String(err)}`,
         };
     }
-    return { success: true, message: `Archived ${taskId}` };
+    return { success: true, message: `Moved ${taskId} to logs` };
 }
 /**
  * Archive a task with support for external destinations (GitHub, Linear)
  * Respects archive.destination from brainfile.md or global config
  */
 async function archiveTaskActionAsync(filePath, taskId) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardState(filePath);
     if (!board)
         return { success: false, error };
     const taskInfo = (0, core_1.findTaskById)(board, taskId);
@@ -271,11 +342,19 @@ async function archiveTaskActionAsync(filePath, taskId) {
             return { success: false, error: `GitHub: ${ghResult.error}` };
         }
         // Remove task from board
-        const deleteResult = (0, core_1.deleteTask)(board, columnId, taskId);
-        if (deleteResult.success) {
-            writeBrainfile(filePath, deleteResult.board);
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const located = resolveV2TaskPath(filePath, taskId);
+            if (located) {
+                (0, core_1.deleteTaskFile)(located.taskPath);
+            }
         }
-        return { success: true, message: `Archived to GitHub #${ghResult.issueNumber}` };
+        else {
+            const deleteResult = (0, core_1.deleteTask)(board, columnId, taskId);
+            if (deleteResult.success) {
+                writeBrainfile(filePath, deleteResult.board);
+            }
+        }
+        return { success: true, message: `Moved to logs via GitHub #${ghResult.issueNumber}` };
     }
     // Handle Linear archive
     if (destination === 'linear') {
@@ -328,11 +407,19 @@ async function archiveTaskActionAsync(filePath, taskId) {
             return { success: false, error: `Linear: ${linearResult.error}` };
         }
         // Remove task from board
-        const deleteResult = (0, core_1.deleteTask)(board, columnId, taskId);
-        if (deleteResult.success) {
-            writeBrainfile(filePath, deleteResult.board);
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const located = resolveV2TaskPath(filePath, taskId);
+            if (located) {
+                (0, core_1.deleteTaskFile)(located.taskPath);
+            }
         }
-        return { success: true, message: `Archived to Linear ${linearResult.issueId}` };
+        else {
+            const deleteResult = (0, core_1.deleteTask)(board, columnId, taskId);
+            if (deleteResult.success) {
+                writeBrainfile(filePath, deleteResult.board);
+            }
+        }
+        return { success: true, message: `Moved to logs via Linear ${linearResult.issueId}` };
     }
     return { success: false, error: `Unknown destination: ${destination}` };
 }
@@ -340,6 +427,73 @@ async function archiveTaskActionAsync(filePath, taskId) {
  * Patch/update task fields
  */
 function patchTaskAction(filePath, taskId, patch) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const located = resolveV2TaskPath(filePath, taskId);
+        if (!located)
+            return { success: false, error: `Task ${taskId} not found` };
+        const doc = (0, core_1.readTaskFile)(located.taskPath);
+        if (!doc)
+            return { success: false, error: `Failed to read task ${taskId}` };
+        const updatedTask = { ...doc.task };
+        if (patch.title !== undefined)
+            updatedTask.title = patch.title;
+        if (patch.description !== undefined) {
+            if (patch.description === null) {
+                delete updatedTask.description;
+            }
+            else {
+                updatedTask.description = patch.description;
+            }
+        }
+        if (patch.priority !== undefined) {
+            if (patch.priority === null) {
+                delete updatedTask.priority;
+            }
+            else {
+                updatedTask.priority = patch.priority;
+            }
+        }
+        if (patch.tags !== undefined) {
+            if (patch.tags === null) {
+                delete updatedTask.tags;
+            }
+            else {
+                updatedTask.tags = patch.tags;
+            }
+        }
+        if (patch.assignee !== undefined) {
+            if (patch.assignee === null) {
+                delete updatedTask.assignee;
+            }
+            else {
+                updatedTask.assignee = patch.assignee;
+            }
+        }
+        if (patch.dueDate !== undefined) {
+            if (patch.dueDate === null) {
+                delete updatedTask.dueDate;
+            }
+            else {
+                updatedTask.dueDate = patch.dueDate;
+            }
+        }
+        if (patch.relatedFiles !== undefined) {
+            if (patch.relatedFiles === null) {
+                delete updatedTask.relatedFiles;
+            }
+            else {
+                updatedTask.relatedFiles = patch.relatedFiles;
+            }
+        }
+        updatedTask.updatedAt = new Date().toISOString();
+        try {
+            (0, core_1.writeTaskFile)(located.taskPath, updatedTask, doc.body);
+            return { success: true, message: `Updated ${taskId}` };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     const { board, error } = readBrainfile(filePath);
     if (!board)
         return { success: false, error };
@@ -355,13 +509,39 @@ function patchTaskAction(filePath, taskId, patch) {
  * Cycle task priority: none -> low -> medium -> high -> critical -> none
  */
 function cyclePriorityAction(filePath, taskId) {
+    const priorities = [undefined, 'low', 'medium', 'high', 'critical'];
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const located = resolveV2TaskPath(filePath, taskId);
+        if (!located)
+            return { success: false, error: `Task ${taskId} not found` };
+        const doc = (0, core_1.readTaskFile)(located.taskPath);
+        if (!doc)
+            return { success: false, error: `Failed to read task ${taskId}` };
+        const currentIndex = priorities.indexOf(doc.task.priority);
+        const nextIndex = (currentIndex + 1) % priorities.length;
+        const nextPriority = priorities[nextIndex];
+        const updatedTask = {
+            ...doc.task,
+            ...(nextPriority ? { priority: nextPriority } : {}),
+            updatedAt: new Date().toISOString(),
+        };
+        if (!nextPriority) {
+            delete updatedTask.priority;
+        }
+        try {
+            (0, core_1.writeTaskFile)(located.taskPath, updatedTask, doc.body);
+            return { success: true, message: `Priority: ${nextPriority || 'none'}` };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     const { board, error } = readBrainfile(filePath);
     if (!board)
         return { success: false, error };
     const taskInfo = (0, core_1.findTaskById)(board, taskId);
     if (!taskInfo)
         return { success: false, error: `Task ${taskId} not found` };
-    const priorities = [undefined, 'low', 'medium', 'high', 'critical'];
     const currentIndex = priorities.indexOf(taskInfo.task.priority);
     const nextIndex = (currentIndex + 1) % priorities.length;
     const nextPriority = priorities[nextIndex];
@@ -378,6 +558,37 @@ function cyclePriorityAction(filePath, taskId) {
  * Toggle a subtask's completion status
  */
 function toggleSubtaskAction(filePath, taskId, subtaskId) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const located = resolveV2TaskPath(filePath, taskId);
+        if (!located)
+            return { success: false, error: `Task ${taskId} not found` };
+        const doc = (0, core_1.readTaskFile)(located.taskPath);
+        if (!doc)
+            return { success: false, error: `Failed to read task ${taskId}` };
+        if (!doc.task.subtasks || doc.task.subtasks.length === 0) {
+            return { success: false, error: `Task ${taskId} has no subtasks` };
+        }
+        const updatedSubtasks = doc.task.subtasks.map((subtask) => {
+            if (subtask.id !== subtaskId)
+                return subtask;
+            return { ...subtask, completed: !subtask.completed };
+        });
+        const found = updatedSubtasks.some((subtask) => subtask.id === subtaskId);
+        if (!found)
+            return { success: false, error: `Subtask ${subtaskId} not found` };
+        const updatedTask = {
+            ...doc.task,
+            subtasks: updatedSubtasks,
+            updatedAt: new Date().toISOString(),
+        };
+        try {
+            (0, core_1.writeTaskFile)(located.taskPath, updatedTask, doc.body);
+            return { success: true, message: `Toggled ${subtaskId}` };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     const { board, error } = readBrainfile(filePath);
     if (!board)
         return { success: false, error };
@@ -393,12 +604,28 @@ function toggleSubtaskAction(filePath, taskId, subtaskId) {
  * Add a new task to a column (quick add - title only)
  */
 function addTaskAction(filePath, columnId, taskInput) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardState(filePath);
     if (!board)
         return { success: false, error };
     const column = (0, core_1.findColumnById)(board, columnId) || (0, core_1.findColumnByName)(board, columnId);
     if (!column)
         return { success: false, error: `Column ${columnId} not found` };
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        const result = (0, core_1.addTaskFile)(dirs.boardDir, {
+            title: taskInput.title,
+            column: column.id,
+            description: taskInput.description,
+            priority: taskInput.priority,
+            tags: taskInput.tags,
+            assignee: taskInput.assignee,
+            dueDate: taskInput.dueDate,
+            relatedFiles: taskInput.relatedFiles,
+        }, taskInput.description ? `## Description\n${taskInput.description.trim()}\n` : '', dirs.logsDir);
+        if (!result.success)
+            return { success: false, error: result.error };
+        return { success: true, message: `Added ${result.task?.id || 'task'}` };
+    }
     const result = (0, core_1.addTask)(board, column.id, taskInput);
     if (!result.success)
         return { success: false, error: result.error };
@@ -414,7 +641,7 @@ function addTaskAction(filePath, columnId, taskInput) {
  * Create a new task using $EDITOR with full template
  */
 function newTaskInEditor(filePath, columnId) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardState(filePath);
     if (!board)
         return { success: false, error };
     const column = (0, core_1.findColumnById)(board, columnId) || (0, core_1.findColumnByName)(board, columnId);
@@ -547,7 +774,7 @@ function parseNewTaskYaml(yaml) {
  * Uses spawnSync to fully block and give terminal control to the editor
  */
 function editTaskInEditor(filePath, taskId) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardState(filePath);
     if (!board) {
         return { success: false, error };
     }
@@ -771,7 +998,7 @@ function copyToClipboard(text) {
  * Add a new rule to a rule category
  */
 function addRuleAction(filePath, ruleType, ruleText) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardConfigOnly(filePath);
     if (!board)
         return { success: false, error };
     // Initialize rules if not present
@@ -805,7 +1032,7 @@ function addRuleAction(filePath, ruleType, ruleText) {
  * Update an existing rule
  */
 function updateRuleAction(filePath, ruleType, ruleId, ruleText) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardConfigOnly(filePath);
     if (!board)
         return { success: false, error };
     if (!board.rules || !board.rules[ruleType]) {
@@ -825,7 +1052,7 @@ function updateRuleAction(filePath, ruleType, ruleId, ruleText) {
  * Delete a rule
  */
 function deleteRuleAction(filePath, ruleType, ruleId) {
-    const { board, error } = readBrainfile(filePath);
+    const { board, error } = readBoardConfigOnly(filePath);
     if (!board)
         return { success: false, error };
     if (!board.rules || !board.rules[ruleType]) {
@@ -845,61 +1072,110 @@ function deleteRuleAction(filePath, ruleType, ruleId) {
 // ARCHIVE OPERATIONS
 // =============================================================================
 /**
- * Load archive from the archive file
+ * Load logs from the logs file
  */
-function loadArchive(filePath) {
+function loadLogs(filePath) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        try {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const docs = (0, core_1.readTasksDir)(dirs.logsDir);
+            const logs = docs
+                .map((doc) => ({ ...doc.task }))
+                .sort((a, b) => {
+                const aTime = a.completedAt ? Date.parse(a.completedAt) : 0;
+                const bTime = b.completedAt ? Date.parse(b.completedAt) : 0;
+                return bTime - aTime;
+            });
+            return { logs };
+        }
+        catch (err) {
+            return { logs: [], error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     const archivePath = getArchivePath(filePath);
     if (!fs.existsSync(archivePath)) {
-        return { archive: [] };
+        return { logs: [] };
     }
     try {
         const archiveContent = fs.readFileSync(archivePath, 'utf-8');
         const parseResult = core_1.Brainfile.parseWithErrors(archiveContent);
         if (parseResult.board && parseResult.board.archive) {
-            return { archive: parseResult.board.archive };
+            return { logs: parseResult.board.archive };
         }
-        return { archive: [] };
+        return { logs: [] };
     }
     catch (err) {
-        return { archive: [], error: err instanceof Error ? err.message : String(err) };
+        return { logs: [], error: err instanceof Error ? err.message : String(err) };
     }
 }
 /**
- * Restore a task from the archive to a column
+ * Restore a task from logs to a column
  */
 function restoreTaskAction(filePath, taskId, toColumnId) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        const { board, error } = readBoardState(filePath);
+        if (!board)
+            return { success: false, error };
+        const column = (0, core_1.findColumnById)(board, toColumnId) || (0, core_1.findColumnByName)(board, toColumnId);
+        if (!column) {
+            return { success: false, error: `Column ${toColumnId} not found` };
+        }
+        if ((0, core_1.findTask)(dirs.boardDir, taskId)) {
+            return { success: false, error: `Task ${taskId} already exists in board` };
+        }
+        const logDoc = (0, core_1.findTask)(dirs.logsDir, taskId);
+        if (!logDoc || !logDoc.filePath) {
+            return { success: false, error: `Task ${taskId} not found in logs` };
+        }
+        const restoredTask = {
+            ...logDoc.task,
+            column: column.id,
+            updatedAt: new Date().toISOString(),
+        };
+        delete restoredTask.completedAt;
+        const targetPath = path.join(dirs.boardDir, `${taskId}.md`);
+        try {
+            (0, core_1.writeTaskFile)(targetPath, restoredTask, logDoc.body);
+            fs.unlinkSync(logDoc.filePath);
+            return { success: true, message: `Restored ${taskId} to ${column.title}` };
+        }
+        catch (err) {
+            return { success: false, error: `Failed to restore task: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
     const archivePath = getArchivePath(filePath);
     // Read archive file
     if (!fs.existsSync(archivePath)) {
-        return { success: false, error: 'Archive file not found' };
+        return { success: false, error: 'Logs file not found' };
     }
     let archiveBoard;
     try {
         const archiveContent = fs.readFileSync(archivePath, 'utf-8');
         const parseResult = core_1.Brainfile.parseWithErrors(archiveContent);
         if (!parseResult.board) {
-            return { success: false, error: 'Failed to parse archive file' };
+            return { success: false, error: 'Failed to parse logs file' };
         }
         archiveBoard = parseResult.board;
     }
     catch (err) {
-        return { success: false, error: `Failed to read archive: ${err instanceof Error ? err.message : String(err)}` };
+        return { success: false, error: `Failed to read logs: ${err instanceof Error ? err.message : String(err)}` };
     }
     // Find task in archive
     if (!archiveBoard.archive || archiveBoard.archive.length === 0) {
-        return { success: false, error: 'Archive is empty' };
+        return { success: false, error: 'Logs are empty' };
     }
     const taskIndex = archiveBoard.archive.findIndex(t => t.id === taskId);
     if (taskIndex === -1) {
-        return { success: false, error: `Task ${taskId} not found in archive` };
+        return { success: false, error: `Task ${taskId} not found in logs` };
     }
     const task = archiveBoard.archive[taskIndex];
     // Read main board
-    const { board, error } = readBrainfile(filePath);
-    if (!board)
-        return { success: false, error };
+    const { board: mainBoard, error: mainBoardError } = readBrainfile(filePath);
+    if (!mainBoard)
+        return { success: false, error: mainBoardError };
     // Find target column
-    const column = (0, core_1.findColumnById)(board, toColumnId) || (0, core_1.findColumnByName)(board, toColumnId);
+    const column = (0, core_1.findColumnById)(mainBoard, toColumnId) || (0, core_1.findColumnByName)(mainBoard, toColumnId);
     if (!column) {
         return { success: false, error: `Column ${toColumnId} not found` };
     }
@@ -908,7 +1184,7 @@ function restoreTaskAction(filePath, taskId, toColumnId) {
     // Remove from archive
     archiveBoard.archive.splice(taskIndex, 1);
     // Save both files
-    const writeResult = writeBrainfile(filePath, board);
+    const writeResult = writeBrainfile(filePath, mainBoard);
     if (!writeResult.success)
         return writeResult;
     try {
@@ -916,38 +1192,50 @@ function restoreTaskAction(filePath, taskId, toColumnId) {
         fs.writeFileSync(archivePath, archiveContent, 'utf-8');
     }
     catch (err) {
-        return { success: false, error: `Task restored but failed to update archive: ${err}` };
+        return { success: false, error: `Task restored but failed to update logs: ${err}` };
     }
     return { success: true, message: `Restored ${taskId} to ${column.title}` };
 }
 /**
- * Permanently delete a task from the archive
+ * Permanently delete a task from logs
  */
 function deleteArchivedTaskAction(filePath, taskId) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+        const logDoc = (0, core_1.findTask)(dirs.logsDir, taskId);
+        if (!logDoc || !logDoc.filePath) {
+            return { success: false, error: `Task ${taskId} not found in logs` };
+        }
+        const result = (0, core_1.deleteTaskFile)(logDoc.filePath);
+        if (!result.success) {
+            return { success: false, error: result.error || `Failed to delete ${taskId}` };
+        }
+        return { success: true, message: `Permanently deleted ${taskId}` };
+    }
     const archivePath = getArchivePath(filePath);
     // Read archive file
     if (!fs.existsSync(archivePath)) {
-        return { success: false, error: 'Archive file not found' };
+        return { success: false, error: 'Logs file not found' };
     }
     let archiveBoard;
     try {
         const archiveContent = fs.readFileSync(archivePath, 'utf-8');
         const parseResult = core_1.Brainfile.parseWithErrors(archiveContent);
         if (!parseResult.board) {
-            return { success: false, error: 'Failed to parse archive file' };
+            return { success: false, error: 'Failed to parse logs file' };
         }
         archiveBoard = parseResult.board;
     }
     catch (err) {
-        return { success: false, error: `Failed to read archive: ${err instanceof Error ? err.message : String(err)}` };
+        return { success: false, error: `Failed to read logs: ${err instanceof Error ? err.message : String(err)}` };
     }
     // Find and remove task from archive
     if (!archiveBoard.archive || archiveBoard.archive.length === 0) {
-        return { success: false, error: 'Archive is empty' };
+        return { success: false, error: 'Logs are empty' };
     }
     const taskIndex = archiveBoard.archive.findIndex(t => t.id === taskId);
     if (taskIndex === -1) {
-        return { success: false, error: `Task ${taskId} not found in archive` };
+        return { success: false, error: `Task ${taskId} not found in logs` };
     }
     archiveBoard.archive.splice(taskIndex, 1);
     // Save archive file
@@ -956,7 +1244,7 @@ function deleteArchivedTaskAction(filePath, taskId) {
         fs.writeFileSync(archivePath, archiveContent, 'utf-8');
     }
     catch (err) {
-        return { success: false, error: `Failed to update archive: ${err}` };
+        return { success: false, error: `Failed to update logs: ${err}` };
     }
     return { success: true, message: `Permanently deleted ${taskId}` };
 }