@backlog-md/core 0.2.2 → 0.3.1

package/dist/core/Core.js

@@ -4,9 +4,9 @@
  * Provides a runtime-agnostic API for managing Backlog.md projects
  * by accepting adapter implementations for I/O operations.
  */
+import { extractMilestoneIdFromFilename, extractTaskIndexFromPath, getMilestoneFilename, parseMilestoneMarkdown, parseTaskMarkdown, serializeMilestoneMarkdown, serializeTaskMarkdown, } from "../markdown";
+import { groupTasksByMilestone, groupTasksByStatus, milestoneKey, sortTasks, sortTasksBy, } from "../utils";
 import { parseBacklogConfig, serializeBacklogConfig } from "./config-parser";
-import { parseTaskMarkdown, extractTaskIndexFromPath } from "../markdown";
-import { sortTasks, sortTasksBy, groupTasksByStatus } from "../utils";
 /**
  * Core class for Backlog.md operations
  *
@@ -243,10 +243,14 @@ export class Core {
             entries = entries.sort((a, b) => {
                 const aNum = parseInt(a.id.replace(/\D/g, ""), 10) || 0;
                 const bNum = parseInt(b.id.replace(/\D/g, ""), 10) || 0;
-                // Completed: descending (most recent first), Active: ascending
-                return source === "completed" && completedSortByIdDesc
-                    ? bNum - aNum
-                    : aNum - bNum;
+                if (source === "completed") {
+                    // Completed: use completedSortByIdDesc option
+                    return completedSortByIdDesc ? bNum - aNum : aNum - bNum;
+                }
+                else {
+                    // Tasks: use tasksSortDirection option
+                    return tasksSortDirection === "desc" ? bNum - aNum : aNum - bNum;
+                }
             });
             const total = entries.length;
             const pageEntries = entries.slice(offset, offset + limit);
@@ -286,10 +290,14 @@ export class Core {
         entries = entries.sort((a, b) => {
             const aNum = parseInt(a.id.replace(/\D/g, ""), 10) || 0;
             const bNum = parseInt(b.id.replace(/\D/g, ""), 10) || 0;
-            // Completed: descending (most recent first), Active: ascending
-            return source === "completed" && completedSortByIdDesc
-                ? bNum - aNum
-                : aNum - bNum;
+            if (source === "completed") {
+                // Completed: use completedSortByIdDesc option
+                return completedSortByIdDesc ? bNum - aNum : aNum - bNum;
+            }
+            else {
+                // Tasks: use sortDirection option
+                return sortDirection === "desc" ? bNum - aNum : aNum - bNum;
+            }
         });
         const total = entries.length;
         const pageEntries = entries.slice(currentOffset, currentOffset + limit);
@@ -310,7 +318,7 @@ export class Core {
      */
     getConfig() {
         this.ensureInitialized();
-        return this.config;
+        return this.safeConfig;
     }
     /**
      * List all tasks, optionally filtered
@@ -325,13 +333,18 @@ export class Core {
             tasks = tasks.filter((t) => t.status === filter.status);
         }
         if (filter?.assignee) {
-            tasks = tasks.filter((t) => t.assignee.includes(filter.assignee));
+            const assignee = filter.assignee;
+            tasks = tasks.filter((t) => t.assignee.includes(assignee));
         }
         if (filter?.priority) {
             tasks = tasks.filter((t) => t.priority === filter.priority);
         }
+        if (filter?.milestone) {
+            const filterKey = milestoneKey(filter.milestone);
+            tasks = tasks.filter((t) => milestoneKey(t.milestone) === filterKey);
+        }
         if (filter?.labels && filter.labels.length > 0) {
-            tasks = tasks.filter((t) => filter.labels.some((label) => t.labels.includes(label)));
+            tasks = tasks.filter((t) => filter.labels?.some((label) => t.labels.includes(label)));
         }
         if (filter?.parentTaskId) {
             tasks = tasks.filter((t) => t.parentTaskId === filter.parentTaskId);
@@ -348,7 +361,232 @@ export class Core {
     getTasksByStatus() {
         this.ensureInitialized();
         const tasks = Array.from(this.tasks.values());
-        return groupTasksByStatus(tasks, this.config.statuses);
+        return groupTasksByStatus(tasks, this.safeConfig.statuses);
+    }
+    /**
+     * Get tasks grouped by milestone
+     *
+     * Returns a MilestoneSummary with:
+     * - milestones: List of milestone IDs in display order
+     * - buckets: Array of MilestoneBucket with tasks, progress, status counts
+     *
+     * The first bucket is always "Tasks without milestone".
+     * Each bucket includes progress percentage based on done status.
+     *
+     * @example
+     * ```typescript
+     * const summary = core.getTasksByMilestone();
+     * for (const bucket of summary.buckets) {
+     *   console.log(`${bucket.label}: ${bucket.progress}% complete`);
+     *   console.log(`  ${bucket.doneCount}/${bucket.total} tasks done`);
+     * }
+     * ```
+     */
+    getTasksByMilestone() {
+        this.ensureInitialized();
+        const tasks = Array.from(this.tasks.values());
+        return groupTasksByMilestone(tasks, this.safeConfig.milestones, this.safeConfig.statuses);
+    }
+    // =========================================================================
+    // Milestone CRUD Operations
+    // =========================================================================
+    /**
+     * Get the milestones directory path
+     */
+    getMilestonesDir() {
+        return this.fs.join(this.projectRoot, "backlog", "milestones");
+    }
+    /**
+     * List all milestones from the milestones directory
+     *
+     * @returns Array of Milestone objects sorted by ID
+     */
+    async listMilestones() {
+        const milestonesDir = this.getMilestonesDir();
+        // Check if directory exists
+        if (!(await this.fs.exists(milestonesDir))) {
+            return [];
+        }
+        const entries = await this.fs.readDir(milestonesDir);
+        const milestones = [];
+        for (const entry of entries) {
+            // Skip non-milestone files
+            if (!entry.endsWith(".md"))
+                continue;
+            if (entry.toLowerCase() === "readme.md")
+                continue;
+            const milestoneId = extractMilestoneIdFromFilename(entry);
+            if (!milestoneId)
+                continue;
+            const filepath = this.fs.join(milestonesDir, entry);
+            // Skip directories
+            if (await this.fs.isDirectory(filepath))
+                continue;
+            try {
+                const content = await this.fs.readFile(filepath);
+                milestones.push(parseMilestoneMarkdown(content));
+            }
+            catch (error) {
+                console.warn(`Failed to parse milestone file ${filepath}:`, error);
+            }
+        }
+        // Sort by ID for consistent ordering
+        return milestones.sort((a, b) => a.id.localeCompare(b.id, undefined, { numeric: true }));
+    }
+    /**
+     * Load a single milestone by ID
+     *
+     * @param id - Milestone ID (e.g., "m-0")
+     * @returns Milestone or null if not found
+     */
+    async loadMilestone(id) {
+        const milestonesDir = this.getMilestonesDir();
+        if (!(await this.fs.exists(milestonesDir))) {
+            return null;
+        }
+        const entries = await this.fs.readDir(milestonesDir);
+        // Find file matching the ID
+        const milestoneFile = entries.find((entry) => {
+            const fileId = extractMilestoneIdFromFilename(entry);
+            return fileId === id;
+        });
+        if (!milestoneFile) {
+            return null;
+        }
+        const filepath = this.fs.join(milestonesDir, milestoneFile);
+        try {
+            const content = await this.fs.readFile(filepath);
+            return parseMilestoneMarkdown(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Create a new milestone
+     *
+     * @param input - Milestone creation input
+     * @returns Created milestone
+     */
+    async createMilestone(input) {
+        const milestonesDir = this.getMilestonesDir();
+        // Ensure milestones directory exists
+        await this.fs.createDir(milestonesDir, { recursive: true });
+        // Find next available milestone ID
+        const entries = await this.fs.readDir(milestonesDir).catch(() => []);
+        const existingIds = entries
+            .map((f) => {
+            const match = f.match(/^m-(\d+)/);
+            return match?.[1] ? parseInt(match[1], 10) : -1;
+        })
+            .filter((id) => id >= 0);
+        const nextId = existingIds.length > 0 ? Math.max(...existingIds) + 1 : 0;
+        const id = `m-${nextId}`;
+        const description = input.description || `Milestone: ${input.title}`;
+        // Create a temporary milestone to generate content
+        const tempMilestone = {
+            id,
+            title: input.title,
+            description,
+            rawContent: "",
+            tasks: [],
+        };
+        // Generate content
+        const content = serializeMilestoneMarkdown(tempMilestone);
+        // Create the final milestone with correct rawContent
+        const milestone = {
+            id,
+            title: input.title,
+            description,
+            rawContent: content,
+            tasks: [],
+        };
+        // Write file
+        const filename = getMilestoneFilename(id, input.title);
+        const filepath = this.fs.join(milestonesDir, filename);
+        await this.fs.writeFile(filepath, content);
+        return milestone;
+    }
+    /**
+     * Update an existing milestone
+     *
+     * @param id - Milestone ID to update
+     * @param input - Fields to update
+     * @returns Updated milestone or null if not found
+     */
+    async updateMilestone(id, input) {
+        const existing = await this.loadMilestone(id);
+        if (!existing) {
+            return null;
+        }
+        const milestonesDir = this.getMilestonesDir();
+        const entries = await this.fs.readDir(milestonesDir);
+        // Find the current file
+        const currentFile = entries.find((entry) => {
+            const fileId = extractMilestoneIdFromFilename(entry);
+            return fileId === id;
+        });
+        if (!currentFile) {
+            return null;
+        }
+        // Build updated values
+        const newTitle = input.title ?? existing.title;
+        const newDescription = input.description ?? existing.description;
+        // Create a temporary milestone to generate content
+        const tempMilestone = {
+            id: existing.id,
+            title: newTitle,
+            description: newDescription,
+            rawContent: "",
+            tasks: existing.tasks,
+        };
+        // Generate new content
+        const content = serializeMilestoneMarkdown(tempMilestone);
+        // Create the final updated milestone
+        const updated = {
+            id: existing.id,
+            title: newTitle,
+            description: newDescription,
+            rawContent: content,
+            tasks: existing.tasks,
+        };
+        // Delete old file
+        const oldPath = this.fs.join(milestonesDir, currentFile);
+        await this.fs.deleteFile(oldPath);
+        // Write new file (with potentially new filename if title changed)
+        const newFilename = getMilestoneFilename(id, updated.title);
+        const newPath = this.fs.join(milestonesDir, newFilename);
+        await this.fs.writeFile(newPath, content);
+        return updated;
+    }
+    /**
+     * Delete a milestone
+     *
+     * @param id - Milestone ID to delete
+     * @returns true if deleted, false if not found
+     */
+    async deleteMilestone(id) {
+        const milestonesDir = this.getMilestonesDir();
+        if (!(await this.fs.exists(milestonesDir))) {
+            return false;
+        }
+        const entries = await this.fs.readDir(milestonesDir);
+        // Find file matching the ID
+        const milestoneFile = entries.find((entry) => {
+            const fileId = extractMilestoneIdFromFilename(entry);
+            return fileId === id;
+        });
+        if (!milestoneFile) {
+            return false;
+        }
+        const filepath = this.fs.join(milestonesDir, milestoneFile);
+        try {
+            await this.fs.deleteFile(filepath);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
     /**
      * Get a single task by ID
@@ -403,7 +641,7 @@ export class Core {
         const byStatus = new Map();
         // Group all tasks by status first (without sorting)
         const allGrouped = new Map();
-        for (const status of this.config.statuses) {
+        for (const status of this.safeConfig.statuses) {
             allGrouped.set(status, []);
         }
         for (const task of this.tasks.values()) {
@@ -416,7 +654,7 @@ export class Core {
             }
         }
         // Paginate each status column
-        for (const status of this.config.statuses) {
+        for (const status of this.safeConfig.statuses) {
             let tasks = allGrouped.get(status) ?? [];
             tasks = sortTasksBy(tasks, sortBy, sortDirection);
             const total = tasks.length;
@@ -431,7 +669,7 @@ export class Core {
         }
         return {
             byStatus,
-            statuses: this.config.statuses,
+            statuses: this.safeConfig.statuses,
         };
     }
     /**
@@ -471,10 +709,16 @@ export class Core {
     }
     // --- Private methods ---
     ensureInitialized() {
-        if (!this.initialized) {
-            throw new Error("Core not initialized. Call initialize() first.");
+        if ((!this.initialized && !this.lazyInitialized) || !this.config) {
+            throw new Error("Core not initialized. Call initialize() or initializeLazy() first.");
         }
     }
+    /**
+     * Get config with type safety (use after ensureInitialized)
+     */
+    get safeConfig() {
+        return this.config;
+    }
     applyFilters(tasks, filter) {
         if (!filter)
             return tasks;
@@ -483,13 +727,18 @@ export class Core {
             result = result.filter((t) => t.status === filter.status);
         }
         if (filter.assignee) {
-            result = result.filter((t) => t.assignee.includes(filter.assignee));
+            const assignee = filter.assignee;
+            result = result.filter((t) => t.assignee.includes(assignee));
         }
         if (filter.priority) {
             result = result.filter((t) => t.priority === filter.priority);
         }
+        if (filter.milestone) {
+            const filterKey = milestoneKey(filter.milestone);
+            result = result.filter((t) => milestoneKey(t.milestone) === filterKey);
+        }
         if (filter.labels && filter.labels.length > 0) {
-            result = result.filter((t) => filter.labels.some((label) => t.labels.includes(label)));
+            result = result.filter((t) => filter.labels?.some((label) => t.labels.includes(label)));
         }
         if (filter.parentTaskId) {
             result = result.filter((t) => t.parentTaskId === filter.parentTaskId);
@@ -521,5 +770,407 @@ export class Core {
             }
         }
     }
+    // =========================================================================
+    // Milestone-Task Sync Helpers
+    // =========================================================================
+    /**
+     * Add a task ID to a milestone's tasks array
+     *
+     * @param taskId - Task ID to add
+     * @param milestoneId - Milestone ID to update
+     */
+    async addTaskToMilestone(taskId, milestoneId) {
+        const milestone = await this.loadMilestone(milestoneId);
+        if (!milestone) {
+            console.warn(`Milestone ${milestoneId} not found when adding task ${taskId}`);
+            return;
+        }
+        // Check if task already in milestone
+        if (milestone.tasks.includes(taskId)) {
+            return;
+        }
+        // Update milestone with new task
+        const updatedMilestone = {
+            ...milestone,
+            tasks: [...milestone.tasks, taskId],
+        };
+        await this.writeMilestoneFile(updatedMilestone);
+    }
+    /**
+     * Remove a task ID from a milestone's tasks array
+     *
+     * @param taskId - Task ID to remove
+     * @param milestoneId - Milestone ID to update
+     */
+    async removeTaskFromMilestone(taskId, milestoneId) {
+        const milestone = await this.loadMilestone(milestoneId);
+        if (!milestone) {
+            return;
+        }
+        // Check if task is in milestone
+        if (!milestone.tasks.includes(taskId)) {
+            return;
+        }
+        // Update milestone without the task
+        const updatedMilestone = {
+            ...milestone,
+            tasks: milestone.tasks.filter((id) => id !== taskId),
+        };
+        await this.writeMilestoneFile(updatedMilestone);
+    }
+    /**
+     * Write a milestone to disk
+     */
+    async writeMilestoneFile(milestone) {
+        const milestonesDir = this.getMilestonesDir();
+        const entries = await this.fs.readDir(milestonesDir).catch(() => []);
+        // Find and delete the current file
+        const currentFile = entries.find((entry) => {
+            const fileId = extractMilestoneIdFromFilename(entry);
+            return fileId === milestone.id;
+        });
+        if (currentFile) {
+            const oldPath = this.fs.join(milestonesDir, currentFile);
+            await this.fs.deleteFile(oldPath).catch(() => { });
+        }
+        // Write new file
+        const content = serializeMilestoneMarkdown(milestone);
+        const filename = getMilestoneFilename(milestone.id, milestone.title);
+        const filepath = this.fs.join(milestonesDir, filename);
+        await this.fs.writeFile(filepath, content);
+    }
+    /**
+     * Get the tasks directory path
+     */
+    getTasksDir() {
+        return this.fs.join(this.projectRoot, "backlog", "tasks");
+    }
+    /**
+     * Get the completed directory path
+     */
+    getCompletedDir() {
+        return this.fs.join(this.projectRoot, "backlog", "completed");
+    }
+    // =========================================================================
+    // Task CRUD Operations
+    // =========================================================================
+    /**
+     * Create a new task
+     *
+     * @param input - Task creation input
+     * @returns Created task
+     */
+    async createTask(input) {
+        this.ensureInitialized();
+        const tasksDir = this.getTasksDir();
+        // Ensure tasks directory exists
+        await this.fs.createDir(tasksDir, { recursive: true });
+        // Generate next task ID
+        const existingIds = Array.from(this.tasks.keys())
+            .map((id) => parseInt(id.replace(/\D/g, ""), 10))
+            .filter((n) => !Number.isNaN(n));
+        const nextId = existingIds.length > 0 ? Math.max(...existingIds) + 1 : 1;
+        const taskId = String(nextId);
+        // Build task object
+        const now = new Date().toISOString().split("T")[0];
+        const task = {
+            id: taskId,
+            title: input.title,
+            status: input.status || this.config?.defaultStatus || "To Do",
+            priority: input.priority,
+            assignee: input.assignee || [],
+            createdDate: now,
+            labels: input.labels || [],
+            milestone: input.milestone,
+            dependencies: input.dependencies || [],
+            parentTaskId: input.parentTaskId,
+            description: input.description,
+            implementationPlan: input.implementationPlan,
+            implementationNotes: input.implementationNotes,
+            acceptanceCriteriaItems: input.acceptanceCriteria?.map((ac, i) => ({
+                index: i + 1,
+                text: ac.text,
+                checked: ac.checked || false,
+            })),
+            rawContent: input.rawContent,
+            source: "local",
+        };
+        // Serialize and write file
+        const content = serializeTaskMarkdown(task);
+        const safeTitle = input.title
+            .replace(/[<>:"/\\|?*]/g, "")
+            .replace(/\s+/g, " ")
+            .slice(0, 50);
+        const filename = `${taskId} - ${safeTitle}.md`;
+        const filepath = this.fs.join(tasksDir, filename);
+        await this.fs.writeFile(filepath, content);
+        // Update in-memory cache
+        task.filePath = filepath;
+        this.tasks.set(taskId, task);
+        // Sync milestone if specified
+        if (input.milestone) {
+            await this.addTaskToMilestone(taskId, input.milestone);
+        }
+        return task;
+    }
+    /**
+     * Update an existing task
+     *
+     * @param id - Task ID to update
+     * @param input - Fields to update
+     * @returns Updated task or null if not found
+     */
+    async updateTask(id, input) {
+        this.ensureInitialized();
+        const existing = this.tasks.get(id);
+        if (!existing) {
+            return null;
+        }
+        const oldMilestone = existing.milestone;
+        const newMilestone = input.milestone === null
+            ? undefined
+            : input.milestone !== undefined
+                ? input.milestone
+                : oldMilestone;
+        // Build updated task
+        const now = new Date().toISOString().split("T")[0];
+        const updated = {
+            ...existing,
+            title: input.title ?? existing.title,
+            status: input.status ?? existing.status,
+            priority: input.priority ?? existing.priority,
+            milestone: newMilestone,
+            updatedDate: now,
+            description: input.description ?? existing.description,
+            implementationPlan: input.clearImplementationPlan
+                ? undefined
+                : (input.implementationPlan ?? existing.implementationPlan),
+            implementationNotes: input.clearImplementationNotes
+                ? undefined
+                : (input.implementationNotes ?? existing.implementationNotes),
+            ordinal: input.ordinal ?? existing.ordinal,
+            dependencies: input.dependencies ?? existing.dependencies,
+        };
+        // Handle label operations
+        if (input.labels) {
+            updated.labels = input.labels;
+        }
+        else {
+            if (input.addLabels) {
+                updated.labels = [...new Set([...updated.labels, ...input.addLabels])];
+            }
+            if (input.removeLabels) {
+                updated.labels = updated.labels.filter((l) => !input.removeLabels?.includes(l));
+            }
+        }
+        // Handle assignee
+        if (input.assignee) {
+            updated.assignee = input.assignee;
+        }
+        // Handle dependency operations
+        if (input.addDependencies) {
+            updated.dependencies = [...new Set([...updated.dependencies, ...input.addDependencies])];
+        }
+        if (input.removeDependencies) {
+            updated.dependencies = updated.dependencies.filter((d) => !input.removeDependencies?.includes(d));
+        }
+        // Handle acceptance criteria
+        if (input.acceptanceCriteria) {
+            updated.acceptanceCriteriaItems = input.acceptanceCriteria.map((ac, i) => ({
+                index: i + 1,
+                text: ac.text,
+                checked: ac.checked || false,
+            }));
+        }
+        // Serialize and write file
+        const content = serializeTaskMarkdown(updated);
+        // Delete old file if exists
+        if (existing.filePath) {
+            await this.fs.deleteFile(existing.filePath).catch(() => { });
+        }
+        // Write new file
+        const tasksDir = this.getTasksDir();
+        const safeTitle = updated.title
+            .replace(/[<>:"/\\|?*]/g, "")
+            .replace(/\s+/g, " ")
+            .slice(0, 50);
+        const filename = `${id} - ${safeTitle}.md`;
+        const filepath = this.fs.join(tasksDir, filename);
+        await this.fs.writeFile(filepath, content);
+        // Update in-memory cache
+        updated.filePath = filepath;
+        this.tasks.set(id, updated);
+        // Handle milestone sync
+        const milestoneChanged = milestoneKey(oldMilestone) !== milestoneKey(newMilestone);
+        if (milestoneChanged) {
+            // Remove from old milestone
+            if (oldMilestone) {
+                await this.removeTaskFromMilestone(id, oldMilestone);
+            }
+            // Add to new milestone
+            if (newMilestone) {
+                await this.addTaskToMilestone(id, newMilestone);
+            }
+        }
+        return updated;
+    }
+    /**
+     * Delete a task
+     *
+     * @param id - Task ID to delete
+     * @returns true if deleted, false if not found
+     */
+    async deleteTask(id) {
+        this.ensureInitialized();
+        const task = this.tasks.get(id);
+        if (!task) {
+            return false;
+        }
+        // Remove from milestone if assigned
+        if (task.milestone) {
+            await this.removeTaskFromMilestone(id, task.milestone);
+        }
+        // Delete file
+        if (task.filePath) {
+            try {
+                await this.fs.deleteFile(task.filePath);
+            }
+            catch {
+                // File may already be deleted
+            }
+        }
+        // Remove from in-memory cache
+        this.tasks.delete(id);
+        return true;
+    }
+    /**
+     * Archive a task (move from tasks/ to completed/)
+     *
+     * @param id - Task ID to archive
+     * @returns Archived task or null if not found or already archived
+     */
+    async archiveTask(id) {
+        this.ensureInitialized();
+        const task = this.tasks.get(id);
+        if (!task) {
+            return null;
+        }
+        // Check if already in completed
+        if (task.source === "completed") {
+            return null;
+        }
+        const completedDir = this.getCompletedDir();
+        // Ensure completed directory exists
+        await this.fs.createDir(completedDir, { recursive: true });
+        // Build new filepath in completed/
+        const safeTitle = task.title
+            .replace(/[<>:"/\\|?*]/g, "")
+            .replace(/\s+/g, " ")
+            .slice(0, 50);
+        const filename = `${id} - ${safeTitle}.md`;
+        const newFilepath = this.fs.join(completedDir, filename);
+        // Delete old file
+        if (task.filePath) {
+            try {
+                await this.fs.deleteFile(task.filePath);
+            }
+            catch {
+                // File may not exist
+            }
+        }
+        // Update task
+        const archived = {
+            ...task,
+            source: "completed",
+            filePath: newFilepath,
+        };
+        // Write to new location
+        const content = serializeTaskMarkdown(archived);
+        await this.fs.writeFile(newFilepath, content);
+        // Update in-memory cache
+        this.tasks.set(id, archived);
+        // Update task index if lazy initialized
+        if (this.lazyInitialized) {
+            const entry = this.taskIndex.get(id);
+            if (entry) {
+                entry.source = "completed";
+                entry.filePath = newFilepath;
+            }
+        }
+        return archived;
+    }
+    /**
+     * Restore a task (move from completed/ to tasks/)
+     *
+     * @param id - Task ID to restore
+     * @returns Restored task or null if not found or not archived
+     */
+    async restoreTask(id) {
+        this.ensureInitialized();
+        const task = this.tasks.get(id);
+        if (!task) {
+            return null;
+        }
+        // Check if in completed
+        if (task.source !== "completed") {
+            return null;
+        }
+        const tasksDir = this.getTasksDir();
+        // Ensure tasks directory exists
+        await this.fs.createDir(tasksDir, { recursive: true });
+        // Build new filepath in tasks/
+        const safeTitle = task.title
+            .replace(/[<>:"/\\|?*]/g, "")
+            .replace(/\s+/g, " ")
+            .slice(0, 50);
+        const filename = `${id} - ${safeTitle}.md`;
+        const newFilepath = this.fs.join(tasksDir, filename);
+        // Delete old file
+        if (task.filePath) {
+            try {
+                await this.fs.deleteFile(task.filePath);
+            }
+            catch {
+                // File may not exist
+            }
+        }
+        // Update task
+        const restored = {
+            ...task,
+            source: "local",
+            filePath: newFilepath,
+        };
+        // Write to new location
+        const content = serializeTaskMarkdown(restored);
+        await this.fs.writeFile(newFilepath, content);
+        // Update in-memory cache
+        this.tasks.set(id, restored);
+        // Update task index if lazy initialized
+        if (this.lazyInitialized) {
+            const entry = this.taskIndex.get(id);
+            if (entry) {
+                entry.source = "tasks";
+                entry.filePath = newFilepath;
+            }
+        }
+        return restored;
+    }
+    /**
+     * Load specific tasks by their IDs (for lazy loading milestone tasks)
+     *
+     * @param ids - Array of task IDs to load
+     * @returns Array of loaded tasks (missing tasks excluded)
+     */
+    async loadTasksByIds(ids) {
+        // If fully initialized, return from cache
+        if (this.initialized) {
+            return ids.map((id) => this.tasks.get(id)).filter((t) => t !== undefined);
+        }
+        // If lazy initialized, load on demand
+        if (this.lazyInitialized) {
+            return this.loadTasks(ids);
+        }
+        throw new Error("Core not initialized. Call initialize() or initializeLazy() first.");
+    }
 }
 //# sourceMappingURL=Core.js.map