kanban-lite 1.0.9 → 1.0.13

package/dist/mcp-server.js

@@ -24,15 +24,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/mcp-server/index.ts
-var path6 = __toESM(require("path"));
-var fs5 = __toESM(require("fs/promises"));
+var path7 = __toESM(require("path"));
+var fs6 = __toESM(require("fs/promises"));
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 var import_zod = require("zod");
 
 // src/sdk/KanbanSDK.ts
-var fs3 = __toESM(require("fs/promises"));
-var path4 = __toESM(require("path"));
+var fs4 = __toESM(require("fs/promises"));
+var path5 = __toESM(require("path"));
 
 // node_modules/.pnpm/fractional-indexing@3.2.0/node_modules/fractional-indexing/src/index.js
 var BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@@ -263,23 +263,34 @@ function extractNumericId(filenameOrId) {
   const match = filenameOrId.match(/^(\d+)(?:-|$)/);
   return match ? parseInt(match[1], 10) : null;
 }
+var 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" }
+];
 
 // src/shared/config.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
+var DEFAULT_BOARD_CONFIG = {
+  name: "Default",
+  columns: [...DEFAULT_COLUMNS],
+  nextCardId: 1,
+  defaultStatus: "backlog",
+  defaultPriority: "medium"
+};
 var 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,
@@ -293,12 +304,65 @@ var CONFIG_FILENAME = ".kanban.json";
 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;
   }
