kanban-lite 1.0.9 → 1.0.13

package/dist/extension.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -30,6 +33,47 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/shared/types.ts
+var types_exports = {};
+__export(types_exports, {
+  DEFAULT_COLUMNS: () => DEFAULT_COLUMNS,
+  extractNumericId: () => extractNumericId,
+  generateFeatureFilename: () => generateFeatureFilename,
+  generateSlug: () => generateSlug,
+  getTitleFromContent: () => getTitleFromContent
+});
+function getTitleFromContent(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  if (match)
+    return match[1].trim();
+  const firstLine = content.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
+  return firstLine || "Untitled";
+}
+function generateSlug(title) {
+  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "feature";
+}
+function generateFeatureFilename(id, title) {
+  const slug = generateSlug(title);
+  return `${id}-${slug}`;
+}
+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" }
+    ];
+  }
+});
+
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/constants.js
 var require_constants = __commonJS({
   "node_modules/.pnpm/ws@8.19.0/node_modules/ws/lib/constants.js"(exports2, module2) {
@@ -3747,25 +3791,30 @@ __export(extension_exports, {
 });
 module.exports = __toCommonJS(extension_exports);
 var net = __toESM(require("node:net"));
-var path9 = __toESM(require("node:path"));
+var path10 = __toESM(require("node:path"));
 var vscode3 = __toESM(require("vscode"));
 
 // src/shared/config.ts
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
+init_types();
+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,
@@ -3779,12 +3828,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;
   }
@@ -3793,19 +3895,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) {
@@ -3837,8 +3959,8 @@ function settingsToConfig(config, settings) {
 }
 
 // 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";
@@ -4050,25 +4172,8 @@ function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
   ];
 }
 
-// src/shared/types.ts
-function getTitleFromContent(content) {
-  const match = content.match(/^#\s+(.+)$/m);
-  if (match)
-    return match[1].trim();
-  const firstLine = content.split("\n").map((l) => l.trim()).find((l) => l.length > 0);
-  return firstLine || "Untitled";
-}
-function generateSlug(title) {
-  return title.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 50) || "feature";
-}
-function generateFeatureFilename(id, title) {
-  const slug = generateSlug(title);
-  return `${id}-${slug}`;
-}
-function extractNumericId(filenameOrId) {
-  const match = filenameOrId.match(/^(\d+)(?:-|$)/);
-  return match ? parseInt(match[1], 10) : null;
-}
+// src/sdk/KanbanSDK.ts
+init_types();
 
 // src/sdk/parser.ts
 var path2 = __toESM(require("path"));
@@ -4257,30 +4362,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 {
         }
@@ -4288,26 +4566,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 {
         }
       }
@@ -4325,65 +4610,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) {
@@ -4391,46 +4683,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)
@@ -4438,8 +4732,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)
@@ -4448,48 +4742,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)
@@ -4506,11 +4800,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);
@@ -4518,34 +4812,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)
@@ -4553,37 +4858,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));
   }
@@ -4593,19 +4906,19 @@ 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/server.ts
 var http2 = __toESM(require("http"));
-var fs5 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -4690,7 +5003,7 @@ var ReaddirpStream = class extends import_node_stream.Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
     if (wantBigintFsStats) {
-      this._stat = (path10) => statMethod(path10, { bigint: true });
+      this._stat = (path11) => statMethod(path11, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -4715,8 +5028,8 @@ var ReaddirpStream = class extends import_node_stream.Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path10, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
+          const { path: path11, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path11));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -4756,20 +5069,20 @@ var ReaddirpStream = class extends import_node_stream.Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path10, depth) {
+  async _exploreDir(path11, depth) {
     let files;
     try {
-      files = await (0, import_promises.readdir)(path10, this._rdOptions);
+      files = await (0, import_promises.readdir)(path11, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path10 };
+    return { files, depth, path: path11 };
   }
-  async _formatEntry(dirent, path10) {
+  async _formatEntry(dirent, path11) {
     let entry;
     const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path10, basename6));
+      const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path11, basename6));
       entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -5169,16 +5482,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path11, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path10);
