@kaban-board/cli 0.2.5 → 0.2.8

package/dist/index.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
+// @bun
 
 // src/index.ts
-import { createRequire } 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,26 @@ 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)
+      return;
+    const primaryVal = args[primary];
+    if (typeof primaryVal === "string" && primaryVal.trim())
+      return primaryVal;
+    const aliasVal = args[alias];
+    if (typeof aliasVal === "string" && aliasVal.trim())
+      return aliasVal;
+    return;
+  },
+  errorResponse(message) {
+    return { content: [{ type: "text", text: JSON.stringify({ error: message }) }], isError: true };
+  },
+  jsonResponse(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  }
+};
 function getKabanPaths2(basePath) {
   const base = basePath ?? process.cwd();
   const kabanDir = join4(base, ".kaban");
@@ -867,8 +1127,10 @@ async function startMcpServer(workingDirectory) {
         description: "Get a task by its ID",
         inputSchema: {
           type: "object",
-          properties: { id: { type: "string", description: "Task ID (ULID)" } },
-          required: ["id"]
+          properties: {
+            id: { type: "string", description: "Task ID (ULID)" },
+            taskId: { type: "string", description: "Task ID (ULID) - alias for 'id'" }
+          }
         }
       },
       {
@@ -878,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" }
           }
         }
@@ -890,10 +1153,11 @@ async function startMcpServer(workingDirectory) {
           type: "object",
           properties: {
             id: { type: "string", description: "Task ID (ULID)" },
+            taskId: { type: "string", description: "Task ID (ULID) - alias for 'id'" },
             columnId: { type: "string", description: "Target column ID" },
+            column: { type: "string", description: "Target column ID - alias for 'columnId'" },
             force: { type: "boolean", description: "Force move even if WIP limit exceeded" }
-          },
-          required: ["id", "columnId"]
+          }
         }
       },
       {
@@ -903,6 +1167,7 @@ async function startMcpServer(workingDirectory) {
           type: "object",
           properties: {
             id: { type: "string", description: "Task ID (ULID)" },
+            taskId: { type: "string", description: "Task ID (ULID) - alias for 'id'" },
             title: { type: "string", description: "New task title" },
             description: { type: ["string", "null"], description: "New task description" },
             assignedTo: { type: ["string", "null"], description: "Assigned agent name" },
@@ -916,8 +1181,7 @@ async function startMcpServer(workingDirectory) {
               type: "number",
               description: "Expected version for optimistic locking"
             }
-          },
-          required: ["id"]
+          }
         }
       },
       {
@@ -925,8 +1189,10 @@ async function startMcpServer(workingDirectory) {
         description: "Delete a task",
         inputSchema: {
           type: "object",
-          properties: { id: { type: "string", description: "Task ID (ULID)" } },
-          required: ["id"]
+          properties: {
+            id: { type: "string", description: "Task ID (ULID)" },
+            taskId: { type: "string", description: "Task ID (ULID) - alias for 'id'" }
+          }
         }
       },
       {
@@ -934,17 +1200,144 @@ async function startMcpServer(workingDirectory) {
         description: "Mark a task as completed (move to terminal column)",
         inputSchema: {
           type: "object",
-          properties: { id: { type: "string", description: "Task ID (ULID) or partial ID" } },
-          required: ["id"]
+          properties: {
+            id: { type: "string", description: "Task ID (ULID) or partial ID" },
+            taskId: {
+              type: "string",
+              description: "Task ID (ULID) or partial ID - alias for 'id'"
+            }
+          }
         }
       },
       {
         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"]
+        }
       }
     ]
   }));
+  const { getParam, errorResponse, jsonResponse } = mcpHelpers;
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
@@ -953,15 +1346,7 @@ async function startMcpServer(workingDirectory) {
         const targetPath = basePath ?? workingDirectory;
         const { kabanDir, dbPath, configPath } = getKabanPaths2(targetPath);
         if (existsSync5(dbPath)) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({ error: "Board already exists in this directory" })
-              }
-            ],
-            isError: true
-          };
+          return errorResponse("Board already exists in this directory");
         }
         mkdirSync2(kabanDir, { recursive: true });
         const config = {
@@ -973,70 +1358,77 @@ async function startMcpServer(workingDirectory) {
         await initializeSchema2(db);
         const boardService2 = new BoardService3(db);
         await boardService2.initializeBoard(config);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({
-                success: true,
-                board: boardName,
-                paths: { database: dbPath, config: configPath }
-              }, null, 2)
-            }
-          ]
-        };
+        return jsonResponse({
+          success: true,
+          board: boardName,
+          paths: { database: dbPath, config: configPath }
+        });
       }
       const { taskService, boardService } = await createContext(workingDirectory);