@@ -307,19 +371,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 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 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`);
+  }
+  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) {
@@ -537,30 +621,203 @@ async function fileExists(filePath) {
   }
 }
 
+// src/sdk/migration.ts
+var fs3 = __toESM(require("fs/promises"));
+var path4 = __toESM(require("path"));
+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)
+      );
+    }
+  }
+}
+
 // src/sdk/KanbanSDK.ts
 var 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 {
         }
@@ -568,26 +825,33 @@ var KanbanSDK = class {
     } 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 {
         }
       }
@@ -605,65 +869,72 @@ var KanbanSDK = class {
         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) {
@@ -671,46 +942,48 @@ var KanbanSDK = class {
       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)
@@ -718,8 +991,8 @@ var KanbanSDK = class {
     }
     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)
@@ -728,48 +1001,48 @@ var KanbanSDK = class {
     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)
@@ -786,11 +1059,11 @@ var KanbanSDK = class {
     };
     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);
@@ -798,34 +1071,45 @@ var KanbanSDK = class {
       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)
@@ -833,37 +1117,45 @@ var KanbanSDK = class {
     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));
   }
@@ -873,26 +1165,26 @@ var KanbanSDK = class {
   }
   // --- 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);
   }
 };
 
 // src/standalone/webhooks.ts
-var fs4 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var crypto = __toESM(require("crypto"));
 var WEBHOOKS_FILENAME = ".kanban-webhooks.json";
 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 {
@@ -900,7 +1192,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);
@@ -929,16 +1221,16 @@ async function findWorkspaceRoot(startDir) {
   let dir = startDir;
   while (true) {
     try {
-      await fs5.access(path6.join(dir, ".git"));
+      await fs6.access(path7.join(dir, ".git"));
       return dir;
     } catch {
     }
     try {
-      await fs5.access(path6.join(dir, "package.json"));
+      await fs6.access(path7.join(dir, "package.json"));
       return dir;
     } catch {
     }
-    const parent = path6.dirname(dir);
+    const parent = path7.dirname(dir);
     if (parent === dir)
       return startDir;
     dir = parent;
@@ -947,13 +1239,13 @@ async function findWorkspaceRoot(startDir) {
 async function resolveFeaturesDir() {
   const dirIndex = process.argv.indexOf("--dir");
   if (dirIndex !== -1 && process.argv[dirIndex + 1]) {
-    return path6.resolve(process.argv[dirIndex + 1]);
+    return path7.resolve(process.argv[dirIndex + 1]);
   }
   if (process.env.KANBAN_FEATURES_DIR) {
-    return path6.resolve(process.env.KANBAN_FEATURES_DIR);
+    return path7.resolve(process.env.KANBAN_FEATURES_DIR);
   }
   const root = await findWorkspaceRoot(process.cwd());
-  return path6.join(root, ".devtool", "features");
+  return path7.join(root, ".devtool", "features");
 }
 function getTitleFromContent2(content) {
   const match = content.match(/^#\s+(.+)$/m);
@@ -969,17 +1261,68 @@ async function main() {
     name: "kanban-lite",
     version: "1.0.0"
   });
+  server.tool("list_boards", "List all kanban boards.", {}, async () => {
+    const boards = sdk.listBoards();
+    return { content: [{ type: "text", text: JSON.stringify(boards, null, 2) }] };
+  });
+  server.tool("create_board", "Create a new kanban board.", {
+    id: import_zod.z.string().describe("Board ID (used in directory name)"),
+    name: import_zod.z.string().describe("Display name"),
+    description: import_zod.z.string().optional().describe("Board description"),
+    columns: import_zod.z.array(import_zod.z.object({ id: import_zod.z.string(), name: import_zod.z.string(), color: import_zod.z.string() })).optional().describe("Board columns (defaults to standard columns)")
+  }, async ({ id, name, description, columns }) => {
+    try {
+      const board = sdk.createBoard(id, name, { description, columns });
+      return { content: [{ type: "text", text: JSON.stringify(board, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: String(err) }], isError: true };
+    }
+  });
+  server.tool("get_board", "Get details of a specific board.", {
+    boardId: import_zod.z.string().describe("Board ID")
+  }, async ({ boardId }) => {
+    try {
+      const board = sdk.getBoard(boardId);
+      return { content: [{ type: "text", text: JSON.stringify({ id: boardId, ...board }, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: String(err) }], isError: true };
+    }
+  });
+  server.tool("delete_board", "Delete an empty kanban board.", {
+    boardId: import_zod.z.string().describe("Board ID to delete")
+  }, async ({ boardId }) => {
+    try {
+      await sdk.deleteBoard(boardId);
+      return { content: [{ type: "text", text: `Deleted board: ${boardId}` }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: String(err) }], isError: true };
+    }
+  });
+  server.tool("transfer_card", "Transfer a card from one board to another.", {
+    cardId: import_zod.z.string().describe("Card ID"),
+    fromBoard: import_zod.z.string().describe("Source board ID"),
+    toBoard: import_zod.z.string().describe("Target board ID"),
+    targetStatus: import_zod.z.string().optional().describe("Status in the target board (defaults to board default)")
+  }, async ({ cardId, fromBoard, toBoard, targetStatus }) => {
+    try {
+      const card = await sdk.transferCard(cardId, fromBoard, toBoard, targetStatus);
+      return { content: [{ type: "text", text: JSON.stringify(card, null, 2) }] };
+    } catch (err) {
+      return { content: [{ type: "text", text: String(err) }], isError: true };
+    }
+  });
   server.tool(
     "list_cards",
     "List all kanban cards. Optionally filter by status, priority, assignee, or label.",
     {
-      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("Filter by status"),
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
+      status: import_zod.z.string().optional().describe("Filter by status"),
       priority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("Filter by priority"),
       assignee: import_zod.z.string().optional().describe("Filter by assignee name"),
       label: import_zod.z.string().optional().describe("Filter by label")
     },
-    async ({ status, priority, assignee, label }) => {
-      let cards = await sdk.listCards();
+    async ({ boardId, status, priority, assignee, label }) => {
+      let cards = await sdk.listCards(void 0, boardId);
       if (status)
         cards = cards.filter((c) => c.status === status);
       if (priority)
@@ -1009,12 +1352,13 @@ async function main() {
     "get_card",
     "Get full details of a specific kanban card by ID. Supports partial ID matching.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)")
     },
-    async ({ cardId }) => {
-      let card = await sdk.getCard(cardId);
+    async ({ boardId, cardId }) => {
+      let 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) {
           card = matches[0];
@@ -1042,23 +1386,25 @@ async function main() {
     "create_card",
     "Create a new kanban card. Returns the created card.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       title: import_zod.z.string().describe("Card title"),
       body: import_zod.z.string().optional().describe("Card body/description (markdown)"),
-      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("Initial status (default: backlog)"),
+      status: import_zod.z.string().optional().describe("Initial status (default: backlog)"),
       priority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("Priority level (default: medium)"),
       assignee: import_zod.z.string().optional().describe("Assignee name"),
       dueDate: import_zod.z.string().optional().describe("Due date (ISO format or YYYY-MM-DD)"),
       labels: import_zod.z.array(import_zod.z.string()).optional().describe("Labels/tags")
     },
-    async ({ title, body, status, priority, assignee, dueDate, labels }) => {
+    async ({ boardId, title, body, status, priority, assignee, dueDate, labels }) => {
       const content = `# ${title}${body ? "\n\n" + body : ""}`;
       const card = await sdk.createCard({
         content,
-        status,
+        status: status || void 0,
         priority,
         assignee: assignee || null,
         dueDate: dueDate || null,
-        labels: labels || []
+        labels: labels || [],
+        boardId
       });
       return {
         content: [{
@@ -1072,19 +1418,20 @@ async function main() {
     "update_card",
     "Update fields of an existing kanban card. Only specified fields are changed.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
-      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("New status"),
+      status: import_zod.z.string().optional().describe("New status"),
       priority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("New priority"),
       assignee: import_zod.z.string().optional().describe("New assignee"),
       dueDate: import_zod.z.string().optional().describe("New due date"),
       labels: import_zod.z.array(import_zod.z.string()).optional().describe("New labels (replaces existing)"),
       content: import_zod.z.string().optional().describe("New markdown content (replaces existing body)")
     },
-    async ({ cardId, status, priority, assignee, dueDate, labels, content }) => {
+    async ({ boardId, cardId, status, priority, assignee, dueDate, labels, content }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1113,7 +1460,7 @@ async function main() {
         updates.labels = labels;
       if (content !== void 0)
         updates.content = content;
-      const updated = await sdk.updateCard(resolvedId, updates);
+      const updated = await sdk.updateCard(resolvedId, updates, boardId);
       return {
         content: [{
           type: "text",
@@ -1126,14 +1473,15 @@ async function main() {
     "move_card",
     "Move a kanban card to a different status column.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
-      status: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).describe("Target status column")
+      status: import_zod.z.string().describe("Target status column")
     },
-    async ({ cardId, status }) => {
+    async ({ boardId, cardId, status }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1149,7 +1497,7 @@ async function main() {
           };
         }
       }
-      const updated = await sdk.moveCard(resolvedId, status);
+      const updated = await sdk.moveCard(resolvedId, status, void 0, boardId);
       return {
         content: [{
           type: "text",
@@ -1162,13 +1510,14 @@ async function main() {
     "delete_card",
     "Permanently delete a kanban card.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)")
     },
-    async ({ cardId }) => {
+    async ({ boardId, cardId }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1184,7 +1533,7 @@ async function main() {
           };
         }
       }
-      await sdk.deleteCard(resolvedId);
+      await sdk.deleteCard(resolvedId, boardId);
       return {
         content: [{
           type: "text",
@@ -1197,13 +1546,14 @@ async function main() {
     "list_attachments",
     "List all attachments on a kanban card.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)")
     },
-    async ({ cardId }) => {
+    async ({ boardId, cardId }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1219,7 +1569,7 @@ async function main() {
           };
         }
       }
-      const attachments = await sdk.listAttachments(resolvedId);
+      const attachments = await sdk.listAttachments(resolvedId, boardId);
       return {
         content: [{
           type: "text",
@@ -1232,14 +1582,15 @@ async function main() {
     "add_attachment",
     "Add a file attachment to a kanban card. Copies the file to the card directory.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
       filePath: import_zod.z.string().describe("Absolute path to the file to attach")
     },
-    async ({ cardId, filePath }) => {
+    async ({ boardId, cardId, filePath }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1255,7 +1606,7 @@ async function main() {
           };
         }
       }
-      const updated = await sdk.addAttachment(resolvedId, filePath);
+      const updated = await sdk.addAttachment(resolvedId, filePath, boardId);
       return {
         content: [{
           type: "text",
@@ -1268,14 +1619,15 @@ async function main() {
     "remove_attachment",
     "Remove an attachment from a kanban card. Only removes the reference, not the file.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
       attachment: import_zod.z.string().describe("Attachment filename to remove")
     },
-    async ({ cardId, attachment }) => {
+    async ({ boardId, cardId, attachment }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1291,7 +1643,7 @@ async function main() {
           };
         }
       }
-      const updated = await sdk.removeAttachment(resolvedId, attachment);
+      const updated = await sdk.removeAttachment(resolvedId, attachment, boardId);
       return {
         content: [{
           type: "text",
@@ -1304,13 +1656,14 @@ async function main() {
     "list_comments",
     "List all comments on a kanban card.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)")
     },
-    async ({ cardId }) => {
+    async ({ boardId, cardId }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1326,7 +1679,7 @@ async function main() {
           };
         }
       }
-      const comments = await sdk.listComments(resolvedId);
+      const comments = await sdk.listComments(resolvedId, boardId);
       return {
         content: [{
           type: "text",
@@ -1339,15 +1692,16 @@ async function main() {
     "add_comment",
     "Add a comment to a kanban card.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
       author: import_zod.z.string().describe("Comment author name"),
       content: import_zod.z.string().describe("Comment text (supports markdown)")
     },
-    async ({ cardId, author, content }) => {
+    async ({ boardId, cardId, author, content }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1363,7 +1717,7 @@ async function main() {
           };
         }
       }
-      const updated = await sdk.addComment(resolvedId, author, content);
+      const updated = await sdk.addComment(resolvedId, author, content, boardId);
       const added = updated.comments[updated.comments.length - 1];
       return {
         content: [{
@@ -1377,15 +1731,16 @@ async function main() {
     "update_comment",
     "Update the content of a comment on a kanban card.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
       commentId: import_zod.z.string().describe('Comment ID (e.g. "c1")'),
       content: import_zod.z.string().describe("New comment text")
     },
-    async ({ cardId, commentId, content }) => {
+    async ({ boardId, cardId, commentId, content }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1402,7 +1757,7 @@ async function main() {
         }
       }
       try {
-        const updated = await sdk.updateComment(resolvedId, commentId, content);
+        const updated = await sdk.updateComment(resolvedId, commentId, content, boardId);
         const comment = updated.comments.find((c) => c.id === commentId);
         return {
           content: [{
@@ -1422,14 +1777,15 @@ async function main() {
     "delete_comment",
     "Delete a comment from a kanban card.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       cardId: import_zod.z.string().describe("Card ID (or partial ID)"),
       commentId: import_zod.z.string().describe('Comment ID (e.g. "c1")')
     },
-    async ({ cardId, commentId }) => {
+    async ({ boardId, cardId, commentId }) => {
       let resolvedId = cardId;
-      const card = await sdk.getCard(cardId);
+      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) {
           resolvedId = matches[0].id;
@@ -1446,7 +1802,7 @@ async function main() {
         }
       }
       try {
-        await sdk.deleteComment(resolvedId, commentId);
+        await sdk.deleteComment(resolvedId, commentId, boardId);
         return {
           content: [{
             type: "text",
@@ -1464,9 +1820,11 @@ async function main() {
   server.tool(
     "list_columns",
     "List all kanban board columns.",
-    {},
-    async () => {
-      const columns = await sdk.listColumns();
+    {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)")
+    },
+    async ({ boardId }) => {
+      const columns = await sdk.listColumns(boardId);
       return {
         content: [{
           type: "text",
@@ -1479,12 +1837,13 @@ async function main() {
     "add_column",
     "Add a new column to the kanban board.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       id: import_zod.z.string().describe("Unique column ID (used in card status field)"),
       name: import_zod.z.string().describe("Display name for the column"),
       color: import_zod.z.string().describe('Column color (hex format, e.g. "#3b82f6")')
     },
-    async ({ id, name, color }) => {
-      const columns = await sdk.addColumn({ id, name, color });
+    async ({ boardId, id, name, color }) => {
+      const columns = await sdk.addColumn({ id, name, color }, boardId);
       return {
         content: [{
           type: "text",
@@ -1497,17 +1856,18 @@ async function main() {
     "update_column",
     "Update an existing kanban board column.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       columnId: import_zod.z.string().describe("Column ID to update"),
       name: import_zod.z.string().optional().describe("New display name"),
       color: import_zod.z.string().optional().describe("New color (hex format)")
     },
-    async ({ columnId, name, color }) => {
+    async ({ boardId, columnId, name, color }) => {
       const updates = {};
       if (name)
         updates.name = name;
       if (color)
         updates.color = color;
-      const columns = await sdk.updateColumn(columnId, updates);
+      const columns = await sdk.updateColumn(columnId, updates, boardId);
       return {
         content: [{
           type: "text",
@@ -1520,10 +1880,11 @@ async function main() {
     "remove_column",
     "Remove a column from the kanban board. Fails if any cards are in the column.",
     {
+      boardId: import_zod.z.string().optional().describe("Board ID (uses default board if omitted)"),
       columnId: import_zod.z.string().describe("Column ID to remove")
     },
-    async ({ columnId }) => {
-      const columns = await sdk.removeColumn(columnId);
+    async ({ boardId, columnId }) => {
+      const columns = await sdk.removeColumn(columnId, boardId);
       return {
         content: [{
           type: "text",
@@ -1532,7 +1893,7 @@ async function main() {
       };
     }
   );
-  const workspaceRoot = path6.dirname(featuresDir);
+  const workspaceRoot = path7.dirname(featuresDir);
   server.tool(
     "get_settings",
     "Get the current kanban board display settings.",
@@ -1559,7 +1920,7 @@ async function main() {
       showFileName: import_zod.z.boolean().optional().describe("Show file name on cards"),
       compactMode: import_zod.z.boolean().optional().describe("Enable compact card display"),
       defaultPriority: import_zod.z.enum(["critical", "high", "medium", "low"]).optional().describe("Default priority for new cards"),
-      defaultStatus: import_zod.z.enum(["backlog", "todo", "in-progress", "review", "done"]).optional().describe("Default status for new cards")
+      defaultStatus: import_zod.z.string().optional().describe("Default status for new cards")
     },
     async (updates) => {
       const config = readConfig(workspaceRoot);