kanban-lite 1.0.9 → 1.0.13

package/dist/cli.js

@@ -267,9 +267,17 @@ function extractNumericId(filenameOrId) {
   const match = filenameOrId.match(/^(\d+)(?:-|$)/);
   return match ? parseInt(match[1], 10) : null;
 }
+var DEFAULT_COLUMNS;
 var init_types = __esm({
   "src/shared/types.ts"() {
     "use strict";
+    DEFAULT_COLUMNS = [
+      { id: "backlog", name: "Backlog", color: "#6b7280" },
+      { id: "todo", name: "To Do", color: "#3b82f6" },
+      { id: "in-progress", name: "In Progress", color: "#f59e0b" },
+      { id: "review", name: "Review", color: "#8b5cf6" },
+      { id: "done", name: "Done", color: "#22c55e" }
+    ];
   }
 });
 
@@ -277,12 +285,65 @@ var init_types = __esm({
 function configPath(workspaceRoot) {
   return path.join(workspaceRoot, CONFIG_FILENAME);
 }
+function migrateConfigV1ToV2(raw) {
+  const v1Defaults = {
+    featuresDirectory: ".kanban",
+    defaultPriority: "medium",
+    defaultStatus: "backlog",
+    columns: [...DEFAULT_COLUMNS],
+    aiAgent: "claude",
+    nextCardId: 1,
+    showPriorityBadges: true,
+    showAssignee: true,
+    showDueDate: true,
+    showLabels: true,
+    showBuildWithAI: true,
+    showFileName: false,
+    compactMode: false,
+    markdownEditorMode: false
+  };
+  const v1 = { ...v1Defaults, ...raw };
+  return {
+    version: 2,
+    boards: {
+      default: {
+        name: "Default",
+        columns: v1.columns,
+        nextCardId: v1.nextCardId,
+        defaultStatus: v1.defaultStatus,
+        defaultPriority: v1.defaultPriority
+      }
+    },
+    defaultBoard: "default",
+    featuresDirectory: v1.featuresDirectory,
+    aiAgent: v1.aiAgent,
+    defaultPriority: v1.defaultPriority,
+    defaultStatus: v1.defaultStatus,
+    showPriorityBadges: v1.showPriorityBadges,
+    showAssignee: v1.showAssignee,
+    showDueDate: v1.showDueDate,
+    showLabels: v1.showLabels,
+    showBuildWithAI: v1.showBuildWithAI,
+    showFileName: v1.showFileName,
+    compactMode: v1.compactMode,
+    markdownEditorMode: v1.markdownEditorMode
+  };
+}
 function readConfig(workspaceRoot) {
   const filePath = configPath(workspaceRoot);
-  const defaults = { ...DEFAULT_CONFIG, columns: [...DEFAULT_CONFIG.columns] };
+  const defaults = { ...DEFAULT_CONFIG, boards: { default: { ...DEFAULT_BOARD_CONFIG, columns: [...DEFAULT_COLUMNS] } } };
   try {
     const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-    return { ...defaults, ...raw };
+    if (!raw.version || raw.version === 1) {
+      const v2 = migrateConfigV1ToV2(raw);
+      writeConfig(workspaceRoot, v2);
+      return v2;
+    }
+    const config = { ...defaults, ...raw };
+    if (!config.boards || Object.keys(config.boards).length === 0) {
+      config.boards = defaults.boards;
+    }
+    return config;
   } catch {
     return defaults;
   }
@@ -291,19 +352,39 @@ function writeConfig(workspaceRoot, config) {
   const filePath = configPath(workspaceRoot);
   fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
-function allocateCardId(workspaceRoot) {
+function getBoardConfig(workspaceRoot, boardId) {
   const config = readConfig(workspaceRoot);
-  const id = config.nextCardId;
-  writeConfig(workspaceRoot, { ...config, nextCardId: id + 1 });
+  const resolvedId = boardId || config.defaultBoard;
+  const board = config.boards[resolvedId];
+  if (!board) {
+    throw new Error(`Board '${resolvedId}' not found`);
+  }
+  return board;
+}
+function allocateCardId(workspaceRoot, boardId) {
+  const config = readConfig(workspaceRoot);
+  const resolvedId = boardId || config.defaultBoard;
+  const board = config.boards[resolvedId];
+  if (!board) {
+    throw new Error(`Board '${resolvedId}' not found`);
+  }
+  const id = board.nextCardId;
+  board.nextCardId = id + 1;
+  writeConfig(workspaceRoot, config);
   return id;
 }
-function syncCardIdCounter(workspaceRoot, existingIds) {
+function syncCardIdCounter(workspaceRoot, boardId, existingIds) {
   if (existingIds.length === 0)
     return;
   const maxId = Math.max(...existingIds);
   const config = readConfig(workspaceRoot);
-  if (config.nextCardId <= maxId) {
-    writeConfig(workspaceRoot, { ...config, nextCardId: maxId + 1 });
+  const resolvedId = boardId || config.defaultBoard;
+  const board = config.boards[resolvedId];
+  if (!board)
+    return;
+  if (board.nextCardId <= maxId) {
+    board.nextCardId = maxId + 1;
+    writeConfig(workspaceRoot, config);
   }
 }
 function configToSettings(config) {
@@ -333,25 +414,30 @@ function settingsToConfig(config, settings) {
     defaultStatus: settings.defaultStatus
   };
 }
-var fs, path, DEFAULT_CONFIG, CONFIG_FILENAME;
+var fs, path, DEFAULT_BOARD_CONFIG, DEFAULT_CONFIG, CONFIG_FILENAME;
 var init_config = __esm({
   "src/shared/config.ts"() {
     "use strict";
     fs = __toESM(require("fs"));
     path = __toESM(require("path"));
+    init_types();
+    DEFAULT_BOARD_CONFIG = {
+      name: "Default",
+      columns: [...DEFAULT_COLUMNS],
+      nextCardId: 1,
+      defaultStatus: "backlog",
+      defaultPriority: "medium"
+    };
     DEFAULT_CONFIG = {
+      version: 2,
+      boards: {
+        default: { ...DEFAULT_BOARD_CONFIG, columns: [...DEFAULT_COLUMNS] }
+      },
+      defaultBoard: "default",
       featuresDirectory: ".kanban",
+      aiAgent: "claude",
       defaultPriority: "medium",
       defaultStatus: "backlog",
-      columns: [
-        { id: "backlog", name: "Backlog", color: "#6b7280" },
-        { id: "todo", name: "To Do", color: "#3b82f6" },
-        { id: "in-progress", name: "In Progress", color: "#f59e0b" },
-        { id: "review", name: "Review", color: "#8b5cf6" },
-        { id: "done", name: "Done", color: "#22c55e" }
-      ],
-      aiAgent: "claude",
-      nextCardId: 1,
       showPriorityBadges: true,
       showAssignee: true,
       showDueDate: true,
@@ -564,41 +650,221 @@ var init_fileUtils = __esm({
   }
 });
 
+// src/sdk/migration.ts
+async function migrateFileSystemToMultiBoard(featuresDir) {
+  const boardsDir = path4.join(featuresDir, "boards");
+  const defaultBoardDir = path4.join(boardsDir, "default");
+  try {
+    await fs3.access(boardsDir);
+    return;
+  } catch {
+  }
+  await fs3.mkdir(defaultBoardDir, { recursive: true });
+  let entries;
+  try {
+    entries = await fs3.readdir(featuresDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    if (entry.name === "boards" || entry.name.startsWith("."))
+      continue;
+    const src = path4.join(featuresDir, entry.name);
+    const dest = path4.join(defaultBoardDir, entry.name);
+    await fs3.rename(src, dest);
+  }
+  const rootMdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md"));
+  if (rootMdFiles.length > 0) {
+    const backlogDir = path4.join(defaultBoardDir, "backlog");
+    await fs3.mkdir(backlogDir, { recursive: true });
+    for (const file of rootMdFiles) {
+      await fs3.rename(
+        path4.join(featuresDir, file.name),
+        path4.join(backlogDir, file.name)
+      );
+    }
+  }
+}
+var fs3, path4;
+var init_migration = __esm({
+  "src/sdk/migration.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs/promises"));
+    path4 = __toESM(require("path"));
+  }
+});
+
 // src/sdk/KanbanSDK.ts
-var fs3, path4, KanbanSDK;
+var fs4, path5, KanbanSDK;
 var init_KanbanSDK = __esm({
   "src/sdk/KanbanSDK.ts"() {
     "use strict";
-    fs3 = __toESM(require("fs/promises"));
-    path4 = __toESM(require("path"));
+    fs4 = __toESM(require("fs/promises"));
+    path5 = __toESM(require("path"));
     init_src();
     init_types();
     init_config();
     init_parser();
     init_fileUtils();
+    init_migration();
     KanbanSDK = class {
       constructor(featuresDir) {
         this.featuresDir = featuresDir;
+        this._migrated = false;
       }
       get workspaceRoot() {
-        return path4.dirname(this.featuresDir);
+        return path5.dirname(this.featuresDir);
+      }
+      // --- Board resolution helpers ---
+      _resolveBoardId(boardId) {
+        const config = readConfig(this.workspaceRoot);
+        return boardId || config.defaultBoard;
+      }
+      _boardDir(boardId) {
+        const resolvedId = this._resolveBoardId(boardId);
+        return path5.join(this.featuresDir, "boards", resolvedId);
+      }
+      _isCompletedStatus(status, boardId) {
+        const config = readConfig(this.workspaceRoot);
+        const resolvedId = boardId || config.defaultBoard;
+        const board = config.boards[resolvedId];
+        if (!board || board.columns.length === 0)
+          return status === "done";
+        return board.columns[board.columns.length - 1].id === status;
+      }
+      async _ensureMigrated() {
+        if (this._migrated)
+          return;
+        await migrateFileSystemToMultiBoard(this.featuresDir);
+        this._migrated = true;
       }
       async init() {
-        await ensureDirectories(this.featuresDir);
+        await this._ensureMigrated();
+        const boardDir = this._boardDir();
+        await ensureDirectories(boardDir);
+      }
+      // --- Board management ---
+      listBoards() {
+        const config = readConfig(this.workspaceRoot);
+        return Object.entries(config.boards).map(([id, board]) => ({
+          id,
+          name: board.name,
+          description: board.description
+        }));
+      }
+      createBoard(id, name, options) {
+        const config = readConfig(this.workspaceRoot);
+        if (config.boards[id]) {
+          throw new Error(`Board already exists: ${id}`);
+        }
+        const columns = options?.columns || [...config.boards[config.defaultBoard]?.columns || [
+          { id: "backlog", name: "Backlog", color: "#6b7280" },
+          { id: "todo", name: "To Do", color: "#3b82f6" },
+          { id: "in-progress", name: "In Progress", color: "#f59e0b" },
+          { id: "review", name: "Review", color: "#8b5cf6" },
+          { id: "done", name: "Done", color: "#22c55e" }
+        ]];
+        config.boards[id] = {
+          name,
+          description: options?.description,
+          columns,
+          nextCardId: 1,
+          defaultStatus: options?.defaultStatus || columns[0]?.id || "backlog",
+          defaultPriority: options?.defaultPriority || config.defaultPriority
+        };
+        writeConfig(this.workspaceRoot, config);
+        return { id, name, description: options?.description };
+      }
+      async deleteBoard(boardId) {
+        const config = readConfig(this.workspaceRoot);
+        if (!config.boards[boardId]) {
+          throw new Error(`Board not found: ${boardId}`);
+        }
+        if (config.defaultBoard === boardId) {
+          throw new Error(`Cannot delete the default board: ${boardId}`);
+        }
+        const cards = await this.listCards(void 0, boardId);
+        if (cards.length > 0) {
+          throw new Error(`Cannot delete board "${boardId}": ${cards.length} card(s) still exist`);
+        }
+        const boardDir = this._boardDir(boardId);
+        try {
+          await fs4.rm(boardDir, { recursive: true });
+        } catch {
+        }
+        delete config.boards[boardId];
+        writeConfig(this.workspaceRoot, config);
+      }
+      getBoard(boardId) {
+        return getBoardConfig(this.workspaceRoot, boardId);
+      }
+      updateBoard(boardId, updates) {
+        const config = readConfig(this.workspaceRoot);
+        const board = config.boards[boardId];
+        if (!board) {
+          throw new Error(`Board not found: ${boardId}`);
+        }
+        if (updates.name !== void 0)
+          board.name = updates.name;
+        if (updates.description !== void 0)
+          board.description = updates.description;
+        if (updates.columns !== void 0)
+          board.columns = updates.columns;
+        if (updates.defaultStatus !== void 0)
+          board.defaultStatus = updates.defaultStatus;
+        if (updates.defaultPriority !== void 0)
+          board.defaultPriority = updates.defaultPriority;
+        writeConfig(this.workspaceRoot, config);
+        return board;
+      }
+      async transferCard(cardId, fromBoardId, toBoardId, targetStatus) {
+        const toBoardDir = this._boardDir(toBoardId);
+        const config = readConfig(this.workspaceRoot);
+        if (!config.boards[fromBoardId])
+          throw new Error(`Board not found: ${fromBoardId}`);
+        if (!config.boards[toBoardId])
+          throw new Error(`Board not found: ${toBoardId}`);
+        const card = await this.getCard(cardId, fromBoardId);
+        if (!card)
+          throw new Error(`Card not found: ${cardId} in board ${fromBoardId}`);
+        const toBoard = config.boards[toBoardId];
+        const newStatus = targetStatus || toBoard.defaultStatus || toBoard.columns[0]?.id || "backlog";
+        const targetDir = path5.join(toBoardDir, newStatus);
+        await fs4.mkdir(targetDir, { recursive: true });
+        const oldPath = card.filePath;
+        const filename = path5.basename(oldPath);
+        const newPath = path5.join(targetDir, filename);
+        await fs4.rename(oldPath, newPath);
+        card.status = newStatus;
+        card.boardId = toBoardId;
+        card.filePath = newPath;
+        card.modified = (/* @__PURE__ */ new Date()).toISOString();
+        card.completedAt = this._isCompletedStatus(newStatus, toBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
+        const targetCards = await this.listCards(void 0, toBoardId);
+        const cardsInStatus = targetCards.filter((c) => c.status === newStatus && c.id !== cardId).sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
+        const lastOrder = cardsInStatus.length > 0 ? cardsInStatus[cardsInStatus.length - 1].order : null;
+        card.order = generateKeyBetween(lastOrder, null);
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        return card;
       }
       // --- Card CRUD ---
-      async listCards(columns) {
-        await ensureDirectories(this.featuresDir);
+      async listCards(columns, boardId) {
+        await this._ensureMigrated();
+        const boardDir = this._boardDir(boardId);
+        const resolvedBoardId = this._resolveBoardId(boardId);
+        await ensureDirectories(boardDir);
         if (columns) {
-          await ensureStatusSubfolders(this.featuresDir, columns);
+          await ensureStatusSubfolders(boardDir, columns);
         }
         try {
-          const rootFiles = await this._readMdFiles(this.featuresDir);
+          const rootFiles = await this._readMdFiles(boardDir);
           for (const filePath of rootFiles) {
             try {
               const card = await this._loadCard(filePath);
               if (card) {
-                await moveFeatureFile(filePath, this.featuresDir, card.status, card.attachments);
+                await moveFeatureFile(filePath, boardDir, card.status, card.attachments);
               }
             } catch {
             }
@@ -606,26 +872,33 @@ var init_KanbanSDK = __esm({
         } catch {
         }
         const cards = [];
-        const entries = await fs3.readdir(this.featuresDir, { withFileTypes: true });
+        let entries;
+        try {
+          entries = await fs4.readdir(boardDir, { withFileTypes: true });
+        } catch {
+          return [];
+        }
         for (const entry of entries) {
           if (!entry.isDirectory() || entry.name.startsWith("."))
             continue;
-          const subdir = path4.join(this.featuresDir, entry.name);
+          const subdir = path5.join(boardDir, entry.name);
           try {
             const mdFiles = await this._readMdFiles(subdir);
             for (const filePath of mdFiles) {
               const card = await this._loadCard(filePath);
-              if (card)
+              if (card) {
+                card.boardId = resolvedBoardId;
                 cards.push(card);
+              }
             }
           } catch {
           }
         }
         for (const card of cards) {
-          const pathStatus = getStatusFromPath(card.filePath, this.featuresDir);
+          const pathStatus = getStatusFromPath(card.filePath, boardDir);
           if (pathStatus !== null && pathStatus !== card.status) {
             try {
-              card.filePath = await moveFeatureFile(card.filePath, this.featuresDir, card.status, card.attachments);
+              card.filePath = await moveFeatureFile(card.filePath, boardDir, card.status, card.attachments);
             } catch {
             }
           }
@@ -643,65 +916,72 @@ var init_KanbanSDK = __esm({
             const keys = generateNKeysBetween(null, null, columnCards.length);
             for (let i = 0; i < columnCards.length; i++) {
               columnCards[i].order = keys[i];
-              await fs3.writeFile(columnCards[i].filePath, serializeFeature(columnCards[i]), "utf-8");
+              await fs4.writeFile(columnCards[i].filePath, serializeFeature(columnCards[i]), "utf-8");
             }
           }
         }
         const numericIds = cards.map((c) => parseInt(c.id, 10)).filter((n) => !Number.isNaN(n));
         if (numericIds.length > 0) {
-          syncCardIdCounter(path4.dirname(this.featuresDir), numericIds);
+          syncCardIdCounter(this.workspaceRoot, resolvedBoardId, numericIds);
         }
         return cards.sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
       }
-      async getCard(cardId) {
-        const cards = await this.listCards();
+      async getCard(cardId, boardId) {
+        const cards = await this.listCards(void 0, boardId);
         return cards.find((c) => c.id === cardId) || null;
       }
       async createCard(data) {
-        await ensureDirectories(this.featuresDir);
-        const status = data.status || "backlog";
-        const priority = data.priority || "medium";
+        await this._ensureMigrated();
+        const resolvedBoardId = this._resolveBoardId(data.boardId);
+        const boardDir = this._boardDir(resolvedBoardId);
+        await ensureDirectories(boardDir);
+        const config = readConfig(this.workspaceRoot);
+        const board = config.boards[resolvedBoardId];
+        const status = data.status || board?.defaultStatus || config.defaultStatus || "backlog";
+        const priority = data.priority || board?.defaultPriority || config.defaultPriority || "medium";
         const title = getTitleFromContent(data.content);
-        const workspaceRoot = path4.dirname(this.featuresDir);
-        const numericId = allocateCardId(workspaceRoot);
+        const numericId = allocateCardId(this.workspaceRoot, resolvedBoardId);
         const filename = generateFeatureFilename(numericId, title);
         const now = (/* @__PURE__ */ new Date()).toISOString();
-        const cards = await this.listCards();
+        const cards = await this.listCards(void 0, resolvedBoardId);
         const cardsInStatus = cards.filter((c) => c.status === status).sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
         const lastOrder = cardsInStatus.length > 0 ? cardsInStatus[cardsInStatus.length - 1].order : null;
         const card = {
           id: String(numericId),
+          boardId: resolvedBoardId,
           status,
           priority,
           assignee: data.assignee ?? null,
           dueDate: data.dueDate ?? null,
           created: now,
           modified: now,
-          completedAt: status === "done" ? now : null,
+          completedAt: this._isCompletedStatus(status, resolvedBoardId) ? now : null,
           labels: data.labels || [],
           attachments: data.attachments || [],
           comments: [],
           order: generateKeyBetween(lastOrder, null),
           content: data.content,
-          filePath: getFeatureFilePath(this.featuresDir, status, filename)
+          filePath: getFeatureFilePath(boardDir, status, filename)
         };
-        await fs3.mkdir(path4.dirname(card.filePath), { recursive: true });
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.mkdir(path5.dirname(card.filePath), { recursive: true });
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         return card;
       }
-      async updateCard(cardId, updates) {
-        const card = await this.getCard(cardId);
+      async updateCard(cardId, updates, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
+        const resolvedBoardId = card.boardId || this._resolveBoardId(boardId);
+        const boardDir = this._boardDir(resolvedBoardId);
         const oldStatus = card.status;
         const oldTitle = getTitleFromContent(card.content);
-        const { filePath: _fp, id: _id, ...safeUpdates } = updates;
+        const { filePath: _fp, id: _id, boardId: _bid, ...safeUpdates } = updates;
         Object.assign(card, safeUpdates);
         card.modified = (/* @__PURE__ */ new Date()).toISOString();
         if (oldStatus !== card.status) {
-          card.completedAt = card.status === "done" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+          card.completedAt = this._isCompletedStatus(card.status, resolvedBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
         }
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         const newTitle = getTitleFromContent(card.content);
         const numericId = extractNumericId(card.id);
         if (numericId !== null && newTitle !== oldTitle) {
@@ -709,46 +989,48 @@ var init_KanbanSDK = __esm({
           card.filePath = await renameFeatureFile(card.filePath, newFilename);
         }
         if (oldStatus !== card.status) {
-          const newPath = await moveFeatureFile(card.filePath, this.featuresDir, card.status, card.attachments);
+          const newPath = await moveFeatureFile(card.filePath, boardDir, card.status, card.attachments);
           card.filePath = newPath;
         }
         return card;
       }
-      async moveCard(cardId, newStatus, position) {
-        const cards = await this.listCards();
+      async moveCard(cardId, newStatus, position, boardId) {
+        const cards = await this.listCards(void 0, boardId);
         const card = cards.find((c) => c.id === cardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
+        const resolvedBoardId = card.boardId || this._resolveBoardId(boardId);
+        const boardDir = this._boardDir(resolvedBoardId);
         const oldStatus = card.status;
         card.status = newStatus;
         card.modified = (/* @__PURE__ */ new Date()).toISOString();
         if (oldStatus !== newStatus) {
-          card.completedAt = newStatus === "done" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+          card.completedAt = this._isCompletedStatus(newStatus, resolvedBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
         }
         const targetColumnCards = cards.filter((c) => c.status === newStatus && c.id !== cardId).sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
         const pos = position !== void 0 ? Math.max(0, Math.min(position, targetColumnCards.length)) : targetColumnCards.length;
         const before = pos > 0 ? targetColumnCards[pos - 1].order : null;
         const after = pos < targetColumnCards.length ? targetColumnCards[pos].order : null;
         card.order = generateKeyBetween(before, after);
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         if (oldStatus !== newStatus) {
-          const newPath = await moveFeatureFile(card.filePath, this.featuresDir, newStatus, card.attachments);
+          const newPath = await moveFeatureFile(card.filePath, boardDir, newStatus, card.attachments);
           card.filePath = newPath;
         }
         return card;
       }
-      async deleteCard(cardId) {
-        const card = await this.getCard(cardId);
+      async deleteCard(cardId, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
-        await fs3.unlink(card.filePath);
+        await fs4.unlink(card.filePath);
       }
-      async getCardsByStatus(status) {
-        const cards = await this.listCards();
+      async getCardsByStatus(status, boardId) {
+        const cards = await this.listCards(void 0, boardId);
         return cards.filter((c) => c.status === status);
       }
-      async getUniqueAssignees() {
-        const cards = await this.listCards();
+      async getUniqueAssignees(boardId) {
+        const cards = await this.listCards(void 0, boardId);
         const assignees = /* @__PURE__ */ new Set();
         for (const c of cards) {
           if (c.assignee)
@@ -756,8 +1038,8 @@ var init_KanbanSDK = __esm({
         }
         return [...assignees].sort();
       }
-      async getUniqueLabels() {
-        const cards = await this.listCards();
+      async getUniqueLabels(boardId) {
+        const cards = await this.listCards(void 0, boardId);
         const labels = /* @__PURE__ */ new Set();
         for (const c of cards) {
           for (const l of c.labels)
@@ -766,48 +1048,48 @@ var init_KanbanSDK = __esm({
         return [...labels].sort();
       }
       // --- Attachment management ---
-      async addAttachment(cardId, sourcePath) {
-        const card = await this.getCard(cardId);
+      async addAttachment(cardId, sourcePath, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
-        const fileName = path4.basename(sourcePath);
-        const cardDir = path4.dirname(card.filePath);
-        const destPath = path4.join(cardDir, fileName);
-        const sourceDir = path4.dirname(path4.resolve(sourcePath));
+        const fileName = path5.basename(sourcePath);
+        const cardDir = path5.dirname(card.filePath);
+        const destPath = path5.join(cardDir, fileName);
+        const sourceDir = path5.dirname(path5.resolve(sourcePath));
         if (sourceDir !== cardDir) {
-          await fs3.copyFile(path4.resolve(sourcePath), destPath);
+          await fs4.copyFile(path5.resolve(sourcePath), destPath);
         }
         if (!card.attachments.includes(fileName)) {
           card.attachments.push(fileName);
         }
         card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         return card;
       }
-      async removeAttachment(cardId, attachment) {
-        const card = await this.getCard(cardId);
+      async removeAttachment(cardId, attachment, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
         card.attachments = card.attachments.filter((a) => a !== attachment);
         card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         return card;
       }
-      async listAttachments(cardId) {
-        const card = await this.getCard(cardId);
+      async listAttachments(cardId, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
         return card.attachments;
       }
       // --- Comment management ---
-      async listComments(cardId) {
-        const card = await this.getCard(cardId);
+      async listComments(cardId, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
         return card.comments || [];
       }
-      async addComment(cardId, author, content) {
-        const card = await this.getCard(cardId);
+      async addComment(cardId, author, content, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
         if (!card.comments)
@@ -824,11 +1106,11 @@ var init_KanbanSDK = __esm({
         };
         card.comments.push(comment);
         card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         return card;
       }
-      async updateComment(cardId, commentId, content) {
-        const card = await this.getCard(cardId);
+      async updateComment(cardId, commentId, content, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
         const comment = (card.comments || []).find((c) => c.id === commentId);
@@ -836,34 +1118,45 @@ var init_KanbanSDK = __esm({
           throw new Error(`Comment not found: ${commentId}`);
         comment.content = content;
         card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         return card;
       }
-      async deleteComment(cardId, commentId) {
-        const card = await this.getCard(cardId);
+      async deleteComment(cardId, commentId, boardId) {
+        const card = await this.getCard(cardId, boardId);
         if (!card)
           throw new Error(`Card not found: ${cardId}`);
         card.comments = (card.comments || []).filter((c) => c.id !== commentId);
         card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await fs3.writeFile(card.filePath, serializeFeature(card), "utf-8");
+        await fs4.writeFile(card.filePath, serializeFeature(card), "utf-8");
         return card;
       }
-      // --- Column management ---
-      listColumns() {
-        return readConfig(this.workspaceRoot).columns;
+      // --- Column management (board-scoped) ---
+      listColumns(boardId) {
+        const config = readConfig(this.workspaceRoot);
+        const resolvedId = boardId || config.defaultBoard;
+        const board = config.boards[resolvedId];
+        return board?.columns || [];
       }
-      addColumn(column) {
+      addColumn(column, boardId) {
         const config = readConfig(this.workspaceRoot);
-        if (config.columns.some((c) => c.id === column.id)) {
+        const resolvedId = boardId || config.defaultBoard;
+        const board = config.boards[resolvedId];
+        if (!board)
+          throw new Error(`Board not found: ${resolvedId}`);
+        if (board.columns.some((c) => c.id === column.id)) {
           throw new Error(`Column already exists: ${column.id}`);
         }
-        config.columns.push(column);
+        board.columns.push(column);
         writeConfig(this.workspaceRoot, config);
-        return config.columns;
+        return board.columns;
       }
-      updateColumn(columnId, updates) {
+      updateColumn(columnId, updates, boardId) {
         const config = readConfig(this.workspaceRoot);
-        const col = config.columns.find((c) => c.id === columnId);
+        const resolvedId = boardId || config.defaultBoard;
+        const board = config.boards[resolvedId];
+        if (!board)
+          throw new Error(`Board not found: ${resolvedId}`);
+        const col = board.columns.find((c) => c.id === columnId);
         if (!col)
           throw new Error(`Column not found: ${columnId}`);
         if (updates.name !== void 0)
@@ -871,37 +1164,45 @@ var init_KanbanSDK = __esm({
         if (updates.color !== void 0)
           col.color = updates.color;
         writeConfig(this.workspaceRoot, config);
-        return config.columns;
+        return board.columns;
       }
-      async removeColumn(columnId) {
+      async removeColumn(columnId, boardId) {
         const config = readConfig(this.workspaceRoot);
-        const idx = config.columns.findIndex((c) => c.id === columnId);
+        const resolvedId = boardId || config.defaultBoard;
+        const board = config.boards[resolvedId];
+        if (!board)
+          throw new Error(`Board not found: ${resolvedId}`);
+        const idx = board.columns.findIndex((c) => c.id === columnId);
         if (idx === -1)
           throw new Error(`Column not found: ${columnId}`);
-        const cards = await this.listCards();
+        const cards = await this.listCards(void 0, resolvedId);
         const cardsInColumn = cards.filter((c) => c.status === columnId);
         if (cardsInColumn.length > 0) {
           throw new Error(`Cannot remove column "${columnId}": ${cardsInColumn.length} card(s) still in this column`);
         }
-        config.columns.splice(idx, 1);
+        board.columns.splice(idx, 1);
         writeConfig(this.workspaceRoot, config);
-        return config.columns;
+        return board.columns;
       }
-      reorderColumns(columnIds) {
+      reorderColumns(columnIds, boardId) {
         const config = readConfig(this.workspaceRoot);
-        const colMap = new Map(config.columns.map((c) => [c.id, c]));
+        const resolvedId = boardId || config.defaultBoard;
+        const board = config.boards[resolvedId];
+        if (!board)
+          throw new Error(`Board not found: ${resolvedId}`);
+        const colMap = new Map(board.columns.map((c) => [c.id, c]));
         for (const id of columnIds) {
           if (!colMap.has(id))
             throw new Error(`Column not found: ${id}`);
         }
-        if (columnIds.length !== config.columns.length) {
+        if (columnIds.length !== board.columns.length) {
           throw new Error("Must include all column IDs when reordering");
         }
-        config.columns = columnIds.map((id) => colMap.get(id));
+        board.columns = columnIds.map((id) => colMap.get(id));
         writeConfig(this.workspaceRoot, config);
-        return config.columns;
+        return board.columns;
       }
-      // --- Settings management ---
+      // --- Settings management (global) ---
       getSettings() {
         return configToSettings(readConfig(this.workspaceRoot));
       }
@@ -911,11 +1212,11 @@ var init_KanbanSDK = __esm({
       }
       // --- Private helpers ---
       async _readMdFiles(dir) {
-        const entries = await fs3.readdir(dir, { withFileTypes: true });
-        return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => path4.join(dir, e.name));
+        const entries = await fs4.readdir(dir, { withFileTypes: true });
+        return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => path5.join(dir, e.name));
       }
       async _loadCard(filePath) {
-        const content = await fs3.readFile(filePath, "utf-8");
+        const content = await fs4.readFile(filePath, "utf-8");
         return parseFeatureFile(content, filePath);
       }
     };
@@ -924,11 +1225,11 @@ var init_KanbanSDK = __esm({
 
 // src/standalone/webhooks.ts
 function webhooksPath(workspaceRoot) {
-  return path5.join(workspaceRoot, WEBHOOKS_FILENAME);
+  return path6.join(workspaceRoot, WEBHOOKS_FILENAME);
 }
 function loadWebhooks(workspaceRoot) {
   try {
-    const raw = fs4.readFileSync(webhooksPath(workspaceRoot), "utf-8");
+    const raw = fs5.readFileSync(webhooksPath(workspaceRoot), "utf-8");
     const data = JSON.parse(raw);
     return Array.isArray(data) ? data : [];
   } catch {
@@ -936,7 +1237,7 @@ function loadWebhooks(workspaceRoot) {
   }
 }
 function saveWebhooks(workspaceRoot, webhooks) {
-  fs4.writeFileSync(webhooksPath(workspaceRoot), JSON.stringify(webhooks, null, 2) + "\n", "utf-8");
+  fs5.writeFileSync(webhooksPath(workspaceRoot), JSON.stringify(webhooks, null, 2) + "\n", "utf-8");
 }
 function createWebhook(workspaceRoot, config) {
   const webhooks = loadWebhooks(workspaceRoot);
@@ -1018,12 +1319,12 @@ async function deliverWebhook(webhook, event, payload) {
     req.end();
   });
 }
-var fs4, path5, http, https, crypto, WEBHOOKS_FILENAME;
+var fs5, path6, http, https, crypto, WEBHOOKS_FILENAME;
 var init_webhooks = __esm({
   "src/standalone/webhooks.ts"() {
     "use strict";
-    fs4 = __toESM(require("fs"));
-    path5 = __toESM(require("path"));
+    fs5 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
     http = __toESM(require("http"));
     https = __toESM(require("https"));
     crypto = __toESM(require("crypto"));
@@ -4841,7 +5142,7 @@ var init_esm = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path9) => statMethod(path9, { bigint: true });
+          this._stat = (path10) => statMethod(path10, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -4866,8 +5167,8 @@ var init_esm = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path9, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path9));
+              const { path: path10, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -4907,20 +5208,20 @@ var init_esm = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path9, depth) {
+      async _exploreDir(path10, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path9, this._rdOptions);
+          files = await (0, import_promises.readdir)(path10, this._rdOptions);
         } catch (error) {
           this._onError(error);
         }
-        return { files, depth, path: path9 };
+        return { files, depth, path: path10 };
       }
-      async _formatEntry(dirent, path9) {
+      async _formatEntry(dirent, path10) {
         let entry;
         const basename7 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path9, basename7));
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path10, basename7));
           entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename7 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
@@ -4977,16 +5278,16 @@ var init_esm = __esm({
 });
 
 // node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
-function createFsWatchInstance(path9, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path9);
-    emitRaw(rawEvent, evPath, { watchedPath: path9 });
-    if (evPath && path9 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path9, evPath), KEY_LISTENERS, sysPath.join(path9, evPath));
+    listener(path10);
+    emitRaw(rawEvent, evPath, { watchedPath: path10 });
+    if (evPath && path10 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path10, evPath), KEY_LISTENERS, sysPath.join(path10, evPath));
     }
   };
   try {
-    return (0, import_fs.watch)(path9, {
+    return (0, import_fs.watch)(path10, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -5334,12 +5635,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path9, fullPath, options, handlers) => {
+    setFsWatchListener = (path10, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path9, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -5350,7 +5651,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path9,
+          path10,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -5365,7 +5666,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path9, "r");
+              const fd = await (0, import_promises2.open)(path10, "r");
               await fd.close();
               broadcastErr(error);
             } catch (err) {
@@ -5396,7 +5697,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path9, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path10, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -5418,7 +5719,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path9, curr));
+              foreach(cont.listeners, (listener2) => listener2(path10, curr));
             }
           })
         };
@@ -5446,13 +5747,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path9, listener) {
+      _watchWithNodeFs(path10, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path9);
-        const basename7 = sysPath.basename(path9);
+        const directory = sysPath.dirname(path10);
+        const basename7 = sysPath.basename(path10);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename7);
-        const absolutePath = sysPath.resolve(path9);
+        const absolutePath = sysPath.resolve(path10);
         const options = {
           persistent: opts.persistent
         };
@@ -5462,12 +5763,12 @@ var init_handler = __esm({
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
           options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path9, absolutePath, options, {
+          closer = setFsWatchFileListener(path10, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path9, absolutePath, options, {
+          closer = setFsWatchListener(path10, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -5489,7 +5790,7 @@ var init_handler = __esm({
         let prevStats = stats;
         if (parent.has(basename7))
           return;
-        const listener = async (path9, newStats) => {
+        const listener = async (path10, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -5503,11 +5804,11 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path9);
+                this.fsw._closeFile(path10);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path9, closer2);
+                  this.fsw._addPathCloser(path10, closer2);
               } else {
                 prevStats = newStats2;
               }
@@ -5539,7 +5840,7 @@ var init_handler = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path9, item) {
+      async _handleSymlink(entry, directory, path10, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -5549,7 +5850,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path9);
+            linkPath = await (0, import_promises2.realpath)(path10);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -5559,12 +5860,12 @@ var init_handler = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path9, entry.stats);
+              this.fsw._emit(EV.CHANGE, path10, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path9, entry.stats);
+            this.fsw._emit(EV.ADD, path10, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -5593,9 +5894,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path9 = sysPath.join(directory, item);
+          let path10 = sysPath.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path9, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -5604,8 +5905,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path9 = sysPath.join(dir, sysPath.relative(dir, path9));
-            this._addToNodeFs(path9, initialAdd, wh, depth + 1);
+            path10 = sysPath.join(dir, sysPath.relative(dir, path10));
+            this._addToNodeFs(path10, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve6, reject) => {
@@ -5674,13 +5975,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path9, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path9) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path10) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path9);
+        const wh = this.fsw._getWatchHelpers(path10);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -5696,8 +5997,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path9);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path9) : path9;
+            const absPath = sysPath.resolve(path10);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path10) : path10;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5707,29 +6008,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path9) : path9;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path10) : path10;
             if (this.fsw.closed)
               return;
             const parent = sysPath.dirname(wh.watchPath);
             this.fsw._getWatchedDir(parent).add(wh.watchPath);
             this.fsw._emit(EV.ADD, wh.watchPath, stats);
-            closer = await this._handleDir(parent, stats, initialAdd, depth, path9, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path10, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path9), targetPath);
+              this.fsw._symlinkPaths.set(sysPath.resolve(path10), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path9, closer);
+            this.fsw._addPathCloser(path10, closer);
           return false;
         } catch (error) {
           if (this.fsw._handleError(error)) {
             ready();
-            return path9;
+            return path10;
           }
         }
       }
@@ -5764,26 +6065,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path9) {
-  if (typeof path9 !== "string")
+function normalizePath(path10) {
+  if (typeof path10 !== "string")
     throw new Error("string expected");
-  path9 = sysPath2.normalize(path9);
-  path9 = path9.replace(/\\/g, "/");
+  path10 = sysPath2.normalize(path10);
+  path10 = path10.replace(/\\/g, "/");
   let prepend = false;
-  if (path9.startsWith("//"))
+  if (path10.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path9.match(DOUBLE_SLASH_RE2))
-    path9 = path9.replace(DOUBLE_SLASH_RE2, "/");
+  while (path10.match(DOUBLE_SLASH_RE2))
+    path10 = path10.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path9 = "/" + path9;
-  return path9;
+    path10 = "/" + path10;
+  return path10;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path9 = normalizePath(testString);
+  const path10 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path9, stats)) {
+    if (pattern(path10, stats)) {
       return true;
     }
   }
@@ -5847,19 +6148,19 @@ var init_esm2 = __esm({
       }
       return str;
     };
-    normalizePathToUnix = (path9) => toUnix(sysPath2.normalize(toUnix(path9)));
-    normalizeIgnored = (cwd = "") => (path9) => {
-      if (typeof path9 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path9) ? path9 : sysPath2.join(cwd, path9));
+    normalizePathToUnix = (path10) => toUnix(sysPath2.normalize(toUnix(path10)));
+    normalizeIgnored = (cwd = "") => (path10) => {
+      if (typeof path10 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path10) ? path10 : sysPath2.join(cwd, path10));
       } else {
-        return path9;
+        return path10;
       }
     };
-    getAbsolutePath = (path9, cwd) => {
-      if (sysPath2.isAbsolute(path9)) {
-        return path9;
+    getAbsolutePath = (path10, cwd) => {
+      if (sysPath2.isAbsolute(path10)) {
+        return path10;
       }
-      return sysPath2.join(cwd, path9);
+      return sysPath2.join(cwd, path10);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -5914,10 +6215,10 @@ var init_esm2 = __esm({
     STAT_METHOD_F = "stat";
     STAT_METHOD_L = "lstat";
     WatchHelper = class {
-      constructor(path9, follow, fsw) {
+      constructor(path10, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path9;
-        this.path = path9 = path9.replace(REPLACER_RE, "");
+        const watchPath = path10;
+        this.path = path10 = path10.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sysPath2.resolve(watchPath);
         this.dirParts = [];
@@ -6039,20 +6340,20 @@ var init_esm2 = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path9) => {
-            const absPath = getAbsolutePath(path9, cwd);
+          paths = paths.map((path10) => {
+            const absPath = getAbsolutePath(path10, cwd);
             return absPath;
           });
         }
-        paths.forEach((path9) => {
-          this._removeIgnoredPath(path9);
+        paths.forEach((path10) => {
+          this._removeIgnoredPath(path10);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path9) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path9, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path10) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -6074,17 +6375,17 @@ var init_esm2 = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path9) => {
-          if (!sysPath2.isAbsolute(path9) && !this._closers.has(path9)) {
+        paths.forEach((path10) => {
+          if (!sysPath2.isAbsolute(path10) && !this._closers.has(path10)) {
             if (cwd)
-              path9 = sysPath2.join(cwd, path9);
-            path9 = sysPath2.resolve(path9);
+              path10 = sysPath2.join(cwd, path10);
+            path10 = sysPath2.resolve(path10);
           }
-          this._closePath(path9);
-          this._addIgnoredPath(path9);
-          if (this._watched.has(path9)) {
+          this._closePath(path10);
+          this._addIgnoredPath(path10);
+          if (this._watched.has(path10)) {
             this._addIgnoredPath({
-              path: path9,
+              path: path10,
               recursive: true
             });
           }
@@ -6148,38 +6449,38 @@ var init_esm2 = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path9, stats) {
+      async _emit(event, path10, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path9 = sysPath2.normalize(path9);
+          path10 = sysPath2.normalize(path10);
         if (opts.cwd)
-          path9 = sysPath2.relative(opts.cwd, path9);
-        const args = [path9];
+          path10 = sysPath2.relative(opts.cwd, path10);
+        const args = [path10];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path9))) {
+        if (awf && (pw = this._pendingWrites.get(path10))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path9, [event, ...args]);
+            this._pendingUnlinks.set(path10, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path10) => {
+              this._pendingUnlinks.forEach((entry, path11) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path10);
+                this._pendingUnlinks.delete(path11);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path9)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path9);
+            this._pendingUnlinks.delete(path10);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -6197,16 +6498,16 @@ var init_esm2 = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path9, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path9, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 50);
           if (isThrottled)
             return this;
         }
         if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path9) : path9;
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path10) : path10;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -6237,23 +6538,23 @@ var init_esm2 = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path9, timeout) {
+      _throttle(actionType, path10, timeout) {
         if (!this._throttled.has(actionType)) {
           this._throttled.set(actionType, /* @__PURE__ */ new Map());
         }
         const action = this._throttled.get(actionType);
         if (!action)
           throw new Error("invalid throttle");
-        const actionPath = action.get(path9);
+        const actionPath = action.get(path10);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path9);
+          const item = action.get(path10);
           const count = item ? item.count : 0;
-          action.delete(path9);
+          action.delete(path10);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -6261,7 +6562,7 @@ var init_esm2 = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path9, thr);
+        action.set(path10, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -6275,44 +6576,44 @@ var init_esm2 = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path9, threshold, event, awfEmit) {
+      _awaitWriteFinish(path10, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path9;
-        if (this.options.cwd && !sysPath2.isAbsolute(path9)) {
-          fullPath = sysPath2.join(this.options.cwd, path9);
+        let fullPath = path10;
+        if (this.options.cwd && !sysPath2.isAbsolute(path10)) {
+          fullPath = sysPath2.join(this.options.cwd, path10);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path9)) {
+            if (err || !writes.has(path10)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path9).lastChange = now2;
+              writes.get(path10).lastChange = now2;
             }
-            const pw = writes.get(path9);
+            const pw = writes.get(path10);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path9);
+              writes.delete(path10);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path9)) {
-          writes.set(path9, {
+        if (!writes.has(path10)) {
+          writes.set(path10, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path9);
+              writes.delete(path10);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -6323,8 +6624,8 @@ var init_esm2 = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path9, stats) {
-        if (this.options.atomic && DOT_RE.test(path9))
+      _isIgnored(path10, stats) {
+        if (this.options.atomic && DOT_RE.test(path10))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -6334,17 +6635,17 @@ var init_esm2 = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path9, stats);
+        return this._userIgnored(path10, stats);
       }
-      _isntIgnored(path9, stat4) {
-        return !this._isIgnored(path9, stat4);
+      _isntIgnored(path10, stat4) {
+        return !this._isIgnored(path10, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path9) {
-        return new WatchHelper(path9, this.options.followSymlinks, this);
+      _getWatchHelpers(path10) {
+        return new WatchHelper(path10, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -6376,63 +6677,63 @@ var init_esm2 = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path9 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path9);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path9) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path9, 100))
+        const path10 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path10);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path10) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path10, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path9);
+        const wp = this._getWatchedDir(path10);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path9, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path10, nested));
         const parent = this._getWatchedDir(directory);
         const wasTracked = parent.has(item);
         parent.remove(item);
         if (this._symlinkPaths.has(fullPath)) {
           this._symlinkPaths.delete(fullPath);
         }
-        let relPath = path9;
+        let relPath = path10;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path9);
+          relPath = sysPath2.relative(this.options.cwd, path10);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path9);
+        this._watched.delete(path10);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path9))
-          this._emit(eventName, path9);
-        this._closePath(path9);
+        if (wasTracked && !this._isIgnored(path10))
+          this._emit(eventName, path10);
+        this._closePath(path10);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path9) {
-        this._closeFile(path9);
-        const dir = sysPath2.dirname(path9);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path9));
+      _closePath(path10) {
+        this._closeFile(path10);
+        const dir = sysPath2.dirname(path10);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path10));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path9) {
-        const closers = this._closers.get(path9);
+      _closeFile(path10) {
+        const closers = this._closers.get(path10);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path9);
+        this._closers.delete(path10);
       }
-      _addPathCloser(path9, closer) {
+      _addPathCloser(path10, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path9);
+        let list = this._closers.get(path10);
         if (!list) {
           list = [];
-          this._closers.set(path9, list);
+          this._closers.set(path10, list);
         }
         list.push(closer);
       }
@@ -6464,13 +6765,14 @@ __export(server_exports, {
   startServer: () => startServer
 });
 function startServer(featuresDir, port, webviewDir) {
-  const absoluteFeaturesDir = path6.resolve(featuresDir);
+  const absoluteFeaturesDir = path7.resolve(featuresDir);
   let features = [];
   let migrating = false;
   let currentEditingFeatureId = null;
   let lastWrittenContent = "";
-  const resolvedWebviewDir = webviewDir || path6.join(__dirname, "standalone-webview");
-  const workspaceRoot = path6.dirname(absoluteFeaturesDir);
+  let currentBoardId;
+  const resolvedWebviewDir = webviewDir || path7.join(__dirname, "standalone-webview");
+  const workspaceRoot = path7.dirname(absoluteFeaturesDir);
   const sdk = new KanbanSDK(absoluteFeaturesDir);
   function sanitizeFeature(feature) {
     const { filePath: _, ...rest } = feature;
@@ -6536,17 +6838,20 @@ function startServer(featuresDir, port, webviewDir) {
 </body>
 </html>`;
   async function loadFeatures() {
-    features = await sdk.listCards(sdk.listColumns().map((c) => c.id));
+    features = await sdk.listCards(sdk.listColumns(currentBoardId).map((c) => c.id), currentBoardId);
   }
   function buildInitMessage() {
+    const config = readConfig(workspaceRoot);
     const settings = sdk.getSettings();
     settings.showBuildWithAI = false;
     settings.markdownEditorMode = false;
     return {
       type: "init",
       features,
-      columns: sdk.listColumns(),
-      settings
+      columns: sdk.listColumns(currentBoardId),
+      settings,
+      boards: sdk.listBoards(),
+      currentBoard: currentBoardId || config.defaultBoard
     };
   }
   function broadcast(message) {
@@ -6566,7 +6871,8 @@ function startServer(featuresDir, port, webviewDir) {
         priority: data.priority,
         assignee: data.assignee,
         dueDate: data.dueDate,
-        labels: data.labels
+        labels: data.labels,
+        boardId: currentBoardId
       });
       await loadFeatures();
       broadcast(buildInitMessage());
@@ -6583,7 +6889,7 @@ function startServer(featuresDir, port, webviewDir) {
     const oldStatus = feature.status;
     migrating = true;
     try {
-      const updated = await sdk.moveCard(featureId, newStatus, newOrder);
+      const updated = await sdk.moveCard(featureId, newStatus, newOrder, currentBoardId);
       await loadFeatures();
       broadcast(buildInitMessage());
       fireWebhooks(workspaceRoot, "task.moved", {
@@ -6601,7 +6907,7 @@ function startServer(featuresDir, port, webviewDir) {
       return null;
     migrating = true;
     try {
-      const updated = await sdk.updateCard(featureId, updates);
+      const updated = await sdk.updateCard(featureId, updates, currentBoardId);
       lastWrittenContent = serializeFeature(updated);
       await loadFeatures();
       broadcast(buildInitMessage());
@@ -6617,7 +6923,7 @@ function startServer(featuresDir, port, webviewDir) {
       return false;
     try {
       const deleted = sanitizeFeature(feature);
-      await sdk.deleteCard(featureId);
+      await sdk.deleteCard(featureId, currentBoardId);
       await loadFeatures();
       broadcast(buildInitMessage());
       fireWebhooks(workspaceRoot, "task.deleted", deleted);
@@ -6628,7 +6934,7 @@ function startServer(featuresDir, port, webviewDir) {
     }
   }
   function doAddColumn(name, color) {
-    const existingColumns = sdk.listColumns();
+    const existingColumns = sdk.listColumns(currentBoardId);
     const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
     let uniqueId = id;
     let counter = 1;
@@ -6636,14 +6942,14 @@ function startServer(featuresDir, port, webviewDir) {
       uniqueId = `${id}-${counter++}`;
     }
     const column = { id: uniqueId, name, color };
-    sdk.addColumn(column);
+    sdk.addColumn(column, currentBoardId);
     broadcast(buildInitMessage());
     fireWebhooks(workspaceRoot, "column.created", column);
     return column;
   }
   function doEditColumn(columnId, updates) {
     try {
-      const columns = sdk.updateColumn(columnId, { name: updates.name, color: updates.color });
+      const columns = sdk.updateColumn(columnId, { name: updates.name, color: updates.color }, currentBoardId);
       const updated = columns.find((c) => c.id === columnId) ?? null;
       broadcast(buildInitMessage());
       if (updated)
@@ -6655,13 +6961,13 @@ function startServer(featuresDir, port, webviewDir) {
   }
   async function doRemoveColumn(columnId) {
     try {
-      const columns = sdk.listColumns();
+      const columns = sdk.listColumns(currentBoardId);
       if (columns.length <= 1)
         return { removed: false, error: "Cannot remove last column" };
       const col = columns.find((c) => c.id === columnId);
       if (!col)
         return { removed: false, error: "Column not found" };
-      await sdk.removeColumn(columnId);
+      await sdk.removeColumn(columnId, currentBoardId);
       broadcast(buildInitMessage());
       fireWebhooks(workspaceRoot, "column.deleted", col);
       return { removed: true };
@@ -6677,11 +6983,11 @@ function startServer(featuresDir, port, webviewDir) {
     const feature = features.find((f) => f.id === featureId);
     if (!feature)
       return false;
-    const featureDir = path6.dirname(feature.filePath);
-    fs5.writeFileSync(path6.join(featureDir, filename), fileData);
+    const featureDir = path7.dirname(feature.filePath);
+    fs6.writeFileSync(path7.join(featureDir, filename), fileData);
     migrating = true;
     try {
-      const updated = await sdk.addAttachment(featureId, path6.join(featureDir, filename));
+      const updated = await sdk.addAttachment(featureId, path7.join(featureDir, filename), currentBoardId);
       lastWrittenContent = serializeFeature(updated);
       await loadFeatures();
     } finally {
@@ -6695,7 +7001,7 @@ function startServer(featuresDir, port, webviewDir) {
       return null;
     migrating = true;
     try {
-      const updated = await sdk.removeAttachment(featureId, attachment);
+      const updated = await sdk.removeAttachment(featureId, attachment, currentBoardId);
       lastWrittenContent = serializeFeature(updated);
       await loadFeatures();
       broadcast(buildInitMessage());
@@ -6707,7 +7013,7 @@ function startServer(featuresDir, port, webviewDir) {
   async function doAddComment(featureId, author, content) {
     migrating = true;
     try {
-      const updated = await sdk.addComment(featureId, author, content);
+      const updated = await sdk.addComment(featureId, author, content, currentBoardId);
       lastWrittenContent = serializeFeature(updated);
       const comment = updated.comments[updated.comments.length - 1];
       await loadFeatures();
@@ -6723,7 +7029,7 @@ function startServer(featuresDir, port, webviewDir) {
   async function doUpdateComment(featureId, commentId, content) {
     migrating = true;
     try {
-      const updated = await sdk.updateComment(featureId, commentId, content);
+      const updated = await sdk.updateComment(featureId, commentId, content, currentBoardId);
       lastWrittenContent = serializeFeature(updated);
       const comment = (updated.comments || []).find((c) => c.id === commentId);
       await loadFeatures();
@@ -6746,7 +7052,7 @@ function startServer(featuresDir, port, webviewDir) {
       return false;
     migrating = true;
     try {
-      const updated = await sdk.deleteComment(featureId, commentId);
+      const updated = await sdk.deleteComment(featureId, commentId, currentBoardId);
       lastWrittenContent = serializeFeature(updated);
       await loadFeatures();
       broadcast(buildInitMessage());
@@ -6931,6 +7237,34 @@ function startServer(featuresDir, port, webviewDir) {
         }
         break;
       }
+      case "switchBoard":
+        currentBoardId = msg.boardId;
+        migrating = true;
+        try {
+          await loadFeatures();
+          broadcast(buildInitMessage());
+        } finally {
+          migrating = false;
+        }
+        break;
+      case "createBoard": {
+        const boardName = msg.name;
+        const boardId = generateSlug(boardName) || "board";
+        try {
+          sdk.createBoard(boardId, boardName);
+          currentBoardId = boardId;
+          migrating = true;
+          try {
+            await loadFeatures();
+            broadcast(buildInitMessage());
+          } finally {
+            migrating = false;
+          }
+        } catch (err) {
+          console.error("Failed to create board:", err);
+        }
+        break;
+      }
       case "openFile":
       case "focusMenuBar":
       case "startWithAI":
@@ -6954,7 +7288,178 @@ function startServer(featuresDir, port, webviewDir) {
       return;
     }
     const route = (expectedMethod, pattern) => matchRoute(expectedMethod, method, pathname, pattern);
-    let params = route("GET", "/api/tasks");
+    let params = route("GET", "/api/boards");
+    if (params) {
+      return jsonOk(res, sdk.listBoards());
+    }
+    params = route("POST", "/api/boards");
+    if (params) {
+      try {
+        const body = await readBody(req);
+        const id = body.id;
+        const name = body.name;
+        if (!id)
+          return jsonError(res, 400, "id is required");
+        if (!name)
+          return jsonError(res, 400, "name is required");
+        const board = sdk.createBoard(id, name, {
+          description: body.description,
+          columns: body.columns
+        });
+        return jsonOk(res, board, 201);
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("GET", "/api/boards/:boardId");
+    if (params) {
+      try {
+        const { boardId } = params;
+        const board = sdk.getBoard(boardId);
+        return jsonOk(res, board);
+      } catch (err) {
+        return jsonError(res, 404, String(err));
+      }
+    }
+    params = route("PUT", "/api/boards/:boardId");
+    if (params) {
+      try {
+        const { boardId } = params;
+        const body = await readBody(req);
+        const board = sdk.updateBoard(boardId, body);
+        return jsonOk(res, board);
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("DELETE", "/api/boards/:boardId");
+    if (params) {
+      try {
+        const { boardId } = params;
+        await sdk.deleteBoard(boardId);
+        return jsonOk(res, { deleted: true });
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("POST", "/api/boards/:boardId/tasks/:id/transfer");
+    if (params) {
+      try {
+        const { boardId, id } = params;
+        const body = await readBody(req);
+        const config = readConfig(workspaceRoot);
+        const fromBoard = currentBoardId || config.defaultBoard;
+        const targetStatus = body.targetStatus;
+        const card = await sdk.transferCard(id, fromBoard, boardId, targetStatus);
+        return jsonOk(res, sanitizeFeature(card));
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("GET", "/api/boards/:boardId/tasks");
+    if (params) {
+      try {
+        const { boardId } = params;
+        const boardColumns = sdk.listColumns(boardId);
+        const boardTasks = await sdk.listCards(boardColumns.map((c) => c.id), boardId);
+        let result = boardTasks.map(sanitizeFeature);
+        const status = url.searchParams.get("status");
+        if (status)
+          result = result.filter((f) => f.status === status);
+        const priority = url.searchParams.get("priority");
+        if (priority)
+          result = result.filter((f) => f.priority === priority);
+        const assignee = url.searchParams.get("assignee");
+        if (assignee)
+          result = result.filter((f) => f.assignee === assignee);
+        const label = url.searchParams.get("label");
+        if (label)
+          result = result.filter((f) => f.labels.includes(label));
+        return jsonOk(res, result);
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("POST", "/api/boards/:boardId/tasks");
+    if (params) {
+      try {
+        const { boardId } = params;
+        const body = await readBody(req);
+        const content = body.content || "";
+        if (!content)
+          return jsonError(res, 400, "content is required");
+        const feature = await sdk.createCard({
+          content,
+          status: body.status || "backlog",
+          priority: body.priority || "medium",
+          assignee: body.assignee || null,
+          dueDate: body.dueDate || null,
+          labels: body.labels || [],
+          boardId
+        });
+        return jsonOk(res, sanitizeFeature(feature), 201);
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("GET", "/api/boards/:boardId/tasks/:id");
+    if (params) {
+      try {
+        const { boardId, id } = params;
+        const card = await sdk.getCard(id, boardId);
+        if (!card)
+          return jsonError(res, 404, "Task not found");
+        return jsonOk(res, sanitizeFeature(card));
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("PUT", "/api/boards/:boardId/tasks/:id");
+    if (params) {
+      try {
+        const { boardId, id } = params;
+        const body = await readBody(req);
+        const feature = await sdk.updateCard(id, body, boardId);
+        return jsonOk(res, sanitizeFeature(feature));
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("PATCH", "/api/boards/:boardId/tasks/:id/move");
+    if (params) {
+      try {
+        const { boardId, id } = params;
+        const body = await readBody(req);
+        const newStatus = body.status;
+        const position = body.position ?? 0;
+        if (!newStatus)
+          return jsonError(res, 400, "status is required");
+        const feature = await sdk.moveCard(id, newStatus, position, boardId);
+        return jsonOk(res, sanitizeFeature(feature));
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("DELETE", "/api/boards/:boardId/tasks/:id");
+    if (params) {
+      try {
+        const { boardId, id } = params;
+        await sdk.deleteCard(id, boardId);
+        return jsonOk(res, { deleted: true });
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("GET", "/api/boards/:boardId/columns");
+    if (params) {
+      try {
+        const { boardId } = params;
+        return jsonOk(res, sdk.listColumns(boardId));
+      } catch (err) {
+        return jsonError(res, 400, String(err));
+      }
+    }
+    params = route("GET", "/api/tasks");
     if (params) {
       await loadFeatures();
       let result = features.map(sanitizeFeature);
@@ -7065,16 +7570,16 @@ function startServer(featuresDir, port, webviewDir) {
       const feature = features.find((f) => f.id === id);
       if (!feature)
         return jsonError(res, 404, "Task not found");
-      const featureDir = path6.dirname(feature.filePath);
-      const attachmentPath = path6.resolve(featureDir, attachName);
+      const featureDir = path7.dirname(feature.filePath);
+      const attachmentPath = path7.resolve(featureDir, attachName);
       if (!attachmentPath.startsWith(absoluteFeaturesDir)) {
         res.writeHead(403, { "Content-Type": "text/plain" });
         res.end("Forbidden");
         return;
       }
-      const ext2 = path6.extname(attachName);
+      const ext2 = path7.extname(attachName);
       const contentType2 = MIME_TYPES[ext2] || "application/octet-stream";
-      fs5.readFile(attachmentPath, (err, data) => {
+      fs6.readFile(attachmentPath, (err, data) => {
         if (err) {
           res.writeHead(404);
           res.end("File not found");
@@ -7150,7 +7655,7 @@ function startServer(featuresDir, port, webviewDir) {
     }
     params = route("GET", "/api/columns");
     if (params) {
-      return jsonOk(res, sdk.listColumns());
+      return jsonOk(res, sdk.listColumns(currentBoardId));
     }
     params = route("POST", "/api/columns");
     if (params) {
@@ -7289,16 +7794,16 @@ function startServer(featuresDir, port, webviewDir) {
         res.end("Feature not found");
         return;
       }
-      const featureDir = path6.dirname(feature.filePath);
-      const attachmentPath = path6.resolve(featureDir, filename);
+      const featureDir = path7.dirname(feature.filePath);
+      const attachmentPath = path7.resolve(featureDir, filename);
       if (!attachmentPath.startsWith(absoluteFeaturesDir)) {
         res.writeHead(403, { "Content-Type": "text/plain" });
         res.end("Forbidden");
         return;
       }
-      const ext2 = path6.extname(filename);
+      const ext2 = path7.extname(filename);
       const contentType2 = MIME_TYPES[ext2] || "application/octet-stream";
-      fs5.readFile(attachmentPath, (err, data) => {
+      fs6.readFile(attachmentPath, (err, data) => {
         if (err) {
           res.writeHead(404, { "Content-Type": "text/plain" });
           res.end("File not found");
@@ -7312,15 +7817,15 @@ function startServer(featuresDir, port, webviewDir) {
     if (pathname.startsWith("/api/")) {
       return jsonError(res, 404, "Not found");
     }
-    const filePath = path6.join(resolvedWebviewDir, pathname === "/" ? "index.html" : pathname);
-    if (!path6.extname(filePath)) {
+    const filePath = path7.join(resolvedWebviewDir, pathname === "/" ? "index.html" : pathname);
+    if (!path7.extname(filePath)) {
       res.writeHead(200, { "Content-Type": "text/html" });
       res.end(indexHtml);
       return;
     }
-    const ext = path6.extname(filePath);
+    const ext = path7.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
-    fs5.readFile(filePath, (err, data) => {
+    fs6.readFile(filePath, (err, data) => {
       if (err) {
         res.writeHead(200, { "Content-Type": "text/html" });
         res.end(indexHtml);
@@ -7342,7 +7847,7 @@ function startServer(featuresDir, port, webviewDir) {
     });
   });
   let debounceTimer;
-  fs5.mkdirSync(absoluteFeaturesDir, { recursive: true });
+  fs6.mkdirSync(absoluteFeaturesDir, { recursive: true });
   const watcher = esm_default.watch(absoluteFeaturesDir, {
     ignoreInitial: true,
     awaitWriteFinish: { stabilityThreshold: 100 }
@@ -7402,17 +7907,19 @@ function startServer(featuresDir, port, webviewDir) {
   });
   return server;
 }
-var http2, fs5, path6, MIME_TYPES;
+var http2, fs6, path7, MIME_TYPES;
 var init_server = __esm({
   "src/standalone/server.ts"() {
     "use strict";
     http2 = __toESM(require("http"));
-    fs5 = __toESM(require("fs"));
-    path6 = __toESM(require("path"));
+    fs6 = __toESM(require("fs"));
+    path7 = __toESM(require("path"));
     init_wrapper();
     init_esm2();
+    init_types();
     init_KanbanSDK();
     init_parser();
+    init_config();
     init_webhooks();
     MIME_TYPES = {
       ".html": "text/html",
@@ -8018,12 +8525,11 @@ var init_open = __esm({
 });
 
 // src/cli/index.ts
-var path8 = __toESM(require("path"));
-var fs11 = __toESM(require("fs/promises"));
+var path9 = __toESM(require("path"));
+var fs12 = __toESM(require("fs/promises"));
 init_KanbanSDK();
 init_webhooks();
 init_config();
-var VALID_STATUSES = ["backlog", "todo", "in-progress", "review", "done"];
 var VALID_PRIORITIES = ["critical", "high", "medium", "low"];
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -8047,20 +8553,27 @@ function parseArgs(argv) {
   }
   return { command, positional, flags };
 }
+function getBoardId(flags) {
+  return typeof flags.board === "string" ? flags.board : void 0;
+}
+async function getValidStatuses(sdk, boardId) {
+  const columns = await sdk.listColumns(boardId);
+  return columns.map((c) => c.id);
+}
 async function findWorkspaceRoot(startDir) {
   let dir = startDir;
   while (true) {
     try {
-      await fs11.access(path8.join(dir, ".git"));
+      await fs12.access(path9.join(dir, ".git"));
       return dir;
     } catch {
     }
     try {
-      await fs11.access(path8.join(dir, "package.json"));
+      await fs12.access(path9.join(dir, "package.json"));
       return dir;
     } catch {
     }
-    const parent = path8.dirname(dir);
+    const parent = path9.dirname(dir);
     if (parent === dir)
       return startDir;
     dir = parent;
@@ -8068,10 +8581,10 @@ async function findWorkspaceRoot(startDir) {
 }
 async function resolveFeaturesDir(flags) {
   if (typeof flags.dir === "string") {
-    return path8.resolve(flags.dir);
+    return path9.resolve(flags.dir);
   }
   const root = await findWorkspaceRoot(process.cwd());
-  return path8.join(root, ".kanban");
+  return path9.join(root, ".kanban");
 }
 var bold = (s) => `\x1B[1m${s}\x1B[0m`;
 var dim = (s) => `\x1B[2m${s}\x1B[0m`;
@@ -8138,6 +8651,9 @@ function formatCardDetail(c) {
     `  Modified:  ${c.modified}`,
     `  File:      ${c.filePath}`
   ];
+  if (c.boardId) {
+    lines.push(`  Board:     ${c.boardId}`);
+  }
   if (c.completedAt) {
     lines.push(`  Completed: ${c.completedAt}`);
   }
@@ -8148,7 +8664,8 @@ function formatCardDetail(c) {
   return lines.join("\n");
 }
 async function cmdList(sdk, flags) {
-  let cards = await sdk.listCards();
+  const boardId = getBoardId(flags);
+  let cards = await sdk.listCards(void 0, boardId);
   if (typeof flags.status === "string") {
     cards = cards.filter((c) => c.status === flags.status);
   }
@@ -8183,9 +8700,10 @@ async function cmdShow(sdk, positional, flags) {
     console.error(red("Error: card ID required. Usage: kl show <id>"));
     process.exit(1);
   }
-  const card = await sdk.getCard(cardId);
+  const boardId = getBoardId(flags);
+  const card = await sdk.getCard(cardId, boardId);
   if (!card) {
-    const all = await sdk.listCards();
+    const all = await sdk.listCards(void 0, boardId);
     const matches = all.filter((c) => c.id.includes(cardId));
     if (matches.length === 1) {
       if (flags.json) {
@@ -8215,10 +8733,14 @@ async function cmdAdd(sdk, flags) {
     console.error(red('Error: --title is required. Usage: kl add --title "My card"'));
     process.exit(1);
   }
-  const status = typeof flags.status === "string" ? flags.status : "backlog";
-  if (!VALID_STATUSES.includes(status)) {
-    console.error(red(`Invalid status: ${status}. Must be one of: ${VALID_STATUSES.join(", ")}`));
-    process.exit(1);
+  const boardId = getBoardId(flags);
+  const status = typeof flags.status === "string" ? flags.status : void 0;
+  if (status) {
+    const validStatuses = await getValidStatuses(sdk, boardId);
+    if (!validStatuses.includes(status)) {
+      console.error(red(`Invalid status: ${status}. Must be one of: ${validStatuses.join(", ")}`));
+      process.exit(1);
+    }
   }
   const priority = typeof flags.priority === "string" ? flags.priority : "medium";
   if (!VALID_PRIORITIES.includes(priority)) {
@@ -8230,7 +8752,7 @@ async function cmdAdd(sdk, flags) {
   const labels = typeof flags.label === "string" ? flags.label.split(",").map((l) => l.trim()) : [];
   const body = typeof flags.body === "string" ? flags.body : "";
   const content = `# ${title}${body ? "\n\n" + body : ""}`;
-  const card = await sdk.createCard({ content, status, priority, assignee, dueDate, labels });
+  const card = await sdk.createCard({ content, status, priority, assignee, dueDate, labels, boardId });
   if (flags.json) {
     console.log(JSON.stringify(card, null, 2));
   } else {
@@ -8246,29 +8768,15 @@ async function cmdMove(sdk, positional, flags) {
     console.error(red("Usage: kl move <id> <status> [--position <n>]"));
     process.exit(1);
   }
-  if (!VALID_STATUSES.includes(newStatus)) {
-    console.error(red(`Invalid status: ${newStatus}. Must be one of: ${VALID_STATUSES.join(", ")}`));
+  const boardId = getBoardId(flags);
+  const validStatuses = await getValidStatuses(sdk, boardId);
+  if (!validStatuses.includes(newStatus)) {
+    console.error(red(`Invalid status: ${newStatus}. Must be one of: ${validStatuses.join(", ")}`));
     process.exit(1);
   }
-  let resolvedId = cardId;
-  const card = await sdk.getCard(cardId);
-  if (!card) {
-    const all = await sdk.listCards();
-    const matches = all.filter((c) => c.id.includes(cardId));
-    if (matches.length === 1) {
-      resolvedId = matches[0].id;
-    } else if (matches.length > 1) {
-      console.error(red(`Multiple cards match "${cardId}":`));
-      for (const m of matches)
-        console.error(`  ${m.id}`);
-      process.exit(1);
-    } else {
-      console.error(red(`Card not found: ${cardId}`));
-      process.exit(1);
-    }
-  }
+  const resolvedId = await resolveCardId(sdk, cardId, boardId);
   const position = typeof flags.position === "string" ? parseInt(flags.position, 10) : void 0;
-  const updated = await sdk.moveCard(resolvedId, newStatus, position);
+  const updated = await sdk.moveCard(resolvedId, newStatus, position, boardId);
   console.log(green(`Moved ${updated.id} \u2192 ${colorStatus(newStatus)}`));
 }
 async function cmdEdit(sdk, positional, flags) {
@@ -8277,27 +8785,13 @@ async function cmdEdit(sdk, positional, flags) {
     console.error(red("Usage: kl edit <id> [--status ...] [--priority ...] [--assignee ...] [--due ...] [--label ...]"));
     process.exit(1);
   }
-  let resolvedId = cardId;
-  const card = await sdk.getCard(cardId);
-  if (!card) {
-    const all = await sdk.listCards();
-    const matches = all.filter((c) => c.id.includes(cardId));
-    if (matches.length === 1) {
-      resolvedId = matches[0].id;
-    } else if (matches.length > 1) {
-      console.error(red(`Multiple cards match "${cardId}":`));
-      for (const m of matches)
-        console.error(`  ${m.id}`);
-      process.exit(1);
-    } else {
-      console.error(red(`Card not found: ${cardId}`));
-      process.exit(1);
-    }
-  }
+  const boardId = getBoardId(flags);
+  const resolvedId = await resolveCardId(sdk, cardId, boardId);
   const updates = {};
   if (typeof flags.status === "string") {
-    if (!VALID_STATUSES.includes(flags.status)) {
-      console.error(red(`Invalid status: ${flags.status}`));
+    const validStatuses = await getValidStatuses(sdk, boardId);
+    if (!validStatuses.includes(flags.status)) {
+      console.error(red(`Invalid status: ${flags.status}. Must be one of: ${validStatuses.join(", ")}`));
       process.exit(1);
     }
     updates.status = flags.status;
@@ -8319,45 +8813,136 @@ async function cmdEdit(sdk, positional, flags) {
     console.error(red("No updates specified. Use --status, --priority, --assignee, --due, or --label"));
     process.exit(1);
   }
-  const updated = await sdk.updateCard(resolvedId, updates);
+  const updated = await sdk.updateCard(resolvedId, updates, boardId);
   console.log(green(`Updated: ${updated.id}`));
 }
-async function cmdDelete(sdk, positional) {
+async function cmdDelete(sdk, positional, flags) {
   const cardId = positional[0];
   if (!cardId) {
     console.error(red("Usage: kl delete <id>"));
     process.exit(1);
   }
-  let resolvedId = cardId;
-  const card = await sdk.getCard(cardId);
-  if (!card) {
-    const all = await sdk.listCards();
-    const matches = all.filter((c) => c.id.includes(cardId));
-    if (matches.length === 1) {
-      resolvedId = matches[0].id;
-    } else if (matches.length > 1) {
-      console.error(red(`Multiple cards match "${cardId}":`));
-      for (const m of matches)
-        console.error(`  ${m.id}`);
-      process.exit(1);
-    } else {
-      console.error(red(`Card not found: ${cardId}`));
-      process.exit(1);
-    }
-  }
-  await sdk.deleteCard(resolvedId);
+  const boardId = getBoardId(flags);
+  const resolvedId = await resolveCardId(sdk, cardId, boardId);
+  await sdk.deleteCard(resolvedId, boardId);
   console.log(green(`Deleted: ${resolvedId}`));
 }
 async function cmdInit(sdk) {
   await sdk.init();
   console.log(green(`Initialized: ${sdk.featuresDir}`));
 }
+async function cmdBoards(sdk, positional, flags, workspaceRoot) {
+  const subcommand = positional[0] || "list";
+  switch (subcommand) {
+    case "list": {
+      const boards = sdk.listBoards();
+      if (flags.json) {
+        console.log(JSON.stringify(boards, null, 2));
+      } else if (boards.length === 0) {
+        console.log(dim("  No boards found."));
+      } else {
+        console.log(`  ${dim("ID".padEnd(20))}  ${dim("NAME".padEnd(20))}  ${dim("DESCRIPTION")}`);
+        console.log(dim("  " + "-".repeat(60)));
+        for (const b of boards) {
+          console.log(`  ${bold(b.id.padEnd(20))}  ${b.name.padEnd(20)}  ${b.description || "-"}`);
+        }
+      }
+      break;
+    }
+    case "add": {
+      const id = typeof flags.id === "string" ? flags.id : "";
+      const name = typeof flags.name === "string" ? flags.name : "";
+      if (!id || !name) {
+        console.error(red("Usage: kl boards add --id <id> --name <name> [--description <desc>]"));
+        process.exit(1);
+      }
+      const description = typeof flags.description === "string" ? flags.description : void 0;
+      const board = await sdk.createBoard(id, name, { description });
+      if (flags.json) {
+        console.log(JSON.stringify(board, null, 2));
+      } else {
+        console.log(green(`Created board: ${board.id} (${board.name})`));
+      }
+      break;
+    }
+    case "show": {
+      const boardId = positional[1];
+      if (!boardId) {
+        console.error(red("Usage: kl boards show <id>"));
+        process.exit(1);
+      }
+      const board = sdk.getBoard(boardId);
+      if (flags.json) {
+        console.log(JSON.stringify(board, null, 2));
+      } else {
+        console.log(`${bold(board.name)}`);
+        console.log(`  ID:          ${boardId}`);
+        if (board.description)
+          console.log(`  Description: ${board.description}`);
+        console.log(`  Columns:     ${board.columns.map((c) => c.name).join(", ")}`);
+        console.log(`  Next Card:   ${board.nextCardId}`);
+        console.log(`  Default:     status=${board.defaultStatus}, priority=${board.defaultPriority}`);
+      }
+      break;
+    }
+    case "remove":
+    case "rm": {
+      const boardId = positional[1];
+      if (!boardId) {
+        console.error(red("Usage: kl boards remove <id>"));
+        process.exit(1);
+      }
+      await sdk.deleteBoard(boardId);
+      console.log(green(`Removed board: ${boardId}`));
+      break;
+    }
+    case "default": {
+      const boardId = positional[1];
+      if (!boardId) {
+        const config2 = readConfig(workspaceRoot);
+        console.log(config2.defaultBoard);
+        break;
+      }
+      const config = readConfig(workspaceRoot);
+      if (!config.boards[boardId]) {
+        console.error(red(`Board not found: ${boardId}`));
+        process.exit(1);
+      }
+      config.defaultBoard = boardId;
+      writeConfig(workspaceRoot, config);
+      console.log(green(`Default board set to: ${boardId}`));
+      break;
+    }
+    default:
+      console.error(red(`Unknown boards subcommand: ${subcommand}`));
+      console.error("Available: list, add, show, remove, default");
+      process.exit(1);
+  }
+}
+async function cmdTransfer(sdk, positional, flags) {
+  const cardId = positional[0];
+  if (!cardId) {
+    console.error(red("Usage: kl transfer <card-id> --from <board> --to <board> [--status <status>]"));
+    process.exit(1);
+  }
+  const fromBoard = typeof flags.from === "string" ? flags.from : void 0;
+  const toBoard = typeof flags.to === "string" ? flags.to : void 0;
+  if (!fromBoard || !toBoard) {
+    console.error(red("Both --from and --to are required"));
+    process.exit(1);
+  }
+  const targetStatus = typeof flags.status === "string" ? flags.status : void 0;
+  const resolvedId = await resolveCardId(sdk, cardId, fromBoard);
+  const card = await sdk.transferCard(resolvedId, fromBoard, toBoard, targetStatus);
+  console.log(green(`Transferred ${card.id} from ${fromBoard} \u2192 ${toBoard} (${colorStatus(card.status)})`));
+}
 async function cmdAttach(sdk, positional, flags) {
   const subcommand = positional[0] || "list";
   const cardId = positional[1];
+  const boardId = getBoardId(flags);
   if (subcommand !== "list" && subcommand !== "add" && subcommand !== "rm" && subcommand !== "remove") {
-    const resolvedId = await resolveCardId(sdk, subcommand);
-    const attachments = await sdk.listAttachments(resolvedId);
+    const resolvedId = await resolveCardId(sdk, subcommand, boardId);
+    const attachments = await sdk.listAttachments(resolvedId, boardId);
     if (flags.json) {
       console.log(JSON.stringify(attachments, null, 2));
     } else if (attachments.length === 0) {
@@ -8374,8 +8959,8 @@ async function cmdAttach(sdk, positional, flags) {
         console.error(red("Usage: kl attach list <card-id>"));
         process.exit(1);
       }
-      const resolvedId = await resolveCardId(sdk, cardId);
-      const attachments = await sdk.listAttachments(resolvedId);
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      const attachments = await sdk.listAttachments(resolvedId, boardId);
       if (flags.json) {
         console.log(JSON.stringify(attachments, null, 2));
       } else if (attachments.length === 0) {
@@ -8396,9 +8981,9 @@ async function cmdAttach(sdk, positional, flags) {
         console.error(red("Usage: kl attach add <card-id> <file-path>"));
         process.exit(1);
       }
-      const resolvedId = await resolveCardId(sdk, cardId);
-      const updated = await sdk.addAttachment(resolvedId, filePath);
-      console.log(green(`Attached to ${updated.id}: ${path8.basename(filePath)}`));
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      const updated = await sdk.addAttachment(resolvedId, filePath, boardId);
+      console.log(green(`Attached to ${updated.id}: ${path9.basename(filePath)}`));
       break;
     }
     case "remove":
@@ -8412,18 +8997,18 @@ async function cmdAttach(sdk, positional, flags) {
         console.error(red("Usage: kl attach remove <card-id> <filename>"));
         process.exit(1);
       }
-      const resolvedId = await resolveCardId(sdk, cardId);
-      const updated = await sdk.removeAttachment(resolvedId, filename);
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      const updated = await sdk.removeAttachment(resolvedId, filename, boardId);
       console.log(green(`Removed from ${updated.id}: ${filename}`));
       break;
     }
   }
 }
-async function resolveCardId(sdk, cardId) {
-  const card = await sdk.getCard(cardId);
+async function resolveCardId(sdk, cardId, boardId) {
+  const card = await sdk.getCard(cardId, boardId);
   if (card)
     return cardId;
-  const all = await sdk.listCards();
+  const all = await sdk.listCards(void 0, boardId);
   const matches = all.filter((c) => c.id.includes(cardId));
   if (matches.length === 1)
     return matches[0].id;
@@ -8438,9 +9023,10 @@ async function resolveCardId(sdk, cardId) {
 }
 async function cmdComment(sdk, positional, flags) {
   const subcommand = positional[0] || "list";
+  const boardId = getBoardId(flags);
   if (subcommand !== "list" && subcommand !== "add" && subcommand !== "edit" && subcommand !== "remove" && subcommand !== "rm") {
-    const resolvedId = await resolveCardId(sdk, subcommand);
-    const comments = await sdk.listComments(resolvedId);
+    const resolvedId = await resolveCardId(sdk, subcommand, boardId);
+    const comments = await sdk.listComments(resolvedId, boardId);
     if (flags.json) {
       console.log(JSON.stringify(comments, null, 2));
     } else if (comments.length === 0) {
@@ -8461,8 +9047,8 @@ async function cmdComment(sdk, positional, flags) {
         console.error(red("Usage: kl comment list <card-id>"));
         process.exit(1);
       }
-      const resolvedId = await resolveCardId(sdk, cardId);
-      const comments = await sdk.listComments(resolvedId);
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      const comments = await sdk.listComments(resolvedId, boardId);
       if (flags.json) {
         console.log(JSON.stringify(comments, null, 2));
       } else if (comments.length === 0) {
@@ -8491,8 +9077,8 @@ async function cmdComment(sdk, positional, flags) {
         console.error(red("Error: --body is required"));
         process.exit(1);
       }
-      const resolvedId = await resolveCardId(sdk, cardId);
-      const card = await sdk.addComment(resolvedId, author, body);
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      const card = await sdk.addComment(resolvedId, author, body, boardId);
       const added = card.comments[card.comments.length - 1];
       if (flags.json) {
         console.log(JSON.stringify(added, null, 2));
@@ -8516,10 +9102,10 @@ async function cmdComment(sdk, positional, flags) {
         console.error(red("Error: --body is required"));
         process.exit(1);
       }
-      const resolvedId = await resolveCardId(sdk, cardId);
-      await sdk.updateComment(resolvedId, commentId, body);
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      await sdk.updateComment(resolvedId, commentId, body, boardId);
       if (flags.json) {
-        const comments = await sdk.listComments(resolvedId);
+        const comments = await sdk.listComments(resolvedId, boardId);
         const updated = comments.find((c) => c.id === commentId);
         console.log(JSON.stringify(updated, null, 2));
       } else {
@@ -8538,8 +9124,8 @@ async function cmdComment(sdk, positional, flags) {
         console.error(red("Usage: kl comment remove <card-id> <comment-id>"));
         process.exit(1);
       }
-      const resolvedId = await resolveCardId(sdk, cardId);
-      await sdk.deleteComment(resolvedId, commentId);
+      const resolvedId = await resolveCardId(sdk, cardId, boardId);
+      await sdk.deleteComment(resolvedId, commentId, boardId);
       console.log(green(`Deleted comment ${commentId}`));
       break;
     }
@@ -8547,9 +9133,10 @@ async function cmdComment(sdk, positional, flags) {
 }
 async function cmdColumns(sdk, positional, flags) {
   const subcommand = positional[0] || "list";
+  const boardId = getBoardId(flags);
   switch (subcommand) {
     case "list": {
-      const columns = await sdk.listColumns();
+      const columns = await sdk.listColumns(boardId);
       if (flags.json) {
         console.log(JSON.stringify(columns, null, 2));
       } else {
@@ -8569,7 +9156,7 @@ async function cmdColumns(sdk, positional, flags) {
         console.error(red("Usage: kl columns add --id <id> --name <name> [--color <hex>]"));
         process.exit(1);
       }
-      const columns = await sdk.addColumn({ id, name, color });
+      const columns = await sdk.addColumn({ id, name, color }, boardId);
       console.log(green(`Added column: ${id} (${name})`));
       if (flags.json)
         console.log(JSON.stringify(columns, null, 2));
@@ -8590,7 +9177,7 @@ async function cmdColumns(sdk, positional, flags) {
         console.error(red("No updates specified. Use --name or --color"));
         process.exit(1);
       }
-      const columns = await sdk.updateColumn(columnId, updates);
+      const columns = await sdk.updateColumn(columnId, updates, boardId);
       console.log(green(`Updated column: ${columnId}`));
       if (flags.json)
         console.log(JSON.stringify(columns, null, 2));
@@ -8603,7 +9190,7 @@ async function cmdColumns(sdk, positional, flags) {
         console.error(red("Usage: kl columns remove <id>"));
         process.exit(1);
       }
-      const columns = await sdk.removeColumn(columnId);
+      const columns = await sdk.removeColumn(columnId, boardId);
       console.log(green(`Removed column: ${columnId}`));
       if (flags.json)
         console.log(JSON.stringify(columns, null, 2));
@@ -8783,6 +9370,14 @@ ${bold("Card Commands:")}
   edit <id> [--field value]   Update card fields
   delete <id>                 Delete a card
 
+${bold("Board Commands:")}
+  boards                      List boards
+  boards add                  Create a board (--id, --name, --description)
+  boards show <id>            Show board details
+  boards remove <id>          Remove a board
+  boards default [id]         Get or set the default board
+  transfer <id>               Transfer a card (--from, --to, --status)
+
 ${bold("Attachment Commands:")}
   attach <id>                 List attachments on a card
   attach add <id> <path>      Attach a file to a card
@@ -8818,6 +9413,7 @@ ${bold("Other:")}
 
 ${bold("Global Options:")}
   --dir <path>                Features directory (default: .kanban)
+  --board <id>                Target board (default: default board)
   --json                      Output as JSON
 
 ${bold("List Filters:")}
@@ -8835,6 +9431,11 @@ ${bold("Add/Edit Options:")}
   --due <date>                Due date
   --label <l1,l2>             Labels (comma-separated)
 
+${bold("Transfer Options:")}
+  --from <board>              Source board (required)
+  --to <board>                Destination board (required)
+  --status <status>           Target status in destination board
+
 ${bold("Webhook Options:")}
   --url <url>                 Webhook target URL (required for add)
   --events <e1,e2>            Events to subscribe to (default: *)
@@ -8856,7 +9457,7 @@ async function main() {
     return;
   }
   const featuresDir = await resolveFeaturesDir(flags);
-  const workspaceRoot = path8.dirname(featuresDir);
+  const workspaceRoot = path9.dirname(featuresDir);
   const sdk = new KanbanSDK(featuresDir);
   switch (command) {
     case "list":
@@ -8882,7 +9483,14 @@ async function main() {
       break;
     case "delete":
     case "rm":
-      await cmdDelete(sdk, positional);
+      await cmdDelete(sdk, positional, flags);
+      break;
+    case "boards":
+    case "board":
+      await cmdBoards(sdk, positional, flags, workspaceRoot);
+      break;
+    case "transfer":
+      await cmdTransfer(sdk, positional, flags);
       break;
     case "attach":
       await cmdAttach(sdk, positional, flags);