kanban-lite 1.0.39 → 1.0.41

package/dist/cli.js

@@ -33,221 +33,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/.pnpm/fractional-indexing@3.2.0/node_modules/fractional-indexing/src/index.js
-function midpoint(a, b, digits) {
-  const zero = digits[0];
-  if (b != null && a >= b) {
-    throw new Error(a + " >= " + b);
-  }
-  if (a.slice(-1) === zero || b && b.slice(-1) === zero) {
-    throw new Error("trailing zero");
-  }
-  if (b) {
-    let n = 0;
-    while ((a[n] || zero) === b[n]) {
-      n++;
-    }
-    if (n > 0) {
-      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
-    }
-  }
-  const digitA = a ? digits.indexOf(a[0]) : 0;
-  const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
-  if (digitB - digitA > 1) {
-    const midDigit = Math.round(0.5 * (digitA + digitB));
-    return digits[midDigit];
-  } else {
-    if (b && b.length > 1) {
-      return b.slice(0, 1);
-    } else {
-      return digits[digitA] + midpoint(a.slice(1), null, digits);
-    }
-  }
-}
-function validateInteger(int4) {
-  if (int4.length !== getIntegerLength(int4[0])) {
-    throw new Error("invalid integer part of order key: " + int4);
-  }
-}
-function getIntegerLength(head) {
-  if (head >= "a" && head <= "z") {
-    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
-  } else if (head >= "A" && head <= "Z") {
-    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
-  } else {
-    throw new Error("invalid order key head: " + head);
-  }
-}
-function getIntegerPart(key) {
-  const integerPartLength = getIntegerLength(key[0]);
-  if (integerPartLength > key.length) {
-    throw new Error("invalid order key: " + key);
-  }
-  return key.slice(0, integerPartLength);
-}
-function validateOrderKey(key, digits) {
-  if (key === "A" + digits[0].repeat(26)) {
-    throw new Error("invalid order key: " + key);
-  }
-  const i = getIntegerPart(key);
-  const f = key.slice(i.length);
-  if (f.slice(-1) === digits[0]) {
-    throw new Error("invalid order key: " + key);
-  }
-}
-function incrementInteger(x, digits) {
-  validateInteger(x);
-  const [head, ...digs] = x.split("");
-  let carry = true;
-  for (let i = digs.length - 1; carry && i >= 0; i--) {
-    const d = digits.indexOf(digs[i]) + 1;
-    if (d === digits.length) {
-      digs[i] = digits[0];
-    } else {
-      digs[i] = digits[d];
-      carry = false;
-    }
-  }
-  if (carry) {
-    if (head === "Z") {
-      return "a" + digits[0];
-    }
-    if (head === "z") {
-      return null;
-    }
-    const h = String.fromCharCode(head.charCodeAt(0) + 1);
-    if (h > "a") {
-      digs.push(digits[0]);
-    } else {
-      digs.pop();
-    }
-    return h + digs.join("");
-  } else {
-    return head + digs.join("");
-  }
-}
-function decrementInteger(x, digits) {
-  validateInteger(x);
-  const [head, ...digs] = x.split("");
-  let borrow = true;
-  for (let i = digs.length - 1; borrow && i >= 0; i--) {
-    const d = digits.indexOf(digs[i]) - 1;
-    if (d === -1) {
-      digs[i] = digits.slice(-1);
-    } else {
-      digs[i] = digits[d];
-      borrow = false;
-    }
-  }
-  if (borrow) {
-    if (head === "a") {
-      return "Z" + digits.slice(-1);
-    }
-    if (head === "A") {
-      return null;
-    }
-    const h = String.fromCharCode(head.charCodeAt(0) - 1);
-    if (h < "Z") {
-      digs.push(digits.slice(-1));
-    } else {
-      digs.pop();
-    }
-    return h + digs.join("");
-  } else {
-    return head + digs.join("");
-  }
-}
-function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
-  if (a != null) {
-    validateOrderKey(a, digits);
-  }
-  if (b != null) {
-    validateOrderKey(b, digits);
-  }
-  if (a != null && b != null && a >= b) {
-    throw new Error(a + " >= " + b);
-  }
-  if (a == null) {
-    if (b == null) {
-      return "a" + digits[0];
-    }
-    const ib2 = getIntegerPart(b);
-    const fb2 = b.slice(ib2.length);
-    if (ib2 === "A" + digits[0].repeat(26)) {
-      return ib2 + midpoint("", fb2, digits);
-    }
-    if (ib2 < b) {
-      return ib2;
-    }
-    const res = decrementInteger(ib2, digits);
-    if (res == null) {
-      throw new Error("cannot decrement any more");
-    }
-    return res;
-  }
-  if (b == null) {
-    const ia2 = getIntegerPart(a);
-    const fa2 = a.slice(ia2.length);
-    const i2 = incrementInteger(ia2, digits);
-    return i2 == null ? ia2 + midpoint(fa2, null, digits) : i2;
-  }
-  const ia = getIntegerPart(a);
-  const fa = a.slice(ia.length);
-  const ib = getIntegerPart(b);
-  const fb = b.slice(ib.length);
-  if (ia === ib) {
-    return ia + midpoint(fa, fb, digits);
-  }
-  const i = incrementInteger(ia, digits);
-  if (i == null) {
-    throw new Error("cannot increment any more");
-  }
-  if (i < b) {
-    return i;
-  }
-  return ia + midpoint(fa, null, digits);
-}
-function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
-  if (n === 0) {
-    return [];
-  }
-  if (n === 1) {
-    return [generateKeyBetween(a, b, digits)];
-  }
-  if (b == null) {
-    let c2 = generateKeyBetween(a, b, digits);
-    const result = [c2];
-    for (let i = 0; i < n - 1; i++) {
-      c2 = generateKeyBetween(c2, b, digits);
-      result.push(c2);
-    }
-    return result;
-  }
-  if (a == null) {
-    let c2 = generateKeyBetween(a, b, digits);
-    const result = [c2];
-    for (let i = 0; i < n - 1; i++) {
-      c2 = generateKeyBetween(a, c2, digits);
-      result.push(c2);
-    }
-    result.reverse();
-    return result;
-  }
-  const mid = Math.floor(n / 2);
-  const c = generateKeyBetween(a, b, digits);
-  return [
-    ...generateNKeysBetween(a, c, mid, digits),
-    c,
-    ...generateNKeysBetween(c, b, n - mid - 1, digits)
-  ];
-}
-var BASE_62_DIGITS;
-var init_src = __esm({
-  "node_modules/.pnpm/fractional-indexing@3.2.0/node_modules/fractional-indexing/src/index.js"() {
-    BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-  }
-});
-
 // src/shared/types.ts
 function getTitleFromContent(content) {
   const match = content.match(/^#\s+(.+)$/m);
@@ -3224,11 +3009,11 @@ var init_js_yaml = __esm({
 
 // src/sdk/parser.ts
 function extractIdFromFilename(filePath) {
-  const basename9 = path3.basename(filePath, ".md");
-  const numericMatch = basename9.match(/^(\d+)-/);
+  const basename10 = path3.basename(filePath, ".md");
+  const numericMatch = basename10.match(/^(\d+)-/);
   if (numericMatch)
     return numericMatch[1];
-  return basename9;
+  return basename10;
 }
 function parseCommentBlock(header, body) {
   const getValue = (key) => {
@@ -3611,21 +3396,21 @@ var require_file_uri_to_path = __commonJS({
       var rest = decodeURI(uri.substring(7));
       var firstSlash = rest.indexOf("/");
       var host = rest.substring(0, firstSlash);
-      var path13 = rest.substring(firstSlash + 1);
+      var path17 = rest.substring(firstSlash + 1);
       if ("localhost" == host)
         host = "";
       if (host) {
         host = sep2 + sep2 + host;
       }
-      path13 = path13.replace(/^(.+)\|/, "$1:");
+      path17 = path17.replace(/^(.+)\|/, "$1:");
       if (sep2 == "\\") {
-        path13 = path13.replace(/\//g, "\\");
+        path17 = path17.replace(/\//g, "\\");
       }
-      if (/^.+\:/.test(path13)) {
+      if (/^.+\:/.test(path17)) {
       } else {
-        path13 = sep2 + path13;
+        path17 = sep2 + path17;
       }
-      return host + path13;
+      return host + path17;
     }
   }
 });
@@ -3633,19 +3418,19 @@ var require_file_uri_to_path = __commonJS({
 // node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
 var require_bindings = __commonJS({
   "node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports2, module2) {
-    var fs15 = require("fs");
-    var path13 = require("path");
+    var fs16 = require("fs");
+    var path17 = require("path");
     var fileURLToPath2 = require_file_uri_to_path();
-    var join13 = path13.join;
-    var dirname11 = path13.dirname;
-    var exists = fs15.accessSync && function(path14) {
+    var join16 = path17.join;
+    var dirname12 = path17.dirname;
+    var exists = fs16.accessSync && function(path18) {
       try {
-        fs15.accessSync(path14);
+        fs16.accessSync(path18);
       } catch (e) {
         return false;
       }
       return true;
-    } || fs15.existsSync || path13.existsSync;
+    } || fs16.existsSync || path17.existsSync;
     var defaults = {
       arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
       compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
@@ -3691,13 +3476,13 @@ var require_bindings = __commonJS({
       if (!opts.module_root) {
         opts.module_root = exports2.getRoot(exports2.getFileName());
       }
-      if (path13.extname(opts.bindings) != ".node") {
+      if (path17.extname(opts.bindings) != ".node") {
         opts.bindings += ".node";
       }
       var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
       var tries = [], i = 0, l = opts.try.length, n, b, err;
       for (; i < l; i++) {
-        n = join13.apply(
+        n = join16.apply(
           null,
           opts.try[i].map(function(p) {
             return opts[p] || p;
@@ -3753,12 +3538,12 @@ var require_bindings = __commonJS({
       return fileName;
     };
     exports2.getRoot = function getRoot(file3) {
-      var dir = dirname11(file3), prev;
+      var dir = dirname12(file3), prev;
       while (true) {
         if (dir === ".") {
           dir = process.cwd();
         }
-        if (exists(join13(dir, "package.json")) || exists(join13(dir, "node_modules"))) {
+        if (exists(join16(dir, "package.json")) || exists(join16(dir, "node_modules"))) {
           return dir;
         }
         if (prev === dir) {
@@ -3767,7 +3552,7 @@ var require_bindings = __commonJS({
           );
         }
         prev = dir;
-        dir = join13(dir, "..");
+        dir = join16(dir, "..");
       }
     };
   }
@@ -3934,11 +3719,11 @@ var require_pragma = __commonJS({
 var require_backup = __commonJS({
   "node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
     "use strict";
-    var fs15 = require("fs");
-    var path13 = require("path");
+    var fs16 = require("fs");
+    var path17 = require("path");
     var { promisify: promisify6 } = require("util");
     var { cppdb } = require_util();
-    var fsAccess = promisify6(fs15.access);
+    var fsAccess = promisify6(fs16.access);
     module2.exports = async function backup(filename, options) {
       if (options == null)
         options = {};
@@ -3959,7 +3744,7 @@ var require_backup = __commonJS({
         throw new TypeError('The "attached" option cannot be an empty string');
       if (handler != null && typeof handler !== "function")
         throw new TypeError('Expected the "progress" option to be a function');
-      await fsAccess(path13.dirname(filename)).catch(() => {
+      await fsAccess(path17.dirname(filename)).catch(() => {
         throw new TypeError("Cannot save backup because the directory does not exist");
       });
       const isNewFile = await fsAccess(filename).then(() => false, () => true);
@@ -4289,8 +4074,8 @@ var require_inspect = __commonJS({
 var require_database = __commonJS({
   "node_modules/.pnpm/better-sqlite3@12.6.2/node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
     "use strict";
-    var fs15 = require("fs");
-    var path13 = require("path");
+    var fs16 = require("fs");
+    var path17 = require("path");
     var util2 = require_util();
     var SqliteError = require_sqlite_error();
     var DEFAULT_ADDON;
@@ -4337,7 +4122,7 @@ var require_database = __commonJS({
         addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
       } else if (typeof nativeBinding === "string") {
         const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
-        addon = requireFunc(path13.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+        addon = requireFunc(path17.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
       } else {
         addon = nativeBinding;
       }
@@ -4345,7 +4130,7 @@ var require_database = __commonJS({
         addon.setErrorConstructor(SqliteError);
         addon.isInitialized = true;
       }
-      if (!anonymous && !filename.startsWith("file:") && !fs15.existsSync(path13.dirname(filename))) {
+      if (!anonymous && !filename.startsWith("file:") && !fs16.existsSync(path17.dirname(filename))) {
         throw new TypeError("Cannot open database because the directory does not exist");
       }
       Object.defineProperties(this, {
@@ -4617,7 +4402,7 @@ CREATE INDEX IF NOT EXISTS idx_comments_card       ON comments (card_id, board_i
         default_status   = excluded.default_status,
         default_priority = excluded.default_priority
     `);
-        const deleteBoard = this.db.prepare("DELETE FROM boards WHERE id = ?");
+        const deleteBoard2 = this.db.prepare("DELETE FROM boards WHERE id = ?");
         const existingBoardIds = this.db.prepare("SELECT id FROM boards").all().map((r) => r.id);
         const newBoardIds = new Set(Object.keys(config3.boards));
         const doWrite = this.db.transaction(() => {
@@ -4634,7 +4419,7 @@ CREATE INDEX IF NOT EXISTS idx_comments_card       ON comments (card_id, board_i
           }
           for (const id of existingBoardIds) {
             if (!newBoardIds.has(id))
-              deleteBoard.run(id);
+              deleteBoard2.run(id);
           }
           this.db.prepare("DELETE FROM labels").run();
           const insertLabel = this.db.prepare("INSERT INTO labels (name, color, group_name) VALUES (?, ?, ?)");
@@ -4866,9 +4651,9 @@ function createStorageEngine(kanbanDir, options = {}) {
 }
 function readBootstrapConfig(workspaceRoot) {
   try {
-    const fs15 = require("fs");
+    const fs16 = require("fs");
     const configFile = path7.join(workspaceRoot, ".kanban.json");
-    const raw = JSON.parse(fs15.readFileSync(configFile, "utf-8"));
+    const raw = JSON.parse(fs16.readFileSync(configFile, "utf-8"));
     return {
       storageEngine: raw.storageEngine,
       sqlitePath: raw.sqlitePath
@@ -4889,6 +4674,339 @@ var init_storage = __esm({
   }
 });
 
+// src/sdk/webhooks.ts
+function fireWebhooks(workspaceRoot, event, data) {
+  const config3 = readConfig(workspaceRoot);
+  const webhooks = config3.webhooks || [];
+  const matching = webhooks.filter(
+    (w) => w.active && (w.events.includes("*") || w.events.includes(event))
+  );
+  if (matching.length === 0)
+    return;
+  const payload = JSON.stringify({
+    event,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    data
+  });
+  for (const webhook of matching) {
+    deliverWebhook(webhook, event, payload).catch((err) => {
+      console.error(`Webhook delivery failed for ${webhook.id} (${webhook.url}):`, err.message || err);
+    });
+  }
+}
+async function deliverWebhook(webhook, event, payload) {
+  const url3 = new URL(webhook.url);
+  const isHttps = url3.protocol === "https:";
+  const transport = isHttps ? https : http;
+  const headers = {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(payload).toString(),
+    "X-Webhook-Event": event
+  };
+  if (webhook.secret) {
+    const signature = crypto.createHmac("sha256", webhook.secret).update(payload).digest("hex");
+    headers["X-Webhook-Signature"] = `sha256=${signature}`;
+  }
+  return new Promise((resolve9, reject) => {
+    const req = transport.request(
+      {
+        hostname: url3.hostname,
+        port: url3.port || (isHttps ? 443 : 80),
+        path: url3.pathname + url3.search,
+        method: "POST",
+        headers,
+        timeout: 1e4
+      },
+      (res) => {
+        res.resume();
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          resolve9();
+        } else {
+          reject(new Error(`HTTP ${res.statusCode}`));
+        }
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Timeout"));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+function loadWebhooks(workspaceRoot) {
+  const config3 = readConfig(workspaceRoot);
+  return config3.webhooks || [];
+}
+function saveWebhooks(workspaceRoot, webhooks) {
+  const config3 = readConfig(workspaceRoot);
+  config3.webhooks = webhooks;
+  writeConfig(workspaceRoot, config3);
+}
+function createWebhook(workspaceRoot, webhookConfig) {
+  const webhooks = loadWebhooks(workspaceRoot);
+  const webhook = {
+    id: "wh_" + crypto.randomBytes(8).toString("hex"),
+    url: webhookConfig.url,
+    events: webhookConfig.events,
+    secret: webhookConfig.secret,
+    active: true
+  };
+  webhooks.push(webhook);
+  saveWebhooks(workspaceRoot, webhooks);
+  return webhook;
+}
+function deleteWebhook(workspaceRoot, id) {
+  const webhooks = loadWebhooks(workspaceRoot);
+  const filtered = webhooks.filter((w) => w.id !== id);
+  if (filtered.length === webhooks.length)
+    return false;
+  saveWebhooks(workspaceRoot, filtered);
+  return true;
+}
+function updateWebhook(workspaceRoot, id, updates) {
+  const webhooks = loadWebhooks(workspaceRoot);
+  const webhook = webhooks.find((w) => w.id === id);
+  if (!webhook)
+    return null;
+  if (updates.url !== void 0)
+    webhook.url = updates.url;
+  if (updates.events !== void 0)
+    webhook.events = updates.events;
+  if (updates.secret !== void 0)
+    webhook.secret = updates.secret;
+  if (updates.active !== void 0)
+    webhook.active = updates.active;
+  saveWebhooks(workspaceRoot, webhooks);
+  return webhook;
+}
+var crypto, http, https;
+var init_webhooks = __esm({
+  "src/sdk/webhooks.ts"() {
+    "use strict";
+    crypto = __toESM(require("crypto"));
+    http = __toESM(require("http"));
+    https = __toESM(require("https"));
+    init_config();
+  }
+});
+
+// node_modules/.pnpm/fractional-indexing@3.2.0/node_modules/fractional-indexing/src/index.js
+function midpoint(a, b, digits) {
+  const zero = digits[0];
+  if (b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a.slice(-1) === zero || b && b.slice(-1) === zero) {
+    throw new Error("trailing zero");
+  }
+  if (b) {
+    let n = 0;
+    while ((a[n] || zero) === b[n]) {
+      n++;
+    }
+    if (n > 0) {
+      return b.slice(0, n) + midpoint(a.slice(n), b.slice(n), digits);
+    }
+  }
+  const digitA = a ? digits.indexOf(a[0]) : 0;
+  const digitB = b != null ? digits.indexOf(b[0]) : digits.length;
+  if (digitB - digitA > 1) {
+    const midDigit = Math.round(0.5 * (digitA + digitB));
+    return digits[midDigit];
+  } else {
+    if (b && b.length > 1) {
+      return b.slice(0, 1);
+    } else {
+      return digits[digitA] + midpoint(a.slice(1), null, digits);
+    }
+  }
+}
+function validateInteger(int4) {
+  if (int4.length !== getIntegerLength(int4[0])) {
+    throw new Error("invalid integer part of order key: " + int4);
+  }
+}
+function getIntegerLength(head) {
+  if (head >= "a" && head <= "z") {
+    return head.charCodeAt(0) - "a".charCodeAt(0) + 2;
+  } else if (head >= "A" && head <= "Z") {
+    return "Z".charCodeAt(0) - head.charCodeAt(0) + 2;
+  } else {
+    throw new Error("invalid order key head: " + head);
+  }
+}
+function getIntegerPart(key) {
+  const integerPartLength = getIntegerLength(key[0]);
+  if (integerPartLength > key.length) {
+    throw new Error("invalid order key: " + key);
+  }
+  return key.slice(0, integerPartLength);
+}
+function validateOrderKey(key, digits) {
+  if (key === "A" + digits[0].repeat(26)) {
+    throw new Error("invalid order key: " + key);
+  }
+  const i = getIntegerPart(key);
+  const f = key.slice(i.length);
+  if (f.slice(-1) === digits[0]) {
+    throw new Error("invalid order key: " + key);
+  }
+}
+function incrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let carry = true;
+  for (let i = digs.length - 1; carry && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) + 1;
+    if (d === digits.length) {
+      digs[i] = digits[0];
+    } else {
+      digs[i] = digits[d];
+      carry = false;
+    }
+  }
+  if (carry) {
+    if (head === "Z") {
+      return "a" + digits[0];
+    }
+    if (head === "z") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) + 1);
+    if (h > "a") {
+      digs.push(digits[0]);
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function decrementInteger(x, digits) {
+  validateInteger(x);
+  const [head, ...digs] = x.split("");
+  let borrow = true;
+  for (let i = digs.length - 1; borrow && i >= 0; i--) {
+    const d = digits.indexOf(digs[i]) - 1;
+    if (d === -1) {
+      digs[i] = digits.slice(-1);
+    } else {
+      digs[i] = digits[d];
+      borrow = false;
+    }
+  }
+  if (borrow) {
+    if (head === "a") {
+      return "Z" + digits.slice(-1);
+    }
+    if (head === "A") {
+      return null;
+    }
+    const h = String.fromCharCode(head.charCodeAt(0) - 1);
+    if (h < "Z") {
+      digs.push(digits.slice(-1));
+    } else {
+      digs.pop();
+    }
+    return h + digs.join("");
+  } else {
+    return head + digs.join("");
+  }
+}
+function generateKeyBetween(a, b, digits = BASE_62_DIGITS) {
+  if (a != null) {
+    validateOrderKey(a, digits);
+  }
+  if (b != null) {
+    validateOrderKey(b, digits);
+  }
+  if (a != null && b != null && a >= b) {
+    throw new Error(a + " >= " + b);
+  }
+  if (a == null) {
+    if (b == null) {
+      return "a" + digits[0];
+    }
+    const ib2 = getIntegerPart(b);
+    const fb2 = b.slice(ib2.length);
+    if (ib2 === "A" + digits[0].repeat(26)) {
+      return ib2 + midpoint("", fb2, digits);
+    }
+    if (ib2 < b) {
+      return ib2;
+    }
+    const res = decrementInteger(ib2, digits);
+    if (res == null) {
+      throw new Error("cannot decrement any more");
+    }
+    return res;
+  }
+  if (b == null) {
+    const ia2 = getIntegerPart(a);
+    const fa2 = a.slice(ia2.length);
+    const i2 = incrementInteger(ia2, digits);
+    return i2 == null ? ia2 + midpoint(fa2, null, digits) : i2;
+  }
+  const ia = getIntegerPart(a);
+  const fa = a.slice(ia.length);
+  const ib = getIntegerPart(b);
+  const fb = b.slice(ib.length);
+  if (ia === ib) {
+    return ia + midpoint(fa, fb, digits);
+  }
+  const i = incrementInteger(ia, digits);
+  if (i == null) {
+    throw new Error("cannot increment any more");
+  }
+  if (i < b) {
+    return i;
+  }
+  return ia + midpoint(fa, null, digits);
+}
+function generateNKeysBetween(a, b, n, digits = BASE_62_DIGITS) {
+  if (n === 0) {
+    return [];
+  }
+  if (n === 1) {
+    return [generateKeyBetween(a, b, digits)];
+  }
+  if (b == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0; i < n - 1; i++) {
+      c2 = generateKeyBetween(c2, b, digits);
+      result.push(c2);
+    }
+    return result;
+  }
+  if (a == null) {
+    let c2 = generateKeyBetween(a, b, digits);
+    const result = [c2];
+    for (let i = 0; i < n - 1; i++) {
+      c2 = generateKeyBetween(a, c2, digits);
+      result.push(c2);
+    }
+    result.reverse();
+    return result;
+  }
+  const mid = Math.floor(n / 2);
+  const c = generateKeyBetween(a, b, digits);
+  return [
+    ...generateNKeysBetween(a, c, mid, digits),
+    c,
+    ...generateNKeysBetween(c, b, n - mid - 1, digits)
+  ];
+}
+var BASE_62_DIGITS;
+var init_src = __esm({
+  "node_modules/.pnpm/fractional-indexing@3.2.0/node_modules/fractional-indexing/src/index.js"() {
+    BASE_62_DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  }
+});
+
 // src/sdk/types.ts
 function sanitizeCard(card) {
   const { filePath: _, ...rest } = card;
@@ -4903,15 +5021,210 @@ var init_types2 = __esm({
   }
 });
 
+// src/sdk/modules/boards.ts
+function listBoards(ctx) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  return Object.entries(config3.boards).map(([id, board]) => ({
+    id,
+    name: board.name,
+    description: board.description,
+    columns: board.columns,
+    actions: board.actions
+  }));
+}
+function createBoard(ctx, id, name, options) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  if (!id) {
+    const base = generateSlug(name) || "board";
+    let uniqueId = base;
+    let counter = 1;
+    while (config3.boards[uniqueId]) {
+      uniqueId = `${base}-${counter++}`;
+    }
+    id = uniqueId;
+  }
+  if (config3.boards[id]) {
+    throw new Error(`Board already exists: ${id}`);
+  }
+  const columns = options?.columns || [...config3.boards[config3.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" }
+  ]];
+  config3.boards[id] = {
+    name,
+    description: options?.description,
+    columns,
+    nextCardId: 1,
+    defaultStatus: options?.defaultStatus || columns[0]?.id || "backlog",
+    defaultPriority: options?.defaultPriority || config3.defaultPriority
+  };
+  writeConfig(ctx.workspaceRoot, config3);
+  const boardInfo = { id, name, description: options?.description };
+  ctx.emitEvent("board.created", boardInfo);
+  return boardInfo;
+}
+async function deleteBoard(ctx, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  if (!config3.boards[boardId]) {
+    throw new Error(`Board not found: ${boardId}`);
+  }
+  if (config3.defaultBoard === boardId) {
+    throw new Error(`Cannot delete the default board: ${boardId}`);
+  }
+  const cards = await ctx.listCards(void 0, boardId);
+  if (cards.length > 0) {
+    throw new Error(`Cannot delete board "${boardId}": ${cards.length} card(s) still exist`);
+  }
+  const boardDir = ctx._boardDir(boardId);
+  await ctx._storage.deleteBoardData(boardDir, boardId);
+  delete config3.boards[boardId];
+  writeConfig(ctx.workspaceRoot, config3);
+  ctx.emitEvent("board.deleted", { id: boardId });
+}
+function getBoard(ctx, boardId) {
+  return getBoardConfig(ctx.workspaceRoot, boardId);
+}
+function updateBoard(ctx, boardId, updates) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const board = config3.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(ctx.workspaceRoot, config3);
+  ctx.emitEvent("board.updated", { id: boardId, ...board });
+  return board;
+}
+function getBoardActions(ctx, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const resolvedId = boardId || config3.defaultBoard;
+  const board = config3.boards[resolvedId];
+  if (!board)
+    throw new Error(`Board not found: ${resolvedId}`);
+  return board.actions ?? {};
+}
+function addBoardAction(ctx, boardId, key, title) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const board = config3.boards[boardId];
+  if (!board)
+    throw new Error(`Board not found: ${boardId}`);
+  board.actions ??= {};
+  board.actions[key] = title;
+  writeConfig(ctx.workspaceRoot, config3);
+  ctx.emitEvent("board.updated", { id: boardId, ...board });
+  return board.actions;
+}
+function removeBoardAction(ctx, boardId, key) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const board = config3.boards[boardId];
+  if (!board)
+    throw new Error(`Board not found: ${boardId}`);
+  if (!board.actions || !(key in board.actions)) {
+    throw new Error(`Action "${key}" not found on board "${boardId}"`);
+  }
+  delete board.actions[key];
+  if (Object.keys(board.actions).length === 0)
+    delete board.actions;
+  writeConfig(ctx.workspaceRoot, config3);
+  ctx.emitEvent("board.updated", { id: boardId, ...board });
+  return board.actions ?? {};
+}
+async function triggerBoardAction(ctx, boardId, actionKey) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const resolvedId = boardId || config3.defaultBoard;
+  const board = config3.boards[resolvedId];
+  if (!board)
+    throw new Error(`Board not found: ${resolvedId}`);
+  const actions = board.actions ?? {};
+  if (!(actionKey in actions)) {
+    throw new Error(`Action "${actionKey}" not defined on board "${resolvedId}"`);
+  }
+  const actionTitle = actions[actionKey];
+  ctx.emitEvent("board.action", { boardId: resolvedId, action: actionKey, title: actionTitle });
+}
+async function transferCard(ctx, cardId, fromBoardId, toBoardId, targetStatus) {
+  const toBoardDir = ctx._boardDir(toBoardId);
+  const config3 = readConfig(ctx.workspaceRoot);
+  if (!config3.boards[fromBoardId])
+    throw new Error(`Board not found: ${fromBoardId}`);
+  if (!config3.boards[toBoardId])
+    throw new Error(`Board not found: ${toBoardId}`);
+  const card = await ctx.getCard(cardId, fromBoardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId} in board ${fromBoardId}`);
+  const previousStatus = card.status;
+  const toBoard = config3.boards[toBoardId];
+  const newStatus = targetStatus || toBoard.defaultStatus || toBoard.columns[0]?.id || "backlog";
+  await ctx._storage.ensureBoardDirs(toBoardDir, [newStatus]);
+  const srcAttachDir = ctx._storage.getCardDir(card);
+  await ctx._storage.deleteCard(card);
+  card.status = newStatus;
+  card.boardId = toBoardId;
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  card.completedAt = ctx._isCompletedStatus(newStatus, toBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
+  if (ctx._storage.type === "markdown") {
+    card.filePath = path8.join(toBoardDir, newStatus, path8.basename(card.filePath));
+  } else {
+    card.filePath = "";
+  }
+  const targetCards = await ctx.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 ctx._storage.writeCard(card);
+  if (card.attachments.length > 0) {
+    const dstAttachDir = ctx._storage.getCardDir(card);
+    if (srcAttachDir !== dstAttachDir) {
+      await fs6.mkdir(dstAttachDir, { recursive: true });
+      await Promise.all(
+        card.attachments.map(async (filename) => {
+          const src = path8.join(srcAttachDir, filename);
+          const dst = path8.join(dstAttachDir, filename);
+          await fs6.rename(src, dst).catch(() => {
+          });
+        })
+      );
+    }
+  }
+  ctx.emitEvent("task.moved", { ...sanitizeCard(card), previousStatus, fromBoard: fromBoardId, toBoard: toBoardId });
+  await ctx.addLog(card.id, `Status changed: \`${previousStatus}\` \u2192 \`${newStatus}\``, { source: "system" }, toBoardId).catch(() => {
+  });
+  return card;
+}
+var path8, fs6;
+var init_boards = __esm({
+  "src/sdk/modules/boards.ts"() {
+    "use strict";
+    path8 = __toESM(require("path"));
+    fs6 = __toESM(require("fs/promises"));
+    init_src();
+    init_types();
+    init_config();
+    init_types2();
+  }
+});
+
 // src/sdk/metaUtils.ts
-function getNestedValue(obj, path13) {
-  return path13.split(".").reduce((curr, key) => curr != null && typeof curr === "object" ? curr[key] : void 0, obj);
+function getNestedValue(obj, path17) {
+  return path17.split(".").reduce((curr, key) => curr != null && typeof curr === "object" ? curr[key] : void 0, obj);
 }
 function matchesMetaFilter(metadata, filter) {
   if (!metadata)
     return false;
-  for (const [path13, needle] of Object.entries(filter)) {
-    const value = getNestedValue(metadata, path13);
+  for (const [path17, needle] of Object.entries(filter)) {
+    const value = getNestedValue(metadata, path17);
     if (value == null)
       return false;
     if (!String(value).toLowerCase().includes(needle.toLowerCase()))
@@ -4925,20 +5238,769 @@ var init_metaUtils = __esm({
   }
 });
 
-// src/sdk/KanbanSDK.ts
-var path8, fs6, KanbanSDK;
-var init_KanbanSDK = __esm({
-  "src/sdk/KanbanSDK.ts"() {
+// src/sdk/modules/cards.ts
+async function listCards(ctx, columns, boardId, metaFilter, sort) {
+  await ctx._ensureMigrated();
+  const boardDir = ctx._boardDir(boardId);
+  const resolvedBoardId = ctx._resolveBoardId(boardId);
+  await ctx._storage.ensureBoardDirs(boardDir, columns);
+  const cards = await ctx._storage.scanCards(boardDir, resolvedBoardId);
+  const hasLegacyOrder = cards.some((c) => /^\d+$/.test(c.order));
+  if (hasLegacyOrder) {
+    const byStatus = /* @__PURE__ */ new Map();
+    for (const c of cards) {
+      const list = byStatus.get(c.status) || [];
+      list.push(c);
+      byStatus.set(c.status, list);
+    }
+    for (const columnCards of byStatus.values()) {
+      columnCards.sort((a, b) => parseInt(a.order) - parseInt(b.order));
+      const keys = generateNKeysBetween(null, null, columnCards.length);
+      for (let i = 0; i < columnCards.length; i++) {
+        columnCards[i].order = keys[i];
+        await ctx._storage.writeCard(columnCards[i]);
+      }
+    }
+  }
+  const numericIds = cards.map((c) => parseInt(c.id, 10)).filter((n) => !Number.isNaN(n));
+  if (numericIds.length > 0) {
+    syncCardIdCounter(ctx.workspaceRoot, resolvedBoardId, numericIds);
+  }
+  const filtered = metaFilter && Object.keys(metaFilter).length > 0 ? cards.filter((c) => matchesMetaFilter(c.metadata, metaFilter)) : cards;
+  if (sort) {
+    const [field, dir] = sort.split(":");
+    return filtered.sort((a, b) => {
+      const aVal = field === "created" ? a.created : a.modified;
+      const bVal = field === "created" ? b.created : b.modified;
+      return dir === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+    });
+  }
+  return filtered.sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
+}
+async function getCard(ctx, cardId, boardId) {
+  const cards = await listCards(ctx, void 0, boardId);
+  return cards.find((c) => c.id === cardId) || null;
+}
+async function createCard(ctx, data) {
+  await ctx._ensureMigrated();
+  const resolvedBoardId = ctx._resolveBoardId(data.boardId);
+  const boardDir = ctx._boardDir(resolvedBoardId);
+  await ctx._storage.ensureBoardDirs(boardDir);
+  const config3 = readConfig(ctx.workspaceRoot);
+  const board = config3.boards[resolvedBoardId];
+  const status = data.status || board?.defaultStatus || config3.defaultStatus || "backlog";
+  const priority = data.priority || board?.defaultPriority || config3.defaultPriority || "medium";
+  const title = getTitleFromContent(data.content);
+  const numericId = allocateCardId(ctx.workspaceRoot, resolvedBoardId);
+  const filename = generateCardFilename(numericId, title);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const cards = await listCards(ctx, 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 = {
+    version: CARD_FORMAT_VERSION,
+    id: String(numericId),
+    boardId: resolvedBoardId,
+    status,
+    priority,
+    assignee: data.assignee ?? null,
+    dueDate: data.dueDate ?? null,
+    created: now,
+    modified: now,
+    completedAt: ctx._isCompletedStatus(status, resolvedBoardId) ? now : null,
+    labels: data.labels || [],
+    attachments: data.attachments || [],
+    comments: [],
+    order: generateKeyBetween(lastOrder, null),
+    content: data.content,
+    ...data.metadata && Object.keys(data.metadata).length > 0 ? { metadata: data.metadata } : {},
+    ...data.actions && (Array.isArray(data.actions) ? data.actions.length > 0 : Object.keys(data.actions).length > 0) ? { actions: data.actions } : {},
+    filePath: ctx._storage.type === "markdown" ? getCardFilePath(boardDir, status, filename) : ""
+  };
+  await ctx._storage.writeCard(card);
+  ctx.emitEvent("task.created", sanitizeCard(card));
+  return card;
+}
+async function updateCard(ctx, cardId, updates, boardId) {
+  const card = await getCard(ctx, cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const resolvedBoardId = card.boardId || ctx._resolveBoardId(boardId);
+  const boardDir = ctx._boardDir(resolvedBoardId);
+  const oldStatus = card.status;
+  const oldTitle = getTitleFromContent(card.content);
+  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 = ctx._isCompletedStatus(card.status, resolvedBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
+  }
+  await ctx._storage.writeCard(card);
+  const newTitle = getTitleFromContent(card.content);
+  const numericId = extractNumericId(card.id);
+  if (numericId !== null && newTitle !== oldTitle) {
+    const newFilename = generateCardFilename(numericId, newTitle);
+    const newPath = await ctx._storage.renameCard(card, newFilename);
+    if (newPath)
+      card.filePath = newPath;
+  }
+  if (oldStatus !== card.status) {
+    const newPath = await ctx._storage.moveCard(card, boardDir, card.status);
+    if (newPath)
+      card.filePath = newPath;
+  }
+  ctx.emitEvent("task.updated", sanitizeCard(card));
+  if (oldStatus !== card.status) {
+    await ctx.addLog(card.id, `Status changed: \`${oldStatus}\` \u2192 \`${card.status}\``, { source: "system" }, resolvedBoardId).catch(() => {
+    });
+  }
+  return card;
+}
+async function triggerAction(ctx, cardId, action, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const { actionWebhookUrl } = config3;
+  if (!actionWebhookUrl) {
+    throw new Error("No action webhook URL configured. Set actionWebhookUrl in .kanban.json");
+  }
+  const card = await getCard(ctx, cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const resolvedBoardId = card.boardId || ctx._resolveBoardId(boardId);
+  const payload = {
+    action,
+    board: resolvedBoardId,
+    list: card.status,
+    card: sanitizeCard(card)
+  };
+  const response = await fetch(actionWebhookUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error(`Action webhook responded with ${response.status}: ${response.statusText}`);
+  }
+  await ctx.addLog(cardId, `Action triggered: \`${action}\``, { source: "system" }, resolvedBoardId).catch(() => {
+  });
+}
+async function moveCard(ctx, cardId, newStatus, position, boardId) {
+  const cards = await listCards(ctx, void 0, boardId);
+  const card = cards.find((c) => c.id === cardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const resolvedBoardId = card.boardId || ctx._resolveBoardId(boardId);
+  const boardDir = ctx._boardDir(resolvedBoardId);
+  const oldStatus = card.status;
+  card.status = newStatus;
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  if (oldStatus !== newStatus) {
+    card.completedAt = ctx._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 ctx._storage.writeCard(card);
+  if (oldStatus !== newStatus) {
+    const newPath = await ctx._storage.moveCard(card, boardDir, newStatus);
+    if (newPath)
+      card.filePath = newPath;
+  }
+  ctx.emitEvent("task.moved", { ...sanitizeCard(card), previousStatus: oldStatus });
+  if (oldStatus !== newStatus) {
+    await ctx.addLog(card.id, `Status changed: \`${oldStatus}\` \u2192 \`${newStatus}\``, { source: "system" }, resolvedBoardId).catch(() => {
+    });
+  }
+  return card;
+}
+async function deleteCard(ctx, cardId, boardId) {
+  const card = await getCard(ctx, cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  if (card.status === DELETED_STATUS_ID)
+    return;
+  await updateCard(ctx, cardId, { status: DELETED_STATUS_ID }, boardId);
+}
+async function permanentlyDeleteCard(ctx, cardId, boardId) {
+  const card = await getCard(ctx, cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const snapshot = sanitizeCard(card);
+  await ctx._storage.deleteCard(card);
+  ctx.emitEvent("task.deleted", snapshot);
+}
+async function getCardsByStatus(ctx, status, boardId) {
+  const cards = await listCards(ctx, void 0, boardId);
+  return cards.filter((c) => c.status === status);
+}
+async function getUniqueAssignees(ctx, boardId) {
+  const cards = await listCards(ctx, void 0, boardId);
+  const assignees = /* @__PURE__ */ new Set();
+  for (const c of cards) {
+    if (c.assignee)
+      assignees.add(c.assignee);
+  }
+  return [...assignees].sort();
+}
+async function getUniqueLabels(ctx, boardId) {
+  const cards = await listCards(ctx, void 0, boardId);
+  const labels = /* @__PURE__ */ new Set();
+  for (const c of cards) {
+    for (const l of c.labels)
+      labels.add(l);
+  }
+  return [...labels].sort();
+}
+var init_cards = __esm({
+  "src/sdk/modules/cards.ts"() {
     "use strict";
-    path8 = __toESM(require("path"));
-    fs6 = __toESM(require("fs/promises"));
     init_src();
     init_types();
     init_config();
     init_fileUtils();
+    init_metaUtils();
     init_types2();
+  }
+});
+
+// src/sdk/modules/labels.ts
+function getLabels(ctx) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  return config3.labels || {};
+}
+function setLabel(ctx, name, definition) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  if (!config3.labels)
+    config3.labels = {};
+  config3.labels[name] = definition;
+  writeConfig(ctx.workspaceRoot, config3);
+}
+async function deleteLabel(ctx, name) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  if (config3.labels) {
+    delete config3.labels[name];
+    writeConfig(ctx.workspaceRoot, config3);
+  }
+  const cards = await ctx.listCards();
+  for (const card of cards) {
+    if (card.labels.includes(name)) {
+      await ctx.updateCard(card.id, { labels: card.labels.filter((l) => l !== name) });
+    }
+  }
+}
+async function renameLabel(ctx, oldName, newName) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  if (config3.labels && config3.labels[oldName]) {
+    config3.labels[newName] = config3.labels[oldName];
+    delete config3.labels[oldName];
+    writeConfig(ctx.workspaceRoot, config3);
+  }
+  const cards = await ctx.listCards();
+  for (const card of cards) {
+    if (card.labels.includes(oldName)) {
+      const newLabels = card.labels.map((l) => l === oldName ? newName : l);
+      await ctx.updateCard(card.id, { labels: newLabels });
+    }
+  }
+}
+function getLabelsInGroup(ctx, group) {
+  const labels = getLabels(ctx);
+  return Object.entries(labels).filter(([, def]) => def.group === group).map(([name]) => name).sort();
+}
+async function filterCardsByLabelGroup(ctx, group, boardId) {
+  const groupLabels = getLabelsInGroup(ctx, group);
+  if (groupLabels.length === 0)
+    return [];
+  const cards = await ctx.listCards(void 0, boardId);
+  return cards.filter((c) => c.labels.some((l) => groupLabels.includes(l)));
+}
+var init_labels = __esm({
+  "src/sdk/modules/labels.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/sdk/modules/attachments.ts
+async function addAttachment(ctx, cardId, sourcePath, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const fileName = path9.basename(sourcePath);
+  await ctx._storage.copyAttachment(sourcePath, card);
+  if (!card.attachments.includes(fileName)) {
+    card.attachments.push(fileName);
+  }
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx._storage.writeCard(card);
+  ctx.emitEvent("attachment.added", { cardId, attachment: fileName });
+  return card;
+}
+async function removeAttachment(ctx, cardId, attachment, boardId) {
+  const card = await ctx.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 ctx._storage.writeCard(card);
+  ctx.emitEvent("attachment.removed", { cardId, attachment });
+  return card;
+}
+async function listAttachments(ctx, cardId, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  return card.attachments;
+}
+async function getAttachmentDir(ctx, cardId, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    return null;
+  return ctx._storage.getCardDir(card);
+}
+var path9;
+var init_attachments = __esm({
+  "src/sdk/modules/attachments.ts"() {
+    "use strict";
+    path9 = __toESM(require("path"));
+  }
+});
+
+// src/sdk/modules/comments.ts
+async function listComments(ctx, cardId, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  return card.comments || [];
+}
+async function addComment(ctx, cardId, author, content, boardId) {
+  if (!content?.trim())
+    throw new Error("Comment content cannot be empty");
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  if (!card.comments)
+    card.comments = [];
+  const maxId = card.comments.reduce((max, c) => {
+    const num = parseInt(c.id.replace("c", ""), 10);
+    return Number.isNaN(num) ? max : Math.max(max, num);
+  }, 0);
+  const comment = {
+    id: `c${maxId + 1}`,
+    author,
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    content
+  };
+  card.comments.push(comment);
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx._storage.writeCard(card);
+  ctx.emitEvent("comment.created", { ...comment, cardId });
+  return card;
+}
+async function updateComment(ctx, cardId, commentId, content, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const comment = (card.comments || []).find((c) => c.id === commentId);
+  if (!comment)
+    throw new Error(`Comment not found: ${commentId}`);
+  comment.content = content;
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx._storage.writeCard(card);
+  ctx.emitEvent("comment.updated", { ...comment, cardId });
+  return card;
+}
+async function deleteComment(ctx, cardId, commentId, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const comment = (card.comments || []).find((c) => c.id === commentId);
+  card.comments = (card.comments || []).filter((c) => c.id !== commentId);
+  card.modified = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx._storage.writeCard(card);
+  if (comment) {
+    ctx.emitEvent("comment.deleted", { ...comment, cardId });
+  }
+  return card;
+}
+var init_comments = __esm({
+  "src/sdk/modules/comments.ts"() {
+    "use strict";
+  }
+});
+
+// src/sdk/modules/logs.ts
+function parseLogLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed)
+    return null;
+  const match = trimmed.match(/^(\S+)\s+\[([^\]]+)\]\s+(.+)$/);
+  if (!match)
+    return null;
+  const [, timestamp2, source, rest] = match;
+  const jsonMatch = rest.match(/^(.*?)\s+(\{.+\})\s*$/);
+  if (jsonMatch) {
+    try {
+      const obj = JSON.parse(jsonMatch[2]);
+      return { timestamp: timestamp2, source, text: jsonMatch[1], object: obj };
+    } catch {
+    }
+  }
+  return { timestamp: timestamp2, source, text: rest };
+}
+function serializeLogEntry(entry) {
+  let line = `${entry.timestamp} [${entry.source}] ${entry.text}`;
+  if (entry.object && Object.keys(entry.object).length > 0) {
+    line += ` ${JSON.stringify(entry.object)}`;
+  }
+  return line;
+}
+async function getLogFilePath(ctx, cardId, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    return null;
+  const dir = ctx._storage.getCardDir(card);
+  return path10.join(dir, `${card.id}.log`);
+}
+async function listLogs(ctx, cardId, boardId) {
+  const logPath = await getLogFilePath(ctx, cardId, boardId);
+  if (!logPath)
+    throw new Error(`Card not found: ${cardId}`);
+  try {
+    const content = await fs7.readFile(logPath, "utf-8");
+    const entries = [];
+    for (const line of content.split("\n")) {
+      const entry = parseLogLine(line);
+      if (entry)
+        entries.push(entry);
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+async function addLog(ctx, cardId, text, options, boardId) {
+  if (!text?.trim())
+    throw new Error("Log text cannot be empty");
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const entry = {
+    timestamp: options?.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+    source: options?.source || "default",
+    text: text.trim(),
+    ...options?.object && Object.keys(options.object).length > 0 ? { object: options.object } : {}
+  };
+  const dir = ctx._storage.getCardDir(card);
+  const logFileName = `${card.id}.log`;
+  const logPath = path10.join(dir, logFileName);
+  await fs7.mkdir(dir, { recursive: true });
+  const line = serializeLogEntry(entry) + "\n";
+  await fs7.appendFile(logPath, line, "utf-8");
+  if (!card.attachments.includes(logFileName)) {
+    card.attachments.push(logFileName);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await ctx._storage.writeCard(card);
+  }
+  ctx.emitEvent("log.added", { cardId, entry });
+  return entry;
+}
+async function clearLogs(ctx, cardId, boardId) {
+  const card = await ctx.getCard(cardId, boardId);
+  if (!card)
+    throw new Error(`Card not found: ${cardId}`);
+  const logFileName = `${card.id}.log`;
+  const dir = ctx._storage.getCardDir(card);
+  const logPath = path10.join(dir, logFileName);
+  try {
+    await fs7.unlink(logPath);
+  } catch {
+  }
+  if (card.attachments.includes(logFileName)) {
+    card.attachments = card.attachments.filter((a) => a !== logFileName);
+    card.modified = (/* @__PURE__ */ new Date()).toISOString();
+    await ctx._storage.writeCard(card);
+  }
+  ctx.emitEvent("log.cleared", { cardId });
+}
+function getBoardLogFilePath(ctx, boardId) {
+  return path10.join(ctx._boardDir(boardId), "board.log");
+}
+async function listBoardLogs(ctx, boardId) {
+  const logPath = getBoardLogFilePath(ctx, boardId);
+  let content;
+  try {
+    content = await fs7.readFile(logPath, "utf-8");
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const entry = parseLogLine(trimmed);
+    if (entry)
+      entries.push(entry);
+  }
+  return entries;
+}
+async function addBoardLog(ctx, text, options, boardId) {
+  const entry = {
+    timestamp: options?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    source: options?.source ?? "sdk",
+    text,
+    ...options?.object ? { object: options.object } : {}
+  };
+  const logPath = getBoardLogFilePath(ctx, boardId);
+  await fs7.mkdir(path10.dirname(logPath), { recursive: true });
+  const line = serializeLogEntry(entry) + "\n";
+  await fs7.appendFile(logPath, line, "utf-8");
+  ctx.emitEvent("board.log.added", { boardId, entry });
+  return entry;
+}
+async function clearBoardLogs(ctx, boardId) {
+  const logPath = getBoardLogFilePath(ctx, boardId);
+  try {
+    await fs7.unlink(logPath);
+  } catch {
+  }
+  ctx.emitEvent("board.log.cleared", { boardId });
+}
+var path10, fs7;
+var init_logs = __esm({
+  "src/sdk/modules/logs.ts"() {
+    "use strict";
+    path10 = __toESM(require("path"));
+    fs7 = __toESM(require("fs/promises"));
+  }
+});
+
+// src/sdk/modules/columns.ts
+function listColumns(ctx, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const resolvedId = boardId || config3.defaultBoard;
+  const board = config3.boards[resolvedId];
+  return board?.columns || [];
+}
+function addColumn(ctx, column, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const resolvedId = boardId || config3.defaultBoard;
+  const board = config3.boards[resolvedId];
+  if (!board)
+    throw new Error(`Board not found: ${resolvedId}`);
+  if (!column.id) {
+    const base = generateSlug(column.name) || "column";
+    let uniqueId = base;
+    let counter = 1;
+    while (board.columns.some((c) => c.id === uniqueId)) {
+      uniqueId = `${base}-${counter++}`;
+    }
+    column = { ...column, id: uniqueId };
+  }
+  if (column.id === DELETED_STATUS_ID)
+    throw new Error(`"${DELETED_STATUS_ID}" is a reserved column ID`);
+  if (board.columns.some((c) => c.id === column.id)) {
+    throw new Error(`Column already exists: ${column.id}`);
+  }
+  board.columns.push(column);
+  writeConfig(ctx.workspaceRoot, config3);
+  ctx.emitEvent("column.created", column);
+  return board.columns;
+}
+function updateColumn(ctx, columnId, updates, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const resolvedId = boardId || config3.defaultBoard;
+  const board = config3.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)
+    col.name = updates.name;
+  if (updates.color !== void 0)
+    col.color = updates.color;
+  writeConfig(ctx.workspaceRoot, config3);
+  ctx.emitEvent("column.updated", col);
+  return board.columns;
+}
+async function removeColumn(ctx, columnId, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const resolvedId = boardId || config3.defaultBoard;
+  const board = config3.boards[resolvedId];
+  if (!board)
+    throw new Error(`Board not found: ${resolvedId}`);
+  if (columnId === DELETED_STATUS_ID)
+    throw new Error(`Cannot remove the reserved "${DELETED_STATUS_ID}" column`);
+  const idx = board.columns.findIndex((c) => c.id === columnId);
+  if (idx === -1)
+    throw new Error(`Column not found: ${columnId}`);
+  const cards = await ctx.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`);
+  }
+  const removed = board.columns[idx];
+  board.columns.splice(idx, 1);
+  writeConfig(ctx.workspaceRoot, config3);
+  ctx.emitEvent("column.deleted", removed);
+  return board.columns;
+}
+async function cleanupColumn(ctx, columnId, boardId) {
+  if (columnId === DELETED_STATUS_ID)
+    return 0;
+  const cards = await ctx.listCards(void 0, boardId);
+  const cardsToMove = cards.filter((c) => c.status === columnId);
+  for (const card of cardsToMove) {
+    await ctx.moveCard(card.id, DELETED_STATUS_ID, 0, boardId);
+  }
+  return cardsToMove.length;
+}
+async function purgeDeletedCards(ctx, boardId) {
+  const cards = await ctx.listCards(void 0, boardId);
+  const deleted = cards.filter((c) => c.status === DELETED_STATUS_ID);
+  for (const card of deleted) {
+    await ctx.permanentlyDeleteCard(card.id, boardId);
+  }
+  return deleted.length;
+}
+function reorderColumns(ctx, columnIds, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  const resolvedId = boardId || config3.defaultBoard;
+  const board = config3.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 !== board.columns.length) {
+    throw new Error("Must include all column IDs when reordering");
+  }
+  board.columns = columnIds.map((id) => colMap.get(id));
+  writeConfig(ctx.workspaceRoot, config3);
+  return board.columns;
+}
+var init_columns = __esm({
+  "src/sdk/modules/columns.ts"() {
+    "use strict";
+    init_config();
+    init_types();
+  }
+});
+
+// src/sdk/modules/settings.ts
+function getSettings(ctx) {
+  return configToSettings(readConfig(ctx.workspaceRoot));
+}
+function updateSettings(ctx, settings) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  writeConfig(ctx.workspaceRoot, settingsToConfig(config3, settings));
+  ctx.emitEvent("settings.updated", settings);
+}
+function setDefaultBoard(ctx, boardId) {
+  const config3 = readConfig(ctx.workspaceRoot);
+  if (!config3.boards[boardId])
+    throw new Error(`Board not found: ${boardId}`);
+  config3.defaultBoard = boardId;
+  writeConfig(ctx.workspaceRoot, config3);
+}
+var init_settings = __esm({
+  "src/sdk/modules/settings.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/sdk/modules/migration.ts
+async function migrateToSqlite(ctx, dbPath) {
+  if (ctx._storage.type === "sqlite") {
+    throw new Error("Storage engine is already sqlite");
+  }
+  await ctx._ensureMigrated();
+  const resolvedDbPath = dbPath ?? ".kanban/kanban.db";
+  const absDbPath = path11.resolve(ctx.workspaceRoot, resolvedDbPath);
+  const { SqliteStorageEngine: SqliteStorageEngine2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
+  const sqliteEngine = new SqliteStorageEngine2(ctx._storage.kanbanDir, absDbPath);
+  await sqliteEngine.init();
+  const config3 = readConfig(ctx.workspaceRoot);
+  const boardIds = Object.keys(config3.boards);
+  let count = 0;
+  for (const boardId of boardIds) {
+    const boardDir = path11.join(ctx._storage.kanbanDir, "boards", boardId);
+    const cards = await ctx._storage.scanCards(boardDir, boardId);
+    for (const card of cards) {
+      await sqliteEngine.writeCard({ ...card, filePath: "" });
+      count++;
+    }
+  }
+  sqliteEngine.close();
+  writeConfig(ctx.workspaceRoot, { ...config3, storageEngine: "sqlite", sqlitePath: resolvedDbPath });
+  ctx.emitEvent("storage.migrated", { from: "markdown", to: "sqlite", count });
+  return count;
+}
+async function migrateToMarkdown(ctx) {
+  if (ctx._storage.type === "markdown") {
+    throw new Error("Storage engine is already markdown");
+  }
+  await ctx._ensureMigrated();
+  const { MarkdownStorageEngine: MarkdownStorageEngine2 } = await Promise.resolve().then(() => (init_markdown(), markdown_exports));
+  const mdEngine = new MarkdownStorageEngine2(ctx._storage.kanbanDir);
+  await mdEngine.init();
+  const config3 = readConfig(ctx.workspaceRoot);
+  const boardIds = Object.keys(config3.boards);
+  let count = 0;
+  for (const boardId of boardIds) {
+    const boardDir = path11.join(ctx._storage.kanbanDir, "boards", boardId);
+    const cards = await ctx._storage.scanCards(boardDir, boardId);
+    for (const card of cards) {
+      const numericId = Number(card.id) || 0;
+      const title = getTitleFromContent(card.content) || card.id;
+      const filename = generateCardFilename(numericId, title);
+      const filePath = getCardFilePath(boardDir, card.status, filename);
+      await mdEngine.writeCard({ ...card, filePath });
+      count++;
+    }
+  }
+  mdEngine.close();
+  const { storageEngine: _se, sqlitePath: _sp, ...restConfig } = config3;
+  writeConfig(ctx.workspaceRoot, restConfig);
+  ctx.emitEvent("storage.migrated", { from: "sqlite", to: "markdown", count });
+  return count;
+}
+var path11;
+var init_migration2 = __esm({
+  "src/sdk/modules/migration.ts"() {
+    "use strict";
+    path11 = __toESM(require("path"));
+    init_config();
+    init_types();
+    init_fileUtils();
+  }
+});
+
+// src/sdk/KanbanSDK.ts
+var path12, KanbanSDK;
+var init_KanbanSDK = __esm({
+  "src/sdk/KanbanSDK.ts"() {
+    "use strict";
+    path12 = __toESM(require("path"));
+    init_types();
+    init_config();
     init_storage();
-    init_metaUtils();
+    init_webhooks();
+    init_boards();
+    init_cards();
+    init_labels();
+    init_attachments();
+    init_comments();
+    init_logs();
+    init_columns();
+    init_settings();
+    init_migration2();
     KanbanSDK = class {
       /**
        * Creates a new KanbanSDK instance.
@@ -4990,6 +6052,7 @@ var init_KanbanSDK = __esm({
        * Emits an event to the registered handler, if one exists.
        * Called internally after every successful mutating operation.
        */
+      /** @internal */
       emitEvent(event, data) {
         if (this._onEvent) {
           try {
@@ -4997,6 +6060,8 @@ var init_KanbanSDK = __esm({
           } catch (err) {
             console.error(`SDK event handler error for ${event}:`, err);
           }
+        } else {
+          fireWebhooks(this.workspaceRoot, event, data);
         }
       }
       /**
@@ -5013,17 +6078,20 @@ var init_KanbanSDK = __esm({
        * ```
        */
       get workspaceRoot() {
-        return path8.dirname(this.kanbanDir);
+        return path12.dirname(this.kanbanDir);
       }
       // --- Board resolution helpers ---
+      /** @internal */
       _resolveBoardId(boardId) {
         const config3 = readConfig(this.workspaceRoot);
         return boardId || config3.defaultBoard;
       }
+      /** @internal */
       _boardDir(boardId) {
         const resolvedId = this._resolveBoardId(boardId);
-        return path8.join(this.kanbanDir, "boards", resolvedId);
+        return path12.join(this.kanbanDir, "boards", resolvedId);
       }
+      /** @internal */
       _isCompletedStatus(status, boardId) {
         const config3 = readConfig(this.workspaceRoot);
         const resolvedId = boardId || config3.defaultBoard;
@@ -5032,6 +6100,7 @@ var init_KanbanSDK = __esm({
           return status === "done";
         return board.columns[board.columns.length - 1].id === status;
       }
+      /** @internal */
       async _ensureMigrated() {
         if (this._migrated)
           return;
@@ -5073,14 +6142,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       listBoards() {
-        const config3 = readConfig(this.workspaceRoot);
-        return Object.entries(config3.boards).map(([id, board]) => ({
-          id,
-          name: board.name,
-          description: board.description,
-          columns: board.columns,
-          actions: board.actions
-        }));
+        return listBoards(this);
       }
       /**
        * Creates a new board with the given ID and name.
@@ -5108,29 +6170,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       createBoard(id, name, options) {
-        const config3 = readConfig(this.workspaceRoot);
-        if (config3.boards[id]) {
-          throw new Error(`Board already exists: ${id}`);
-        }
-        const columns = options?.columns || [...config3.boards[config3.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" }
-        ]];
-        config3.boards[id] = {
-          name,
-          description: options?.description,
-          columns,
-          nextCardId: 1,
-          defaultStatus: options?.defaultStatus || columns[0]?.id || "backlog",
-          defaultPriority: options?.defaultPriority || config3.defaultPriority
-        };
-        writeConfig(this.workspaceRoot, config3);
-        const boardInfo = { id, name, description: options?.description };
-        this.emitEvent("board.created", boardInfo);
-        return boardInfo;
+        return createBoard(this, id, name, options);
       }
       /**
        * Deletes a board and its directory from the filesystem.
@@ -5151,22 +6191,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async deleteBoard(boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        if (!config3.boards[boardId]) {
-          throw new Error(`Board not found: ${boardId}`);
-        }
-        if (config3.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);
-        await this._storage.deleteBoardData(boardDir, boardId);
-        delete config3.boards[boardId];
-        writeConfig(this.workspaceRoot, config3);
-        this.emitEvent("board.deleted", { id: boardId });
+        return deleteBoard(this, boardId);
       }
       /**
        * Retrieves the full configuration for a specific board.
@@ -5182,7 +6207,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       getBoard(boardId) {
-        return getBoardConfig(this.workspaceRoot, boardId);
+        return getBoard(this, boardId);
       }
       /**
        * Updates properties of an existing board.
@@ -5209,24 +6234,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       updateBoard(boardId, updates) {
-        const config3 = readConfig(this.workspaceRoot);
-        const board = config3.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, config3);
-        this.emitEvent("board.updated", { id: boardId, ...board });
-        return board;
+        return updateBoard(this, boardId, updates);
       }
       /**
        * Returns the named actions defined on a board.
@@ -5236,12 +6244,7 @@ var init_KanbanSDK = __esm({
        * @throws {Error} If the board does not exist.
        */
       getBoardActions(boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        const resolvedId = boardId || config3.defaultBoard;
-        const board = config3.boards[resolvedId];
-        if (!board)
-          throw new Error(`Board not found: ${resolvedId}`);
-        return board.actions ?? {};
+        return getBoardActions(this, boardId);
       }
       /**
        * Adds or updates a named action on a board.
@@ -5253,15 +6256,7 @@ var init_KanbanSDK = __esm({
        * @throws {Error} If the board does not exist.
        */
       addBoardAction(boardId, key, title) {
-        const config3 = readConfig(this.workspaceRoot);
-        const board = config3.boards[boardId];
-        if (!board)
-          throw new Error(`Board not found: ${boardId}`);
-        board.actions ??= {};
-        board.actions[key] = title;
-        writeConfig(this.workspaceRoot, config3);
-        this.emitEvent("board.updated", { id: boardId, ...board });
-        return board.actions;
+        return addBoardAction(this, boardId, key, title);
       }
       /**
        * Removes a named action from a board.
@@ -5273,19 +6268,7 @@ var init_KanbanSDK = __esm({
        * @throws {Error} If the action key is not found on the board.
        */
       removeBoardAction(boardId, key) {
-        const config3 = readConfig(this.workspaceRoot);
-        const board = config3.boards[boardId];
-        if (!board)
-          throw new Error(`Board not found: ${boardId}`);
-        if (!board.actions || !(key in board.actions)) {
-          throw new Error(`Action "${key}" not found on board "${boardId}"`);
-        }
-        delete board.actions[key];
-        if (Object.keys(board.actions).length === 0)
-          delete board.actions;
-        writeConfig(this.workspaceRoot, config3);
-        this.emitEvent("board.updated", { id: boardId, ...board });
-        return board.actions ?? {};
+        return removeBoardAction(this, boardId, key);
       }
       /**
        * Fires the `board.action` webhook event for a named board action.
@@ -5296,17 +6279,7 @@ var init_KanbanSDK = __esm({
        * @throws {Error} If the action key is not defined on the board.
        */
       async triggerBoardAction(boardId, actionKey) {
-        const config3 = readConfig(this.workspaceRoot);
-        const resolvedId = boardId || config3.defaultBoard;
-        const board = config3.boards[resolvedId];
-        if (!board)
-          throw new Error(`Board not found: ${resolvedId}`);
-        const actions = board.actions ?? {};
-        if (!(actionKey in actions)) {
-          throw new Error(`Action "${actionKey}" not defined on board "${resolvedId}"`);
-        }
-        const actionTitle = actions[actionKey];
-        this.emitEvent("board.action", { boardId: resolvedId, action: actionKey, title: actionTitle });
+        return triggerBoardAction(this, boardId, actionKey);
       }
       /**
        * Transfers a card from one board to another.
@@ -5334,55 +6307,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async transferCard(cardId, fromBoardId, toBoardId, targetStatus) {
-        const toBoardDir = this._boardDir(toBoardId);
-        const config3 = readConfig(this.workspaceRoot);
-        if (!config3.boards[fromBoardId])
-          throw new Error(`Board not found: ${fromBoardId}`);
-        if (!config3.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 previousStatus = card.status;
-        const toBoard = config3.boards[toBoardId];
-        const newStatus = targetStatus || toBoard.defaultStatus || toBoard.columns[0]?.id || "backlog";
-        await this._storage.ensureBoardDirs(toBoardDir, [newStatus]);
-        const srcAttachDir = this._storage.getCardDir(card);
-        await this._storage.deleteCard(card);
-        card.status = newStatus;
-        card.boardId = toBoardId;
-        card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        card.completedAt = this._isCompletedStatus(newStatus, toBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
-        if (this._storage.type === "markdown") {
-          card.filePath = path8.join(toBoardDir, newStatus, path8.basename(card.filePath));
-        } else {
-          card.filePath = "";
-        }
-        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 this._storage.writeCard(card);
-        if (card.attachments.length > 0) {
-          const dstAttachDir = this._storage.getCardDir(card);
-          if (srcAttachDir !== dstAttachDir) {
-            await fs6.mkdir(dstAttachDir, { recursive: true });
-            await Promise.all(
-              card.attachments.map(async (filename) => {
-                const src = path8.join(srcAttachDir, filename);
-                const dst = path8.join(dstAttachDir, filename);
-                await fs6.rename(src, dst).catch(() => {
-                });
-              })
-            );
-          }
-        }
-        this.emitEvent("task.moved", { ...sanitizeCard(card), previousStatus, fromBoard: fromBoardId, toBoard: toBoardId });
-        if (previousStatus !== newStatus) {
-          await this.addLog(card.id, `Status changed: \`${previousStatus}\` \u2192 \`${newStatus}\``, { source: "system" }, toBoardId).catch(() => {
-          });
-        }
-        return card;
+        return transferCard(this, cardId, fromBoardId, toBoardId, targetStatus);
       }
       // --- Card CRUD ---
       /**
@@ -5426,42 +6351,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async listCards(columns, boardId, metaFilter, sort) {
-        await this._ensureMigrated();
-        const boardDir = this._boardDir(boardId);
-        const resolvedBoardId = this._resolveBoardId(boardId);
-        await this._storage.ensureBoardDirs(boardDir, columns);
-        const cards = await this._storage.scanCards(boardDir, resolvedBoardId);
-        const hasLegacyOrder = cards.some((c) => /^\d+$/.test(c.order));
-        if (hasLegacyOrder) {
-          const byStatus = /* @__PURE__ */ new Map();
-          for (const c of cards) {
-            const list = byStatus.get(c.status) || [];
-            list.push(c);
-            byStatus.set(c.status, list);
-          }
-          for (const columnCards of byStatus.values()) {
-            columnCards.sort((a, b) => parseInt(a.order) - parseInt(b.order));
-            const keys = generateNKeysBetween(null, null, columnCards.length);
-            for (let i = 0; i < columnCards.length; i++) {
-              columnCards[i].order = keys[i];
-              await this._storage.writeCard(columnCards[i]);
-            }
-          }
-        }
-        const numericIds = cards.map((c) => parseInt(c.id, 10)).filter((n) => !Number.isNaN(n));
-        if (numericIds.length > 0) {
-          syncCardIdCounter(this.workspaceRoot, resolvedBoardId, numericIds);
-        }
-        const filtered = metaFilter && Object.keys(metaFilter).length > 0 ? cards.filter((c) => matchesMetaFilter(c.metadata, metaFilter)) : cards;
-        if (sort) {
-          const [field, dir] = sort.split(":");
-          return filtered.sort((a, b) => {
-            const aVal = field === "created" ? a.created : a.modified;
-            const bVal = field === "created" ? b.created : b.modified;
-            return dir === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
-          });
-        }
-        return filtered.sort((a, b) => a.order < b.order ? -1 : a.order > b.order ? 1 : 0);
+        return listCards(this, columns, boardId, metaFilter, sort);
       }
       /**
        * Retrieves a single card by its ID.
@@ -5482,8 +6372,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async getCard(cardId, boardId) {
-        const cards = await this.listCards(void 0, boardId);
-        return cards.find((c) => c.id === cardId) || null;
+        return getCard(this, cardId, boardId);
       }
       /**
        * Creates a new card on a board.
@@ -5518,44 +6407,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async createCard(data) {
-        await this._ensureMigrated();
-        const resolvedBoardId = this._resolveBoardId(data.boardId);
-        const boardDir = this._boardDir(resolvedBoardId);
-        await this._storage.ensureBoardDirs(boardDir);
-        const config3 = readConfig(this.workspaceRoot);
-        const board = config3.boards[resolvedBoardId];
-        const status = data.status || board?.defaultStatus || config3.defaultStatus || "backlog";
-        const priority = data.priority || board?.defaultPriority || config3.defaultPriority || "medium";
-        const title = getTitleFromContent(data.content);
-        const numericId = allocateCardId(this.workspaceRoot, resolvedBoardId);
-        const filename = generateCardFilename(numericId, title);
-        const now = (/* @__PURE__ */ new Date()).toISOString();
-        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 = {
-          version: CARD_FORMAT_VERSION,
-          id: String(numericId),
-          boardId: resolvedBoardId,
-          status,
-          priority,
-          assignee: data.assignee ?? null,
-          dueDate: data.dueDate ?? null,
-          created: now,
-          modified: now,
-          completedAt: this._isCompletedStatus(status, resolvedBoardId) ? now : null,
-          labels: data.labels || [],
-          attachments: data.attachments || [],
-          comments: [],
-          order: generateKeyBetween(lastOrder, null),
-          content: data.content,
-          ...data.metadata && Object.keys(data.metadata).length > 0 ? { metadata: data.metadata } : {},
-          ...data.actions && (Array.isArray(data.actions) ? data.actions.length > 0 : Object.keys(data.actions).length > 0) ? { actions: data.actions } : {},
-          filePath: this._storage.type === "markdown" ? getCardFilePath(boardDir, status, filename) : ""
-        };
-        await this._storage.writeCard(card);
-        this.emitEvent("task.created", sanitizeCard(card));
-        return card;
+        return createCard(this, data);
       }
       /**
        * Updates an existing card's properties.
@@ -5582,39 +6434,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       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, boardId: _bid, ...safeUpdates } = updates;
-        Object.assign(card, safeUpdates);
-        card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        if (oldStatus !== card.status) {
-          card.completedAt = this._isCompletedStatus(card.status, resolvedBoardId) ? (/* @__PURE__ */ new Date()).toISOString() : null;
-        }
-        await this._storage.writeCard(card);
-        const newTitle = getTitleFromContent(card.content);
-        const numericId = extractNumericId(card.id);
-        if (numericId !== null && newTitle !== oldTitle) {
-          const newFilename = generateCardFilename(numericId, newTitle);
-          const newPath = await this._storage.renameCard(card, newFilename);
-          if (newPath)
-            card.filePath = newPath;
-        }
-        if (oldStatus !== card.status) {
-          const newPath = await this._storage.moveCard(card, boardDir, card.status);
-          if (newPath)
-            card.filePath = newPath;
-        }
-        this.emitEvent("task.updated", sanitizeCard(card));
-        if (oldStatus !== card.status) {
-          await this.addLog(card.id, `Status changed: \`${oldStatus}\` \u2192 \`${card.status}\``, { source: "system" }, resolvedBoardId).catch(() => {
-          });
-        }
-        return card;
+        return updateCard(this, cardId, updates, boardId);
       }
       /**
        * Triggers a named action for a card by POSTing to the global `actionWebhookUrl`
@@ -5640,31 +6460,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async triggerAction(cardId, action, boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        const { actionWebhookUrl } = config3;
-        if (!actionWebhookUrl) {
-          throw new Error("No action webhook URL configured. Set actionWebhookUrl in .kanban.json");
-        }
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        const resolvedBoardId = card.boardId || this._resolveBoardId(boardId);
-        const payload = {
-          action,
-          board: resolvedBoardId,
-          list: card.status,
-          card: sanitizeCard(card)
-        };
-        const response = await fetch(actionWebhookUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(payload)
-        });
-        if (!response.ok) {
-          throw new Error(`Action webhook responded with ${response.status}: ${response.statusText}`);
-        }
-        await this.addLog(cardId, `Action triggered: \`${action}\``, { source: "system" }, resolvedBoardId).catch(() => {
-        });
+        return triggerAction(this, cardId, action, boardId);
       }
       /**
        * Moves a card to a different status column and/or position within that column.
@@ -5691,35 +6487,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       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 = 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 this._storage.writeCard(card);
-        if (oldStatus !== newStatus) {
-          const newPath = await this._storage.moveCard(card, boardDir, newStatus);
-          if (newPath)
-            card.filePath = newPath;
-        }
-        this.emitEvent("task.moved", { ...sanitizeCard(card), previousStatus: oldStatus });
-        if (oldStatus !== newStatus) {
-          await this.addLog(card.id, `Status changed: \`${oldStatus}\` \u2192 \`${newStatus}\``, { source: "system" }, resolvedBoardId).catch(() => {
-          });
-        }
-        return card;
+        return moveCard(this, cardId, newStatus, position, boardId);
       }
       /**
        * Soft-deletes a card by moving it to the `deleted` status column.
@@ -5736,12 +6504,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async deleteCard(cardId, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        if (card.status === DELETED_STATUS_ID)
-          return;
-        await this.updateCard(cardId, { status: DELETED_STATUS_ID }, boardId);
+        return deleteCard(this, cardId, boardId);
       }
       /**
        * Permanently deletes a card's markdown file from disk.
@@ -5758,12 +6521,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async permanentlyDeleteCard(cardId, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        const snapshot = sanitizeCard(card);
-        await this._storage.deleteCard(card);
-        this.emitEvent("task.deleted", snapshot);
+        return permanentlyDeleteCard(this, cardId, boardId);
       }
       /**
        * Returns all cards in a specific status column.
@@ -5782,8 +6540,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async getCardsByStatus(status, boardId) {
-        const cards = await this.listCards(void 0, boardId);
-        return cards.filter((c) => c.status === status);
+        return getCardsByStatus(this, status, boardId);
       }
       /**
        * Returns a sorted list of unique assignee names across all cards on a board.
@@ -5800,13 +6557,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async getUniqueAssignees(boardId) {
-        const cards = await this.listCards(void 0, boardId);
-        const assignees = /* @__PURE__ */ new Set();
-        for (const c of cards) {
-          if (c.assignee)
-            assignees.add(c.assignee);
-        }
-        return [...assignees].sort();
+        return getUniqueAssignees(this, boardId);
       }
       /**
        * Returns a sorted list of unique labels across all cards on a board.
@@ -5821,13 +6572,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       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)
-            labels.add(l);
-        }
-        return [...labels].sort();
+        return getUniqueLabels(this, boardId);
       }
       // --- Label definition management ---
       /**
@@ -5845,8 +6590,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       getLabels() {
-        const config3 = readConfig(this.workspaceRoot);
-        return config3.labels || {};
+        return getLabels(this);
       }
       /**
        * Creates or updates a label definition in the workspace configuration.
@@ -5864,11 +6608,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       setLabel(name, definition) {
-        const config3 = readConfig(this.workspaceRoot);
-        if (!config3.labels)
-          config3.labels = {};
-        config3.labels[name] = definition;
-        writeConfig(this.workspaceRoot, config3);
+        setLabel(this, name, definition);
       }
       /**
        * Removes a label definition from the workspace configuration and cascades
@@ -5882,17 +6622,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async deleteLabel(name) {
-        const config3 = readConfig(this.workspaceRoot);
-        if (config3.labels) {
-          delete config3.labels[name];
-          writeConfig(this.workspaceRoot, config3);
-        }
-        const cards = await this.listCards();
-        for (const card of cards) {
-          if (card.labels.includes(name)) {
-            await this.updateCard(card.id, { labels: card.labels.filter((l) => l !== name) });
-          }
-        }
+        return deleteLabel(this, name);
       }
       /**
        * Renames a label in the configuration and cascades the change to all cards.
@@ -5911,19 +6641,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async renameLabel(oldName, newName) {
-        const config3 = readConfig(this.workspaceRoot);
-        if (config3.labels && config3.labels[oldName]) {
-          config3.labels[newName] = config3.labels[oldName];
-          delete config3.labels[oldName];
-          writeConfig(this.workspaceRoot, config3);
-        }
-        const cards = await this.listCards();
-        for (const card of cards) {
-          if (card.labels.includes(oldName)) {
-            const newLabels = card.labels.map((l) => l === oldName ? newName : l);
-            await this.updateCard(card.id, { labels: newLabels });
-          }
-        }
+        return renameLabel(this, oldName, newName);
       }
       /**
        * Returns a sorted list of label names that belong to the given group.
@@ -5944,8 +6662,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       getLabelsInGroup(group) {
-        const labels = this.getLabels();
-        return Object.entries(labels).filter(([, def]) => def.group === group).map(([name]) => name).sort();
+        return getLabelsInGroup(this, group);
       }
       /**
        * Returns all cards that have at least one label belonging to the given group.
@@ -5964,11 +6681,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async filterCardsByLabelGroup(group, boardId) {
-        const groupLabels = this.getLabelsInGroup(group);
-        if (groupLabels.length === 0)
-          return [];
-        const cards = await this.listCards(void 0, boardId);
-        return cards.filter((c) => c.labels.some((l) => groupLabels.includes(l)));
+        return filterCardsByLabelGroup(this, group, boardId);
       }
       // --- Attachment management ---
       /**
@@ -5991,18 +6704,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async addAttachment(cardId, sourcePath, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        const fileName = path8.basename(sourcePath);
-        await this._storage.copyAttachment(sourcePath, card);
-        if (!card.attachments.includes(fileName)) {
-          card.attachments.push(fileName);
-        }
-        card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await this._storage.writeCard(card);
-        this.emitEvent("attachment.added", { cardId, attachment: fileName });
-        return card;
+        return addAttachment(this, cardId, sourcePath, boardId);
       }
       /**
        * Removes an attachment reference from a card's metadata.
@@ -6022,14 +6724,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       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 this._storage.writeCard(card);
-        this.emitEvent("attachment.removed", { cardId, attachment });
-        return card;
+        return removeAttachment(this, cardId, attachment, boardId);
       }
       /**
        * Lists all attachment filenames for a card.
@@ -6046,10 +6741,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async listAttachments(cardId, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        return card.attachments;
+        return listAttachments(this, cardId, boardId);
       }
       /**
        * Returns the absolute path to the attachment directory for a card.
@@ -6068,10 +6760,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async getAttachmentDir(cardId, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          return null;
-        return this._storage.getCardDir(card);
+        return getAttachmentDir(this, cardId, boardId);
       }
       // --- Comment management ---
       /**
@@ -6091,10 +6780,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async listComments(cardId, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        return card.comments || [];
+        return listComments(this, cardId, boardId);
       }
       /**
        * Adds a comment to a card.
@@ -6116,28 +6802,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async addComment(cardId, author, content, boardId) {
-        if (!content?.trim())
-          throw new Error("Comment content cannot be empty");
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        if (!card.comments)
-          card.comments = [];
-        const maxId = card.comments.reduce((max, c) => {
-          const num = parseInt(c.id.replace("c", ""), 10);
-          return Number.isNaN(num) ? max : Math.max(max, num);
-        }, 0);
-        const comment = {
-          id: `c${maxId + 1}`,
-          author,
-          created: (/* @__PURE__ */ new Date()).toISOString(),
-          content
-        };
-        card.comments.push(comment);
-        card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await this._storage.writeCard(card);
-        this.emitEvent("comment.created", { ...comment, cardId });
-        return card;
+        return addComment(this, cardId, author, content, boardId);
       }
       /**
        * Updates the content of an existing comment on a card.
@@ -6156,17 +6821,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       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);
-        if (!comment)
-          throw new Error(`Comment not found: ${commentId}`);
-        comment.content = content;
-        card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await this._storage.writeCard(card);
-        this.emitEvent("comment.updated", { ...comment, cardId });
-        return card;
+        return updateComment(this, cardId, commentId, content, boardId);
       }
       /**
        * Deletes a comment from a card.
@@ -6183,17 +6838,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async deleteComment(cardId, commentId, 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);
-        card.comments = (card.comments || []).filter((c) => c.id !== commentId);
-        card.modified = (/* @__PURE__ */ new Date()).toISOString();
-        await this._storage.writeCard(card);
-        if (comment) {
-          this.emitEvent("comment.deleted", { ...comment, cardId });
-        }
-        return card;
+        return deleteComment(this, cardId, commentId, boardId);
       }
       // --- Log management ---
       /**
@@ -6207,44 +6852,7 @@ var init_KanbanSDK = __esm({
        * @returns A promise resolving to the log file path, or `null` if the card is not found.
        */
       async getLogFilePath(cardId, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          return null;
-        const dir = this._storage.getCardDir(card);
-        return path8.join(dir, `${card.id}.log`);
-      }
-      /**
-       * Parses a single log line into a {@link LogEntry}.
-       *
-       * Expected format: `timestamp [source] text {json}`
-       */
-      _parseLogLine(line) {
-        const trimmed = line.trim();
-        if (!trimmed)
-          return null;
-        const match = trimmed.match(/^(\S+)\s+\[([^\]]+)\]\s+(.+)$/);
-        if (!match)
-          return null;
-        const [, timestamp2, source, rest] = match;
-        const jsonMatch = rest.match(/^(.*?)\s+(\{.+\})\s*$/);
-        if (jsonMatch) {
-          try {
-            const obj = JSON.parse(jsonMatch[2]);
-            return { timestamp: timestamp2, source, text: jsonMatch[1], object: obj };
-          } catch {
-          }
-        }
-        return { timestamp: timestamp2, source, text: rest };
-      }
-      /**
-       * Serializes a {@link LogEntry} into a single log line.
-       */
-      _serializeLogEntry(entry) {
-        let line = `${entry.timestamp} [${entry.source}] ${entry.text}`;
-        if (entry.object && Object.keys(entry.object).length > 0) {
-          line += ` ${JSON.stringify(entry.object)}`;
-        }
-        return line;
+        return getLogFilePath(this, cardId, boardId);
       }
       /**
        * Lists all log entries for a card.
@@ -6266,21 +6874,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async listLogs(cardId, boardId) {
-        const logPath = await this.getLogFilePath(cardId, boardId);
-        if (!logPath)
-          throw new Error(`Card not found: ${cardId}`);
-        try {
-          const content = await fs6.readFile(logPath, "utf-8");
-          const entries = [];
-          for (const line of content.split("\n")) {
-            const entry = this._parseLogLine(line);
-            if (entry)
-              entries.push(entry);
-          }
-          return entries;
-        } catch {
-          return [];
-        }
+        return listLogs(this, cardId, boardId);
       }
       /**
        * Adds a log entry to a card.
@@ -6310,30 +6904,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async addLog(cardId, text, options, boardId) {
-        if (!text?.trim())
-          throw new Error("Log text cannot be empty");
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        const entry = {
-          timestamp: options?.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
-          source: options?.source || "default",
-          text: text.trim(),
-          ...options?.object && Object.keys(options.object).length > 0 ? { object: options.object } : {}
-        };
-        const dir = this._storage.getCardDir(card);
-        const logFileName = `${card.id}.log`;
-        const logPath = path8.join(dir, logFileName);
-        await fs6.mkdir(dir, { recursive: true });
-        const line = this._serializeLogEntry(entry) + "\n";
-        await fs6.appendFile(logPath, line, "utf-8");
-        if (!card.attachments.includes(logFileName)) {
-          card.attachments.push(logFileName);
-          card.modified = (/* @__PURE__ */ new Date()).toISOString();
-          await this._storage.writeCard(card);
-        }
-        this.emitEvent("log.added", { cardId, entry });
-        return entry;
+        return addLog(this, cardId, text, options, boardId);
       }
       /**
        * Clears all log entries for a card by deleting the `.log` file.
@@ -6352,22 +6923,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async clearLogs(cardId, boardId) {
-        const card = await this.getCard(cardId, boardId);
-        if (!card)
-          throw new Error(`Card not found: ${cardId}`);
-        const logFileName = `${card.id}.log`;
-        const dir = this._storage.getCardDir(card);
-        const logPath = path8.join(dir, logFileName);
-        try {
-          await fs6.unlink(logPath);
-        } catch {
-        }
-        if (card.attachments.includes(logFileName)) {
-          card.attachments = card.attachments.filter((a) => a !== logFileName);
-          card.modified = (/* @__PURE__ */ new Date()).toISOString();
-          await this._storage.writeCard(card);
-        }
-        this.emitEvent("log.cleared", { cardId });
+        return clearLogs(this, cardId, boardId);
       }
       // --- Board-level log management ---
       /**
@@ -6386,7 +6942,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       getBoardLogFilePath(boardId) {
-        return path8.join(this._boardDir(boardId), "board.log");
+        return getBoardLogFilePath(this, boardId);
       }
       /**
        * Lists all log entries from the board-level log file.
@@ -6403,23 +6959,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async listBoardLogs(boardId) {
-        const logPath = this.getBoardLogFilePath(boardId);
-        let content;
-        try {
-          content = await fs6.readFile(logPath, "utf-8");
-        } catch {
-          return [];
-        }
-        const entries = [];
-        for (const line of content.split("\n")) {
-          const trimmed = line.trim();
-          if (!trimmed)
-            continue;
-          const entry = this._parseLogLine(trimmed);
-          if (entry)
-            entries.push(entry);
-        }
-        return entries;
+        return listBoardLogs(this, boardId);
       }
       /**
        * Appends a new log entry to the board-level log file.
@@ -6437,18 +6977,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async addBoardLog(text, options, boardId) {
-        const entry = {
-          timestamp: options?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
-          source: options?.source ?? "sdk",
-          text,
-          ...options?.object ? { object: options.object } : {}
-        };
-        const logPath = this.getBoardLogFilePath(boardId);
-        await fs6.mkdir(path8.dirname(logPath), { recursive: true });
-        const line = this._serializeLogEntry(entry) + "\n";
-        await fs6.appendFile(logPath, line, "utf-8");
-        this.emitEvent("board.log.added", { boardId, entry });
-        return entry;
+        return addBoardLog(this, text, options, boardId);
       }
       /**
        * Clears all log entries for a board by deleting the board-level `board.log` file.
@@ -6465,12 +6994,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async clearBoardLogs(boardId) {
-        const logPath = this.getBoardLogFilePath(boardId);
-        try {
-          await fs6.unlink(logPath);
-        } catch {
-        }
-        this.emitEvent("board.log.cleared", { boardId });
+        return clearBoardLogs(this, boardId);
       }
       // --- Column management (board-scoped) ---
       /**
@@ -6486,10 +7010,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       listColumns(boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        const resolvedId = boardId || config3.defaultBoard;
-        const board = config3.boards[resolvedId];
-        return board?.columns || [];
+        return listColumns(this, boardId);
       }
       /**
        * Adds a new column to a board.
@@ -6515,20 +7036,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       addColumn(column, boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        const resolvedId = boardId || config3.defaultBoard;
-        const board = config3.boards[resolvedId];
-        if (!board)
-          throw new Error(`Board not found: ${resolvedId}`);
-        if (column.id === DELETED_STATUS_ID)
-          throw new Error(`"${DELETED_STATUS_ID}" is a reserved column ID`);
-        if (board.columns.some((c) => c.id === column.id)) {
-          throw new Error(`Column already exists: ${column.id}`);
-        }
-        board.columns.push(column);
-        writeConfig(this.workspaceRoot, config3);
-        this.emitEvent("column.created", column);
-        return board.columns;
+        return addColumn(this, column, boardId);
       }
       /**
        * Updates the properties of an existing column.
@@ -6554,21 +7062,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       updateColumn(columnId, updates, boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        const resolvedId = boardId || config3.defaultBoard;
-        const board = config3.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)
-          col.name = updates.name;
-        if (updates.color !== void 0)
-          col.color = updates.color;
-        writeConfig(this.workspaceRoot, config3);
-        this.emitEvent("column.updated", col);
-        return board.columns;
+        return updateColumn(this, columnId, updates, boardId);
       }
       /**
        * Removes a column from a board.
@@ -6590,26 +7084,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async removeColumn(columnId, boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        const resolvedId = boardId || config3.defaultBoard;
-        const board = config3.boards[resolvedId];
-        if (!board)
-          throw new Error(`Board not found: ${resolvedId}`);
-        if (columnId === DELETED_STATUS_ID)
-          throw new Error(`Cannot remove the reserved "${DELETED_STATUS_ID}" column`);
-        const idx = board.columns.findIndex((c) => c.id === columnId);
-        if (idx === -1)
-          throw new Error(`Column not found: ${columnId}`);
-        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`);
-        }
-        const removed = board.columns[idx];
-        board.columns.splice(idx, 1);
-        writeConfig(this.workspaceRoot, config3);
-        this.emitEvent("column.deleted", removed);
-        return board.columns;
+        return removeColumn(this, columnId, boardId);
       }
       /**
        * Moves all cards in the specified column to the `deleted` (soft-delete) column.
@@ -6630,14 +7105,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async cleanupColumn(columnId, boardId) {
-        if (columnId === DELETED_STATUS_ID)
-          return 0;
-        const cards = await this.listCards(void 0, boardId);
-        const cardsToMove = cards.filter((c) => c.status === columnId);
-        for (const card of cardsToMove) {
-          await this.moveCard(card.id, DELETED_STATUS_ID, 0, boardId);
-        }
-        return cardsToMove.length;
+        return cleanupColumn(this, columnId, boardId);
       }
       /**
        * Permanently deletes all cards currently in the `deleted` column.
@@ -6655,12 +7123,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async purgeDeletedCards(boardId) {
-        const cards = await this.listCards(void 0, boardId);
-        const deleted = cards.filter((c) => c.status === DELETED_STATUS_ID);
-        for (const card of deleted) {
-          await this.permanentlyDeleteCard(card.id, boardId);
-        }
-        return deleted.length;
+        return purgeDeletedCards(this, boardId);
       }
       /**
        * Reorders the columns of a board.
@@ -6684,22 +7147,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       reorderColumns(columnIds, boardId) {
-        const config3 = readConfig(this.workspaceRoot);
-        const resolvedId = boardId || config3.defaultBoard;
-        const board = config3.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 !== board.columns.length) {
-          throw new Error("Must include all column IDs when reordering");
-        }
-        board.columns = columnIds.map((id) => colMap.get(id));
-        writeConfig(this.workspaceRoot, config3);
-        return board.columns;
+        return reorderColumns(this, columnIds, boardId);
       }
       // --- Settings management (global) ---
       /**
@@ -6717,7 +7165,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       getSettings() {
-        return configToSettings(readConfig(this.workspaceRoot));
+        return getSettings(this);
       }
       /**
        * Updates the global card display settings for the workspace.
@@ -6738,9 +7186,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       updateSettings(settings) {
-        const config3 = readConfig(this.workspaceRoot);
-        writeConfig(this.workspaceRoot, settingsToConfig(config3, settings));
-        this.emitEvent("settings.updated", settings);
+        updateSettings(this, settings);
       }
       // ---------------------------------------------------------------------------
       // Storage migration
@@ -6768,30 +7214,7 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async migrateToSqlite(dbPath) {
-        if (this._storage.type === "sqlite") {
-          throw new Error("Storage engine is already sqlite");
-        }
-        await this._ensureMigrated();
-        const resolvedDbPath = dbPath ?? ".kanban/kanban.db";
-        const absDbPath = path8.resolve(this.workspaceRoot, resolvedDbPath);
-        const { SqliteStorageEngine: SqliteStorageEngine2 } = await Promise.resolve().then(() => (init_sqlite(), sqlite_exports));
-        const sqliteEngine = new SqliteStorageEngine2(this._storage.kanbanDir, absDbPath);
-        await sqliteEngine.init();
-        const config3 = readConfig(this.workspaceRoot);
-        const boardIds = Object.keys(config3.boards);
-        let count = 0;
-        for (const boardId of boardIds) {
-          const boardDir = path8.join(this._storage.kanbanDir, "boards", boardId);
-          const cards = await this._storage.scanCards(boardDir, boardId);
-          for (const card of cards) {
-            await sqliteEngine.writeCard({ ...card, filePath: "" });
-            count++;
-          }
-        }
-        sqliteEngine.close();
-        writeConfig(this.workspaceRoot, { ...config3, storageEngine: "sqlite", sqlitePath: resolvedDbPath });
-        this.emitEvent("storage.migrated", { from: "markdown", to: "sqlite", count });
-        return count;
+        return migrateToSqlite(this, dbPath);
       }
       /**
        * Migrates all card data from the current SQLite engine back to markdown files.
@@ -6814,152 +7237,59 @@ var init_KanbanSDK = __esm({
        * ```
        */
       async migrateToMarkdown() {
-        if (this._storage.type === "markdown") {
-          throw new Error("Storage engine is already markdown");
-        }
-        await this._ensureMigrated();
-        const { MarkdownStorageEngine: MarkdownStorageEngine2 } = await Promise.resolve().then(() => (init_markdown(), markdown_exports));
-        const mdEngine = new MarkdownStorageEngine2(this._storage.kanbanDir);
-        await mdEngine.init();
-        const config3 = readConfig(this.workspaceRoot);
-        const boardIds = Object.keys(config3.boards);
-        let count = 0;
-        for (const boardId of boardIds) {
-          const boardDir = path8.join(this._storage.kanbanDir, "boards", boardId);
-          const cards = await this._storage.scanCards(boardDir, boardId);
-          for (const card of cards) {
-            const numericId = Number(card.id) || 0;
-            const title = getTitleFromContent(card.content) || card.id;
-            const filename = generateCardFilename(numericId, title);
-            const filePath = getCardFilePath(boardDir, card.status, filename);
-            await mdEngine.writeCard({ ...card, filePath });
-            count++;
-          }
-        }
-        mdEngine.close();
-        const { storageEngine: _se, sqlitePath: _sp, ...restConfig } = config3;
-        writeConfig(this.workspaceRoot, restConfig);
-        this.emitEvent("storage.migrated", { from: "sqlite", to: "markdown", count });
-        return count;
+        return migrateToMarkdown(this);
       }
-    };
-  }
-});
-
-// src/standalone/webhooks.ts
-function loadWebhooks(workspaceRoot) {
-  const config3 = readConfig(workspaceRoot);
-  return config3.webhooks || [];
-}
-function saveWebhooks(workspaceRoot, webhooks) {
-  const config3 = readConfig(workspaceRoot);
-  config3.webhooks = webhooks;
-  writeConfig(workspaceRoot, config3);
-}
-function createWebhook(workspaceRoot, webhookConfig) {
-  const webhooks = loadWebhooks(workspaceRoot);
-  const webhook = {
-    id: "wh_" + crypto.randomBytes(8).toString("hex"),
-    url: webhookConfig.url,
-    events: webhookConfig.events,
-    secret: webhookConfig.secret,
-    active: true
-  };
-  webhooks.push(webhook);
-  saveWebhooks(workspaceRoot, webhooks);
-  return webhook;
-}
-function deleteWebhook(workspaceRoot, id) {
-  const webhooks = loadWebhooks(workspaceRoot);
-  const filtered = webhooks.filter((w) => w.id !== id);
-  if (filtered.length === webhooks.length)
-    return false;
-  saveWebhooks(workspaceRoot, filtered);
-  return true;
-}
-function updateWebhook(workspaceRoot, id, updates) {
-  const webhooks = loadWebhooks(workspaceRoot);
-  const webhook = webhooks.find((w) => w.id === id);
-  if (!webhook)
-    return null;
-  if (updates.url !== void 0)
-    webhook.url = updates.url;
-  if (updates.events !== void 0)
-    webhook.events = updates.events;
-  if (updates.secret !== void 0)
-    webhook.secret = updates.secret;
-  if (updates.active !== void 0)
-    webhook.active = updates.active;
-  saveWebhooks(workspaceRoot, webhooks);
-  return webhook;
-}
-function fireWebhooks(workspaceRoot, event, data) {
-  const webhooks = loadWebhooks(workspaceRoot);
-  const matching = webhooks.filter(
-    (w) => w.active && (w.events.includes("*") || w.events.includes(event))
-  );
-  if (matching.length === 0)
-    return;
-  const payload = JSON.stringify({
-    event,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    data
-  });
-  for (const webhook of matching) {
-    deliverWebhook(webhook, event, payload).catch((err) => {
-      console.error(`Webhook delivery failed for ${webhook.id} (${webhook.url}):`, err.message || err);
-    });
-  }
-}
-async function deliverWebhook(webhook, event, payload) {
-  const url3 = new URL(webhook.url);
-  const isHttps = url3.protocol === "https:";
-  const transport = isHttps ? https : http;
-  const headers = {
-    "Content-Type": "application/json",
-    "Content-Length": Buffer.byteLength(payload).toString(),
-    "X-Webhook-Event": event
-  };
-  if (webhook.secret) {
-    const signature = crypto.createHmac("sha256", webhook.secret).update(payload).digest("hex");
-    headers["X-Webhook-Signature"] = `sha256=${signature}`;
-  }
-  return new Promise((resolve9, reject) => {
-    const req = transport.request(
-      {
-        hostname: url3.hostname,
-        port: url3.port || (isHttps ? 443 : 80),
-        path: url3.pathname + url3.search,
-        method: "POST",
-        headers,
-        timeout: 1e4
-      },
-      (res) => {
-        res.resume();
-        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-          resolve9();
-        } else {
-          reject(new Error(`HTTP ${res.statusCode}`));
-        }
+      /**
+       * Sets the default board for the workspace.
+       *
+       * @param boardId - The ID of the board to set as the default.
+       * @throws {Error} If the board does not exist.
+       *
+       * @example
+       * ```ts
+       * sdk.setDefaultBoard('sprint-2')
+       * ```
+       */
+      setDefaultBoard(boardId) {
+        setDefaultBoard(this, boardId);
       }
-    );
-    req.on("error", reject);
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Timeout"));
-    });
-    req.write(payload);
-    req.end();
-  });
-}
-var crypto, http, https;
-var init_webhooks = __esm({
-  "src/standalone/webhooks.ts"() {
-    "use strict";
-    crypto = __toESM(require("crypto"));
-    http = __toESM(require("http"));
-    https = __toESM(require("https"));
-    init_config();
+      /**
+       * Lists all registered webhooks.
+       *
+       * @returns Array of {@link Webhook} objects.
+       */
+      listWebhooks() {
+        return loadWebhooks(this.workspaceRoot);
+      }
+      /**
+       * Creates and persists a new webhook.
+       *
+       * @param webhookConfig - The webhook configuration.
+       * @returns The newly created {@link Webhook}.
+       */
+      createWebhook(webhookConfig) {
+        return createWebhook(this.workspaceRoot, webhookConfig);
+      }
+      /**
+       * Deletes a webhook by its ID.
+       *
+       * @param id - The webhook ID to delete.
+       * @returns `true` if deleted, `false` if not found.
+       */
+      deleteWebhook(id) {
+        return deleteWebhook(this.workspaceRoot, id);
+      }
+      /**
+       * Updates an existing webhook's configuration.
+       *
+       * @param id - The webhook ID to update.
+       * @param updates - Partial webhook fields to merge.
+       * @returns The updated {@link Webhook}, or `null` if not found.
+       */
+      updateWebhook(id, updates) {
+        return updateWebhook(this.workspaceRoot, id, updates);
+      }
+    };
   }
 });
 
@@ -7368,8 +7698,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path13, errorMaps, issueData } = params;
-      const fullPath = [...path13, ...issueData.path || []];
+      const { data, path: path17, errorMaps, issueData } = params;
+      const fullPath = [...path17, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -7649,11 +7979,11 @@ var init_types3 = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path13, key) {
+      constructor(parent, value, path17, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path13;
+        this._path = path17;
         this._key = key;
       }
       get path() {
@@ -11159,10 +11489,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema2) {
   return mergeDefs(schema2._zod.def);
 }
-function getElementAtPath(obj, path13) {
-  if (!path13)
+function getElementAtPath(obj, path17) {
+  if (!path17)
     return obj;
-  return path13.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11474,11 +11804,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path13, issues) {
+function prefixIssues(path17, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path13);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -25968,8 +26298,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path13) {
-      let input = path13;
+    function removeDotSegments(path17) {
+      let input = path17;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -26168,8 +26498,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path13, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path13 && path13 !== "/" ? path13 : void 0;
+        const [path17, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path17 && path17 !== "/" ? path17 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -29532,12 +29862,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs15, exportName) {
+    function addFormats(ajv, list, fs16, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs15[f]);
+        ajv.addFormat(f, fs16[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -31394,10 +31724,10 @@ function mergeDefs2(...defs) {
 function cloneDef2(schema2) {
   return mergeDefs2(schema2._zod.def);
 }
-function getElementAtPath2(obj, path13) {
-  if (!path13)
+function getElementAtPath2(obj, path17) {
+  if (!path17)
     return obj;
-  return path13.reduce((acc, key) => acc?.[key], obj);
+  return path17.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -31709,11 +32039,11 @@ function aborted2(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues2(path13, issues) {
+function prefixIssues2(path17, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path13);
+    iss.path.unshift(path17);
     return iss;
   });
 }
@@ -31955,7 +32285,7 @@ function formatError3(error49, mapper = (issue3) => issue3.message) {
 }
 function treeifyError2(error49, mapper = (issue3) => issue3.message) {
   const result = { errors: [] };
-  const processError = (error50, path13 = []) => {
+  const processError = (error50, path17 = []) => {
     var _a3, _b;
     for (const issue3 of error50.issues) {
       if (issue3.code === "invalid_union" && issue3.errors.length) {
@@ -31965,7 +32295,7 @@ function treeifyError2(error49, mapper = (issue3) => issue3.message) {
       } else if (issue3.code === "invalid_element") {
         processError({ issues: issue3.issues }, issue3.path);
       } else {
-        const fullpath = [...path13, ...issue3.path];
+        const fullpath = [...path17, ...issue3.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue3));
           continue;
@@ -31997,8 +32327,8 @@ function treeifyError2(error49, mapper = (issue3) => issue3.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path13 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path13) {
+  const path17 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path17) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -44691,13 +45021,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path13 = ref.slice(1).split("/").filter(Boolean);
-  if (path13.length === 0) {
+  const path17 = ref.slice(1).split("/").filter(Boolean);
+  if (path17.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path13[0] === defsKey) {
-    const key = path13[1];
+  if (path17[0] === defsKey) {
+    const key = path17[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -45462,16 +45792,16 @@ async function findWorkspaceRoot(startDir) {
   let dir = startDir;
   while (true) {
     try {
-      await fs7.access(path9.join(dir, ".git"));
+      await fs8.access(path13.join(dir, ".git"));
       return dir;
     } catch {
     }
     try {
-      await fs7.access(path9.join(dir, "package.json"));
+      await fs8.access(path13.join(dir, "package.json"));
       return dir;
     } catch {
     }
-    const parent = path9.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir)
       return startDir;
     dir = parent;
@@ -45480,25 +45810,18 @@ async function findWorkspaceRoot(startDir) {
 async function resolveKanbanDir() {
   const dirIndex = process.argv.indexOf("--dir");
   if (dirIndex !== -1 && process.argv[dirIndex + 1]) {
-    return path9.resolve(process.argv[dirIndex + 1]);
+    return path13.resolve(process.argv[dirIndex + 1]);
   }
   const envDir = process.env.KANBAN_DIR || process.env.KANBAN_FEATURES_DIR;
   if (envDir) {
-    return path9.resolve(envDir);
+    return path13.resolve(envDir);
   }
   const root = await findWorkspaceRoot(process.cwd());
-  return path9.join(root, ".devtool", "cards");
-}
-function getTitleFromContent2(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";
+  return path13.join(root, ".kanban");
 }
 async function main() {
   const kanbanDir = await resolveKanbanDir();
-  const workspaceRoot = path9.dirname(kanbanDir);
+  const workspaceRoot = path13.dirname(kanbanDir);
   const sdk = new KanbanSDK(kanbanDir, {
     onEvent: (event, data) => fireWebhooks(workspaceRoot, event, data)
   });
@@ -45571,7 +45894,12 @@ async function main() {
       sort: external_exports4.enum(["created:asc", "created:desc", "modified:asc", "modified:desc"]).optional().describe("Sort order: created:asc, created:desc, modified:asc, or modified:desc. Defaults to board order.")
     },
     async ({ boardId, status, priority, assignee, label, labelGroup, includeDeleted, metaFilter, sort }) => {
-      let cards = await sdk.listCards(void 0, boardId);
+      let cards = await sdk.listCards(
+        void 0,
+        boardId,
+        metaFilter && Object.keys(metaFilter).length > 0 ? metaFilter : void 0,
+        sort || void 0
+      );
       if (!includeDeleted)
         cards = cards.filter((c) => c.status !== DELETED_STATUS_ID);
       if (status)
@@ -45586,19 +45914,9 @@ async function main() {
         const groupLabels = sdk.getLabelsInGroup(labelGroup);
         cards = cards.filter((c) => c.labels.some((l) => groupLabels.includes(l)));
       }
-      if (metaFilter && Object.keys(metaFilter).length > 0)
-        cards = cards.filter((c) => matchesMetaFilter(c.metadata, metaFilter));
-      if (sort) {
-        const [field, dir] = sort.split(":");
-        cards = [...cards].sort((a, b) => {
-          const aVal = field === "created" ? a.created : a.modified;
-          const bVal = field === "created" ? b.created : b.modified;
-          return dir === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
-        });
-      }
       const summary = cards.map((c) => ({
         id: c.id,
-        title: getTitleFromContent2(c.content),
+        title: getTitleFromContent(c.content),
         status: c.status,
         priority: c.priority,
         assignee: c.assignee,
@@ -46506,8 +46824,7 @@ async function main() {
     "Get the current kanban board display settings.",
     {},
     async () => {
-      const config3 = readConfig(workspaceRoot);
-      const settings = configToSettings(config3);
+      const settings = sdk.getSettings();
       return {
         content: [{
           type: "text",
@@ -46531,20 +46848,18 @@ async function main() {
       defaultStatus: external_exports4.string().optional().describe("Default status for new cards")
     },
     async (updates) => {
-      const config3 = readConfig(workspaceRoot);
-      const settings = configToSettings(config3);
+      const settings = sdk.getSettings();
       const merged = { ...settings };
       for (const [key, value] of Object.entries(updates)) {
         if (value !== void 0) {
           merged[key] = value;
         }
       }
-      writeConfig(workspaceRoot, settingsToConfig(config3, merged));
-      const updated = configToSettings(readConfig(workspaceRoot));
+      sdk.updateSettings(merged);
       return {
         content: [{
           type: "text",
-          text: JSON.stringify(updated, null, 2)
+          text: JSON.stringify(sdk.getSettings(), null, 2)
         }]
       };
     }
@@ -46554,7 +46869,7 @@ async function main() {
     "List all registered webhooks.",
     {},
     async () => {
-      const webhooks = loadWebhooks(workspaceRoot);
+      const webhooks = sdk.listWebhooks();
       return {
         content: [{
           type: "text",
@@ -46572,7 +46887,7 @@ async function main() {
       secret: external_exports4.string().optional().describe("Optional HMAC-SHA256 signing secret")
     },
     async ({ url: url3, events, secret }) => {
-      const webhook = createWebhook(workspaceRoot, {
+      const webhook = sdk.createWebhook({
         url: url3,
         events: events || ["*"],
         secret
@@ -46592,7 +46907,7 @@ async function main() {
       webhookId: external_exports4.string().describe('Webhook ID (e.g. "wh_abc123")')
     },
     async ({ webhookId }) => {
-      const removed = deleteWebhook(workspaceRoot, webhookId);
+      const removed = sdk.deleteWebhook(webhookId);
       if (!removed) {
         return {
           content: [{ type: "text", text: `Webhook not found: ${webhookId}` }],
@@ -46627,7 +46942,7 @@ async function main() {
         updates.secret = secret;
       if (active !== void 0)
         updates.active = active;
-      const updated = updateWebhook(workspaceRoot, webhookId, updates);
+      const updated = sdk.updateWebhook(webhookId, updates);
       if (!updated) {
         return {
           content: [{ type: "text", text: `Webhook not found: ${webhookId}` }],
@@ -46726,12 +47041,12 @@ async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }
-var path9, fs7;
+var path13, fs8;
 var init_mcp_server2 = __esm({
   "src/mcp-server/index.ts"() {
     "use strict";
-    path9 = __toESM(require("path"));
-    fs7 = __toESM(require("fs/promises"));
+    path13 = __toESM(require("path"));
+    fs8 = __toESM(require("fs/promises"));
     init_mcp();
     init_stdio2();
     init_zod2();
@@ -46739,7 +47054,6 @@ var init_mcp_server2 = __esm({
     init_types();
     init_config();
     init_webhooks();
-    init_metaUtils();
     main().catch((err) => {
       console.error(`MCP Server error: ${err.message}`);
       process.exit(1);
@@ -50557,7 +50871,7 @@ var init_esm2 = __esm({
         this._directoryFilter = normalizeFilter(opts.directoryFilter);
         const statMethod = opts.lstat ? import_promises.lstat : import_promises.stat;
         if (wantBigintFsStats) {
-          this._stat = (path13) => statMethod(path13, { bigint: true });
+          this._stat = (path17) => statMethod(path17, { bigint: true });
         } else {
           this._stat = statMethod;
         }
@@ -50582,8 +50896,8 @@ var init_esm2 = __esm({
             const par = this.parent;
             const fil = par && par.files;
             if (fil && fil.length > 0) {
-              const { path: path13, depth } = par;
-              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path13));
+              const { path: path17, depth } = par;
+              const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path17));
               const awaited = await Promise.all(slice);
               for (const entry of awaited) {
                 if (!entry)
@@ -50623,21 +50937,21 @@ var init_esm2 = __esm({
           this.reading = false;
         }
       }
-      async _exploreDir(path13, depth) {
+      async _exploreDir(path17, depth) {
         let files;
         try {
-          files = await (0, import_promises.readdir)(path13, this._rdOptions);
+          files = await (0, import_promises.readdir)(path17, this._rdOptions);
         } catch (error49) {
           this._onError(error49);
         }
-        return { files, depth, path: path13 };
+        return { files, depth, path: path17 };
       }
-      async _formatEntry(dirent, path13) {
+      async _formatEntry(dirent, path17) {
         let entry;
-        const basename9 = this._isDirent ? dirent.name : dirent;
+        const basename10 = this._isDirent ? dirent.name : dirent;
         try {
-          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path13, basename9));
-          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename9 };
+          const fullPath = (0, import_node_path.resolve)((0, import_node_path.join)(path17, basename10));
+          entry = { path: (0, import_node_path.relative)(this._root, fullPath), fullPath, basename: basename10 };
           entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
         } catch (err) {
           this._onError(err);
@@ -50693,16 +51007,16 @@ var init_esm2 = __esm({
 });
 
 // node_modules/.pnpm/chokidar@4.0.3/node_modules/chokidar/esm/handler.js
-function createFsWatchInstance(path13, options, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path17, options, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path13);
-    emitRaw(rawEvent, evPath, { watchedPath: path13 });
-    if (evPath && path13 !== evPath) {
-      fsWatchBroadcast(sysPath.resolve(path13, evPath), KEY_LISTENERS, sysPath.join(path13, evPath));
+    listener(path17);
+    emitRaw(rawEvent, evPath, { watchedPath: path17 });
+    if (evPath && path17 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path17, evPath), KEY_LISTENERS, sysPath.join(path17, evPath));
     }
   };
   try {
-    return (0, import_fs.watch)(path13, {
+    return (0, import_fs.watch)(path17, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error49) {
@@ -51050,12 +51364,12 @@ var init_handler = __esm({
         listener(val1, val2, val3);
       });
     };
-    setFsWatchListener = (path13, fullPath, options, handlers) => {
+    setFsWatchListener = (path17, fullPath, options, handlers) => {
       const { listener, errHandler, rawEmitter } = handlers;
       let cont = FsWatchInstances.get(fullPath);
       let watcher;
       if (!options.persistent) {
-        watcher = createFsWatchInstance(path13, options, listener, errHandler, rawEmitter);
+        watcher = createFsWatchInstance(path17, options, listener, errHandler, rawEmitter);
         if (!watcher)
           return;
         return watcher.close.bind(watcher);
@@ -51066,7 +51380,7 @@ var init_handler = __esm({
         addAndConvert(cont, KEY_RAW, rawEmitter);
       } else {
         watcher = createFsWatchInstance(
-          path13,
+          path17,
           options,
           fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
           errHandler,
@@ -51081,7 +51395,7 @@ var init_handler = __esm({
             cont.watcherUnusable = true;
           if (isWindows && error49.code === "EPERM") {
             try {
-              const fd = await (0, import_promises2.open)(path13, "r");
+              const fd = await (0, import_promises2.open)(path17, "r");
               await fd.close();
               broadcastErr(error49);
             } catch (err) {
@@ -51112,7 +51426,7 @@ var init_handler = __esm({
       };
     };
     FsWatchFileInstances = /* @__PURE__ */ new Map();
-    setFsWatchFileListener = (path13, fullPath, options, handlers) => {
+    setFsWatchFileListener = (path17, fullPath, options, handlers) => {
       const { listener, rawEmitter } = handlers;
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
@@ -51134,7 +51448,7 @@ var init_handler = __esm({
             });
             const currmtime = curr.mtimeMs;
             if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-              foreach(cont.listeners, (listener2) => listener2(path13, curr));
+              foreach(cont.listeners, (listener2) => listener2(path17, curr));
             }
           })
         };
@@ -51162,13 +51476,13 @@ var init_handler = __esm({
        * @param listener on fs change
        * @returns closer for the watcher instance
        */
-      _watchWithNodeFs(path13, listener) {
+      _watchWithNodeFs(path17, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path13);
-        const basename9 = sysPath.basename(path13);
+        const directory = sysPath.dirname(path17);
+        const basename10 = sysPath.basename(path17);
         const parent = this.fsw._getWatchedDir(directory);
-        parent.add(basename9);
-        const absolutePath = sysPath.resolve(path13);
+        parent.add(basename10);
+        const absolutePath = sysPath.resolve(path17);
         const options = {
           persistent: opts.persistent
         };
@@ -51177,13 +51491,13 @@ var init_handler = __esm({
         let closer;
         if (opts.usePolling) {
           const enableBin = opts.interval !== opts.binaryInterval;
-          options.interval = enableBin && isBinaryPath(basename9) ? opts.binaryInterval : opts.interval;
-          closer = setFsWatchFileListener(path13, absolutePath, options, {
+          options.interval = enableBin && isBinaryPath(basename10) ? opts.binaryInterval : opts.interval;
+          closer = setFsWatchFileListener(path17, absolutePath, options, {
             listener,
             rawEmitter: this.fsw._emitRaw
           });
         } else {
-          closer = setFsWatchListener(path13, absolutePath, options, {
+          closer = setFsWatchListener(path17, absolutePath, options, {
             listener,
             errHandler: this._boundHandleError,
             rawEmitter: this.fsw._emitRaw
@@ -51199,13 +51513,13 @@ var init_handler = __esm({
         if (this.fsw.closed) {
           return;
         }
-        const dirname11 = sysPath.dirname(file3);
-        const basename9 = sysPath.basename(file3);
-        const parent = this.fsw._getWatchedDir(dirname11);
+        const dirname12 = sysPath.dirname(file3);
+        const basename10 = sysPath.basename(file3);
+        const parent = this.fsw._getWatchedDir(dirname12);
         let prevStats = stats;
-        if (parent.has(basename9))
+        if (parent.has(basename10))
           return;
-        const listener = async (path13, newStats) => {
+        const listener = async (path17, newStats) => {
           if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file3, 5))
             return;
           if (!newStats || newStats.mtimeMs === 0) {
@@ -51219,18 +51533,18 @@ var init_handler = __esm({
                 this.fsw._emit(EV.CHANGE, file3, newStats2);
               }
               if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-                this.fsw._closeFile(path13);
+                this.fsw._closeFile(path17);
                 prevStats = newStats2;
                 const closer2 = this._watchWithNodeFs(file3, listener);
                 if (closer2)
-                  this.fsw._addPathCloser(path13, closer2);
+                  this.fsw._addPathCloser(path17, closer2);
               } else {
                 prevStats = newStats2;
               }
             } catch (error49) {
-              this.fsw._remove(dirname11, basename9);
+              this.fsw._remove(dirname12, basename10);
             }
-          } else if (parent.has(basename9)) {
+          } else if (parent.has(basename10)) {
             const at = newStats.atimeMs;
             const mt = newStats.mtimeMs;
             if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -51255,7 +51569,7 @@ var init_handler = __esm({
        * @param item basename of this item
        * @returns true if no more processing is needed for this entry.
        */
-      async _handleSymlink(entry, directory, path13, item) {
+      async _handleSymlink(entry, directory, path17, item) {
         if (this.fsw.closed) {
           return;
         }
@@ -51265,7 +51579,7 @@ var init_handler = __esm({
           this.fsw._incrReadyCount();
           let linkPath;
           try {
-            linkPath = await (0, import_promises2.realpath)(path13);
+            linkPath = await (0, import_promises2.realpath)(path17);
           } catch (e) {
             this.fsw._emitReady();
             return true;
@@ -51275,12 +51589,12 @@ var init_handler = __esm({
           if (dir.has(item)) {
             if (this.fsw._symlinkPaths.get(full) !== linkPath) {
               this.fsw._symlinkPaths.set(full, linkPath);
-              this.fsw._emit(EV.CHANGE, path13, entry.stats);
+              this.fsw._emit(EV.CHANGE, path17, entry.stats);
             }
           } else {
             dir.add(item);
             this.fsw._symlinkPaths.set(full, linkPath);
-            this.fsw._emit(EV.ADD, path13, entry.stats);
+            this.fsw._emit(EV.ADD, path17, entry.stats);
           }
           this.fsw._emitReady();
           return true;
@@ -51309,9 +51623,9 @@ var init_handler = __esm({
             return;
           }
           const item = entry.path;
-          let path13 = sysPath.join(directory, item);
+          let path17 = sysPath.join(directory, item);
           current.add(item);
-          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path13, item)) {
+          if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path17, item)) {
             return;
           }
           if (this.fsw.closed) {
@@ -51320,8 +51634,8 @@ var init_handler = __esm({
           }
           if (item === target || !target && !previous.has(item)) {
             this.fsw._incrReadyCount();
-            path13 = sysPath.join(dir, sysPath.relative(dir, path13));
-            this._addToNodeFs(path13, initialAdd, wh, depth + 1);
+            path17 = sysPath.join(dir, sysPath.relative(dir, path17));
+            this._addToNodeFs(path17, initialAdd, wh, depth + 1);
           }
         }).on(EV.ERROR, this._boundHandleError);
         return new Promise((resolve9, reject) => {
@@ -51390,13 +51704,13 @@ var init_handler = __esm({
        * @param depth Child path actually targeted for watch
        * @param target Child path actually targeted for watch
        */
-      async _addToNodeFs(path13, initialAdd, priorWh, depth, target) {
+      async _addToNodeFs(path17, initialAdd, priorWh, depth, target) {
         const ready = this.fsw._emitReady;
-        if (this.fsw._isIgnored(path13) || this.fsw.closed) {
+        if (this.fsw._isIgnored(path17) || this.fsw.closed) {
           ready();
           return false;
         }
-        const wh = this.fsw._getWatchHelpers(path13);
+        const wh = this.fsw._getWatchHelpers(path17);
         if (priorWh) {
           wh.filterPath = (entry) => priorWh.filterPath(entry);
           wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -51412,8 +51726,8 @@ var init_handler = __esm({
           const follow = this.fsw.options.followSymlinks;
           let closer;
           if (stats.isDirectory()) {
-            const absPath = sysPath.resolve(path13);
-            const targetPath = follow ? await (0, import_promises2.realpath)(path13) : path13;
+            const absPath = sysPath.resolve(path17);
+            const targetPath = follow ? await (0, import_promises2.realpath)(path17) : path17;
             if (this.fsw.closed)
               return;
             closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -51423,29 +51737,29 @@ var init_handler = __esm({
               this.fsw._symlinkPaths.set(absPath, targetPath);
             }
           } else if (stats.isSymbolicLink()) {
-            const targetPath = follow ? await (0, import_promises2.realpath)(path13) : path13;
+            const targetPath = follow ? await (0, import_promises2.realpath)(path17) : path17;
             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, path13, wh, targetPath);
+            closer = await this._handleDir(parent, stats, initialAdd, depth, path17, wh, targetPath);
             if (this.fsw.closed)
               return;
             if (targetPath !== void 0) {
-              this.fsw._symlinkPaths.set(sysPath.resolve(path13), targetPath);
+              this.fsw._symlinkPaths.set(sysPath.resolve(path17), targetPath);
             }
           } else {
             closer = this._handleFile(wh.watchPath, stats, initialAdd);
           }
           ready();
           if (closer)
-            this.fsw._addPathCloser(path13, closer);
+            this.fsw._addPathCloser(path17, closer);
           return false;
         } catch (error49) {
           if (this.fsw._handleError(error49)) {
             ready();
-            return path13;
+            return path17;
           }
         }
       }
@@ -51480,26 +51794,26 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path13) {
-  if (typeof path13 !== "string")
+function normalizePath(path17) {
+  if (typeof path17 !== "string")
     throw new Error("string expected");
-  path13 = sysPath2.normalize(path13);
-  path13 = path13.replace(/\\/g, "/");
+  path17 = sysPath2.normalize(path17);
+  path17 = path17.replace(/\\/g, "/");
   let prepend = false;
-  if (path13.startsWith("//"))
+  if (path17.startsWith("//"))
     prepend = true;
   const DOUBLE_SLASH_RE2 = /\/\//;
-  while (path13.match(DOUBLE_SLASH_RE2))
-    path13 = path13.replace(DOUBLE_SLASH_RE2, "/");
+  while (path17.match(DOUBLE_SLASH_RE2))
+    path17 = path17.replace(DOUBLE_SLASH_RE2, "/");
   if (prepend)
-    path13 = "/" + path13;
-  return path13;
+    path17 = "/" + path17;
+  return path17;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path13 = normalizePath(testString);
+  const path17 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path13, stats)) {
+    if (pattern(path17, stats)) {
       return true;
     }
   }
@@ -51563,19 +51877,19 @@ var init_esm3 = __esm({
       }
       return str2;
     };
-    normalizePathToUnix = (path13) => toUnix(sysPath2.normalize(toUnix(path13)));
-    normalizeIgnored = (cwd = "") => (path13) => {
-      if (typeof path13 === "string") {
-        return normalizePathToUnix(sysPath2.isAbsolute(path13) ? path13 : sysPath2.join(cwd, path13));
+    normalizePathToUnix = (path17) => toUnix(sysPath2.normalize(toUnix(path17)));
+    normalizeIgnored = (cwd = "") => (path17) => {
+      if (typeof path17 === "string") {
+        return normalizePathToUnix(sysPath2.isAbsolute(path17) ? path17 : sysPath2.join(cwd, path17));
       } else {
-        return path13;
+        return path17;
       }
     };
-    getAbsolutePath = (path13, cwd) => {
-      if (sysPath2.isAbsolute(path13)) {
-        return path13;
+    getAbsolutePath = (path17, cwd) => {
+      if (sysPath2.isAbsolute(path17)) {
+        return path17;
       }
-      return sysPath2.join(cwd, path13);
+      return sysPath2.join(cwd, path17);
     };
     EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
     DirEntry = class {
@@ -51630,10 +51944,10 @@ var init_esm3 = __esm({
     STAT_METHOD_F = "stat";
     STAT_METHOD_L = "lstat";
     WatchHelper = class {
-      constructor(path13, follow, fsw) {
+      constructor(path17, follow, fsw) {
         this.fsw = fsw;
-        const watchPath = path13;
-        this.path = path13 = path13.replace(REPLACER_RE, "");
+        const watchPath = path17;
+        this.path = path17 = path17.replace(REPLACER_RE, "");
         this.watchPath = watchPath;
         this.fullWatchPath = sysPath2.resolve(watchPath);
         this.dirParts = [];
@@ -51755,20 +52069,20 @@ var init_esm3 = __esm({
         this._closePromise = void 0;
         let paths = unifyPaths(paths_);
         if (cwd) {
-          paths = paths.map((path13) => {
-            const absPath = getAbsolutePath(path13, cwd);
+          paths = paths.map((path17) => {
+            const absPath = getAbsolutePath(path17, cwd);
             return absPath;
           });
         }
-        paths.forEach((path13) => {
-          this._removeIgnoredPath(path13);
+        paths.forEach((path17) => {
+          this._removeIgnoredPath(path17);
         });
         this._userIgnored = void 0;
         if (!this._readyCount)
           this._readyCount = 0;
         this._readyCount += paths.length;
-        Promise.all(paths.map(async (path13) => {
-          const res = await this._nodeFsHandler._addToNodeFs(path13, !_internal, void 0, 0, _origAdd);
+        Promise.all(paths.map(async (path17) => {
+          const res = await this._nodeFsHandler._addToNodeFs(path17, !_internal, void 0, 0, _origAdd);
           if (res)
             this._emitReady();
           return res;
@@ -51790,17 +52104,17 @@ var init_esm3 = __esm({
           return this;
         const paths = unifyPaths(paths_);
         const { cwd } = this.options;
-        paths.forEach((path13) => {
-          if (!sysPath2.isAbsolute(path13) && !this._closers.has(path13)) {
+        paths.forEach((path17) => {
+          if (!sysPath2.isAbsolute(path17) && !this._closers.has(path17)) {
             if (cwd)
-              path13 = sysPath2.join(cwd, path13);
-            path13 = sysPath2.resolve(path13);
+              path17 = sysPath2.join(cwd, path17);
+            path17 = sysPath2.resolve(path17);
           }
-          this._closePath(path13);
-          this._addIgnoredPath(path13);
-          if (this._watched.has(path13)) {
+          this._closePath(path17);
+          this._addIgnoredPath(path17);
+          if (this._watched.has(path17)) {
             this._addIgnoredPath({
-              path: path13,
+              path: path17,
               recursive: true
             });
           }
@@ -51864,38 +52178,38 @@ var init_esm3 = __esm({
        * @param stats arguments to be passed with event
        * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
        */
-      async _emit(event, path13, stats) {
+      async _emit(event, path17, stats) {
         if (this.closed)
           return;
         const opts = this.options;
         if (isWindows)
-          path13 = sysPath2.normalize(path13);
+          path17 = sysPath2.normalize(path17);
         if (opts.cwd)
-          path13 = sysPath2.relative(opts.cwd, path13);
-        const args = [path13];
+          path17 = sysPath2.relative(opts.cwd, path17);
+        const args = [path17];
         if (stats != null)
           args.push(stats);
         const awf = opts.awaitWriteFinish;
         let pw;
-        if (awf && (pw = this._pendingWrites.get(path13))) {
+        if (awf && (pw = this._pendingWrites.get(path17))) {
           pw.lastChange = /* @__PURE__ */ new Date();
           return this;
         }
         if (opts.atomic) {
           if (event === EVENTS.UNLINK) {
-            this._pendingUnlinks.set(path13, [event, ...args]);
+            this._pendingUnlinks.set(path17, [event, ...args]);
             setTimeout(() => {
-              this._pendingUnlinks.forEach((entry, path14) => {
+              this._pendingUnlinks.forEach((entry, path18) => {
                 this.emit(...entry);
                 this.emit(EVENTS.ALL, ...entry);
-                this._pendingUnlinks.delete(path14);
+                this._pendingUnlinks.delete(path18);
               });
             }, typeof opts.atomic === "number" ? opts.atomic : 100);
             return this;
           }
-          if (event === EVENTS.ADD && this._pendingUnlinks.has(path13)) {
+          if (event === EVENTS.ADD && this._pendingUnlinks.has(path17)) {
             event = EVENTS.CHANGE;
-            this._pendingUnlinks.delete(path13);
+            this._pendingUnlinks.delete(path17);
           }
         }
         if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -51913,16 +52227,16 @@ var init_esm3 = __esm({
               this.emitWithAll(event, args);
             }
           };
-          this._awaitWriteFinish(path13, awf.stabilityThreshold, event, awfEmit);
+          this._awaitWriteFinish(path17, awf.stabilityThreshold, event, awfEmit);
           return this;
         }
         if (event === EVENTS.CHANGE) {
-          const isThrottled = !this._throttle(EVENTS.CHANGE, path13, 50);
+          const isThrottled = !this._throttle(EVENTS.CHANGE, path17, 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, path13) : path13;
+          const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path17) : path17;
           let stats2;
           try {
             stats2 = await (0, import_promises3.stat)(fullPath);
@@ -51953,23 +52267,23 @@ var init_esm3 = __esm({
        * @param timeout duration of time to suppress duplicate actions
        * @returns tracking object or false if action should be suppressed
        */
-      _throttle(actionType, path13, timeout) {
+      _throttle(actionType, path17, 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(path13);
+        const actionPath = action.get(path17);
         if (actionPath) {
           actionPath.count++;
           return false;
         }
         let timeoutObject;
         const clear = () => {
-          const item = action.get(path13);
+          const item = action.get(path17);
           const count = item ? item.count : 0;
-          action.delete(path13);
+          action.delete(path17);
           clearTimeout(timeoutObject);
           if (item)
             clearTimeout(item.timeoutObject);
@@ -51977,7 +52291,7 @@ var init_esm3 = __esm({
         };
         timeoutObject = setTimeout(clear, timeout);
         const thr = { timeoutObject, clear, count: 0 };
-        action.set(path13, thr);
+        action.set(path17, thr);
         return thr;
       }
       _incrReadyCount() {
@@ -51991,44 +52305,44 @@ var init_esm3 = __esm({
        * @param event
        * @param awfEmit Callback to be called when ready for event to be emitted.
        */
-      _awaitWriteFinish(path13, threshold, event, awfEmit) {
+      _awaitWriteFinish(path17, threshold, event, awfEmit) {
         const awf = this.options.awaitWriteFinish;
         if (typeof awf !== "object")
           return;
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
-        let fullPath = path13;
-        if (this.options.cwd && !sysPath2.isAbsolute(path13)) {
-          fullPath = sysPath2.join(this.options.cwd, path13);
+        let fullPath = path17;
+        if (this.options.cwd && !sysPath2.isAbsolute(path17)) {
+          fullPath = sysPath2.join(this.options.cwd, path17);
         }
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
           (0, import_fs2.stat)(fullPath, (err, curStat) => {
-            if (err || !writes.has(path13)) {
+            if (err || !writes.has(path17)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
               return;
             }
             const now2 = Number(/* @__PURE__ */ new Date());
             if (prevStat && curStat.size !== prevStat.size) {
-              writes.get(path13).lastChange = now2;
+              writes.get(path17).lastChange = now2;
             }
-            const pw = writes.get(path13);
+            const pw = writes.get(path17);
             const df = now2 - pw.lastChange;
             if (df >= threshold) {
-              writes.delete(path13);
+              writes.delete(path17);
               awfEmit(void 0, curStat);
             } else {
               timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
             }
           });
         }
-        if (!writes.has(path13)) {
-          writes.set(path13, {
+        if (!writes.has(path17)) {
+          writes.set(path17, {
             lastChange: now,
             cancelWait: () => {
-              writes.delete(path13);
+              writes.delete(path17);
               clearTimeout(timeoutHandler);
               return event;
             }
@@ -52039,8 +52353,8 @@ var init_esm3 = __esm({
       /**
        * Determines whether user has asked to ignore this path.
        */
-      _isIgnored(path13, stats) {
-        if (this.options.atomic && DOT_RE.test(path13))
+      _isIgnored(path17, stats) {
+        if (this.options.atomic && DOT_RE.test(path17))
           return true;
         if (!this._userIgnored) {
           const { cwd } = this.options;
@@ -52050,17 +52364,17 @@ var init_esm3 = __esm({
           const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
           this._userIgnored = anymatch(list, void 0);
         }
-        return this._userIgnored(path13, stats);
+        return this._userIgnored(path17, stats);
       }
-      _isntIgnored(path13, stat4) {
-        return !this._isIgnored(path13, stat4);
+      _isntIgnored(path17, stat4) {
+        return !this._isIgnored(path17, stat4);
       }
       /**
        * Provides a set of common helpers and properties relating to symlink handling.
        * @param path file or directory pattern being watched
        */
-      _getWatchHelpers(path13) {
-        return new WatchHelper(path13, this.options.followSymlinks, this);
+      _getWatchHelpers(path17) {
+        return new WatchHelper(path17, this.options.followSymlinks, this);
       }
       // Directory helpers
       // -----------------
@@ -52092,63 +52406,63 @@ var init_esm3 = __esm({
        * @param item      base path of item/directory
        */
       _remove(directory, item, isDirectory) {
-        const path13 = sysPath2.join(directory, item);
-        const fullPath = sysPath2.resolve(path13);
-        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path13) || this._watched.has(fullPath);
-        if (!this._throttle("remove", path13, 100))
+        const path17 = sysPath2.join(directory, item);
+        const fullPath = sysPath2.resolve(path17);
+        isDirectory = isDirectory != null ? isDirectory : this._watched.has(path17) || this._watched.has(fullPath);
+        if (!this._throttle("remove", path17, 100))
           return;
         if (!isDirectory && this._watched.size === 1) {
           this.add(directory, item, true);
         }
-        const wp = this._getWatchedDir(path13);
+        const wp = this._getWatchedDir(path17);
         const nestedDirectoryChildren = wp.getChildren();
-        nestedDirectoryChildren.forEach((nested) => this._remove(path13, nested));
+        nestedDirectoryChildren.forEach((nested) => this._remove(path17, 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 = path13;
+        let relPath = path17;
         if (this.options.cwd)
-          relPath = sysPath2.relative(this.options.cwd, path13);
+          relPath = sysPath2.relative(this.options.cwd, path17);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
           const event = this._pendingWrites.get(relPath).cancelWait();
           if (event === EVENTS.ADD)
             return;
         }
-        this._watched.delete(path13);
+        this._watched.delete(path17);
         this._watched.delete(fullPath);
         const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-        if (wasTracked && !this._isIgnored(path13))
-          this._emit(eventName, path13);
-        this._closePath(path13);
+        if (wasTracked && !this._isIgnored(path17))
+          this._emit(eventName, path17);
+        this._closePath(path17);
       }
       /**
        * Closes all watchers for a path
        */
-      _closePath(path13) {
-        this._closeFile(path13);
-        const dir = sysPath2.dirname(path13);
-        this._getWatchedDir(dir).remove(sysPath2.basename(path13));
+      _closePath(path17) {
+        this._closeFile(path17);
+        const dir = sysPath2.dirname(path17);
+        this._getWatchedDir(dir).remove(sysPath2.basename(path17));
       }
       /**
        * Closes only file-specific watchers
        */
-      _closeFile(path13) {
-        const closers = this._closers.get(path13);
+      _closeFile(path17) {
+        const closers = this._closers.get(path17);
         if (!closers)
           return;
         closers.forEach((closer) => closer());
-        this._closers.delete(path13);
+        this._closers.delete(path17);
       }
-      _addPathCloser(path13, closer) {
+      _addPathCloser(path17, closer) {
         if (!closer)
           return;
-        let list = this._closers.get(path13);
+        let list = this._closers.get(path17);
         if (!list) {
           list = [];
-          this._closers.set(path13, list);
+          this._closers.set(path17, list);
         }
         list.push(closer);
       }
@@ -52174,13 +52488,21 @@ var init_esm3 = __esm({
   }
 });
 
+// src/standalone/webhooks.ts
+var init_webhooks2 = __esm({
+  "src/standalone/webhooks.ts"() {
+    "use strict";
+    init_webhooks();
+  }
+});
+
 // src/standalone/server.ts
 var server_exports = {};
 __export(server_exports, {
   startServer: () => startServer
 });
 function startServer(kanbanDir, port, webviewDir) {
-  const absoluteKanbanDir = path10.resolve(kanbanDir);
+  const absoluteKanbanDir = path14.resolve(kanbanDir);
   let cards = [];
   let migrating = false;
   let currentEditingCardId = null;
@@ -52197,15 +52519,15 @@ function startServer(kanbanDir, port, webviewDir) {
     }
     if (tempFilePath) {
       try {
-        fs8.unlinkSync(tempFilePath);
+        fs9.unlinkSync(tempFilePath);
       } catch {
       }
       tempFilePath = void 0;
     }
     tempFileCardId = void 0;
   }
-  const resolvedWebviewDir = webviewDir || path10.join(__dirname, "standalone-webview");
-  const workspaceRoot = path10.dirname(absoluteKanbanDir);
+  const resolvedWebviewDir = webviewDir || path14.join(__dirname, "standalone-webview");
+  const workspaceRoot = path14.dirname(absoluteKanbanDir);
   const sdk = new KanbanSDK(absoluteKanbanDir, {
     onEvent: (event, data) => {
       fireWebhooks(workspaceRoot, event, data);
@@ -52413,15 +52735,8 @@ function startServer(kanbanDir, port, webviewDir) {
     }
   }
   function doAddColumn(name, color) {
-    const existingColumns = sdk.listColumns(currentBoardId);
-    const id = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-    let uniqueId = id;
-    let counter = 1;
-    while (existingColumns.some((c) => c.id === uniqueId)) {
-      uniqueId = `${id}-${counter++}`;
-    }
-    const column = { id: uniqueId, name, color };
-    sdk.addColumn(column, currentBoardId);
+    const columns = sdk.addColumn({ id: "", name, color }, currentBoardId);
+    const column = columns[columns.length - 1];
     broadcast(buildInitMessage());
     return column;
   }
@@ -52473,11 +52788,11 @@ function startServer(kanbanDir, port, webviewDir) {
     if (!card)
       return false;
     const cardDir = sdk.storageEngine.getCardDir(card);
-    fs8.mkdirSync(cardDir, { recursive: true });
-    fs8.writeFileSync(path10.join(cardDir, filename), fileData);
+    fs9.mkdirSync(cardDir, { recursive: true });
+    fs9.writeFileSync(path14.join(cardDir, filename), fileData);
     migrating = true;
     try {
-      const updated = await sdk.addAttachment(cardId, path10.join(cardDir, filename), currentBoardId);
+      const updated = await sdk.addAttachment(cardId, path14.join(cardDir, filename), currentBoardId);
       lastWrittenContent = serializeCard(updated);
       await loadCards();
     } finally {
@@ -52880,10 +53195,9 @@ function startServer(kanbanDir, port, webviewDir) {
         break;
       case "createBoard": {
         const boardName = msg.name;
-        const boardId = generateSlug(boardName) || "board";
         try {
-          sdk.createBoard(boardId, boardName);
-          currentBoardId = boardId;
+          const createdBoard = sdk.createBoard("", boardName);
+          currentBoardId = createdBoard.id;
           migrating = true;
           try {
             await loadCards();
@@ -53027,13 +53341,15 @@ function startServer(kanbanDir, port, webviewDir) {
         const { boardId } = params;
         const body = await readBody(req);
         const actions = body.actions;
-        const config3 = readConfig(workspaceRoot);
-        const board = config3.boards[boardId];
-        if (!board)
-          return jsonError(res, 404, `Board not found: ${boardId}`);
-        board.actions = actions;
-        writeConfig(workspaceRoot, config3);
-        return jsonOk(res, actions);
+        const existing = sdk.getBoardActions(boardId);
+        for (const key of Object.keys(existing)) {
+          if (!(key in actions))
+            sdk.removeBoardAction(boardId, key);
+        }
+        for (const [key, title] of Object.entries(actions)) {
+          sdk.addBoardAction(boardId, key, title);
+        }
+        return jsonOk(res, sdk.getBoardActions(boardId));
       } catch (err) {
         return jsonError(res, 400, String(err));
       }
@@ -53092,7 +53408,18 @@ function startServer(kanbanDir, port, webviewDir) {
       try {
         const { boardId } = params;
         const boardColumns = sdk.listColumns(boardId);
-        const boardTasks = await sdk.listCards(boardColumns.map((c) => c.id), boardId);
+        const metaFilter = {};
+        for (const [param, value] of url3.searchParams.entries()) {
+          if (param.startsWith("meta."))
+            metaFilter[param.slice(5)] = value;
+        }
+        const sortParam = url3.searchParams.get("sort");
+        const boardTasks = await sdk.listCards(
+          boardColumns.map((c) => c.id),
+          boardId,
+          Object.keys(metaFilter).length > 0 ? metaFilter : void 0,
+          sortParam || void 0
+        );
         let result = boardTasks.map(sanitizeCard);
         if (url3.searchParams.get("includeDeleted") !== "true") {
           result = result.filter((f) => f.status !== "deleted");
@@ -53114,14 +53441,6 @@ function startServer(kanbanDir, port, webviewDir) {
           const groupLabels = sdk.getLabelsInGroup(labelGroup);
           result = result.filter((f) => f.labels.some((l) => groupLabels.includes(l)));
         }
-        const metaFilter = {};
-        for (const [param, value] of url3.searchParams.entries()) {
-          if (param.startsWith("meta."))
-            metaFilter[param.slice(5)] = value;
-        }
-        if (Object.keys(metaFilter).length > 0)
-          result = result.filter((f) => matchesMetaFilter(f.metadata, metaFilter));
-        result = applySortParam(result, url3.searchParams.get("sort"));
         return jsonOk(res, result);
       } catch (err) {
         return jsonError(res, 400, String(err));
@@ -53239,6 +53558,12 @@ function startServer(kanbanDir, port, webviewDir) {
     }
     params = route("GET", "/api/tasks");
     if (params) {
+      const metaFilter2 = {};
+      for (const [param, value] of url3.searchParams.entries()) {
+        if (param.startsWith("meta."))
+          metaFilter2[param.slice(5)] = value;
+      }
+      const sortParam2 = url3.searchParams.get("sort");
       await loadCards();
       let result = cards.map(sanitizeCard);
       if (url3.searchParams.get("includeDeleted") !== "true") {
@@ -53261,14 +53586,9 @@ function startServer(kanbanDir, port, webviewDir) {
         const groupLabels = sdk.getLabelsInGroup(labelGroup);
         result = result.filter((f) => f.labels.some((l) => groupLabels.includes(l)));
       }
-      const metaFilter = {};
-      for (const [param, value] of url3.searchParams.entries()) {
-        if (param.startsWith("meta."))
-          metaFilter[param.slice(5)] = value;
-      }
-      if (Object.keys(metaFilter).length > 0)
-        result = result.filter((f) => matchesMetaFilter(f.metadata, metaFilter));
-      result = applySortParam(result, url3.searchParams.get("sort"));
+      if (Object.keys(metaFilter2).length > 0)
+        result = result.filter((f) => matchesMetaFilter(f.metadata, metaFilter2));
+      result = applySortParam(result, sortParam2);
       return jsonOk(res, result);
     }
     params = route("POST", "/api/tasks");
@@ -53388,7 +53708,7 @@ function startServer(kanbanDir, port, webviewDir) {
       const rawPath = url3.searchParams.get("path") ?? "";
       if (!rawPath)
         return jsonError(res, 400, "path is required");
-      const resolved = /^([/~]|[A-Za-z]:[/\\])/.test(rawPath) ? rawPath.replace(/^~/, process.env.HOME ?? os.homedir()) : path10.resolve(workspaceRoot, rawPath);
+      const resolved = /^([/~]|[A-Za-z]:[/\\])/.test(rawPath) ? rawPath.replace(/^~/, process.env.HOME ?? os.homedir()) : path14.resolve(workspaceRoot, rawPath);
       return jsonOk(res, { path: resolved });
     }
     params = route("GET", "/api/card-file");
@@ -53407,16 +53727,16 @@ function startServer(kanbanDir, port, webviewDir) {
         if (tempFileCardId === cardId && tempFilePath) {
           tempFileWriting = true;
           try {
-            fs8.writeFileSync(tempFilePath, serializeCard(openCard), "utf-8");
+            fs9.writeFileSync(tempFilePath, serializeCard(openCard), "utf-8");
           } finally {
             tempFileWriting = false;
           }
           return jsonOk(res, { path: tempFilePath });
         }
-        const tmpPath = path10.join(os.tmpdir(), `kanban-card-${openCard.id}.md`);
+        const tmpPath = path14.join(os.tmpdir(), `kanban-card-${openCard.id}.md`);
         tempFileWriting = true;
         try {
-          fs8.writeFileSync(tmpPath, serializeCard(openCard), "utf-8");
+          fs9.writeFileSync(tmpPath, serializeCard(openCard), "utf-8");
         } finally {
           tempFileWriting = false;
         }
@@ -53435,7 +53755,7 @@ function startServer(kanbanDir, port, webviewDir) {
             if (!cid || !fp)
               return;
             try {
-              const raw = fs8.readFileSync(fp, "utf-8");
+              const raw = fs9.readFileSync(fp, "utf-8");
               const parsed = parseCardFile(raw, `${cid}.md`);
               if (!parsed)
                 return;
@@ -53475,15 +53795,15 @@ function startServer(kanbanDir, port, webviewDir) {
       if (!card)
         return jsonError(res, 404, "Task not found");
       const cardDir = sdk.storageEngine.getCardDir(card);
-      const attachmentPath = path10.resolve(cardDir, attachName);
+      const attachmentPath = path14.resolve(cardDir, attachName);
       if (!attachmentPath.startsWith(absoluteKanbanDir)) {
         res.writeHead(403, { "Content-Type": "text/plain" });
         res.end("Forbidden");
         return;
       }
-      const ext2 = path10.extname(attachName);
+      const ext2 = path14.extname(attachName);
       const contentType2 = MIME_TYPES[ext2] || "application/octet-stream";
-      fs8.readFile(attachmentPath, (err, data) => {
+      fs9.readFile(attachmentPath, (err, data) => {
         if (err) {
           res.writeHead(404);
           res.end("File not found");
@@ -53687,7 +54007,7 @@ function startServer(kanbanDir, port, webviewDir) {
     }
     params = route("GET", "/api/webhooks");
     if (params) {
-      return jsonOk(res, loadWebhooks(workspaceRoot));
+      return jsonOk(res, sdk.listWebhooks());
     }
     params = route("POST", "/api/webhooks");
     if (params) {
@@ -53701,7 +54021,7 @@ function startServer(kanbanDir, port, webviewDir) {
         if (!events || !Array.isArray(events) || events.length === 0) {
           return jsonError(res, 400, "events array is required");
         }
-        const webhook = createWebhook(workspaceRoot, { url: webhookUrl, events, secret });
+        const webhook = sdk.createWebhook({ url: webhookUrl, events, secret });
         return jsonOk(res, webhook, 201);
       } catch (err) {
         return jsonError(res, 400, String(err));
@@ -53712,7 +54032,7 @@ function startServer(kanbanDir, port, webviewDir) {
       try {
         const { id } = params;
         const body = await readBody(req);
-        const webhook = updateWebhook(workspaceRoot, id, body);
+        const webhook = sdk.updateWebhook(id, body);
         if (!webhook)
           return jsonError(res, 404, "Webhook not found");
         return jsonOk(res, webhook);
@@ -53723,7 +54043,7 @@ function startServer(kanbanDir, port, webviewDir) {
     params = route("DELETE", "/api/webhooks/:id");
     if (params) {
       const { id } = params;
-      const ok = deleteWebhook(workspaceRoot, id);
+      const ok = sdk.deleteWebhook(id);
       if (!ok)
         return jsonError(res, 404, "Webhook not found");
       return jsonOk(res, { deleted: true });
@@ -53866,15 +54186,15 @@ function startServer(kanbanDir, port, webviewDir) {
         return;
       }
       const cardDir = sdk.storageEngine.getCardDir(card);
-      const attachmentPath = path10.resolve(cardDir, filename);
+      const attachmentPath = path14.resolve(cardDir, filename);
       if (!attachmentPath.startsWith(absoluteKanbanDir)) {
         res.writeHead(403, { "Content-Type": "text/plain" });
         res.end("Forbidden");
         return;
       }
-      const ext2 = path10.extname(filename);
+      const ext2 = path14.extname(filename);
       const contentType2 = MIME_TYPES[ext2] || "application/octet-stream";
-      fs8.readFile(attachmentPath, (err, data) => {
+      fs9.readFile(attachmentPath, (err, data) => {
         if (err) {
           res.writeHead(404, { "Content-Type": "text/plain" });
           res.end("File not found");
@@ -53888,15 +54208,15 @@ function startServer(kanbanDir, port, webviewDir) {
     if (pathname.startsWith("/api/")) {
       return jsonError(res, 404, "Not found");
     }
-    const filePath = path10.join(resolvedWebviewDir, pathname === "/" ? "index.html" : pathname);
-    if (!path10.extname(filePath)) {
+    const filePath = path14.join(resolvedWebviewDir, pathname === "/" ? "index.html" : pathname);
+    if (!path14.extname(filePath)) {
       res.writeHead(200, { "Content-Type": "text/html" });
       res.end(indexHtml);
       return;
     }
-    const ext = path10.extname(filePath);
+    const ext = path14.extname(filePath);
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
-    fs8.readFile(filePath, (err, data) => {
+    fs9.readFile(filePath, (err, data) => {
       if (err) {
         res.writeHead(200, { "Content-Type": "text/html" });
         res.end(indexHtml);
@@ -53918,7 +54238,7 @@ function startServer(kanbanDir, port, webviewDir) {
     });
   });
   let debounceTimer;
-  fs8.mkdirSync(absoluteKanbanDir, { recursive: true });
+  fs9.mkdirSync(absoluteKanbanDir, { recursive: true });
   const handleFileChange = (changedPath) => {
     if (changedPath && !changedPath.endsWith(".md"))
       return;
@@ -53964,13 +54284,17 @@ function startServer(kanbanDir, port, webviewDir) {
     }, 100);
   };
   if (sdk.storageEngine.type === "markdown") {
+    let watcherReady = false;
     const watcher = esm_default.watch(absoluteKanbanDir, {
       ignoreInitial: true,
       awaitWriteFinish: { stabilityThreshold: 100 }
     });
-    watcher.on("change", handleFileChange);
-    watcher.on("add", handleFileChange);
-    watcher.on("unlink", handleFileChange);
+    watcher.on("ready", () => {
+      watcherReady = true;
+    });
+    watcher.on("change", (p) => watcherReady && handleFileChange(p));
+    watcher.on("add", (p) => watcherReady && handleFileChange(p));
+    watcher.on("unlink", (p) => watcherReady && handleFileChange(p));
     server.on("close", () => {
       watcher.close();
       wss.close();
@@ -53988,22 +54312,21 @@ function startServer(kanbanDir, port, webviewDir) {
   });
   return server;
 }
-var http2, fs8, os, path10, MIME_TYPES;
+var http2, fs9, os, path14, MIME_TYPES;
 var init_server3 = __esm({
   "src/standalone/server.ts"() {
     "use strict";
     http2 = __toESM(require("http"));
-    fs8 = __toESM(require("fs"));
+    fs9 = __toESM(require("fs"));
     os = __toESM(require("os"));
-    path10 = __toESM(require("path"));
+    path14 = __toESM(require("path"));
     init_wrapper();
     init_esm3();
-    init_types();
     init_KanbanSDK();
     init_parser();
     init_config();
     init_types2();
-    init_webhooks();
+    init_webhooks2();
     init_metaUtils();
     MIME_TYPES = {
       ".html": "text/html",
@@ -54617,12 +54940,11 @@ var init_open = __esm({
 });
 
 // src/cli/index.ts
-var path12 = __toESM(require("path"));
-var fs14 = __toESM(require("fs/promises"));
+var path16 = __toESM(require("path"));
+var fs15 = __toESM(require("fs/promises"));
 init_KanbanSDK();
-init_webhooks();
+init_types();
 init_config();
-init_metaUtils();
 var VALID_PRIORITIES = ["critical", "high", "medium", "low"];
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -54665,16 +54987,16 @@ async function findWorkspaceRoot2(startDir) {
   let dir = startDir;
   while (true) {
     try {
-      await fs14.access(path12.join(dir, ".git"));
+      await fs15.access(path16.join(dir, ".git"));
       return dir;
     } catch {
     }
     try {
-      await fs14.access(path12.join(dir, "package.json"));
+      await fs15.access(path16.join(dir, "package.json"));
       return dir;
     } catch {
     }
-    const parent = path12.dirname(dir);
+    const parent = path16.dirname(dir);
     if (parent === dir)
       return startDir;
     dir = parent;
@@ -54682,10 +55004,10 @@ async function findWorkspaceRoot2(startDir) {
 }
 async function resolveKanbanDir2(flags) {
   if (typeof flags.dir === "string") {
-    return path12.resolve(flags.dir);
+    return path16.resolve(flags.dir);
   }
   const root = await findWorkspaceRoot2(process.cwd());
-  return path12.join(root, ".kanban");
+  return path16.join(root, ".kanban");
 }
 var bold = (s) => `\x1B[1m${s}\x1B[0m`;
 var dim = (s) => `\x1B[2m${s}\x1B[0m`;
@@ -54724,21 +55046,14 @@ function colorPriority(priority) {
       return priority;
   }
 }
-function getTitleFromContent3(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 formatCardRow(c) {
-  const title = getTitleFromContent3(c.content);
+  const title = getTitleFromContent(c.content);
   const truncTitle = title.length > 40 ? title.slice(0, 37) + "..." : title;
   const assignee = c.assignee || "-";
   return `  ${bold(c.id.slice(0, 30).padEnd(30))}  ${colorStatus(c.status.padEnd(12))}  ${colorPriority(c.priority.padEnd(8))}  ${assignee.padEnd(12)}  ${truncTitle}`;
 }
 function formatCardDetail(c) {
-  const title = getTitleFromContent3(c.content);
+  const title = getTitleFromContent(c.content);
   const lines = [
     `${bold(title)}`,
     "",
@@ -54769,7 +55084,29 @@ function formatCardDetail(c) {
 }
 async function cmdList(sdk, flags) {
   const boardId = getBoardId(flags);
-  let cards = await sdk.listCards(void 0, boardId);
+  const metaFilter = Array.isArray(flags.meta) ? (() => {
+    const mf = {};
+    for (const entry of flags.meta) {
+      const eq = entry.indexOf("=");
+      if (eq < 1) {
+        console.error(red(`Invalid --meta format: "${entry}". Expected key=value`));
+        process.exit(1);
+      }
+      mf[entry.slice(0, eq)] = entry.slice(eq + 1);
+    }
+    return Object.keys(mf).length > 0 ? mf : void 0;
+  })() : void 0;
+  const VALID_SORTS = ["created:asc", "created:desc", "modified:asc", "modified:desc"];
+  let sortOpt;
+  if (typeof flags.sort === "string") {
+    const sort = flags.sort;
+    if (!VALID_SORTS.includes(sort)) {
+      console.error(red(`Invalid --sort value: "${sort}". Must be one of: ${VALID_SORTS.join(", ")}`));
+      process.exit(1);
+    }
+    sortOpt = sort;
+  }
+  let cards = await sdk.listCards(void 0, boardId, metaFilter, sortOpt);
   if (!flags["include-deleted"]) {
     cards = cards.filter((c) => c.status !== "deleted");
   }
@@ -54789,32 +55126,6 @@ async function cmdList(sdk, flags) {
     const groupLabels = sdk.getLabelsInGroup(flags["label-group"]);
     cards = cards.filter((c) => c.labels.some((l) => groupLabels.includes(l)));
   }
-  if (Array.isArray(flags.meta)) {
-    const metaFilter = {};
-    for (const entry of flags.meta) {
-      const eq = entry.indexOf("=");
-      if (eq < 1) {
-        console.error(red(`Invalid --meta format: "${entry}". Expected key=value`));
-        process.exit(1);
-      }
-      metaFilter[entry.slice(0, eq)] = entry.slice(eq + 1);
-    }
-    cards = cards.filter((c) => matchesMetaFilter(c.metadata, metaFilter));
-  }
-  const VALID_SORTS = ["created:asc", "created:desc", "modified:asc", "modified:desc"];
-  if (typeof flags.sort === "string") {
-    const sort = flags.sort;
-    if (!VALID_SORTS.includes(sort)) {
-      console.error(red(`Invalid --sort value: "${sort}". Must be one of: ${VALID_SORTS.join(", ")}`));
-      process.exit(1);
-    }
-    const [field, dir] = sort.split(":");
-    cards = [...cards].sort((a, b) => {
-      const aVal = field === "created" ? a.created : a.modified;
-      const bVal = field === "created" ? b.created : b.modified;
-      return dir === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
-    });
-  }
   if (flags.json) {
     console.log(JSON.stringify(cards, null, 2));
     return;
@@ -55068,17 +55379,16 @@ async function cmdBoards(sdk, positional, flags, workspaceRoot) {
     case "default": {
       const boardId = positional[1];
       if (!boardId) {
-        const config4 = readConfig(workspaceRoot);
-        console.log(config4.defaultBoard);
+        const config3 = readConfig(workspaceRoot);
+        console.log(config3.defaultBoard);
         break;
       }
-      const config3 = readConfig(workspaceRoot);
-      if (!config3.boards[boardId]) {
-        console.error(red(`Board not found: ${boardId}`));
+      try {
+        sdk.setDefaultBoard(boardId);
+      } catch (err) {
+        console.error(red(String(err)));
         process.exit(1);
       }
-      config3.defaultBoard = boardId;
-      writeConfig(workspaceRoot, config3);
       console.log(green(`Default board set to: ${boardId}`));
       break;
     }
@@ -55214,7 +55524,7 @@ async function cmdAttach(sdk, positional, flags) {
       }
       const resolvedId = await resolveCardId(sdk, cardId, boardId);
       const updated = await sdk.addAttachment(resolvedId, filePath, boardId);
-      console.log(green(`Attached to ${updated.id}: ${path12.basename(filePath)}`));
+      console.log(green(`Attached to ${updated.id}: ${path16.basename(filePath)}`));
       break;
     }
     case "remove":
@@ -55682,11 +55992,11 @@ async function cmdAction(sdk, positional, flags) {
       process.exit(1);
   }
 }
-async function cmdWebhooks(positional, flags, workspaceRoot) {
+async function cmdWebhooks(positional, flags, sdk) {
   const subcommand = positional[0] || "list";
   switch (subcommand) {
     case "list": {
-      const webhooks = loadWebhooks(workspaceRoot);
+      const webhooks = sdk.listWebhooks();
       if (flags.json) {
         console.log(JSON.stringify(webhooks, null, 2));
       } else if (webhooks.length === 0) {
@@ -55710,7 +56020,7 @@ async function cmdWebhooks(positional, flags, workspaceRoot) {
       }
       const events = typeof flags.events === "string" ? flags.events.split(",").map((e) => e.trim()) : ["*"];
       const secret = typeof flags.secret === "string" ? flags.secret : void 0;
-      const webhook = createWebhook(workspaceRoot, { url: url3, events, secret });
+      const webhook = sdk.createWebhook({ url: url3, events, secret });
       if (flags.json) {
         console.log(JSON.stringify(webhook, null, 2));
       } else {
@@ -55729,7 +56039,7 @@ async function cmdWebhooks(positional, flags, workspaceRoot) {
         console.error(red("Usage: kl webhooks remove <id>"));
         process.exit(1);
       }
-      const removed = deleteWebhook(workspaceRoot, webhookId);
+      const removed = sdk.deleteWebhook(webhookId);
       if (removed) {
         console.log(green(`Removed webhook: ${webhookId}`));
       } else {
@@ -55753,7 +56063,7 @@ async function cmdWebhooks(positional, flags, workspaceRoot) {
         updates.secret = flags.secret;
       if (typeof flags.active === "string")
         updates.active = flags.active === "true";
-      const updated = updateWebhook(workspaceRoot, webhookId, updates);
+      const updated = sdk.updateWebhook(webhookId, updates);
       if (!updated) {
         console.error(red(`Webhook not found: ${webhookId}`));
         process.exit(1);
@@ -55785,13 +56095,12 @@ var SETTINGS_KEYS = [
   "defaultPriority",
   "defaultStatus"
 ];
-async function cmdSettings(positional, flags, workspaceRoot) {
+async function cmdSettings(positional, flags, sdk) {
   const subcommand = positional[0] || "show";
   switch (subcommand) {
     case "show":
     case "list": {
-      const config3 = readConfig(workspaceRoot);
-      const settings = configToSettings(config3);
+      const settings = sdk.getSettings();
       if (flags.json) {
         console.log(JSON.stringify(settings, null, 2));
       } else {
@@ -55805,8 +56114,7 @@ async function cmdSettings(positional, flags, workspaceRoot) {
     }
     case "update":
     case "set": {
-      const config3 = readConfig(workspaceRoot);
-      const settings = configToSettings(config3);
+      const settings = sdk.getSettings();
       let changed = false;
       const settingsAny = settings;
       for (const key of SETTINGS_KEYS) {
@@ -55827,10 +56135,10 @@ async function cmdSettings(positional, flags, workspaceRoot) {
         console.error(`Available: ${SETTINGS_KEYS.join(", ")}`);
         process.exit(1);
       }
-      writeConfig(workspaceRoot, settingsToConfig(config3, settings));
+      sdk.updateSettings(settings);
       console.log(green("Settings updated."));
       if (flags.json) {
-        console.log(JSON.stringify(configToSettings(readConfig(workspaceRoot)), null, 2));
+        console.log(JSON.stringify(sdk.getSettings(), null, 2));
       }
       break;
     }
@@ -55842,7 +56150,7 @@ async function cmdSettings(positional, flags, workspaceRoot) {
 }
 async function cmdMcp(flags) {
   if (typeof flags.dir === "string") {
-    process.env.KANBAN_DIR = path12.resolve(flags.dir);
+    process.env.KANBAN_DIR = path16.resolve(flags.dir);
   }
   await Promise.resolve().then(() => (init_mcp_server2(), mcp_server_exports));
 }
@@ -55895,10 +56203,10 @@ async function findPackageRoot() {
   let dir = __dirname;
   while (true) {
     try {
-      await fs14.access(path12.join(dir, "package.json"));
+      await fs15.access(path16.join(dir, "package.json"));
       return dir;
     } catch {
-      const parent = path12.dirname(dir);
+      const parent = path16.dirname(dir);
       if (parent === dir)
         return __dirname;
       dir = parent;
@@ -55913,9 +56221,9 @@ async function showDocHelp(topic) {
     process.exit(1);
   }
   const pkgRoot = await findPackageRoot();
-  const docPath = path12.join(pkgRoot, relativePath);
+  const docPath = path16.join(pkgRoot, relativePath);
   try {
-    const content = await fs14.readFile(docPath, "utf-8");
+    const content = await fs15.readFile(docPath, "utf-8");
     console.log(formatMarkdownForTerminal(content));
   } catch {
     console.error(red(`Documentation not found: ${docPath}`));
@@ -56091,7 +56399,7 @@ async function main2() {
   const { command, positional, flags } = parseArgs(process.argv);
   if (command === "version" || flags.version) {
     const pkgRoot = await findPackageRoot();
-    const pkg = JSON.parse(await fs14.readFile(path12.join(pkgRoot, "package.json"), "utf-8"));
+    const pkg = JSON.parse(await fs15.readFile(path16.join(pkgRoot, "package.json"), "utf-8"));
     console.log(pkg.version);
     return;
   }
@@ -56113,10 +56421,8 @@ async function main2() {
     return;
   }
   const kanbanDir = await resolveKanbanDir2(flags);
-  const workspaceRoot = path12.dirname(kanbanDir);
-  const sdk = new KanbanSDK(kanbanDir, {
-    onEvent: (event, data) => fireWebhooks(workspaceRoot, event, data)
-  });
+  const workspaceRoot = path16.dirname(kanbanDir);
+  const sdk = new KanbanSDK(kanbanDir);
   switch (command) {
     case "list":
     case "ls":
@@ -56187,10 +56493,10 @@ async function main2() {
     case "webhooks":
     case "webhook":
     case "wh":
-      await cmdWebhooks(positional, flags, workspaceRoot);
+      await cmdWebhooks(positional, flags, sdk);
       break;
     case "settings":
-      await cmdSettings(positional, flags, workspaceRoot);
+      await cmdSettings(positional, flags, sdk);
       break;
     case "pwd":
       if (flags.json) {