@kaban-board/cli 0.2.6 → 0.2.9

package/dist/index.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
+// @bun
 
 // src/index.ts
-import { createRequire as createRequire2 } from "node:module";
-import { Command as Command12 } from "commander";
+import { createRequire as createRequire2 } from "module";
+import { Command as Command15 } from "commander";
 
 // src/commands/add.ts
 import { KabanError } from "@kaban-board/core";
 import { Command } from "commander";
 
 // src/lib/context.ts
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
 import { BoardService, createDb, TaskService } from "@kaban-board/core";
 async function getContext() {
   const kabanDir = join(process.cwd(), ".kaban");
@@ -57,20 +58,30 @@ function outputError(code, message) {
 }
 
 // src/commands/add.ts
-var addCommand = new Command("add").description("Add a new task").argument("<title>", "Task title").option("-c, --column <column>", "Column to add task to").option("-a, --agent <agent>", "Agent creating the task").option("-D, --description <text>", "Task description").option("-d, --depends-on <ids>", "Comma-separated task IDs this depends on").option("-j, --json", "Output as JSON").action(async (title, options) => {
+var addCommand = new Command("add").description("Add a new task").argument("<title>", "Task title").option("-c, --column <column>", "Column to add task to").option("-a, --agent <agent>", "Agent creating the task").option("-D, --description <text>", "Task description").option("-d, --depends-on <ids>", "Comma-separated task IDs this depends on").option("-f, --force", "Force creation even if similar tasks exist").option("-j, --json", "Output as JSON").action(async (title, options) => {
   const json = options.json;
   try {
     const { taskService, config } = await getContext();
     const agent = options.agent ?? getAgent();
     const columnId = options.column ?? config.defaults.column;
     const dependsOn = options.dependsOn ? options.dependsOn.split(",").map((s) => s.trim()) : [];
-    const task = await taskService.addTask({
+    const result = await taskService.addTaskChecked({
       title,
       description: options.description,
       columnId,
       agent,
       dependsOn
-    });
+    }, { force: options.force });
+    if (result.rejected) {
+      if (json) {
+        outputError(409, result.rejectionReason ?? "Similar task exists");
+      } else {
+        console.error(`Error: ${result.rejectionReason}`);
+        console.error("Use --force to create anyway.");
+      }
+      process.exit(1);
+    }
+    const task = result.task;
     if (json) {
       outputSuccess(task);
       return;
@@ -78,6 +89,9 @@ var addCommand = new Command("add").description("Add a new task").argument("<tit
     console.log(`Created task [${task.id.slice(0, 8)}] "${task.title}"`);
     console.log(`  Column: ${task.columnId}`);
     console.log(`  Agent: ${task.createdBy}`);
+    if (result.similarTasks.length > 0) {
+      console.log(`  Note: Found ${result.similarTasks.length} similar task(s)`);
+    }
   } catch (error2) {
     if (error2 instanceof KabanError) {
       if (json)
@@ -89,10 +103,237 @@ var addCommand = new Command("add").description("Add a new task").argument("<tit
   }
 });
 
-// src/commands/done.ts
+// src/commands/archive.ts
 import { KabanError as KabanError2 } from "@kaban-board/core";
 import { Command as Command2 } from "commander";
-var doneCommand = new Command2("done").description("Mark a task as done").argument("<id>", "Task ID (can be partial)").option("-j, --json", "Output as JSON").action(async (id, options) => {
+var archiveCommand = new Command2("archive").description("Archive completed tasks").option("-c, --column <column>", "Archive tasks from specific column").option("-o, --older-than <days>", "Archive tasks older than N days", parseInt).option("--all-columns", "Archive from all columns (requires --older-than)").option("--dry-run", "Show what would be archived without archiving").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = await getContext();
+    if (!options.column && !options.allColumns) {
+      const terminal = await boardService.getTerminalColumn();
+      if (!terminal) {
+        if (json)
+          outputError(1, "No terminal column configured and no criteria specified");
+        console.error("Error: No terminal column configured and no criteria specified");
+        process.exit(1);
+      }
+      options.column = terminal.id;
+    }
+    if (options.allColumns && !options.olderThan) {
+      if (json)
+        outputError(1, "--all-columns requires --older-than");
+      console.error("Error: --all-columns requires --older-than");
+      process.exit(1);
+    }
+    const criteria = {};
+    if (options.column && !options.allColumns) {
+      criteria.status = options.column;
+    }
+    if (options.olderThan) {
+      const date = new Date;
+      date.setDate(date.getDate() - options.olderThan);
+      criteria.olderThan = date;
+    }
+    if (options.dryRun) {
+      const tasks = await taskService.listTasks({
+        columnId: criteria.status,
+        includeArchived: false
+      });
+      const olderThan = criteria.olderThan;
+      const filtered = olderThan ? tasks.filter((t) => t.createdAt < olderThan) : tasks;
+      if (json) {
+        outputSuccess({ dryRun: true, wouldArchive: filtered.length, tasks: filtered });
+        return;
+      }
+      console.log(`Would archive ${filtered.length} task(s):`);
+      for (const task of filtered) {
+        console.log(`  [${task.id.slice(0, 8)}] ${task.title}`);
+      }
+      return;
+    }
+    const result = await taskService.archiveTasks(criteria);
+    if (json) {
+      outputSuccess(result);
+      return;
+    }
+    console.log(`Archived ${result.archivedCount} task(s)`);
+  } catch (error2) {
+    if (error2 instanceof KabanError2) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+var restoreCommand = new Command2("restore").description("Restore a task from archive").argument("<id>", "Task ID to restore (can be partial)").option("-t, --to <column>", "Restore to specific column").option("-j, --json", "Output as JSON").action(async (id, options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    const archivedTasks = await taskService.listTasks({ includeArchived: true });
+    const task = archivedTasks.find((t) => t.id.startsWith(id) && t.archived);
+    if (!task) {
+      if (json)
+        outputError(2, `Archived task '${id}' not found`);
+      console.error(`Error: Archived task '${id}' not found`);
+      process.exit(2);
+    }
+    const restored = await taskService.restoreTask(task.id, options.to);
+    if (json) {
+      outputSuccess(restored);
+      return;
+    }
+    console.log(`Restored [${restored.id.slice(0, 8)}] "${restored.title}" to ${restored.columnId}`);
+  } catch (error2) {
+    if (error2 instanceof KabanError2) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+var purgeCommand = new Command2("purge").description("Permanently delete archived tasks").option("--confirm", "Confirm deletion (required)").option("--dry-run", "Show what would be deleted without deleting").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    if (options.dryRun) {
+      const archived = await taskService.listTasks({ includeArchived: true });
+      const archivedOnly = archived.filter((t) => t.archived);
+      if (json) {
+        outputSuccess({ dryRun: true, wouldDelete: archivedOnly.length, tasks: archivedOnly });
+        return;
+      }
+      console.log(`Would permanently delete ${archivedOnly.length} archived task(s):`);
+      for (const task of archivedOnly) {
+        console.log(`  [${task.id.slice(0, 8)}] ${task.title}`);
+      }
+      return;
+    }
+    if (!options.confirm) {
+      if (json)
+        outputError(1, "Use --confirm to permanently delete archived tasks");
+      console.error("Error: Use --confirm to permanently delete archived tasks");
+      process.exit(1);
+    }
+    const result = await taskService.purgeArchive();
+    if (json) {
+      outputSuccess(result);
+      return;
+    }
+    console.log(`Permanently deleted ${result.deletedCount} archived task(s)`);
+  } catch (error2) {
+    if (error2 instanceof KabanError2) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+var resetCommand = new Command2("reset").description("Delete ALL tasks (destructive)").option("--confirm", "Confirm deletion (required)").option("--dry-run", "Show what would be deleted without deleting").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    if (options.dryRun) {
+      const allTasks = await taskService.listTasks({ includeArchived: true });
+      if (json) {
+        outputSuccess({ dryRun: true, wouldDelete: allTasks.length, tasks: allTasks });
+        return;
+      }
+      console.log(`Would permanently delete ALL ${allTasks.length} task(s):`);
+      for (const task of allTasks) {
+        const archived = task.archived ? " [archived]" : "";
+        console.log(`  [${task.id.slice(0, 8)}] ${task.title}${archived}`);
+      }
+      return;
+    }
+    if (!options.confirm) {
+      if (json)
+        outputError(1, "Use --confirm to delete ALL tasks");
+      console.error("Error: Use --confirm to delete ALL tasks");
+      process.exit(1);
+    }
+    const result = await taskService.resetBoard();
+    if (json) {
+      outputSuccess(result);
+      return;
+    }
+    console.log(`Deleted ALL ${result.deletedCount} task(s)`);
+  } catch (error2) {
+    if (error2 instanceof KabanError2) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/assign.ts
+import { KabanError as KabanError3 } from "@kaban-board/core";
+import { Command as Command3 } from "commander";
+var assignCommand = new Command3("assign").description("Assign a task to an agent").argument("<id>", "Task ID (can be partial)").argument("[agent]", "Agent to assign (omit with --clear to unassign)").option("-c, --clear", "Unassign the task").option("-j, --json", "Output as JSON").action(async (id, agent, options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    if (options.clear && agent) {
+      if (json)
+        outputError(4, "Cannot use --clear with agent argument");
+      console.error("Error: Cannot use --clear with agent argument");
+      process.exit(4);
+    }
+    const tasks = await taskService.listTasks();
+    const task = tasks.find((t) => t.id.startsWith(id));
+    if (!task) {
+      if (json)
+        outputError(2, `Task '${id}' not found`);
+      console.error(`Error: Task '${id}' not found`);
+      process.exit(2);
+    }
+    const previousAssignee = task.assignedTo;
+    if (options.clear) {
+      const updated2 = await taskService.updateTask(task.id, { assignedTo: null });
+      if (json) {
+        outputSuccess(updated2);
+        return;
+      }
+      console.log(`Unassigned [${updated2.id.slice(0, 8)}] "${updated2.title}"`);
+      return;
+    }
+    if (!agent) {
+      if (json)
+        outputError(4, "Specify an agent or use --clear");
+      console.error("Error: Specify an agent or use --clear to unassign");
+      process.exit(4);
+    }
+    const updated = await taskService.updateTask(task.id, { assignedTo: agent });
+    if (json) {
+      outputSuccess(updated);
+      return;
+    }
+    const prevMsg = previousAssignee ? ` (was: ${previousAssignee})` : "";
+    console.log(`Assigned [${updated.id.slice(0, 8)}] "${updated.title}" to ${updated.assignedTo}${prevMsg}`);
+  } catch (error2) {
+    if (error2 instanceof KabanError3) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/done.ts
+import { KabanError as KabanError4 } from "@kaban-board/core";
+import { Command as Command4 } from "commander";
+var doneCommand = new Command4("done").description("Mark a task as done").argument("<id>", "Task ID (can be partial)").option("-j, --json", "Output as JSON").action(async (id, options) => {
   const json = options.json;
   try {
     const { taskService, boardService } = await getContext();
@@ -118,7 +359,7 @@ var doneCommand = new Command2("done").description("Mark a task as done").argume
     }
     console.log(`Completed [${moved.id.slice(0, 8)}] "${moved.title}"`);
   } catch (error2) {
-    if (error2 instanceof KabanError2) {
+    if (error2 instanceof KabanError4) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -129,20 +370,20 @@ var doneCommand = new Command2("done").description("Mark a task as done").argume
 });
 
 // src/commands/hook.ts
-import { spawn } from "node:child_process";
-import { existsSync as existsSync3, realpathSync } from "node:fs";
-import { chmod, copyFile as copyFile2, mkdir, readFile as readFile2, stat, unlink } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname, join as join3 } from "node:path";
+import { spawn } from "child_process";
+import { existsSync as existsSync3, realpathSync } from "fs";
+import { chmod, copyFile as copyFile2, mkdir, readFile as readFile2, stat, unlink } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join3 } from "path";
 import * as p from "@clack/prompts";
 import chalk from "chalk";
-import { Command as Command3 } from "commander";
+import { Command as Command5 } from "commander";
 
 // src/hook/settings-manager.ts
-import { existsSync as existsSync2 } from "node:fs";
-import { copyFile, readFile, writeFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync2 } from "fs";
+import { copyFile, readFile, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
 
 // src/hook/schemas.ts
 import { z } from "zod";
@@ -381,7 +622,7 @@ async function checkDependencies() {
 function formatCheckResults(results) {
   const maxNameLen = Math.max(...results.map((r) => r.name.length));
   return results.map((r) => {
-    const icon = r.ok ? chalk.green("✓") : chalk.red("✗");
+    const icon = r.ok ? chalk.green("\u2713") : chalk.red("\u2717");
     const name = r.name.padEnd(maxNameLen);
     const msg = r.ok ? chalk.dim(r.message) : chalk.red(r.message);
     return `  ${icon} ${name}  ${msg}`;
@@ -485,7 +726,7 @@ function formatSize(bytes) {
     return `${bytes} B`;
   return `${Math.round(bytes / 1024)} KB`;
 }
-var installCommand = new Command3("install").description("Install TodoWrite sync hook for Claude Code").option("-y, --yes", "Skip confirmation").action(async (options) => {
+var installCommand = new Command5("install").description("Install TodoWrite sync hook for Claude Code").option("-y, --yes", "Skip confirmation").action(async (options) => {
   p.intro(chalk.bgCyan.black(" kaban hook install "));
   const s = p.spinner();
   s.start("Checking dependencies...");
@@ -527,7 +768,7 @@ var installCommand = new Command3("install").description("Install TodoWrite sync
       summaryLines.push("");
     }
     if (!installResult.hookConfigured) {
-      summaryLines.push(`  ${chalk.yellow("⚠")} Hook was already configured`);
+      summaryLines.push(`  ${chalk.yellow("\u26A0")} Hook was already configured`);
       summaryLines.push("");
     }
     p.note(summaryLines.join(`
@@ -546,7 +787,7 @@ var installCommand = new Command3("install").description("Install TodoWrite sync
     process.exit(1);
   }
 });
-var uninstallCommand = new Command3("uninstall").description("Remove TodoWrite sync hook").option("-y, --yes", "Skip confirmation").option("--clean", "Also remove sync logs").action(async (options) => {
+var uninstallCommand = new Command5("uninstall").description("Remove TodoWrite sync hook").option("-y, --yes", "Skip confirmation").option("--clean", "Also remove sync logs").action(async (options) => {
   p.intro(chalk.bgRed.white(" kaban hook uninstall "));
   const binaryExists = existsSync3(join3(HOOKS_DIR, HOOK_BINARY_NAME));
   const logExists = existsSync3(join3(HOOKS_DIR, LOG_FILE));
@@ -564,7 +805,7 @@ var uninstallCommand = new Command3("uninstall").description("Remove TodoWrite s
     process.exit(0);
   }
   const formatStatusLine = (exists, label) => {
-    const icon = exists ? chalk.green("✓") : chalk.dim("○");
+    const icon = exists ? chalk.green("\u2713") : chalk.dim("\u25CB");
     const text = exists ? "" : chalk.dim(" (not found)");
     return `  ${icon} ${label}${text}`;
   };
@@ -572,7 +813,7 @@ var uninstallCommand = new Command3("uninstall").description("Remove TodoWrite s
     if (!logExists)
       return formatStatusLine(false, "Sync log");
     const suffix = options.clean ? chalk.yellow(" (will be removed)") : chalk.dim(" (will be preserved)");
-    return `  ${chalk.yellow("○")} Sync log${suffix}`;
+    return `  ${chalk.yellow("\u25CB")} Sync log${suffix}`;
   };
   const statusLines = [
     formatStatusLine(binaryExists, "Hook binary"),
@@ -598,13 +839,13 @@ var uninstallCommand = new Command3("uninstall").description("Remove TodoWrite s
     s.stop("Removal complete");
     const summaryLines = [];
     if (result.hookRemoved)
-      summaryLines.push(`  ${chalk.green("✓")} Removed hook from settings.json`);
+      summaryLines.push(`  ${chalk.green("\u2713")} Removed hook from settings.json`);
     if (result.binaryRemoved)
-      summaryLines.push(`  ${chalk.green("✓")} Removed ${HOOK_BINARY_NAME}`);
+      summaryLines.push(`  ${chalk.green("\u2713")} Removed ${HOOK_BINARY_NAME}`);
     if (result.logRemoved)
-      summaryLines.push(`  ${chalk.green("✓")} Removed ${LOG_FILE}`);
+      summaryLines.push(`  ${chalk.green("\u2713")} Removed ${LOG_FILE}`);
     if (logExists && !options.clean)
-      summaryLines.push(`  ${chalk.yellow("○")} Preserved ${LOG_FILE} (use --clean to remove)`);
+      summaryLines.push(`  ${chalk.yellow("\u25CB")} Preserved ${LOG_FILE} (use --clean to remove)`);
     if (summaryLines.length > 0) {
       p.note(summaryLines.join(`
 `), "Removed");
@@ -616,7 +857,7 @@ var uninstallCommand = new Command3("uninstall").description("Remove TodoWrite s
     process.exit(1);
   }
 });
-var statusCommand = new Command3("status").description("Check hook installation status").action(async () => {
+var statusCommand = new Command5("status").description("Check hook installation status").action(async () => {
   p.intro(chalk.bgBlue.white(" kaban hook status "));
   const s = p.spinner();
   s.start("Checking status...");
@@ -652,7 +893,7 @@ var statusCommand = new Command3("status").description("Check hook installation
   ];
   const maxNameLen = Math.max(...results.map((r) => r.name.length));
   const statusLines = results.map((r) => {
-    const icon = r.ok ? chalk.green("✓") : chalk.red("✗");
+    const icon = r.ok ? chalk.green("\u2713") : chalk.red("\u2717");
     const name = r.name.padEnd(maxNameLen);
     const detail = r.ok ? chalk.dim(r.detail) : chalk.red(r.detail);
     return `  ${icon} ${name}  ${detail}`;
@@ -682,18 +923,18 @@ var statusCommand = new Command3("status").description("Check hook installation
     process.exit(1);
   }
 });
-var hookCommand = new Command3("hook").description("Manage TodoWrite sync hook for Claude Code").addCommand(installCommand).addCommand(uninstallCommand).addCommand(statusCommand);
+var hookCommand = new Command5("hook").description("Manage TodoWrite sync hook for Claude Code").addCommand(installCommand).addCommand(uninstallCommand).addCommand(statusCommand);
 
 // src/commands/init.ts
-import { existsSync as existsSync4, mkdirSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync4, mkdirSync, writeFileSync } from "fs";
 import {
   BoardService as BoardService2,
   createDb as createDb2,
   DEFAULT_CONFIG as DEFAULT_CONFIG2,
   initializeSchema
 } from "@kaban-board/core";
-import { Command as Command4 } from "commander";
-var initCommand = new Command4("init").description("Initialize a new Kaban board in the current directory").option("-n, --name <name>", "Board name", "Kaban Board").action(async (options) => {
+import { Command as Command6 } from "commander";
+var initCommand = new Command6("init").description("Initialize a new Kaban board in the current directory").option("-n, --name <name>", "Board name", "Kaban Board").action(async (options) => {
   const { kabanDir, dbPath, configPath } = getKabanPaths();
   if (existsSync4(dbPath)) {
     console.error("Error: Board already exists in this directory");
@@ -715,8 +956,8 @@ var initCommand = new Command4("init").description("Initialize a new Kaban board
 });
 
 // src/commands/list.ts
-import { KabanError as KabanError3 } from "@kaban-board/core";
-import { Command as Command5 } from "commander";
+import { KabanError as KabanError5 } from "@kaban-board/core";
+import { Command as Command7 } from "commander";
 function sortTasks(tasks, sortBy, reverse) {
   const sorted = [...tasks].sort((a, b) => {
     switch (sortBy) {
@@ -732,7 +973,7 @@ function sortTasks(tasks, sortBy, reverse) {
   });
   return reverse ? sorted.reverse() : sorted;
 }
-var listCommand = new Command5("list").description("List tasks").option("-c, --column <column>", "Filter by column").option("-a, --agent <agent>", "Filter by creator agent").option("-u, --assignee <assignee>", "Filter by assigned agent").option("-b, --blocked", "Show only blocked tasks").option("-s, --sort <field>", "Sort by: name, date, updated").option("-r, --reverse", "Reverse sort order").option("-j, --json", "Output as JSON").action(async (options) => {
+var listCommand = new Command7("list").description("List tasks").option("-c, --column <column>", "Filter by column").option("-a, --agent <agent>", "Filter by creator agent").option("-u, --assignee <assignee>", "Filter by assigned agent").option("-b, --blocked", "Show only blocked tasks").option("-s, --sort <field>", "Sort by: name, date, updated").option("-r, --reverse", "Reverse sort order").option("-j, --json", "Output as JSON").action(async (options) => {
   const json = options.json;
   try {
     const { taskService, boardService } = await getContext();
@@ -764,7 +1005,7 @@ var listCommand = new Command5("list").description("List tasks").option("-c, --c
       const column = columnMap.get(task.columnId);
       const blocked = task.blockedReason ? " [blocked]" : "";
       const agent = task.createdBy !== "user" ? ` @${task.createdBy}` : "";
-      const assignee = task.assignedTo ? ` → ${task.assignedTo}` : "";
+      const assignee = task.assignedTo ? ` \u2192 ${task.assignedTo}` : "";
       console.log(`[${task.id.slice(0, 8)}] ${task.title}${agent}${assignee}${blocked}`);
       console.log(`         ${column?.name ?? task.columnId}`);
       if (task.description) {
@@ -773,7 +1014,7 @@ var listCommand = new Command5("list").description("List tasks").option("-c, --c
       }
     }
   } catch (error2) {
-    if (error2 instanceof KabanError3) {
+    if (error2 instanceof KabanError5) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -784,8 +1025,8 @@ var listCommand = new Command5("list").description("List tasks").option("-c, --c
 });
 
 // src/commands/mcp.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
 import {
   BoardService as BoardService3,
   createDb as createDb3,
@@ -801,7 +1042,7 @@ import {
   ListToolsRequestSchema,
   ReadResourceRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { Command as Command6 } from "commander";
+import { Command as Command8 } from "commander";
 var mcpHelpers = {
   getParam(args, primary, alias) {
     if (!args)
@@ -899,7 +1140,8 @@ async function startMcpServer(workingDirectory) {
           type: "object",
           properties: {
             columnId: { type: "string", description: "Filter by column ID" },
-            agent: { type: "string", description: "Filter by agent name" },
+            agent: { type: "string", description: "Filter by creator agent name" },
+            assignee: { type: "string", description: "Filter by assigned agent name" },
             blocked: { type: "boolean", description: "Show only blocked tasks" }
           }
         }
@@ -971,6 +1213,127 @@ async function startMcpServer(workingDirectory) {
         name: "kaban_status",
         description: "Get board status summary",
         inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "kaban_archive_tasks",
+        description: "Archive completed or stale tasks. By default archives from terminal columns only.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            columnId: { type: "string", description: "Archive from this column only" },
+            olderThanDays: { type: "number", description: "Archive tasks older than N days" },
+            allColumns: { type: "boolean", description: "Archive from ALL columns" },
+            dryRun: { type: "boolean", description: "Preview without archiving" }
+          }
+        }
+      },
+      {
+        name: "kaban_search_archive",
+        description: "Search archived tasks using full-text search",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: { type: "string", description: "Search query" },
+            limit: { type: "number", description: "Max results (default: 50)" }
+          },
+          required: ["query"]
+        }
+      },
+      {
+        name: "kaban_restore_task",
+        description: "Restore a task from archive",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID to restore" },
+            taskId: { type: "string", description: "Task ID - alias for id" },
+            columnId: { type: "string", description: "Target column (default: todo)" }
+          }
+        }
+      },
+      {
+        name: "kaban_purge_archive",
+        description: "Permanently delete all archived tasks",
+        inputSchema: {
+          type: "object",
+          properties: {
+            confirm: { type: "boolean", description: "Must be true to confirm" },
+            dryRun: { type: "boolean", description: "Preview without deleting" }
+          },
+          required: ["confirm"]
+        }
+      },
+      {
+        name: "kaban_reset_board",
+        description: "Delete ALL tasks (active and archived)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            confirm: { type: "boolean", description: "Must be true to confirm" },
+            dryRun: { type: "boolean", description: "Preview without deleting" }
+          },
+          required: ["confirm"]
+        }
+      },
+      {
+        name: "kaban_archive_stats",
+        description: "Get archive statistics",
+        inputSchema: { type: "object", properties: {} }
+      },
+      {
+        name: "kaban_add_dependency",
+        description: "Add a dependency to a task (task cannot start until dependency is done)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Task that depends on another" },
+            id: { type: "string", description: "Task ID - alias for taskId" },
+            dependsOnId: { type: "string", description: "Task that must be completed first" }
+          },
+          required: ["dependsOnId"]
+        }
+      },
+      {
+        name: "kaban_remove_dependency",
+        description: "Remove a dependency from a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Task ID" },
+            id: { type: "string", description: "Task ID - alias" },
+            dependsOnId: { type: "string", description: "Dependency to remove" }
+          },
+          required: ["dependsOnId"]
+        }
+      },
+      {
+        name: "kaban_check_dependencies",
+        description: "Check if task dependencies are resolved",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Task ID" },
+            id: { type: "string", description: "Task ID - alias" }
+          }
+        }
+      },
+      {
+        name: "kaban_add_task_checked",
+        description: "Add task with duplicate detection. Rejects if very similar task exists.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            title: { type: "string", description: "Task title" },
+            description: { type: "string", description: "Task description" },
+            columnId: { type: "string", description: "Target column (default: todo)" },
+            createdBy: { type: "string", description: "Creator: user, claude, etc." },
+            agent: { type: "string", description: "Creator (deprecated, use createdBy)" },
+            assignedTo: { type: "string", description: "Assignee" },
+            dependsOn: { type: "array", items: { type: "string" }, description: "Dependency IDs" },
+            force: { type: "boolean", description: "Create even if similar exists" }
+          },
+          required: ["title"]
+        }
       }
     ]
   }));
@@ -1085,6 +1448,153 @@ async function startMcpServer(workingDirectory) {
             totalTasks: tasks.length
           });
         }
+        case "kaban_archive_tasks": {
+          const { columnId, olderThanDays, allColumns, dryRun } = args ?? {};
+          const columns = await boardService.getColumns();
+          const terminalColumns = columns.filter((c) => c.isTerminal);
+          let targetColumnIds = [];
+          if (columnId) {
+            targetColumnIds = [columnId];
+          } else if (allColumns) {
+            targetColumnIds = columns.map((c) => c.id);
+          } else {
+            targetColumnIds = terminalColumns.map((c) => c.id);
+          }
+          if (targetColumnIds.length === 0) {
+            return jsonResponse({
+              archivedCount: 0,
+              taskIds: [],
+              message: "No columns to archive from"
+            });
+          }
+          const allTasks = await taskService.listTasks();
+          let tasksToArchive = allTasks.filter((t) => !t.archived && targetColumnIds.includes(t.columnId));
+          if (olderThanDays !== undefined) {
+            const cutoff = new Date;
+            cutoff.setDate(cutoff.getDate() - olderThanDays);
+            tasksToArchive = tasksToArchive.filter((t) => t.createdAt < cutoff);
+          }
+          if (tasksToArchive.length === 0) {
+            return jsonResponse({
+              archivedCount: 0,
+              taskIds: [],
+              message: "No matching tasks to archive"
+            });
+          }
+          if (dryRun) {
+            return jsonResponse({
+              dryRun: true,
+              wouldArchive: tasksToArchive.length,
+              taskIds: tasksToArchive.map((t) => t.id),
+              tasks: tasksToArchive.map((t) => ({
+                id: t.id,
+                title: t.title,
+                columnId: t.columnId
+              }))
+            });
+          }
+          const result = await taskService.archiveTasks({
+            taskIds: tasksToArchive.map((t) => t.id)
+          });
+          return jsonResponse(result);
+        }
+        case "kaban_search_archive": {
+          const { query, limit } = args ?? {};
+          if (!query)
+            return errorResponse("Query required");
+          const result = await taskService.searchArchive(query, { limit });
+          return jsonResponse(result);
+        }
+        case "kaban_restore_task": {
+          const id = getParam(taskArgs, "id", "taskId");
+          if (!id)
+            return errorResponse("Task ID required");
+          const { columnId } = args ?? {};
+          const task = await taskService.restoreTask(id, columnId);
+          return jsonResponse(task);
+        }
+        case "kaban_purge_archive": {
+          const { confirm: confirm2, dryRun } = args ?? {};
+          if (!confirm2) {
+            return errorResponse("Must set confirm: true to purge archive");
+          }
+          if (dryRun) {
+            const result2 = await taskService.searchArchive("", { limit: 1000 });
+            return jsonResponse({
+              dryRun: true,
+              wouldDelete: result2.total
+            });
+          }
+          const result = await taskService.purgeArchive();
+          return jsonResponse(result);
+        }
+        case "kaban_reset_board": {
+          const { confirm: confirm2, dryRun } = args ?? {};
+          if (!confirm2) {
+            return errorResponse("Must set confirm: true to reset board");
+          }
+          if (dryRun) {
+            const allTasks = await taskService.listTasks();
+            const archivedResult = await taskService.searchArchive("", { limit: 1000 });
+            return jsonResponse({
+              dryRun: true,
+              wouldDelete: allTasks.length + archivedResult.total,
+              activeTasks: allTasks.length,
+              archivedTasks: archivedResult.total
+            });
+          }
+          const result = await taskService.resetBoard();
+          return jsonResponse(result);
+        }
+        case "kaban_archive_stats": {
+          const archivedResult = await taskService.searchArchive("", { limit: 1 });
+          const allTasks = await taskService.listTasks();
+          const columns = await boardService.getColumns();
+          const terminalColumns = columns.filter((c) => c.isTerminal);
+          const completedCount = allTasks.filter((t) => terminalColumns.some((c) => c.id === t.columnId)).length;
+          return jsonResponse({
+            archivedCount: archivedResult.total,
+            activeTasks: allTasks.length,
+            completedNotArchived: completedCount
+          });
+        }
+        case "kaban_add_dependency": {
+          const id = getParam(taskArgs, "taskId", "id");
+          if (!id)
+            return errorResponse("Task ID required");
+          const { dependsOnId } = args ?? {};
+          if (!dependsOnId)
+            return errorResponse("dependsOnId required");
+          const task = await taskService.addDependency(id, dependsOnId);
+          return jsonResponse(task);
+        }
+        case "kaban_remove_dependency": {
+          const id = getParam(taskArgs, "taskId", "id");
+          if (!id)
+            return errorResponse("Task ID required");
+          const { dependsOnId } = args ?? {};
+          if (!dependsOnId)
+            return errorResponse("dependsOnId required");
+          const task = await taskService.removeDependency(id, dependsOnId);
+          return jsonResponse(task);
+        }
+        case "kaban_check_dependencies": {
+          const id = getParam(taskArgs, "taskId", "id");
+          if (!id)
+            return errorResponse("Task ID required");
+          const result = await taskService.validateDependencies(id);
+          return jsonResponse(result);
+        }
+        case "kaban_add_task_checked": {
+          const addCheckedArgs = args;
+          const title = addCheckedArgs?.title;
+          if (typeof title !== "string" || !title.trim()) {
+            return errorResponse("Title required");
+          }
+          const { force, ...taskInput } = addCheckedArgs;
+          const result = await taskService.addTaskChecked(taskInput, { force });
+          return jsonResponse(result);
+        }
         default:
           return errorResponse(`Unknown tool: ${name}`);
       }
@@ -1198,15 +1708,15 @@ async function startMcpServer(workingDirectory) {
   await server.connect(transport);
   console.error("Kaban MCP server running on stdio");
 }
-var mcpCommand = new Command6("mcp").description("Start MCP server for AI agent integration").option("-p, --path <path>", "Working directory for Kaban board").action(async (options) => {
+var mcpCommand = new Command8("mcp").description("Start MCP server for AI agent integration").option("-p, --path <path>", "Working directory for Kaban board").action(async (options) => {
   const workingDirectory = options.path ?? process.env.KABAN_PATH ?? process.cwd();
   await startMcpServer(workingDirectory);
 });
 
 // src/commands/move.ts
-import { KabanError as KabanError4 } from "@kaban-board/core";
-import { Command as Command7 } from "commander";
-var moveCommand = new Command7("move").description("Move a task to a different column").argument("<id>", "Task ID (can be partial)").argument("[column]", "Target column").option("-n, --next", "Move to next column").option("-f, --force", "Force move even if WIP limit exceeded").option("-j, --json", "Output as JSON").action(async (id, column, options) => {
+import { KabanError as KabanError6 } from "@kaban-board/core";
+import { Command as Command9 } from "commander";
+var moveCommand = new Command9("move").description("Move a task to a different column").argument("<id>", "Task ID (can be partial)").argument("[column]", "Target column").option("-n, --next", "Move to next column").option("-f, --force", "Force move even if WIP limit exceeded").option("-A, --assign [agent]", "Assign task to agent (defaults to current agent)").option("-j, --json", "Output as JSON").action(async (id, column, options) => {
   const json = options.json;
   try {
     const { taskService, boardService } = await getContext();
@@ -1240,14 +1750,24 @@ var moveCommand = new Command7("move").description("Move a task to a different c
     const moved = await taskService.moveTask(task.id, targetColumn, {
       force: options.force
     });
+    let assignAgent = null;
+    if (options.assign !== undefined) {
+      assignAgent = options.assign === true ? getAgent() : options.assign;
+      await taskService.updateTask(moved.id, { assignedTo: assignAgent });
+    }
+    const finalTask = assignAgent ? await taskService.getTask(moved.id) : moved;
     if (json) {
-      outputSuccess(moved);
+      outputSuccess(finalTask);
       return;
     }
     const col = await boardService.getColumn(moved.columnId);
-    console.log(`Moved [${moved.id.slice(0, 8)}] to ${col?.name}`);
+    let msg = `Moved [${moved.id.slice(0, 8)}] to ${col?.name}`;
+    if (assignAgent) {
+      msg += ` (assigned to ${assignAgent})`;
+    }
+    console.log(msg);
   } catch (error2) {
-    if (error2 instanceof KabanError4) {
+    if (error2 instanceof KabanError6) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -1259,9 +1779,9 @@ var moveCommand = new Command7("move").description("Move a task to a different c
 
 // src/commands/schema.ts
 import { jsonSchemas } from "@kaban-board/core";
-import { Command as Command8 } from "commander";
+import { Command as Command10 } from "commander";
 var availableSchemas = Object.keys(jsonSchemas);
-var schemaCommand = new Command8("schema").description("Output JSON schemas for AI agents").argument("[name]", "Schema name (omit to list available)").action((name) => {
+var schemaCommand = new Command10("schema").description("Output JSON schemas for AI agents").argument("[name]", "Schema name (omit to list available)").action((name) => {
   if (!name) {
     console.log("Available schemas:");
     for (const schemaName of availableSchemas) {
@@ -1280,10 +1800,52 @@ Usage: kaban schema <name>`);
   console.log(JSON.stringify(schema, null, 2));
 });
 
+// src/commands/search.ts
+import { KabanError as KabanError7 } from "@kaban-board/core";
+import { Command as Command11 } from "commander";
+var searchCommand = new Command11("search").description("Search tasks").argument("<query>", "Search query").option("--archive", "Search in archive only").option("-l, --limit <n>", "Max results", parseInt, 50).option("-j, --json", "Output as JSON").action(async (query, options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    let tasks;
+    if (options.archive) {
+      const result = await taskService.searchArchive(query, {
+        limit: options.limit
+      });
+      tasks = result.tasks;
+    } else {
+      const allTasks = await taskService.listTasks();
+      const queryLower = query.toLowerCase();
+      tasks = allTasks.filter((t) => t.title.toLowerCase().includes(queryLower) || t.description?.toLowerCase().includes(queryLower));
+    }
+    if (json) {
+      outputSuccess(tasks);
+      return;
+    }
+    if (tasks.length === 0) {
+      console.log("No tasks found");
+      return;
+    }
+    for (const task of tasks) {
+      const archived = task.archived ? " [archived]" : "";
+      console.log(`[${task.id.slice(0, 8)}] ${task.title}${archived}`);
+      console.log(`  Column: ${task.columnId} | By: ${task.createdBy}`);
+    }
+  } catch (error2) {
+    if (error2 instanceof KabanError7) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
 // src/commands/status.ts
-import { KabanError as KabanError5 } from "@kaban-board/core";
-import { Command as Command9 } from "commander";
-var statusCommand2 = new Command9("status").description("Show board status summary").option("-j, --json", "Output as JSON").action(async (options) => {
+import { KabanError as KabanError8 } from "@kaban-board/core";
+import { Command as Command12 } from "commander";
+var statusCommand2 = new Command12("status").description("Show board status summary").option("-j, --json", "Output as JSON").action(async (options) => {
   const json = options.json;
   try {
     const { taskService, boardService } = await getContext();
@@ -1326,7 +1888,7 @@ var statusCommand2 = new Command9("status").description("Show board status summa
     }
     console.log();
   } catch (error2) {
-    if (error2 instanceof KabanError5) {
+    if (error2 instanceof KabanError8) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -1337,7 +1899,7 @@ var statusCommand2 = new Command9("status").description("Show board status summa
 });
 
 // src/commands/sync.ts
-import { Command as Command10 } from "commander";
+import { Command as Command13 } from "commander";
 
 // src/hook/constants.ts
 var STATUS_PRIORITY = {
@@ -1431,23 +1993,26 @@ class ConflictResolver {
 }
 
 // src/hook/kaban-client.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn2 } from "child_process";
 
 class KabanClient {
   cwd;
+  kabanCmd;
   constructor(cwd) {
     this.cwd = cwd;
+    const cliOverride = process.env.KABAN_CLI;
+    this.kabanCmd = cliOverride ? cliOverride.split(" ") : ["kaban"];
   }
   async boardExists() {
     try {
-      const result = await this.exec(["kaban", "status", "--json"]);
+      const result = await this.exec([...this.kabanCmd, "status", "--json"]);
       return result.exitCode === 0;
     } catch {
       return false;
     }
   }
   async listTasks(columnId) {
-    const args = ["kaban", "list", "--json"];
+    const args = [...this.kabanCmd, "list", "--json"];
     if (columnId) {
       args.push("--column", columnId);
     }
@@ -1456,7 +2021,8 @@ class KabanClient {
       return [];
     }
     try {
-      const tasks = JSON.parse(result.stdout);
+      const parsed = JSON.parse(result.stdout);
+      const tasks = parsed.data ?? parsed;
       return tasks.map((t) => ({
         id: t.id,
         title: t.title,
@@ -1469,12 +2035,13 @@ class KabanClient {
     }
   }
   async getTaskById(id) {
-    const result = await this.exec(["kaban", "get", id, "--json"]);
+    const result = await this.exec([...this.kabanCmd, "get", id, "--json"]);
     if (result.exitCode !== 0) {
       return null;
     }
     try {
-      const task = JSON.parse(result.stdout);
+      const parsed = JSON.parse(result.stdout);
+      const task = parsed.data ?? parsed;
       return {
         id: task.id,
         title: task.title,
@@ -1491,7 +2058,7 @@ class KabanClient {
     return tasks.find((t) => t.title === title) ?? null;
   }
   async addTask(title, columnId = "todo") {
-    const result = await this.exec(["kaban", "add", title, "--column", columnId, "--json"]);
+    const result = await this.exec([...this.kabanCmd, "add", title, "--column", columnId, "--json"]);
     if (result.exitCode !== 0) {
       return null;
     }
@@ -1504,20 +2071,21 @@ class KabanClient {
     }
   }
   async moveTask(id, columnId) {
-    const result = await this.exec(["kaban", "move", id, "--column", columnId]);
+    const result = await this.exec([...this.kabanCmd, "move", id, columnId]);
     return result.exitCode === 0;
   }
   async completeTask(id) {
-    const result = await this.exec(["kaban", "done", id]);
+    const result = await this.exec([...this.kabanCmd, "done", id]);
     return result.exitCode === 0;
   }
   async getStatus() {
-    const result = await this.exec(["kaban", "status", "--json"]);
+    const result = await this.exec([...this.kabanCmd, "status", "--json"]);
     if (result.exitCode !== 0) {
       return null;
     }
     try {
-      return JSON.parse(result.stdout);
+      const parsed = JSON.parse(result.stdout);
+      return parsed.data ?? parsed;
     } catch {
       return null;
     }
@@ -1634,10 +2202,10 @@ class SyncEngine {
 }
 
 // src/hook/sync-logger.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
-import { homedir as homedir3 } from "node:os";
-import { dirname as dirname2 } from "node:path";
+import { existsSync as existsSync6 } from "fs";
+import { appendFile, mkdir as mkdir2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2 } from "path";
 
 class SyncLogger {
   logPath;
@@ -1673,7 +2241,7 @@ class SyncLogger {
 }
 
 // src/commands/sync.ts
-var syncCommand = new Command10("sync").description("Sync TodoWrite input to Kaban board (reads from stdin)").option("--no-log", "Disable sync logging").action(async (options) => {
+var syncCommand = new Command13("sync").description("Sync TodoWrite input to Kaban board (reads from stdin)").option("--no-log", "Disable sync logging").action(async (options) => {
   const startTime = performance.now();
   let input;
   try {
@@ -1720,12 +2288,12 @@ var syncCommand = new Command10("sync").description("Sync TodoWrite input to Kab
 });
 
 // src/commands/tui.ts
-import { spawn as spawn3, spawnSync } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
-import { Command as Command11 } from "commander";
+import { spawn as spawn3, spawnSync } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname3, join as join5 } from "path";
+import { fileURLToPath } from "url";
+import { Command as Command14 } from "commander";
 var __dirname2 = dirname3(fileURLToPath(import.meta.url));
 var require2 = createRequire(import.meta.url);
 function hasBun() {
@@ -1751,7 +2319,7 @@ function runBinary(path, args) {
   const child = spawn3(path, args, { stdio: "inherit", cwd: process.cwd() });
   child.on("exit", (code) => process.exit(code ?? 0));
 }
-var tuiCommand = new Command11("tui").description("Start interactive Terminal UI").action(async () => {
+var tuiCommand = new Command14("tui").description("Start interactive Terminal UI").action(async () => {
   const cwd = process.cwd();
   const args = process.argv.slice(3);
   const useBun = hasBun();
@@ -1784,17 +2352,23 @@ var tuiCommand = new Command11("tui").description("Start interactive Terminal UI
 // src/index.ts
 var require3 = createRequire2(import.meta.url);
 var pkg = require3("../package.json");
-var program = new Command12;
+var program = new Command15;
 program.name("kaban").description("Terminal Kanban for AI Code Agents").version(pkg.version);
 program.addCommand(initCommand);
 program.addCommand(addCommand);
 program.addCommand(listCommand);
 program.addCommand(moveCommand);
+program.addCommand(assignCommand);
 program.addCommand(doneCommand);
 program.addCommand(statusCommand2);
 program.addCommand(schemaCommand);
+program.addCommand(searchCommand);
 program.addCommand(mcpCommand);
 program.addCommand(tuiCommand);
 program.addCommand(hookCommand);
 program.addCommand(syncCommand);
+program.addCommand(archiveCommand);
+program.addCommand(restoreCommand);
+program.addCommand(purgeCommand);
+program.addCommand(resetCommand);
 program.parse();

package/dist/kaban-hook

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
+// @bun
 
 // src/hook-entry.ts
-import { spawn } from "node:child_process";
+import { spawn } from "child_process";
 var kaban = spawn("kaban", ["sync"], {
   stdio: ["pipe", "inherit", "inherit"]
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaban-board/cli",
-  "version": "0.2.6",
+  "version": "0.2.9",
   "description": "Terminal Kanban for AI Code Agents - CLI and MCP server",
   "type": "module",
   "bin": {
@@ -10,7 +10,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build ./src/index.ts --outdir ./dist --target node --packages external && bun build ./src/hook-entry.ts --outfile ./dist/kaban-hook --target node && chmod +x ./dist/index.js ./dist/kaban-hook",
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun --packages external && bun build ./src/hook-entry.ts --outfile ./dist/kaban-hook --target bun && chmod +x ./dist/index.js ./dist/kaban-hook",
     "dev": "bun run ./src/index.ts",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
@@ -18,12 +18,12 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "@kaban-board/core": "0.2.4",
-    "@kaban-board/tui": "0.2.4",
-    "@modelcontextprotocol/sdk": "^1.25.2",
+    "@kaban-board/core": "0.2.5",
+    "@kaban-board/tui": "0.2.5",
+    "@modelcontextprotocol/sdk": "^1.25.3",
     "chalk": "^5.6.2",
-    "commander": "^12.0.0",
-    "zod": "^4.3.5"
+    "commander": "^14.0.2",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/bun": "latest",