+      const taskArgs = args;
+      const taskId = getParam(taskArgs, "id", "taskId");
       switch (name) {
         case "kaban_add_task": {
+          const addArgs = args;
+          const title = addArgs?.title;
+          if (typeof title !== "string" || !title.trim()) {
+            return errorResponse("Title required (non-empty string)");
+          }
           const task = await taskService.addTask(args);
-          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+          return jsonResponse(task);
         }
         case "kaban_get_task": {
-          const task = await taskService.getTask(args.id);
+          if (!taskId)
+            return errorResponse("Task ID required (use 'id' or 'taskId')");
+          const task = await taskService.getTask(taskId);
           if (!task)
-            return {
-              content: [{ type: "text", text: JSON.stringify({ error: "Task not found" }) }]
-            };
-          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+            return errorResponse("Task not found");
+          return jsonResponse(task);
         }
         case "kaban_list_tasks": {
           const tasks = await taskService.listTasks(args);
-          return { content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }] };
+          return jsonResponse(tasks);
         }
         case "kaban_move_task": {
-          const { id, columnId, force } = args;
-          const task = await taskService.moveTask(id, columnId, { force });
-          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+          if (!taskId)
+            return errorResponse("Task ID required (use 'id' or 'taskId')");
+          const targetColumn = getParam(taskArgs, "columnId", "column");
+          if (!targetColumn)
+            return errorResponse("Column ID required (use 'columnId' or 'column')");
+          const { force } = args ?? {};
+          const task = await taskService.moveTask(taskId, targetColumn, { force });
+          return jsonResponse(task);
         }
         case "kaban_update_task": {
-          const { id, expectedVersion, ...updates } = args;
-          const task = await taskService.updateTask(id, updates, expectedVersion);
-          return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
+          if (!taskId)
+            return errorResponse("Task ID required (use 'id' or 'taskId')");
+          const {
+            taskId: _t,
+            id: _i,
+            expectedVersion,
+            ...updates
+          } = args ?? {};
+          const task = await taskService.updateTask(taskId, updates, expectedVersion);
+          return jsonResponse(task);
         }
         case "kaban_delete_task": {
-          await taskService.deleteTask(args.id);
-          return { content: [{ type: "text", text: JSON.stringify({ success: true }) }] };
+          if (!taskId)
+            return errorResponse("Task ID required (use 'id' or 'taskId')");
+          await taskService.deleteTask(taskId);
+          return jsonResponse({ success: true });
         }
         case "kaban_complete_task": {
-          const { id } = args;
+          if (!taskId)
+            return errorResponse("Task ID required (use 'id' or 'taskId')");
           const tasks = await taskService.listTasks();
-          const task = tasks.find((t) => t.id.startsWith(id));
+          const task = tasks.find((t) => t.id.startsWith(taskId));
           if (!task)
-            return {
-              content: [
-                { type: "text", text: JSON.stringify({ error: `Task '${id}' not found` }) }
-              ]
-            };
+            return errorResponse(`Task '${taskId}' not found`);
           const terminal = await boardService.getTerminalColumn();
           if (!terminal)
-            return {
-              content: [
-                { type: "text", text: JSON.stringify({ error: "No terminal column configured" }) }
-              ]
-            };
+            return errorResponse("No terminal column configured");
           const completed = await taskService.moveTask(task.id, terminal.id);
-          return { content: [{ type: "text", text: JSON.stringify(completed, null, 2) }] };
+          return jsonResponse(completed);
         }
         case "kaban_status": {
           const board = await boardService.getBoard();
@@ -1049,25 +1441,162 @@ async function startMcpServer(workingDirectory) {
             wipLimit: column.wipLimit,
             isTerminal: column.isTerminal
           }));
