@industry-theme/backlogmd-kanban-panel 1.0.3 → 1.0.5

package/dist/panels/KanbanPanel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KanbanPanel.d.ts","sourceRoot":"","sources":["../../src/panels/KanbanPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AAGrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AA4LpD;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAMrD,CAAC"}
+{"version":3,"file":"KanbanPanel.d.ts","sourceRoot":"","sources":["../../src/panels/KanbanPanel.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AAGrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AA6LpD;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,mBAAmB,CAMrD,CAAC"}

package/dist/panels/kanban/hooks/useKanbanData.d.ts

@@ -7,29 +7,39 @@ export interface ColumnState {
     hasMore: boolean;
     isLoadingMore: boolean;
 }
+/** Source column names (directory-based) */
+export type SourceColumn = 'tasks' | 'completed';
+/** Display labels for source columns */
+export declare const SOURCE_DISPLAY_LABELS: Record<SourceColumn, string>;
 export interface UseKanbanDataResult {
     tasks: Task[];
-    statuses: string[];
+    /** Source columns: "tasks" and "completed" */
+    sources: SourceColumn[];
     isLoading: boolean;
     error: string | null;
     isBacklogProject: boolean;
-    tasksByStatus: Map<string, Task[]>;
+    tasksBySource: Map<string, Task[]>;
     /** Per-column pagination state */
     columnStates: Map<string, ColumnState>;
-    /** Load more tasks for a specific status column */
-    loadMore: (status: string) => Promise<void>;
+    /** Load more tasks for a specific source column */
+    loadMore: (source: SourceColumn) => Promise<void>;
     refreshData: () => Promise<void>;
     updateTaskStatus: (taskId: string, newStatus: string) => Promise<void>;
 }
 interface UseKanbanDataOptions {
     context?: PanelContextValue;
     actions?: PanelActions;
-    /** Number of tasks to load per column (default: 10) */
-    pageSize?: number;
+    /** Number of active tasks to load (default: 20) */
+    tasksLimit?: number;
+    /** Number of completed tasks to load (default: 5) */
+    completedLimit?: number;
 }
 /**
- * Hook for managing kanban board data with pagination
- * Integrates with Backlog.md via @backlog-md/core
+ * Hook for managing kanban board data with lazy loading
+ *
+ * Uses 2-column view (Active/Completed) based on directory structure.
+ * Only loads task content for displayed items (no file reads on init).
+ * Completed tasks are sorted by ID descending (most recent first).
  */
 export declare function useKanbanData(options?: UseKanbanDataOptions): UseKanbanDataResult;
 export {};

package/dist/panels/kanban/hooks/useKanbanData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useKanbanData.d.ts","sourceRoot":"","sources":["../../../../src/panels/kanban/hooks/useKanbanData.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,IAAI,EAAwB,MAAM,kBAAkB,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEtE,kCAAkC;AAClC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IACnC,kCAAkC;IAClC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACvC,mDAAmD;IACnD,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxE;AAED,UAAU,oBAAoB;IAC5B,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,mBAAmB,CAmUrB"}
+{"version":3,"file":"useKanbanData.d.ts","sourceRoot":"","sources":["../../../../src/panels/kanban/hooks/useKanbanData.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,KAAK,IAAI,EAAwB,MAAM,kBAAkB,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEtE,kCAAkC;AAClC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,4CAA4C;AAC5C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,WAAW,CAAC;AAEjD,wCAAwC;AACxC,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAG9D,CAAC;AAEF,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,8CAA8C;IAC9C,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;IACnC,kCAAkC;IAClC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IACvC,mDAAmD;IACnD,QAAQ,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACjC,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxE;AAED,UAAU,oBAAoB;IAC5B,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,mDAAmD;IACnD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,CAAC,EAAE,oBAAoB,GAC7B,mBAAmB,CAoUrB"}

package/dist/panels.bundle.js

@@ -526,10 +526,32 @@ function extractIdFromPath(filePath) {
   }
   return filename.replace(/\.md$/, "");
 }
+function extractTitleFromPath(filePath) {
+  const filename = filePath.split("/").pop() || "";
+  const match = filename.match(/^(?:task-)?\d+(?:\.\d+)?\s*-\s*(.+)\.md$/);
+  if (match) {
+    return match[1].trim();
+  }
+  return filename.replace(/\.md$/, "");
+}
+function extractSourceFromPath(filePath) {
+  if (filePath.includes("/completed/") || filePath.includes("\\completed\\")) {
+    return "completed";
+  }
+  return "tasks";
+}
+function extractTaskIndexFromPath(filePath) {
+  return {
+    id: extractIdFromPath(filePath),
+    filePath,
+    title: extractTitleFromPath(filePath),
+    source: extractSourceFromPath(filePath)
+  };
+}
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-const DEFAULT_STATUSES$1 = ["To Do", "In Progress", "Done"];
+const DEFAULT_STATUSES = ["To Do", "In Progress", "Done"];
 function parseBacklogConfig(content) {
   const config = {};
   const lines = content.split("\n");
@@ -609,10 +631,10 @@ function parseBacklogConfig(content) {
   }
   return {
     projectName: config.projectName || "Backlog",
-    statuses: config.statuses || [...DEFAULT_STATUSES$1],
+    statuses: config.statuses || [...DEFAULT_STATUSES],
     labels: config.labels || [],
     milestones: config.milestones || [],
-    defaultStatus: config.defaultStatus || DEFAULT_STATUSES$1[0],
+    defaultStatus: config.defaultStatus || DEFAULT_STATUSES[0],
     dateFormat: config.dateFormat || "YYYY-MM-DD",
     defaultAssignee: config.defaultAssignee,
     defaultReporter: config.defaultReporter,
@@ -747,6 +769,9 @@ class Core {
     __publicField(this, "config", null);
     __publicField(this, "tasks", /* @__PURE__ */ new Map());
     __publicField(this, "initialized", false);
+    /** Lightweight task index for lazy loading (no file reads) */
+    __publicField(this, "taskIndex", /* @__PURE__ */ new Map());
+    __publicField(this, "lazyInitialized", false);
     this.projectRoot = options.projectRoot;
     this.fs = options.adapters.fs;
   }
@@ -828,6 +853,181 @@ class Core {
     }
     this.initialized = true;
   }
+  /**
+   * Initialize with lazy loading (no file content reads)
+   *
+   * Only loads config and builds task index from file paths.
+   * Task content is loaded on-demand via loadTask().
+   * Use this for web/panel contexts where file reads are expensive.
+   *
+   * @param filePaths - Array of all file paths in the project
+   */
+  async initializeLazy(filePaths) {
+    if (this.lazyInitialized)
+      return;
+    const configPath = this.fs.join(this.projectRoot, "backlog", "config.yml");
+    const configExists = await this.fs.exists(configPath);
+    if (!configExists) {
+      throw new Error(`Not a Backlog.md project: config.yml not found at ${configPath}`);
+    }
+    const configContent = await this.fs.readFile(configPath);
+    this.config = parseBacklogConfig(configContent);
+    this.taskIndex.clear();
+    for (const filePath of filePaths) {
+      if (!filePath.endsWith(".md"))
+        continue;
+      const isTaskFile = filePath.includes("backlog/tasks/") || filePath.includes("backlog\\tasks\\");
+      const isCompletedFile = filePath.includes("backlog/completed/") || filePath.includes("backlog\\completed\\");
+      if (!isTaskFile && !isCompletedFile)
+        continue;
+      if (filePath.endsWith("config.yml"))
+        continue;
+      const indexEntry = extractTaskIndexFromPath(filePath);
+      this.taskIndex.set(indexEntry.id, indexEntry);
+    }
+    this.lazyInitialized = true;
+  }
+  /**
+   * Check if lazy initialization is complete
+   */
+  isLazyInitialized() {
+    return this.lazyInitialized;
+  }
+  /**
+   * Get the task index (lightweight entries)
+   */
+  getTaskIndex() {
+    if (!this.lazyInitialized) {
+      throw new Error("Core not lazy initialized. Call initializeLazy() first.");
+    }
+    return this.taskIndex;
+  }
+  /**
+   * Load a single task by ID (on-demand loading)
+   *
+   * @param id - Task ID
+   * @returns Task or undefined if not found
+   */
+  async loadTask(id) {
+    if (this.tasks.has(id)) {
+      return this.tasks.get(id);
+    }
+    const indexEntry = this.taskIndex.get(id);
+    if (!indexEntry) {
+      return void 0;
+    }
+    try {
+      const content = await this.fs.readFile(indexEntry.filePath);
+      const task = parseTaskMarkdown(content, indexEntry.filePath);
+      task.source = indexEntry.source === "completed" ? "completed" : "local";
+      this.tasks.set(task.id, task);
+      return task;
+    } catch (error) {
+      console.warn(`Failed to load task ${id} from ${indexEntry.filePath}:`, error);
+      return void 0;
+    }
+  }
+  /**
+   * Load multiple tasks by ID (on-demand loading)
+   *
+   * @param ids - Array of task IDs to load
+   * @returns Array of loaded tasks (undefined entries filtered out)
+   */
+  async loadTasks(ids) {
+    const tasks = await Promise.all(ids.map((id) => this.loadTask(id)));
+    return tasks.filter((t) => t !== void 0);
+  }
+  /**
+   * Get tasks by source (tasks/completed) with pagination
+   *
+   * This is a lazy-loading alternative to getTasksByStatusPaginated().
+   * Groups by directory (tasks/ or completed/) instead of status.
+   * Only loads task content for items in the requested page.
+   *
+   * @param options - Per-source pagination options
+   * @returns Paginated tasks grouped by source
+   */
+  async getTasksBySourcePaginated(options) {
+    if (!this.lazyInitialized) {
+      throw new Error("Core not lazy initialized. Call initializeLazy() first.");
+    }
+    const tasksLimit = (options == null ? void 0 : options.tasksLimit) ?? 10;
+    const completedLimit = (options == null ? void 0 : options.completedLimit) ?? 10;
+    const offset = (options == null ? void 0 : options.offset) ?? 0;
+    const tasksSortDirection = (options == null ? void 0 : options.tasksSortDirection) ?? "asc";
+    const completedSortByIdDesc = (options == null ? void 0 : options.completedSortByIdDesc) ?? true;
+    const sources = ["tasks", "completed"];
+    const bySource = /* @__PURE__ */ new Map();
+    for (const source of sources) {
+      let entries = Array.from(this.taskIndex.values()).filter((e) => e.source === source);
+      const limit = source === "tasks" ? tasksLimit : completedLimit;
+      if (source === "completed" && completedSortByIdDesc) {
+        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;
+          return bNum - aNum;
+        });
+      } else {
+        entries = entries.sort((a, b) => {
+          const cmp = a.title.localeCompare(b.title);
+          return tasksSortDirection === "asc" ? cmp : -cmp;
+        });
+      }
+      const total = entries.length;
+      const pageEntries = entries.slice(offset, offset + limit);
+      const items = await this.loadTasks(pageEntries.map((e) => e.id));
+      bySource.set(source, {
+        items,
+        total,
+        hasMore: offset + limit < total,
+        offset,
+        limit
+      });
+    }
+    return {
+      bySource,
+      sources
+    };
+  }
+  /**
+   * Load more tasks for a specific source (lazy loading)
+   *
+   * @param source - Source to load more from ("tasks" or "completed")
+   * @param currentOffset - Current offset (items already loaded)
+   * @param options - Pagination options
+   * @returns Paginated result for the source
+   */
+  async loadMoreForSource(source, currentOffset, options) {
+    if (!this.lazyInitialized) {
+      throw new Error("Core not lazy initialized. Call initializeLazy() first.");
+    }
+    const limit = (options == null ? void 0 : options.limit) ?? 10;
+    const sortDirection = (options == null ? void 0 : options.sortDirection) ?? "asc";
+    const completedSortByIdDesc = (options == null ? void 0 : options.completedSortByIdDesc) ?? true;
+    let entries = Array.from(this.taskIndex.values()).filter((e) => e.source === source);
+    if (source === "completed" && completedSortByIdDesc) {
+      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;
+        return bNum - aNum;
+      });
+    } else {
+      entries = entries.sort((a, b) => {
+        const cmp = a.title.localeCompare(b.title);
+        return sortDirection === "asc" ? cmp : -cmp;
+      });
+    }
+    const total = entries.length;
+    const pageEntries = entries.slice(currentOffset, currentOffset + limit);
+    const items = await this.loadTasks(pageEntries.map((e) => e.id));
+    return {
+      items,
+      total,
+      hasMore: currentOffset + limit < total,
+      offset: currentOffset,
+      limit
+    };
+  }
   /**
    * Get the loaded configuration
    *
@@ -1155,16 +1355,26 @@ class PanelFileSystemAdapter {
     return path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\/+/g, "/");
   }
 }
-const DEFAULT_STATUSES = ["To Do", "In Progress", "Done"];
-const DEFAULT_PAGE_SIZE = 10;
+const SOURCE_DISPLAY_LABELS = {
+  tasks: "Active",
+  completed: "Completed"
+};
+const DEFAULT_SOURCES = ["tasks", "completed"];
+const DEFAULT_TASKS_LIMIT = 20;
+const DEFAULT_COMPLETED_LIMIT = 5;
 function useKanbanData(options) {
-  const { context, actions, pageSize = DEFAULT_PAGE_SIZE } = options || {};
+  const {
+    context,
+    actions,
+    tasksLimit = DEFAULT_TASKS_LIMIT,
+    completedLimit = DEFAULT_COMPLETED_LIMIT
+  } = options || {};
   const [tasks, setTasks] = useState([]);
-  const [statuses, setStatuses] = useState(DEFAULT_STATUSES);
+  const [sources] = useState(DEFAULT_SOURCES);
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState(null);
   const [isBacklogProject, setIsBacklogProject] = useState(false);
-  const [tasksByStatus, setTasksByStatus] = useState(
+  const [tasksBySource, setTasksBySource] = useState(
     /* @__PURE__ */ new Map()
   );
   const [columnStates, setColumnStates] = useState(
@@ -1213,8 +1423,7 @@ function useKanbanData(options) {
       console.log("[useKanbanData] No context provided");
       setIsBacklogProject(false);
       setTasks([]);
-      setStatuses(DEFAULT_STATUSES);
-      setTasksByStatus(/* @__PURE__ */ new Map());
+      setTasksBySource(/* @__PURE__ */ new Map());
       setColumnStates(/* @__PURE__ */ new Map());
       setIsLoading(false);
       coreRef.current = null;
@@ -1228,8 +1437,7 @@ function useKanbanData(options) {
         console.log("[useKanbanData] FileTree not available");
         setIsBacklogProject(false);
         setTasks([]);
-        setStatuses(DEFAULT_STATUSES);
-        setTasksByStatus(/* @__PURE__ */ new Map());
+        setTasksBySource(/* @__PURE__ */ new Map());
         setColumnStates(/* @__PURE__ */ new Map());
         coreRef.current = null;
         return;
@@ -1249,31 +1457,30 @@ function useKanbanData(options) {
         console.log("[useKanbanData] Not a Backlog.md project");
         setIsBacklogProject(false);
         setTasks([]);
-        setStatuses(DEFAULT_STATUSES);
-        setTasksByStatus(/* @__PURE__ */ new Map());
+        setTasksBySource(/* @__PURE__ */ new Map());
         setColumnStates(/* @__PURE__ */ new Map());
         coreRef.current = null;
         return;
       }
-      console.log("[useKanbanData] Loading Backlog.md data with pagination...");
+      console.log("[useKanbanData] Loading Backlog.md data with lazy loading...");
       setIsBacklogProject(true);
-      await core.initialize();
+      await core.initializeLazy(filePaths);
       coreRef.current = core;
-      const config = core.getConfig();
-      const paginatedResult = core.getTasksByStatusPaginated({
-        limit: pageSize,
+      const paginatedResult = await core.getTasksBySourcePaginated({
+        tasksLimit,
+        completedLimit,
         offset: 0,
-        sortBy: "title",
-        sortDirection: "asc"
+        tasksSortDirection: "asc",
+        completedSortByIdDesc: true
       });
-      const newTasksByStatus = /* @__PURE__ */ new Map();
+      const newTasksBySource = /* @__PURE__ */ new Map();
       const newColumnStates = /* @__PURE__ */ new Map();
       let allTasks = [];
-      for (const status of paginatedResult.statuses) {
-        const columnResult = paginatedResult.byStatus.get(status);
+      for (const source of paginatedResult.sources) {
+        const columnResult = paginatedResult.bySource.get(source);
         if (columnResult) {
-          newTasksByStatus.set(status, columnResult.items);
-          newColumnStates.set(status, {
+          newTasksBySource.set(source, columnResult.items);
+          newColumnStates.set(source, {
             tasks: columnResult.items,
             total: columnResult.total,
             hasMore: columnResult.hasMore,
@@ -1281,8 +1488,8 @@ function useKanbanData(options) {
           });
           allTasks = allTasks.concat(columnResult.items);
         } else {
-          newTasksByStatus.set(status, []);
-          newColumnStates.set(status, {
+          newTasksBySource.set(source, []);
+          newColumnStates.set(source, {
             tasks: [],
             total: 0,
             hasMore: false,
@@ -1290,72 +1497,71 @@ function useKanbanData(options) {
           });
         }
       }
-      const totalTasks = Array.from(paginatedResult.byStatus.values()).reduce(
+      const totalTasks = Array.from(paginatedResult.bySource.values()).reduce(
         (sum, col) => sum + col.total,
         0
       );
       console.log(
-        `[useKanbanData] Loaded ${allTasks.length}/${totalTasks} tasks with ${config.statuses.length} statuses (page size: ${pageSize})`
+        `[useKanbanData] Loaded ${allTasks.length}/${totalTasks} tasks (active: ${tasksLimit}, completed: ${completedLimit})`
       );
-      setStatuses(config.statuses);
       setTasks(allTasks);
-      setTasksByStatus(newTasksByStatus);
+      setTasksBySource(newTasksBySource);
       setColumnStates(newColumnStates);
     } catch (err) {
       console.error("[useKanbanData] Failed to load Backlog.md data:", err);
       setError(err instanceof Error ? err.message : "Failed to load backlog data");
       setIsBacklogProject(false);
       setTasks([]);
-      setStatuses(DEFAULT_STATUSES);
-      setTasksByStatus(/* @__PURE__ */ new Map());
+      setTasksBySource(/* @__PURE__ */ new Map());
       setColumnStates(/* @__PURE__ */ new Map());
       coreRef.current = null;
     } finally {
       setIsLoading(false);
     }
-  }, [context, actions, fetchFileContent, pageSize]);
+  }, [context, actions, fetchFileContent, tasksLimit, completedLimit]);
   useEffect(() => {
     loadBacklogData();
   }, [loadBacklogData]);
   const loadMore = useCallback(
-    async (status) => {
+    async (source) => {
       const core = coreRef.current;
       if (!core) {
         console.warn("[useKanbanData] Core not available for loadMore");
         return;
       }
-      const currentState = columnStates.get(status);
+      const currentState = columnStates.get(source);
       if (!currentState || !currentState.hasMore || currentState.isLoadingMore) {
         return;
       }
       setColumnStates((prev) => {
         const newStates = new Map(prev);
-        const state = newStates.get(status);
+        const state = newStates.get(source);
         if (state) {
-          newStates.set(status, { ...state, isLoadingMore: true });
+          newStates.set(source, { ...state, isLoadingMore: true });
         }
         return newStates;
       });
       try {
         const currentOffset = currentState.tasks.length;
-        const result = core.loadMoreForStatus(
-          status,
+        const limit = source === "tasks" ? tasksLimit : completedLimit;
+        const result = await core.loadMoreForSource(
+          source,
           currentOffset,
           {
-            limit: pageSize,
-            sortBy: "title",
-            sortDirection: "asc"
+            limit,
+            sortDirection: "asc",
+            completedSortByIdDesc: source === "completed"
           }
         );
         console.log(
-          `[useKanbanData] Loaded ${result.items.length} more tasks for "${status}" (${currentOffset + result.items.length}/${result.total})`
+          `[useKanbanData] Loaded ${result.items.length} more tasks for "${source}" (${currentOffset + result.items.length}/${result.total})`
         );
         setColumnStates((prev) => {
           const newStates = new Map(prev);
-          const state = newStates.get(status);
+          const state = newStates.get(source);
           if (state) {
             const newTasks = [...state.tasks, ...result.items];
-            newStates.set(status, {
+            newStates.set(source, {
               tasks: newTasks,
               total: result.total,
               hasMore: result.hasMore,
@@ -1364,27 +1570,27 @@ function useKanbanData(options) {
           }
           return newStates;
         });
-        setTasksByStatus((prev) => {
+        setTasksBySource((prev) => {
           const newMap = new Map(prev);
-          const currentTasks = newMap.get(status) || [];
-          newMap.set(status, [...currentTasks, ...result.items]);
+          const currentTasks = newMap.get(source) || [];
+          newMap.set(source, [...currentTasks, ...result.items]);
           return newMap;
         });
         setTasks((prev) => [...prev, ...result.items]);
       } catch (err) {
-        console.error(`[useKanbanData] Failed to load more for "${status}":`, err);
+        console.error(`[useKanbanData] Failed to load more for "${source}":`, err);
         setError(err instanceof Error ? err.message : "Failed to load more tasks");
         setColumnStates((prev) => {
           const newStates = new Map(prev);
-          const state = newStates.get(status);
+          const state = newStates.get(source);
           if (state) {
-            newStates.set(status, { ...state, isLoadingMore: false });
+            newStates.set(source, { ...state, isLoadingMore: false });
           }
           return newStates;
         });
       }
     },
-    [columnStates, pageSize]
+    [columnStates, tasksLimit, completedLimit]
   );
   const refreshData = useCallback(async () => {
     await loadBacklogData();
@@ -1401,11 +1607,11 @@ function useKanbanData(options) {
   );
   return {
     tasks,
-    statuses,
+    sources,
     isLoading,
     error,
     isBacklogProject,
-    tasksByStatus,
+    tasksBySource,
     columnStates,
     loadMore,
     refreshData,
@@ -1944,10 +2150,11 @@ const KanbanPanelContent = ({
   var _a, _b;
   const { theme: theme2 } = useTheme();
   const [_selectedTask, setSelectedTask] = useState(null);
-  const { statuses, tasksByStatus, columnStates, loadMore, error, isBacklogProject, refreshData } = useKanbanData({
+  const { sources, tasksBySource, columnStates, loadMore, error, isBacklogProject, refreshData } = useKanbanData({
     context,
     actions,
-    pageSize: 10
+    tasksLimit: 20,
+    completedLimit: 5
   });
   const handleTaskClick = (task) => {
     setSelectedTask(task);
@@ -2091,21 +2298,21 @@ const KanbanPanelContent = ({
               WebkitOverflowScrolling: "touch"
               // Smooth scrolling on iOS
             },
-            children: statuses.map((status) => {
-              const columnTasks = tasksByStatus.get(status) || [];
-              const columnState = columnStates.get(status);
+            children: sources.map((source) => {
+              const columnTasks = tasksBySource.get(source) || [];
+              const columnState = columnStates.get(source);
               return /* @__PURE__ */ jsx(
                 KanbanColumn,
                 {
-                  status,
+                  status: SOURCE_DISPLAY_LABELS[source],
                   tasks: columnTasks,
                   total: columnState == null ? void 0 : columnState.total,
                   hasMore: columnState == null ? void 0 : columnState.hasMore,
                   isLoadingMore: columnState == null ? void 0 : columnState.isLoadingMore,
-                  onLoadMore: () => loadMore(status),
+                  onLoadMore: () => loadMore(source),
                   onTaskClick: handleTaskClick
                 },
-                status
+                source
               );
             })
           }