-    emitRaw(rawEvent, evPath, { watchedPath: path10 });
-    if (evPath && path10 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path10, evPath), KEY_LISTENERS, sysPath.join(path10, evPath));
+    listener(path11);
+    emitRaw(rawEvent, evPath, { watchedPath: path11 });
+    if (evPath && path11 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path11, evPath), KEY_LISTENERS, sysPath.join(path11, evPath));
     }
   };
   try {
-    return (0, import_fs.watch)(path10, {
+    return (0, import_fs.watch)(path11, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error) {
@@ -5194,12 +5507,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path10, fullPath, options, handlers) => {
+var setFsWatchListener = (path11, fullPath, options, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options.persistent) {
-    watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path11, options, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -5210,7 +5523,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path10,
+      path11,
       options,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -5225,7 +5538,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await (0, import_promises2.open)(path10, "r");
+          const fd = await (0, import_promises2.open)(path11, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -5256,7 +5569,7 @@ var setFsWatchListener = (path10, fullPath, options, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
+var setFsWatchFileListener = (path11, fullPath, options, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -5278,7 +5591,7 @@ var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path10, curr));
+          foreach(cont.listeners, (listener2) => listener2(path11, curr));
         }
       })
     };
@@ -5306,13 +5619,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path10, listener) {
+  _watchWithNodeFs(path11, listener) {
     const opts = this.fsw.options;
-    const directory = sysPath.dirname(path10);
-    const basename6 = sysPath.basename(path10);
+    const directory = sysPath.dirname(path11);
+    const basename6 = sysPath.basename(path11);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename6);
-    const absolutePath = sysPath.resolve(path10);
+    const absolutePath = sysPath.resolve(path11);
     const options = {
       persistent: opts.persistent
     };
@@ -5322,12 +5635,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path10, absolutePath, options, {
+      closer = setFsWatchFileListener(path11, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path10, absolutePath, options, {
+      closer = setFsWatchListener(path11, absolutePath, options, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -5349,7 +5662,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename6))
       return;
-    const listener = async (path10, newStats) => {
+    const listener = async (path11, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -5363,11 +5676,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path10);
+            this.fsw._closeFile(path11);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path10, closer2);
+              this.fsw._addPathCloser(path11, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -5399,7 +5712,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path10, item) {
+  async _handleSymlink(entry, directory, path11, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -5409,7 +5722,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await (0, import_promises2.realpath)(path10);
+        linkPath = await (0, import_promises2.realpath)(path11);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -5419,12 +5732,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path10, entry.stats);
+          this.fsw._emit(EV.CHANGE, path11, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path10, entry.stats);
+        this.fsw._emit(EV.ADD, path11, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -5453,9 +5766,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path10 = sysPath.join(directory, item);
+      let path11 = sysPath.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path11, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -5464,8 +5777,8 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path10 = sysPath.join(dir, sysPath.relative(dir, path10));
-        this._addToNodeFs(path10, initialAdd, wh, depth + 1);
+        path11 = sysPath.join(dir, sysPath.relative(dir, path11));
+        this._addToNodeFs(path11, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
     return new Promise((resolve6, reject) => {
@@ -5534,13 +5847,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path11, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path10) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path11) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path10);
+    const wh = this.fsw._getWatchHelpers(path11);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -5556,8 +5869,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sysPath.resolve(path10);
-        const targetPath = follow ? await (0, import_promises2.realpath)(path10) : path10;
+        const absPath = sysPath.resolve(path11);
+        const targetPath = follow ? await (0, import_promises2.realpath)(path11) : path11;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -5567,29 +5880,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await (0, import_promises2.realpath)(path10) : path10;
+        const targetPath = follow ? await (0, import_promises2.realpath)(path11) : path11;
         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, path10, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path11, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sysPath.resolve(path10), targetPath);
+          this.fsw._symlinkPaths.set(sysPath.resolve(path11), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path10, closer);
+        this.fsw._addPathCloser(path11, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path10;
+        return path11;
       }
     }
   }
@@ -5632,26 +5945,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path10) {
-  if (typeof path10 !== "string")
+function normalizePath(path11) {
+  if (typeof path11 !== "string")
     throw new Error("string expected");
-  path10 = sysPath2.normalize(path10);
-  path10 = path10.replace(/\\/g, "/");
+  path11 = sysPath2.normalize(path11);
+  path11 = path11.replace(/\\/g, "/");
   let prepend = false;
-  if (path10.startsWith("//"))
+  if (path11.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path10.match(DOUBLE_SLASH_RE2))
-    path10 = path10.replace(DOUBLE_SLASH_RE2, "/");
+  while (path11.match(DOUBLE_SLASH_RE2))
+    path11 = path11.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path10 = "/" + path10;
-  return path10;
+    path11 = "/" + path11;
+  return path11;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path10 = normalizePath(testString);
+  const path11 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path10, stats)) {
+    if (pattern(path11, stats)) {
       return true;
     }
   }
@@ -5691,19 +6004,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path10) => toUnix(sysPath2.normalize(toUnix(path10)));
-var normalizeIgnored = (cwd = "") => (path10) => {
-  if (typeof path10 === "string") {
-    return normalizePathToUnix(sysPath2.isAbsolute(path10) ? path10 : sysPath2.join(cwd, path10));
+var normalizePathToUnix = (path11) => toUnix(sysPath2.normalize(toUnix(path11)));
+var normalizeIgnored = (cwd = "") => (path11) => {
+  if (typeof path11 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path11) ? path11 : sysPath2.join(cwd, path11));
   } else {
-    return path10;
+    return path11;
   }
 };
-var getAbsolutePath = (path10, cwd) => {
-  if (sysPath2.isAbsolute(path10)) {
-    return path10;
+var getAbsolutePath = (path11, cwd) => {
+  if (sysPath2.isAbsolute(path11)) {
+    return path11;
   }
-  return sysPath2.join(cwd, path10);
+  return sysPath2.join(cwd, path11);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -5758,10 +6071,10 @@ var DirEntry = class {
 var STAT_METHOD_F = "stat";
 var STAT_METHOD_L = "lstat";
 var WatchHelper = class {
-  constructor(path10, follow, fsw) {
+  constructor(path11, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path10;
-    this.path = path10 = path10.replace(REPLACER_RE, "");
+    const watchPath = path11;
+    this.path = path11 = path11.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sysPath2.resolve(watchPath);
     this.dirParts = [];
@@ -5883,20 +6196,20 @@ var FSWatcher = class extends import_events.EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path10) => {
-        const absPath = getAbsolutePath(path10, cwd);
+      paths = paths.map((path11) => {
+        const absPath = getAbsolutePath(path11, cwd);
         return absPath;
       });
     }
-    paths.forEach((path10) => {
-      this._removeIgnoredPath(path10);
+    paths.forEach((path11) => {
+      this._removeIgnoredPath(path11);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path10) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path11) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path11, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -5918,17 +6231,17 @@ var FSWatcher = class extends import_events.EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path10) => {
-      if (!sysPath2.isAbsolute(path10) && !this._closers.has(path10)) {
+    paths.forEach((path11) => {
+      if (!sysPath2.isAbsolute(path11) && !this._closers.has(path11)) {
         if (cwd)
-          path10 = sysPath2.join(cwd, path10);
-        path10 = sysPath2.resolve(path10);
+          path11 = sysPath2.join(cwd, path11);
+        path11 = sysPath2.resolve(path11);
       }
-      this._closePath(path10);
-      this._addIgnoredPath(path10);
-      if (this._watched.has(path10)) {
+      this._closePath(path11);
+      this._addIgnoredPath(path11);
+      if (this._watched.has(path11)) {
         this._addIgnoredPath({
-          path: path10,
+          path: path11,
           recursive: true
         });
       }
@@ -5992,38 +6305,38 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @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, path10, stats) {
+  async _emit(event, path11, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path10 = sysPath2.normalize(path10);
+      path11 = sysPath2.normalize(path11);
     if (opts.cwd)
-      path10 = sysPath2.relative(opts.cwd, path10);
-    const args = [path10];
+      path11 = sysPath2.relative(opts.cwd, path11);
+    const args = [path11];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path10))) {
+    if (awf && (pw = this._pendingWrites.get(path11))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path10, [event, ...args]);
+        this._pendingUnlinks.set(path11, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path11) => {
+          this._pendingUnlinks.forEach((entry, path12) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path11);
+            this._pendingUnlinks.delete(path12);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path11)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path10);
+        this._pendingUnlinks.delete(path11);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -6041,16 +6354,16 @@ var FSWatcher = class extends import_events.EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path11, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path11, 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, path10) : path10;
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path11) : path11;
       let stats2;
       try {
         stats2 = await (0, import_promises3.stat)(fullPath);
@@ -6081,23 +6394,23 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path10, timeout) {
+  _throttle(actionType, path11, 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(path10);
+    const actionPath = action.get(path11);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path10);
+      const item = action.get(path11);
       const count = item ? item.count : 0;
-      action.delete(path10);
+      action.delete(path11);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -6105,7 +6418,7 @@ var FSWatcher = class extends import_events.EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path10, thr);
+    action.set(path11, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -6119,44 +6432,44 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path10, threshold, event, awfEmit) {
+  _awaitWriteFinish(path11, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path10;
-    if (this.options.cwd && !sysPath2.isAbsolute(path10)) {
-      fullPath = sysPath2.join(this.options.cwd, path10);
+    let fullPath = path11;
+    if (this.options.cwd && !sysPath2.isAbsolute(path11)) {
+      fullPath = sysPath2.join(this.options.cwd, path11);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       (0, import_fs2.stat)(fullPath, (err, curStat) => {
-        if (err || !writes.has(path10)) {
+        if (err || !writes.has(path11)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path10).lastChange = now2;
+          writes.get(path11).lastChange = now2;
         }
-        const pw = writes.get(path10);
+        const pw = writes.get(path11);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path10);
+          writes.delete(path11);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path10)) {
-      writes.set(path10, {
+    if (!writes.has(path11)) {
+      writes.set(path11, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path10);
+          writes.delete(path11);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -6167,8 +6480,8 @@ var FSWatcher = class extends import_events.EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path10, stats) {
-    if (this.options.atomic && DOT_RE.test(path10))
+  _isIgnored(path11, stats) {
+    if (this.options.atomic && DOT_RE.test(path11))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -6178,17 +6491,17 @@ var FSWatcher = class extends import_events.EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path10, stats);
+    return this._userIgnored(path11, stats);
   }
-  _isntIgnored(path10, stat4) {
-    return !this._isIgnored(path10, stat4);
+  _isntIgnored(path11, stat4) {
+    return !this._isIgnored(path11, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path10) {
-    return new WatchHelper(path10, this.options.followSymlinks, this);
+  _getWatchHelpers(path11) {
+    return new WatchHelper(path11, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -6220,63 +6533,63 @@ var FSWatcher = class extends import_events.EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    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))
+    const path11 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path11);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path11) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path11, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path10);
+    const wp = this._getWatchedDir(path11);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path10, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path11, 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 = path10;
+    let relPath = path11;
     if (this.options.cwd)
-      relPath = sysPath2.relative(this.options.cwd, path10);
+      relPath = sysPath2.relative(this.options.cwd, path11);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path10);
+    this._watched.delete(path11);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path10))
-      this._emit(eventName, path10);
-    this._closePath(path10);
+    if (wasTracked && !this._isIgnored(path11))
+      this._emit(eventName, path11);
+    this._closePath(path11);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path10) {
-    this._closeFile(path10);
-    const dir = sysPath2.dirname(path10);
-    this._getWatchedDir(dir).remove(sysPath2.basename(path10));
+  _closePath(path11) {
+    this._closeFile(path11);
+    const dir = sysPath2.dirname(path11);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path11));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path10) {
-    const closers = this._closers.get(path10);
+  _closeFile(path11) {
+    const closers = this._closers.get(path11);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path10);
+    this._closers.delete(path11);
   }
-  _addPathCloser(path10, closer) {
+  _addPathCloser(path11, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path10);
+    let list = this._closers.get(path11);
     if (!list) {
       list = [];
-      this._closers.set(path10, list);
+      this._closers.set(path11, list);
     }
     list.push(closer);
   }
@@ -6305,19 +6618,22 @@ function watch(paths, options = {}) {
 }
 var esm_default = { watch, FSWatcher };
 
+// src/standalone/server.ts
+init_types();
+
 // 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 http = __toESM(require("http"));
 var https = __toESM(require("https"));
 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 {
@@ -6325,7 +6641,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);
@@ -6420,13 +6736,14 @@ var MIME_TYPES = {
   ".map": "application/json"
 };
 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;
@@ -6492,17 +6809,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) {
@@ -6522,7 +6842,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());
@@ -6539,7 +6860,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", {
@@ -6557,7 +6878,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());
@@ -6573,7 +6894,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);
@@ -6584,7 +6905,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;
@@ -6592,14 +6913,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)
@@ -6611,13 +6932,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 };
@@ -6633,11 +6954,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 {
@@ -6651,7 +6972,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());
@@ -6663,7 +6984,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();
@@ -6679,7 +7000,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();
@@ -6702,7 +7023,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());
@@ -6887,6 +7208,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":
@@ -6910,7 +7259,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);
@@ -7021,16 +7541,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");
@@ -7106,7 +7626,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) {
@@ -7245,16 +7765,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");
@@ -7268,15 +7788,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);
@@ -7298,7 +7818,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 }
@@ -7361,12 +7881,14 @@ function startServer(featuresDir, port, webviewDir) {
 
 // src/extension/KanbanPanel.ts
 var vscode = __toESM(require("vscode"));
-var path7 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
+init_types();
 var KanbanPanel = class _KanbanPanel {
   constructor(panel, extensionUri, context) {
     this._features = [];
     this._disposables = [];
     this._currentEditingFeatureId = null;
+    this._currentBoardId = void 0;
     this._lastWrittenContent = "";
     this._migrating = false;
     this._onDisposeCallbacks = [];
@@ -7479,6 +8001,26 @@ var KanbanPanel = class _KanbanPanel {
           case "removeColumn":
             await this._removeColumn(message.columnId);
             break;
+          case "switchBoard":
+            this._currentBoardId = message.boardId;
+            await this._loadFeatures();
+            this._sendFeaturesToWebview();
+            break;
+          case "createBoard": {
+            if (!this._sdk)
+              break;
+            const { generateSlug: generateSlug2 } = await Promise.resolve().then(() => (init_types(), types_exports));
+            const boardId = generateSlug2(message.name) || "board";
+            try {
+              this._sdk.createBoard(boardId, message.name);
+              this._currentBoardId = boardId;
+              await this._loadFeatures();
+              this._sendFeaturesToWebview();
+            } catch (err) {
+              vscode.window.showErrorMessage(`Failed to create board: ${err}`);
+            }
+            break;
+          }
           case "toggleTheme":
             await vscode.commands.executeCommand("workbench.action.toggleLightDarkThemes");
             break;
@@ -7528,7 +8070,7 @@ var KanbanPanel = class _KanbanPanel {
     const featuresDir = this._getWorkspaceFeaturesDir();
     if (!featuresDir)
       return;
-    const pattern = new vscode.RelativePattern(featuresDir, "**/*.md");
+    const pattern = new vscode.RelativePattern(featuresDir, "boards/**/*.md");
     this._fileWatcher = vscode.workspace.createFileSystemWatcher(pattern);
     let debounceTimer;
     const handleFileChange = (uri) => {
@@ -7642,7 +8184,7 @@ var KanbanPanel = class _KanbanPanel {
     if (!root)
       return null;
     const config = readConfig(root);
-    return path7.join(root, config.featuresDirectory);
+    return path8.join(root, config.featuresDirectory);
   }
   _getSDK() {
     const featuresDir = this._getWorkspaceFeaturesDir();
@@ -7662,7 +8204,7 @@ var KanbanPanel = class _KanbanPanel {
     try {
       this._migrating = true;
       const columns = this._getColumns().map((c) => c.id);
-      this._features = await sdk.listCards(columns);
+      this._features = await sdk.listCards(columns, this._currentBoardId);
     } catch {
       this._features = [];
     } finally {
@@ -7695,7 +8237,8 @@ var KanbanPanel = class _KanbanPanel {
         priority: data.priority,
         assignee: data.assignee ?? void 0,
         dueDate: data.dueDate ?? void 0,
-        labels: data.labels
+        labels: data.labels,
+        boardId: this._currentBoardId
       });
       this._features.push(feature);
       this._sendFeaturesToWebview();
@@ -7709,7 +8252,7 @@ var KanbanPanel = class _KanbanPanel {
       return;
     this._migrating = true;
     try {
-      const updated = await sdk.moveCard(featureId, newStatus, newOrder);
+      const updated = await sdk.moveCard(featureId, newStatus, newOrder, this._currentBoardId);
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
         this._features[idx] = updated;
@@ -7723,7 +8266,7 @@ var KanbanPanel = class _KanbanPanel {
     if (!sdk)
       return;
     try {
-      await sdk.deleteCard(featureId);
+      await sdk.deleteCard(featureId, this._currentBoardId);
       this._features = this._features.filter((f) => f.id !== featureId);
       this._sendFeaturesToWebview();
     } catch (err) {
@@ -7736,7 +8279,7 @@ var KanbanPanel = class _KanbanPanel {
       return;
     this._migrating = true;
     try {
-      const updated = await sdk.updateCard(featureId, updates);
+      const updated = await sdk.updateCard(featureId, updates, this._currentBoardId);
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
         this._features[idx] = updated;
@@ -7794,7 +8337,7 @@ var KanbanPanel = class _KanbanPanel {
         dueDate: frontmatter.dueDate,
         labels: frontmatter.labels,
         attachments: frontmatter.attachments
-      });
+      }, this._currentBoardId);
       this._lastWrittenContent = serializeFeature(updated);
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
@@ -7820,7 +8363,7 @@ var KanbanPanel = class _KanbanPanel {
     try {
       let updated = feature;
       for (const uri of uris) {
-        updated = await sdk.addAttachment(featureId, uri.fsPath);
+        updated = await sdk.addAttachment(featureId, uri.fsPath, this._currentBoardId);
       }
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
@@ -7837,8 +8380,8 @@ var KanbanPanel = class _KanbanPanel {
     const feature = this._features.find((f) => f.id === featureId);
     if (!feature)
       return;
-    const featureDir = path7.dirname(feature.filePath);
-    const attachmentPath = path7.resolve(featureDir, attachment);
+    const featureDir = path8.dirname(feature.filePath);
+    const attachmentPath = path8.resolve(featureDir, attachment);
     try {
       await vscode.workspace.fs.stat(vscode.Uri.file(attachmentPath));
       const doc = await vscode.workspace.openTextDocument(vscode.Uri.file(attachmentPath));
@@ -7853,7 +8396,7 @@ var KanbanPanel = class _KanbanPanel {
       return;
     this._migrating = true;
     try {
-      const updated = await sdk.removeAttachment(featureId, attachment);
+      const updated = await sdk.removeAttachment(featureId, attachment, this._currentBoardId);
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
         this._features[idx] = updated;
@@ -7871,7 +8414,7 @@ var KanbanPanel = class _KanbanPanel {
       return;
     this._migrating = true;
     try {
-      const updated = await sdk.addComment(featureId, author, content);
+      const updated = await sdk.addComment(featureId, author, content, this._currentBoardId);
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
         this._features[idx] = updated;
@@ -7889,7 +8432,7 @@ var KanbanPanel = class _KanbanPanel {
       return;
     this._migrating = true;
     try {
-      const updated = await sdk.updateComment(featureId, commentId, content);
+      const updated = await sdk.updateComment(featureId, commentId, content, this._currentBoardId);
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
         this._features[idx] = updated;
@@ -7907,7 +8450,7 @@ var KanbanPanel = class _KanbanPanel {
       return;
     this._migrating = true;
     try {
-      const updated = await sdk.deleteComment(featureId, commentId);
+      const updated = await sdk.deleteComment(featureId, commentId, this._currentBoardId);
       const idx = this._features.findIndex((f) => f.id === featureId);
       if (idx !== -1)
         this._features[idx] = updated;
@@ -7983,13 +8526,17 @@ var KanbanPanel = class _KanbanPanel {
   _getColumns() {
     const sdk = this._getSDK();
     if (!sdk)
-      return [...DEFAULT_CONFIG.columns];
-    return sdk.listColumns();
+      return [...DEFAULT_CONFIG.boards.default.columns];
+    return sdk.listColumns(this._currentBoardId);
   }
   _sendFeaturesToWebview() {
     const sdk = this._getSDK();
-    const columns = sdk ? sdk.listColumns() : [...DEFAULT_CONFIG.columns];
+    const columns = sdk ? sdk.listColumns(this._currentBoardId) : [...DEFAULT_CONFIG.boards.default.columns];
     const settings = sdk ? sdk.getSettings() : configToSettings(DEFAULT_CONFIG);
+    const boards = sdk ? sdk.listBoards() : [];
+    const root = this._getWorkspaceRoot();
+    const config = root ? readConfig(root) : DEFAULT_CONFIG;
+    const currentBoard = this._currentBoardId || config.defaultBoard;
     const aiDisabled = vscode.workspace.getConfiguration("chat").get("disableAIFeatures", false);
     if (aiDisabled) {
       settings.showBuildWithAI = false;
@@ -7998,7 +8545,9 @@ var KanbanPanel = class _KanbanPanel {
       type: "init",
       features: this._features,
       columns,
-      settings
+      settings,
+      boards,
+      currentBoard
     });
   }
   _addColumn(column) {
@@ -8012,14 +8561,14 @@ var KanbanPanel = class _KanbanPanel {
     while (existing.some((c) => c.id === uniqueId)) {
       uniqueId = `${id}-${counter++}`;
     }
-    sdk.addColumn({ id: uniqueId, name: column.name, color: column.color });
+    sdk.addColumn({ id: uniqueId, name: column.name, color: column.color }, this._currentBoardId);
     this._sendFeaturesToWebview();
   }
   _editColumn(columnId, updates) {
     const sdk = this._getSDK();
     if (!sdk)
       return;
-    sdk.updateColumn(columnId, updates);
+    sdk.updateColumn(columnId, updates, this._currentBoardId);
     this._sendFeaturesToWebview();
   }
   _removeColumn(columnId) {
@@ -8036,14 +8585,15 @@ var KanbanPanel = class _KanbanPanel {
       vscode.window.showWarningMessage("Cannot remove the last list.");
       return;
     }
-    sdk.removeColumn(columnId);
+    sdk.removeColumn(columnId, this._currentBoardId);
     this._sendFeaturesToWebview();
   }
 };
 
 // src/extension/SidebarViewProvider.ts
 var vscode2 = __toESM(require("vscode"));
-var path8 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
+init_types();
 var SidebarViewProvider = class {
   constructor(_extensionUri, _context) {
     this._extensionUri = _extensionUri;
@@ -8161,7 +8711,7 @@ var SidebarViewProvider = class {
       return null;
     const root = workspaceFolders[0].uri.fsPath;
     const config = readConfig(root);
-    return path8.join(root, config.featuresDirectory);
+    return path9.join(root, config.featuresDirectory);
   }
   _getColumns() {
     const featuresDir = this._getFeaturesDir();
@@ -8518,7 +9068,7 @@ async function createFeatureFromPrompts() {
   });
   const root = workspaceFolders[0].uri.fsPath;
   const kanbanConfig = readConfig(root);
-  const featuresDir = path9.join(root, kanbanConfig.featuresDirectory);
+  const featuresDir = path10.join(root, kanbanConfig.featuresDirectory);
   const sdk = new KanbanSDK(featuresDir);
   const content = `# ${title}${description ? "\n\n" + description : ""}`;
   const feature = await sdk.createCard({ content, status, priority });
@@ -8554,8 +9104,8 @@ function activate(context) {
   if (workspaceFolders) {
     const root = workspaceFolders[0].uri.fsPath;
     const kanbanConfig = readConfig(root);
-    const featuresDir = path9.join(root, kanbanConfig.featuresDirectory);
-    const webviewDir = path9.join(context.extensionPath, "dist", "standalone-webview");
+    const featuresDir = path10.join(root, kanbanConfig.featuresDirectory);
+    const webviewDir = path10.join(context.extensionPath, "dist", "standalone-webview");
     findFreePort(3464).then((port) => {
       standaloneServer = startServer(featuresDir, port, webviewDir);
       standaloneServer.on("error", () => {