-          return {
-            content: [
-              {
-                type: "text",
-                text: JSON.stringify({
-                  board: { name: board?.name ?? "Kaban Board" },
-                  columns: columnStats,
-                  blockedCount: tasks.filter((t) => t.blockedReason).length,
-                  totalTasks: tasks.length
-                }, null, 2)
-              }
-            ]
-          };
+          return jsonResponse({
+            board: { name: board?.name ?? "Kaban Board" },
+            columns: columnStats,
+            blockedCount: tasks.filter((t) => t.blockedReason).length,
+            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 {
-            content: [{ type: "text", text: JSON.stringify({ error: `Unknown tool: ${name}` }) }],
-            isError: true
-          };
+          return errorResponse(`Unknown tool: ${name}`);
       }
     } catch (error2) {
       const message = error2 instanceof Error ? error2.message : String(error2);
@@ -1179,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();
@@ -1221,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}`);
@@ -1240,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) {
@@ -1261,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();
@@ -1307,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}`);
@@ -1318,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 = {
@@ -1412,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);
     }
@@ -1437,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,
@@ -1450,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,
@@ -1472,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;
     }
@@ -1485,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;
     }
@@ -1615,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;
@@ -1654,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 {
@@ -1701,77 +2288,87 @@ 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 { 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() {
+  try {
+    const result = spawnSync("bun", ["--version"], { stdio: "ignore" });
+    return result.status === 0;
+  } catch {
+    return false;
+  }
+}
 function findInPath(name) {
   const result = spawnSync("which", [name], { encoding: "utf-8" });
   return result.status === 0 ? result.stdout.trim() : null;
 }
+function resolveTuiPackage() {
+  try {
+    return require2.resolve("@kaban-board/tui");
+  } catch {
+    return null;
+  }
+}
 function runBinary(path, args) {
   const child = spawn3(path, args, { stdio: "inherit", cwd: process.cwd() });
   child.on("exit", (code) => process.exit(code ?? 0));
 }
-function runBunx(bunPath, args) {
-  let started = false;
-  const child = spawn3(bunPath, ["x", "@kaban-board/tui", ...args], {
-    stdio: "inherit",
-    cwd: process.cwd()
-  });
-  child.on("spawn", () => {
-    started = true;
-  });
-  child.on("error", () => {
-    if (!started)
-      showInstallError();
-  });
-  child.on("exit", (code) => process.exit(code ?? 0));
-  return true;
-}
-function showInstallError() {
-  console.error(`
-Error: kaban-tui not found
-
-The TUI requires Bun runtime. Install with one of:
-
-  # Homebrew (recommended)
-  brew install beshkenadze/tap/kaban-tui
-
-  # Or install Bun, then run via bunx
-  curl -fsSL https://bun.sh/install | bash
-  bunx @kaban-board/tui
-`);
-  process.exit(1);
-}
-var tuiCommand = new Command11("tui").description("Start interactive Terminal UI (requires Bun)").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();
   const siblingBinary = join5(dirname3(process.execPath), "kaban-tui");
   if (existsSync7(siblingBinary))
     return runBinary(siblingBinary, args);
   const pathBinary = findInPath("kaban-tui");
   if (pathBinary)
     return runBinary(pathBinary, args);
-  const bunPath = findInPath("bun");
-  if (bunPath)
-    return runBunx(bunPath, args);
-  showInstallError();
+  const tuiDevEntry = join5(__dirname2, "../../../tui/src/index.ts");
+  if (existsSync7(tuiDevEntry) && useBun) {
+    const child2 = spawn3("bun", ["run", tuiDevEntry], { stdio: "inherit", cwd });
+    child2.on("exit", (code) => process.exit(code ?? 0));
+    return;
+  }
+  if (!useBun) {
+    console.error("TUI requires Bun. Install: curl -fsSL https://bun.sh/install | bash");
+    process.exit(1);
+  }
+  const tuiEntry = resolveTuiPackage();
+  if (tuiEntry) {
+    const child2 = spawn3("bun", [tuiEntry, ...args], { stdio: "inherit", cwd });
+    child2.on("exit", (code) => process.exit(code ?? 0));
+    return;
+  }
+  const child = spawn3("bun", ["x", "@kaban-board/tui", ...args], { stdio: "inherit", cwd });
+  child.on("exit", (code) => process.exit(code ?? 0));
 });
 
 // src/index.ts
-var require2 = createRequire(import.meta.url);
-var pkg = require2("../package.json");
-var program = new Command12;
+var require3 = createRequire2(import.meta.url);
+var pkg = require3("../package.json");
+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();