@kaban-board/cli 0.3.0 → 0.3.2

package/dist/index.js

@@ -3,7 +3,7 @@
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
-import { Command as Command15 } from "commander";
+import { Command as Command23 } from "commander";
 
 // src/commands/add.ts
 import { KabanError } from "@kaban-board/core";
@@ -21,11 +21,11 @@ async function getContext() {
     console.error("Error: No board found. Run 'kaban init' first");
     process.exit(1);
   }
-  const db = await createDb(dbPath);
+  const db2 = await createDb(dbPath);
   const config = JSON.parse(readFileSync(configPath, "utf-8"));
-  const boardService = new BoardService(db);
-  const taskService = new TaskService(db, boardService);
-  return { db, config, boardService, taskService };
+  const boardService = new BoardService(db2);
+  const taskService = new TaskService(db2, boardService);
+  return { db: db2, config, boardService, taskService };
 }
 function getKabanPaths() {
   const kabanDir = join(process.cwd(), ".kaban");
@@ -275,10 +275,200 @@ var resetCommand = new Command2("reset").description("Delete ALL tasks (destruct
   }
 });
 
-// src/commands/assign.ts
-import { KabanError as KabanError3 } from "@kaban-board/core";
+// src/commands/audit.ts
+import { AuditService, 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) => {
+function parseRelativeDate(input) {
+  const match = input.match(/^(\d+)([dwmh])$/);
+  if (!match) {
+    return new Date(input);
+  }
+  const [, numStr, unit] = match;
+  const num = parseInt(numStr, 10);
+  const now = new Date;
+  switch (unit) {
+    case "h":
+      return new Date(now.getTime() - num * 60 * 60 * 1000);
+    case "d":
+      return new Date(now.getTime() - num * 24 * 60 * 60 * 1000);
+    case "w":
+      return new Date(now.getTime() - num * 7 * 24 * 60 * 60 * 1000);
+    case "m":
+      return new Date(now.getTime() - num * 30 * 24 * 60 * 60 * 1000);
+    default:
+      return new Date(input);
+  }
+}
+function formatEntry(entry) {
+  const time = entry.timestamp.toISOString().slice(0, 19).replace("T", " ");
+  const actor = entry.actor ? `@${entry.actor}` : "";
+  const field = entry.fieldName ? `.${entry.fieldName}` : "";
+  let change = "";
+  if (entry.eventType === "UPDATE") {
+    change = `${entry.oldValue ?? "null"} -> ${entry.newValue ?? "null"}`;
+  } else if (entry.eventType === "CREATE") {
+    change = entry.newValue ?? "";
+  } else {
+    change = entry.oldValue ?? "";
+  }
+  return `  ${time} ${entry.eventType.padEnd(6)} ${entry.objectType}${field}
+    ${entry.objectId.slice(0, 8)} ${actor} ${change}`;
+}
+var auditCommand = new Command3("audit").description("View audit log history");
+auditCommand.command("list").description("List recent audit entries").option("-l, --limit <n>", "Max entries", "50").option("-a, --actor <name>", "Filter by actor").option("-t, --type <type>", "Filter by object type (task|column|board)").option("-e, --event <type>", "Filter by event type (CREATE|UPDATE|DELETE)").option("--since <date>", "Filter from date (ISO 8601 or relative: 1d, 1w, 30d)").option("--until <date>", "Filter to date (ISO 8601 or relative: 1d, 1w, 30d)").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { db: db2 } = await getContext();
+    const auditService = new AuditService(db2);
+    const result = await auditService.getHistory({
+      limit: parseInt(options.limit, 10),
+      actor: options.actor,
+      objectType: options.type,
+      eventType: options.event,
+      since: options.since ? parseRelativeDate(options.since) : undefined,
+      until: options.until ? parseRelativeDate(options.until) : undefined
+    });
+    if (json) {
+      outputSuccess(result);
+      return;
+    }
+    console.log(`
+  Audit Log (${result.entries.length} of ${result.total})
+`);
+    for (const entry of result.entries) {
+      console.log(formatEntry(entry));
+    }
+    if (result.hasMore)
+      console.log(`
+  ... more entries available`);
+    console.log();
+  } catch (error2) {
+    if (error2 instanceof KabanError3) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+auditCommand.command("task <id>").description("View history for a specific task").option("-l, --limit <n>", "Max entries", "50").option("-j, --json", "Output as JSON").action(async (id, options) => {
+  const json = options.json;
+  try {
+    const { db: db2, taskService } = await getContext();
+    const task = await taskService.resolveTask(id);
+    if (!task) {
+      if (json)
+        outputError(2, `Task '${id}' not found`);
+      console.error(`Error: Task '${id}' not found`);
+      process.exit(2);
+    }
+    const auditService = new AuditService(db2);
+    const entries = await auditService.getTaskHistory(task.id, parseInt(options.limit, 10));
+    if (json) {
+      outputSuccess({ task: { id: task.id, title: task.title }, entries });
+      return;
+    }
+    console.log(`
+  History for [${task.id.slice(0, 8)}] "${task.title}"
+`);
+    for (const entry of entries) {
+      const time = entry.timestamp.toISOString().slice(0, 19).replace("T", " ");
+      const actor = entry.actor ? `@${entry.actor}` : "";
+      if (entry.eventType === "CREATE") {
+        console.log(`  ${time} CREATED ${actor}`);
+      } else if (entry.eventType === "DELETE") {
+        console.log(`  ${time} DELETED ${actor}`);
+      } else {
+        const field = entry.fieldName ?? "?";
+        console.log(`  ${time} ${field}: ${entry.oldValue ?? "null"} -> ${entry.newValue ?? "null"} ${actor}`);
+      }
+    }
+    console.log();
+  } catch (error2) {
+    if (error2 instanceof KabanError3) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+auditCommand.command("stats").description("Show audit statistics").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { db: db2 } = await getContext();
+    const auditService = new AuditService(db2);
+    const stats = await auditService.getStats();
+    if (json) {
+      outputSuccess(stats);
+      return;
+    }
+    console.log(`
+  Audit Statistics
+`);
+    console.log(`  Total entries: ${stats.totalEntries}`);
+    console.log(`
+  By Event Type:`);
+    for (const [type, count] of Object.entries(stats.byEventType)) {
+      console.log(`    ${type}: ${count}`);
+    }
+    console.log(`
+  By Object Type:`);
+    for (const [type, count] of Object.entries(stats.byObjectType)) {
+      console.log(`    ${type}: ${count}`);
+    }
+    if (stats.recentActors.length > 0) {
+      console.log(`
+  Recent Actors:`);
+      for (const actor of stats.recentActors) {
+        console.log(`    ${actor}`);
+      }
+    }
+    console.log();
+  } catch (error2) {
+    if (error2 instanceof KabanError3) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+auditCommand.command("actor <name>").description("View changes by a specific actor").option("-l, --limit <n>", "Max entries", "50").option("-j, --json", "Output as JSON").action(async (name, options) => {
+  const json = options.json;
+  try {
+    const { db: db2 } = await getContext();
+    const auditService = new AuditService(db2);
+    const entries = await auditService.getChangesByActor(name, parseInt(options.limit, 10));
+    if (json) {
+      outputSuccess({ actor: name, entries, count: entries.length });
+      return;
+    }
+    console.log(`
+  Changes by @${name} (${entries.length} entries)
+`);
+    for (const entry of entries) {
+      console.log(formatEntry(entry));
+    }
+    console.log();
+  } 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/assign.ts
+import { KabanError as KabanError4 } from "@kaban-board/core";
+import { Command as Command4 } from "commander";
+var assignCommand = new Command4("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();
@@ -288,8 +478,7 @@ var assignCommand = new Command3("assign").description("Assign a task to an agen
       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));
+    const task = await taskService.resolveTask(id);
     if (!task) {
       if (json)
         outputError(2, `Task '${id}' not found`);
@@ -320,7 +509,50 @@ var assignCommand = new Command3("assign").description("Assign a task to an agen
     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 (error2 instanceof KabanError4) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/delete.ts
+import { KabanError as KabanError5 } from "@kaban-board/core";
+import { Command as Command5 } from "commander";
+import { createInterface } from "readline";
+var deleteCommand = new Command5("delete").description("Delete a task").argument("<id>", "Task ID").option("-f, --force", "Skip confirmation").option("-j, --json", "Output as JSON").action(async (id, options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    const task = await taskService.resolveTask(id);
+    if (!task) {
+      if (json)
+        outputError(2, `Task '${id}' not found`);
+      console.error(`Error: Task '${id}' not found`);
+      process.exit(2);
+    }
+    if (!options.force && !json) {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      const answer = await new Promise((resolve) => {
+        rl.question(`Delete "${task.title}"? [y/N] `, resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log("Cancelled");
+        return;
+      }
+    }
+    await taskService.deleteTask(task.id);
+    if (json) {
+      outputSuccess({ deleted: true, id: task.id });
+      return;
+    }
+    console.log(`Deleted [${task.id.slice(0, 8)}] "${task.title}"`);
+  } catch (error2) {
+    if (error2 instanceof KabanError5) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -331,14 +563,13 @@ var assignCommand = new Command3("assign").description("Assign a task to an agen
 });
 
 // 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) => {
+import { KabanError as KabanError6 } from "@kaban-board/core";
+import { Command as Command6 } from "commander";
+var doneCommand = new Command6("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();
-    const tasks = await taskService.listTasks();
-    const task = tasks.find((t) => t.id.startsWith(id));
+    const task = await taskService.resolveTask(id);
     if (!task) {
       if (json)
         outputError(2, `Task '${id}' not found`);
@@ -359,7 +590,145 @@ var doneCommand = new Command4("done").description("Mark a task as done").argume
     }
     console.log(`Completed [${moved.id.slice(0, 8)}] "${moved.title}"`);
   } catch (error2) {
-    if (error2 instanceof KabanError4) {
+    if (error2 instanceof KabanError6) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/edit.ts
+import { KabanError as KabanError7 } from "@kaban-board/core";
+import { Command as Command7 } from "commander";
+var editCommand = new Command7("edit").description("Edit a task").argument("<id>", "Task ID").option("-t, --title <title>", "New title").option("-d, --description <desc>", "New description").option("--clear-description", "Clear description").option("-l, --labels <labels>", "Labels (comma-separated)").option("--due <date>", "Due date (natural language)").option("--clear-due", "Clear due date").option("-j, --json", "Output as JSON").action(async (id, options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    const task = await taskService.resolveTask(id);
+    if (!task) {
+      if (json)
+        outputError(2, `Task '${id}' not found`);
+      console.error(`Error: Task '${id}' not found`);
+      process.exit(2);
+    }
+    const updates = {};
+    if (options.title)
+      updates.title = options.title;
+    if (options.description)
+      updates.description = options.description;
+    if (options.clearDescription)
+      updates.description = null;
+    if (options.labels)
+      updates.labels = options.labels.split(",").map((l) => l.trim());
+    if (options.due)
+      updates.dueDate = options.due;
+    if (options.clearDue)
+      updates.dueDate = null;
+    if (Object.keys(updates).length === 0) {
+      if (json)
+        outputError(4, "No updates specified");
+      console.error("Error: No updates specified. Use --title, --description, etc.");
+      process.exit(4);
+    }
+    const updated = await taskService.updateTask(task.id, updates);
+    if (json) {
+      outputSuccess(updated);
+      return;
+    }
+    console.log(`Updated [${updated.id.slice(0, 8)}] "${updated.title}"`);
+  } 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/export.ts
+import { writeFileSync } from "fs";
+import { KabanError as KabanError8, MarkdownService } from "@kaban-board/core";
+import { Command as Command8 } from "commander";
+var exportCommand = new Command8("export").description("Export board to markdown format").option("-o, --output <file>", "Output file path (default: stdout)").option("-a, --archived", "Include archived tasks").option("--no-metadata", "Exclude task metadata (IDs)").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = await getContext();
+    const markdownService = new MarkdownService;
+    const board = await boardService.getBoard();
+    const columns = await boardService.getColumns();
+    const allTasks = await taskService.listTasks({ includeArchived: options.archived });
+    const tasksByColumn = new Map;
+    for (const task of allTasks) {
+      const existing = tasksByColumn.get(task.columnId) ?? [];
+      existing.push(task);
+      tasksByColumn.set(task.columnId, existing);
+    }
+    const markdown = markdownService.exportBoard({ name: board?.name ?? "Kaban Board" }, columns, tasksByColumn, { includeArchived: options.archived, includeMetadata: options.metadata !== false });
+    if (options.output) {
+      writeFileSync(options.output, markdown);
+      if (json) {
+        outputSuccess({ file: options.output, tasks: allTasks.length });
+      } else {
+        console.log(`Exported ${allTasks.length} tasks to ${options.output}`);
+      }
+    } else {
+      if (json) {
+        outputSuccess({ markdown, tasks: allTasks.length });
+      } else {
+        console.log(markdown);
+      }
+    }
+  } catch (error2) {
+    if (error2 instanceof KabanError8) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/get.ts
+import { KabanError as KabanError9 } from "@kaban-board/core";
+import { Command as Command9 } from "commander";
+var getCommand = new Command9("get").description("View a task by ID").argument("<id>", "Task ID (ULID, partial, or #number)").option("-j, --json", "Output as JSON").action(async (id, options) => {
+  const json = options.json;
+  try {
+    const { taskService } = await getContext();
+    const task = await taskService.resolveTask(id);
+    if (!task) {
+      if (json)
+        outputError(2, `Task '${id}' not found`);
+      console.error(`Error: Task '${id}' not found`);
+      process.exit(2);
+    }
+    if (json) {
+      outputSuccess(task);
+      return;
+    }
+    console.log(`
+  [${task.id.slice(0, 8)}] ${task.title}`);
+    console.log(`  Column: ${task.columnId}`);
+    if (task.description)
+      console.log(`  Description: ${task.description}`);
+    if (task.assignedTo)
+      console.log(`  Assigned: ${task.assignedTo}`);
+    if (task.labels.length)
+      console.log(`  Labels: ${task.labels.join(", ")}`);
+    if (task.dueDate)
+      console.log(`  Due: ${task.dueDate.toISOString().split("T")[0]}`);
+    if (task.dependsOn.length)
+      console.log(`  Depends on: ${task.dependsOn.length} task(s)`);
+    console.log(`  Created: ${task.createdAt.toISOString()}`);
+    console.log();
+  } catch (error2) {
+    if (error2 instanceof KabanError9) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -377,7 +746,7 @@ 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 Command5 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/hook/settings-manager.ts
 import { existsSync as existsSync2 } from "fs";
@@ -726,7 +1095,7 @@ function formatSize(bytes) {
     return `${bytes} B`;
   return `${Math.round(bytes / 1024)} KB`;
 }
-var installCommand = new Command5("install").description("Install TodoWrite sync hook for Claude Code").option("-y, --yes", "Skip confirmation").action(async (options) => {
+var installCommand = new Command10("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...");
@@ -787,7 +1156,7 @@ var installCommand = new Command5("install").description("Install TodoWrite sync
     process.exit(1);
   }
 });
-var uninstallCommand = new Command5("uninstall").description("Remove TodoWrite sync hook").option("-y, --yes", "Skip confirmation").option("--clean", "Also remove sync logs").action(async (options) => {
+var uninstallCommand = new Command10("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));
@@ -857,7 +1226,7 @@ var uninstallCommand = new Command5("uninstall").description("Remove TodoWrite s
     process.exit(1);
   }
 });
-var statusCommand = new Command5("status").description("Check hook installation status").action(async () => {
+var statusCommand = new Command10("status").description("Check hook installation status").action(async () => {
   p.intro(chalk.bgBlue.white(" kaban hook status "));
   const s = p.spinner();
   s.start("Checking status...");
@@ -923,18 +1292,95 @@ var statusCommand = new Command5("status").description("Check hook installation
     process.exit(1);
   }
 });
-var hookCommand = new Command5("hook").description("Manage TodoWrite sync hook for Claude Code").addCommand(installCommand).addCommand(uninstallCommand).addCommand(statusCommand);
+var hookCommand = new Command10("hook").description("Manage TodoWrite sync hook for Claude Code").addCommand(installCommand).addCommand(uninstallCommand).addCommand(statusCommand);
+
+// src/commands/import.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { KabanError as KabanError10, MarkdownService as MarkdownService2 } from "@kaban-board/core";
+import { Command as Command11 } from "commander";
+var importCommand = new Command11("import").description("Import tasks from markdown file").argument("<file>", "Markdown file to import").option("-d, --dry-run", "Preview import without creating tasks").option("-j, --json", "Output as JSON").action(async (file, options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = await getContext();
+    const markdownService = new MarkdownService2;
+    const markdown = readFileSync2(file, "utf-8");
+    const parseResult = markdownService.parseMarkdown(markdown);
+    if (parseResult.errors.length > 0) {
+      if (json) {
+        outputError(1, `Parse errors: ${parseResult.errors.join(", ")}`);
+      } else {
+        console.error("Parse errors:");
+        for (const error2 of parseResult.errors) {
+          console.error(`  - ${error2}`);
+        }
+      }
+      process.exit(1);
+    }
+    const columns = await boardService.getColumns();
+    const columnMap = new Map(columns.map((c) => [c.name.toLowerCase(), c.id]));
+    if (options.dryRun) {
+      let taskCount = 0;
+      for (const column of parseResult.columns) {
+        taskCount += column.tasks.length;
+      }
+      if (json) {
+        outputSuccess({
+          dryRun: true,
+          wouldCreate: taskCount,
+          columns: parseResult.columns.map((c) => ({
+            name: c.name,
+            tasks: c.tasks.length
+          }))
+        });
+      } else {
+        console.log(`Dry run: would import ${taskCount} tasks`);
+        for (const column of parseResult.columns) {
+          console.log(`  ${column.name}: ${column.tasks.length} tasks`);
+        }
+      }
+      return;
+    }
+    const createdTasks = [];
+    for (const column of parseResult.columns) {
+      const columnId = columnMap.get(column.name.toLowerCase()) ?? "todo";
+      for (const task of column.tasks) {
+        const created = await taskService.addTask({
+          title: task.title,
+          description: task.description ?? undefined,
+          columnId,
+          labels: task.labels,
+          assignedTo: task.assignedTo ?? undefined,
+          dueDate: task.dueDate?.toISOString()
+        });
+        createdTasks.push(created);
+      }
+    }
+    if (json) {
+      outputSuccess({ imported: createdTasks.length, tasks: createdTasks });
+    } else {
+      console.log(`Imported ${createdTasks.length} tasks`);
+    }
+  } catch (error2) {
+    if (error2 instanceof KabanError10) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
 
 // src/commands/init.ts
-import { existsSync as existsSync4, mkdirSync, writeFileSync } from "fs";
+import { existsSync as existsSync4, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
 import {
   BoardService as BoardService2,
   createDb as createDb2,
   DEFAULT_CONFIG as DEFAULT_CONFIG2,
   initializeSchema
 } from "@kaban-board/core";
-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) => {
+import { Command as Command12 } from "commander";
+var initCommand = new Command12("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");
@@ -945,10 +1391,10 @@ var initCommand = new Command6("init").description("Initialize a new Kaban board
     ...DEFAULT_CONFIG2,
     board: { name: options.name }
   };
-  writeFileSync(configPath, JSON.stringify(config, null, 2));
-  const db = await createDb2(dbPath);
-  await initializeSchema(db);
-  const boardService = new BoardService2(db);
+  writeFileSync2(configPath, JSON.stringify(config, null, 2));
+  const db2 = await createDb2(dbPath);
+  await initializeSchema(db2);
+  const boardService = new BoardService2(db2);
   await boardService.initializeBoard(config);
   console.log(`Initialized Kaban board: ${options.name}`);
   console.log(`  Database: ${dbPath}`);
@@ -956,8 +1402,8 @@ var initCommand = new Command6("init").description("Initialize a new Kaban board
 });
 
 // src/commands/list.ts
-import { KabanError as KabanError5 } from "@kaban-board/core";
-import { Command as Command7 } from "commander";
+import { KabanError as KabanError11 } from "@kaban-board/core";
+import { Command as Command13 } from "commander";
 function sortTasks(tasks, sortBy, reverse) {
   const sorted = [...tasks].sort((a, b) => {
     switch (sortBy) {
@@ -973,7 +1419,7 @@ function sortTasks(tasks, sortBy, reverse) {
   });
   return reverse ? sorted.reverse() : sorted;
 }
-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) => {
+var listCommand = new Command13("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();
@@ -1014,7 +1460,7 @@ var listCommand = new Command7("list").description("List tasks").option("-c, --c
       }
     }
   } catch (error2) {
-    if (error2 instanceof KabanError5) {
+    if (error2 instanceof KabanError11) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -1025,14 +1471,22 @@ var listCommand = new Command7("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 "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { join as join4 } from "path";
 import {
+  AuditService as AuditService2,
   BoardService as BoardService3,
   createDb as createDb3,
   DEFAULT_CONFIG as DEFAULT_CONFIG3,
   initializeSchema as initializeSchema2,
-  TaskService as TaskService2
+  TaskService as TaskService2,
+  LinkService,
+  MarkdownService as MarkdownService3,
+  ScoringService,
+  fifoScorer,
+  priorityScorer,
+  dueDateScorer,
+  createBlockingScorer
 } from "@kaban-board/core";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -1042,7 +1496,7 @@ import {
   ListToolsRequestSchema,
   ReadResourceRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
-import { Command as Command8 } from "commander";
+import { Command as Command14 } from "commander";
 var mcpHelpers = {
   getParam(args, primary, alias) {
     if (!args)
@@ -1076,11 +1530,21 @@ async function createContext(basePath) {
   if (!existsSync5(dbPath)) {
     throw new Error("No board found. Run 'kaban init' first");
   }
-  const db = await createDb3(dbPath);
-  const config = JSON.parse(readFileSync2(configPath, "utf-8"));
-  const boardService = new BoardService3(db);
-  const taskService = new TaskService2(db, boardService);
-  return { db, config, boardService, taskService };
+  const db2 = await createDb3(dbPath);
+  const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+  const boardService = new BoardService3(db2);
+  const taskService = new TaskService2(db2, boardService);
+  const linkService = new LinkService(db2);
+  const markdownService = new MarkdownService3;
+  const scoringService = new ScoringService;
+  scoringService.addScorer(priorityScorer);
+  scoringService.addScorer(dueDateScorer);
+  scoringService.addScorer(createBlockingScorer(async (taskId) => {
+    const blocking = await linkService.getBlocking(taskId);
+    return blocking.length;
+  }));
+  scoringService.addScorer(fifoScorer);
+  return { db: db2, config, boardService, taskService, linkService, markdownService, scoringService };
 }
 async function startMcpServer(workingDirectory) {
   const server = new Server({ name: "kaban-mcp", version: "0.1.0" }, { capabilities: { tools: {}, resources: {} } });
@@ -1184,6 +1648,18 @@ async function startMcpServer(workingDirectory) {
           }
         }
       },
+      {
+        name: "kaban_assign_task",
+        description: "Assign or unassign a task to/from an agent (convenience wrapper for kaban_update_task)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            id: { type: "string", description: "Task ID (ULID)" },
+            taskId: { type: "string", description: "Task ID - alias for 'id'" },
+            assignee: { type: ["string", "null"], description: "Agent name (null to unassign)" }
+          }
+        }
+      },
       {
         name: "kaban_delete_task",
         description: "Delete a task",
@@ -1334,6 +1810,140 @@ async function startMcpServer(workingDirectory) {
           },
           required: ["title"]
         }
+      },
+      {
+        name: "kaban_add_link",
+        description: "Create a link between two tasks",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sourceId: { type: "string", description: "Source task ID" },
+            targetId: { type: "string", description: "Target task ID" },
+            type: {
+              type: "string",
+              enum: ["relates_to", "blocks", "duplicates", "parent_of"],
+              description: "Link type (default: relates_to)"
+            },
+            metadata: { type: "object", description: "Optional metadata for the link" }
+          },
+          required: ["sourceId", "targetId"]
+        }
+      },
+      {
+        name: "kaban_remove_link",
+        description: "Remove a link between two tasks",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sourceId: { type: "string", description: "Source task ID" },
+            targetId: { type: "string", description: "Target task ID" },
+            type: {
+              type: "string",
+              enum: ["relates_to", "blocks", "duplicates", "parent_of"],
+              description: "Link type to remove (removes all types if not specified)"
+            }
+          },
+          required: ["sourceId", "targetId"]
+        }
+      },
+      {
+        name: "kaban_get_links",
+        description: "Get links for a task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Task ID" },
+            id: { type: "string", description: "Task ID - alias for taskId" },
+            direction: {
+              type: "string",
+              enum: ["outgoing", "incoming", "both"],
+              description: "Link direction to return (default: both)"
+            },
+            type: {
+              type: "string",
+              enum: ["relates_to", "blocks", "duplicates", "parent_of"],
+              description: "Filter by link type"
+            }
+          }
+        }
+      },
+      {
+        name: "kaban_get_next_task",
+        description: "Get the highest-priority task to work on next (considering dependencies, due dates, etc.)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            columnId: { type: "string", description: "Filter by column (default: todo)" }
+          }
+        }
+      },
+      {
+        name: "kaban_score_tasks",
+        description: "Get all tasks with their priority scores",
+        inputSchema: {
+          type: "object",
+          properties: {
+            columnId: { type: "string", description: "Filter by column" },
+            limit: { type: "number", description: "Max tasks to return (default: 10)" }
+          }
+        }
+      },
+      {
+        name: "kaban_export_markdown",
+        description: "Export the board to markdown format",
+        inputSchema: {
+          type: "object",
+          properties: {
+            includeArchived: { type: "boolean", description: "Include archived tasks (default: false)" },
+            includeMetadata: { type: "boolean", description: "Include task metadata (default: true)" }
+          }
+        }
+      },
+      {
+        name: "kaban_import_markdown",
+        description: "Import tasks from markdown format (creates new tasks, does not modify existing)",
+        inputSchema: {
+          type: "object",
+          properties: {
+            markdown: { type: "string", description: "Markdown content to import" },
+            dryRun: { type: "boolean", description: "Preview import without creating tasks" }
+          },
+          required: ["markdown"]
+        }
+      },
+      {
+        name: "kaban_get_audit_history",
+        description: "Get audit log history with optional filters",
+        inputSchema: {
+          type: "object",
+          properties: {
+            objectType: {
+              type: "string",
+              enum: ["task", "column", "board"],
+              description: "Filter by object type"
+            },
+            objectId: { type: "string", description: "Filter by object ID" },
+            eventType: {
+              type: "string",
+              enum: ["CREATE", "UPDATE", "DELETE"],
+              description: "Filter by event type"
+            },
+            actor: { type: "string", description: "Filter by actor name" },
+            limit: { type: "number", description: "Max entries (default: 50, max: 1000)" }
+          }
+        }
+      },
+      {
+        name: "kaban_get_task_history",
+        description: "Get change history for a specific task",
+        inputSchema: {
+          type: "object",
+          properties: {
+            taskId: { type: "string", description: "Task ID (ULID or partial)" },
+            id: { type: "string", description: "Task ID - alias for taskId" },
+            limit: { type: "number", description: "Max entries (default: 50)" }
+          }
+        }
       }
     ]
   }));
@@ -1353,10 +1963,10 @@ async function startMcpServer(workingDirectory) {
           ...DEFAULT_CONFIG3,
           board: { name: boardName }
         };
-        writeFileSync2(configPath, JSON.stringify(config, null, 2));
-        const db = await createDb3(dbPath);
-        await initializeSchema2(db);
-        const boardService2 = new BoardService3(db);
+        writeFileSync3(configPath, JSON.stringify(config, null, 2));
+        const db2 = await createDb3(dbPath);
+        await initializeSchema2(db2);
+        const boardService2 = new BoardService3(db2);
         await boardService2.initializeBoard(config);
         return jsonResponse({
           success: true,
@@ -1364,7 +1974,7 @@ async function startMcpServer(workingDirectory) {
           paths: { database: dbPath, config: configPath }
         });
       }
-      const { taskService, boardService } = await createContext(workingDirectory);
+      const { taskService, boardService, linkService, markdownService, scoringService } = await createContext(workingDirectory);
       const taskArgs = args;
       const taskId = getParam(taskArgs, "id", "taskId");
       switch (name) {
@@ -1411,6 +2021,14 @@ async function startMcpServer(workingDirectory) {
           const task = await taskService.updateTask(taskId, updates, expectedVersion);
           return jsonResponse(task);
         }
+        case "kaban_assign_task": {
+          const id = getParam(taskArgs, "id", "taskId");
+          if (!id)
+            return errorResponse("Task ID required (use 'id' or 'taskId')");
+          const { assignee } = args ?? {};
+          const task = await taskService.updateTask(id, { assignedTo: assignee ?? null });
+          return jsonResponse(task);
+        }
         case "kaban_delete_task": {
           if (!taskId)
             return errorResponse("Task ID required (use 'id' or 'taskId')");
@@ -1595,6 +2213,126 @@ async function startMcpServer(workingDirectory) {
           const result = await taskService.addTaskChecked(taskInput, { force });
           return jsonResponse(result);
         }
+        case "kaban_add_link": {
+          const { sourceId, targetId, type } = args ?? {};
+          if (!sourceId)
+            return errorResponse("sourceId required");
+          if (!targetId)
+            return errorResponse("targetId required");
+          const linkType = type ?? "related";
+          const link = await linkService.addLink(sourceId, targetId, linkType);
+          return jsonResponse(link);
+        }
+        case "kaban_remove_link": {
+          const { sourceId, targetId, type } = args ?? {};
+          if (!sourceId)
+            return errorResponse("sourceId required");
+          if (!targetId)
+            return errorResponse("targetId required");
+          if (!type)
+            return errorResponse("type required");
+          await linkService.removeLink(sourceId, targetId, type);
+          return jsonResponse({ success: true });
+        }
+        case "kaban_get_links": {
+          const id = getParam(taskArgs, "taskId", "id");
+          if (!id)
+            return errorResponse("Task ID required");
+          const { direction } = args ?? {};
+          let links;
+          if (direction === "outgoing") {
+            links = await linkService.getLinksFrom(id);
+          } else if (direction === "incoming") {
+            links = await linkService.getLinksTo(id);
+          } else {
+            links = await linkService.getAllLinks(id);
+          }
+          return jsonResponse(links);
+        }
+        case "kaban_get_next_task": {
+          const { columnId } = args ?? {};
+          const allTasks = await taskService.listTasks({ columnId: columnId ?? "todo" });
+          const unblockedTasks = allTasks.filter((t) => !t.blockedReason && t.dependsOn.length === 0);
+          if (unblockedTasks.length === 0) {
+            return jsonResponse({ message: "No actionable tasks found", task: null });
+          }
+          const ranked = await scoringService.rankTasks(unblockedTasks);
+          return jsonResponse(ranked[0]);
+        }
+        case "kaban_score_tasks": {
+          const { columnId, limit } = args ?? {};
+          const allTasks = await taskService.listTasks(columnId ? { columnId } : undefined);
+          const ranked = await scoringService.rankTasks(allTasks);
+          return jsonResponse(ranked.slice(0, limit ?? 10));
+        }
+        case "kaban_export_markdown": {
+          const { includeArchived, includeMetadata } = args ?? {};
+          const board = await boardService.getBoard();
+          const columns = await boardService.getColumns();
+          const allTasks = await taskService.listTasks({ includeArchived });
+          const tasksByColumn = new Map;
+          for (const task of allTasks) {
+            const existing = tasksByColumn.get(task.columnId) ?? [];
+            existing.push(task);
+            tasksByColumn.set(task.columnId, existing);
+          }
+          const markdown = markdownService.exportBoard({ name: board?.name ?? "Kaban Board" }, columns, tasksByColumn, { includeArchived, includeMetadata: includeMetadata ?? true });
+          return jsonResponse({ markdown });
+        }
+        case "kaban_import_markdown": {
+          const { markdown, dryRun } = args ?? {};
+          if (!markdown)
+            return errorResponse("markdown content required");
+          const parseResult = markdownService.parseMarkdown(markdown);
+          if (parseResult.errors.length > 0) {
+            return jsonResponse({ success: false, errors: parseResult.errors, parsed: parseResult });
+          }
+          if (dryRun) {
+            return jsonResponse({ dryRun: true, parsed: parseResult });
+          }
+          const createdTasks = [];
+          for (const column of parseResult.columns) {
+            for (const task of column.tasks) {
+              const created = await taskService.addTask({
+                title: task.title,
+                description: task.description ?? undefined,
+                columnId: column.name.toLowerCase().replace(/\s+/g, "_"),
+                labels: task.labels,
+                assignedTo: task.assignedTo ?? undefined,
+                dueDate: task.dueDate?.toISOString()
+              });
+              createdTasks.push(created);
+            }
+          }
+          return jsonResponse({ success: true, tasksCreated: createdTasks.length, tasks: createdTasks });
+        }
+        case "kaban_get_audit_history": {
+          const { objectType, objectId, eventType, actor, limit } = args ?? {};
+          const auditService = new AuditService2(db);
+          const result = await auditService.getHistory({
+            objectType,
+            objectId,
+            eventType,
+            actor,
+            limit: limit ?? 50
+          });
+          return jsonResponse(result);
+        }
+        case "kaban_get_task_history": {
+          const taskIdArg = getParam(args, "taskId", "id");
+          if (!taskIdArg)
+            return errorResponse("Task ID required (use 'taskId' or 'id')");
+          const task = await taskService.resolveTask(taskIdArg);
+          if (!task)
+            return errorResponse(`Task '${taskIdArg}' not found`);
+          const { limit } = args ?? {};
+          const auditService = new AuditService2(db);
+          const entries = await auditService.getTaskHistory(task.id, limit ?? 50);
+          return jsonResponse({
+            task: { id: task.id, title: task.title },
+            entries
+          });
+        }
         default:
           return errorResponse(`Unknown tool: ${name}`);
       }
@@ -1708,20 +2446,19 @@ async function startMcpServer(workingDirectory) {
   await server.connect(transport);
   console.error("Kaban MCP server running on stdio");
 }
-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) => {
+var mcpCommand = new Command14("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 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) => {
+import { KabanError as KabanError12 } from "@kaban-board/core";
+import { Command as Command15 } from "commander";
+var moveCommand = new Command15("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();
-    const tasks = await taskService.listTasks();
-    const task = tasks.find((t) => t.id.startsWith(id));
+    const task = await taskService.resolveTask(id);
     if (!task) {
       if (json)
         outputError(2, `Task '${id}' not found`);
@@ -1767,7 +2504,64 @@ var moveCommand = new Command9("move").description("Move a task to a different c
     }
     console.log(msg);
   } catch (error2) {
-    if (error2 instanceof KabanError6) {
+    if (error2 instanceof KabanError12) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
+// src/commands/next.ts
+import {
+  KabanError as KabanError13,
+  ScoringService as ScoringService2,
+  fifoScorer as fifoScorer2,
+  priorityScorer as priorityScorer2,
+  dueDateScorer as dueDateScorer2,
+  createBlockingScorer as createBlockingScorer2,
+  LinkService as LinkService2
+} from "@kaban-board/core";
+import { Command as Command16 } from "commander";
+var nextCommand = new Command16("next").description("Get the next highest-priority task").option("-c, --column <column>", "Column to pick from", "todo").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService, db: db2 } = await getContext();
+    const linkService = new LinkService2(db2);
+    const scoringService = new ScoringService2;
+    scoringService.addScorer(priorityScorer2);
+    scoringService.addScorer(dueDateScorer2);
+    scoringService.addScorer(createBlockingScorer2(async (taskId) => {
+      const blocking = await linkService.getBlocking(taskId);
+      return blocking.length;
+    }));
+    scoringService.addScorer(fifoScorer2);
+    const tasks = await taskService.listTasks({ columnId: options.column });
+    const unblocked = tasks.filter((t) => !t.blockedReason && t.dependsOn.length === 0);
+    if (unblocked.length === 0) {
+      if (json) {
+        outputSuccess({ task: null, message: "No actionable tasks" });
+        return;
+      }
+      console.log("No actionable tasks in", options.column);
+      return;
+    }
+    const ranked = await scoringService.rankTasks(unblocked);
+    const next = ranked[0];
+    if (json) {
+      outputSuccess(next);
+      return;
+    }
+    console.log(`
+  Next: [${next.task.id.slice(0, 8)}] "${next.task.title}"`);
+    console.log(`  Score: ${next.score} (${Object.entries(next.breakdown).map(([k, v]) => `${k}:${v}`).join(", ")})`);
+    if (next.task.dueDate)
+      console.log(`  Due: ${next.task.dueDate.toISOString().split("T")[0]}`);
+    console.log();
+  } catch (error2) {
+    if (error2 instanceof KabanError13) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -1779,9 +2573,9 @@ var moveCommand = new Command9("move").description("Move a task to a different c
 
 // src/commands/schema.ts
 import { jsonSchemas } from "@kaban-board/core";
-import { Command as Command10 } from "commander";
+import { Command as Command17 } from "commander";
 var availableSchemas = Object.keys(jsonSchemas);
-var schemaCommand = new Command10("schema").description("Output JSON schemas for AI agents").argument("[name]", "Schema name (omit to list available)").action((name) => {
+var schemaCommand = new Command17("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) {
@@ -1800,10 +2594,65 @@ Usage: kaban schema <name>`);
   console.log(JSON.stringify(schema, null, 2));
 });
 
+// src/commands/stats.ts
+import { KabanError as KabanError14 } from "@kaban-board/core";
+import { Command as Command18 } from "commander";
+var statsCommand = new Command18("stats").description("Show board and archive statistics").option("-j, --json", "Output as JSON").action(async (options) => {
+  const json = options.json;
+  try {
+    const { taskService, boardService } = await getContext();
+    const tasks = await taskService.listTasks();
+    const columns = await boardService.getColumns();
+    const terminalColumns = columns.filter((c) => c.isTerminal);
+    const archivedResult = await taskService.searchArchive("", { limit: 1 });
+    const completedNotArchived = tasks.filter((t) => terminalColumns.some((c) => c.id === t.columnId)).length;
+    const blocked = tasks.filter((t) => t.blockedReason).length;
+    const withDeps = tasks.filter((t) => t.dependsOn.length > 0).length;
+    const stats = {
+      activeTasks: tasks.length,
+      archivedTasks: archivedResult.total,
+      completedNotArchived,
+      blockedTasks: blocked,
+      tasksWithDependencies: withDeps,
+      byColumn: columns.map((c) => ({
+        id: c.id,
+        name: c.name,
+        count: tasks.filter((t) => t.columnId === c.id).length
+      }))
+    };
+    if (json) {
+      outputSuccess(stats);
+      return;
+    }
+    console.log(`
+  Board Statistics
+`);
+    console.log(`  Active tasks:      ${stats.activeTasks}`);
+    console.log(`  Archived tasks:    ${stats.archivedTasks}`);
+    console.log(`  Completed (live):  ${stats.completedNotArchived}`);
+    console.log(`  Blocked:           ${stats.blockedTasks}`);
+    console.log(`  With dependencies: ${stats.tasksWithDependencies}`);
+    console.log(`
+  By Column:`);
+    for (const col of stats.byColumn) {
+      console.log(`    ${col.name}: ${col.count}`);
+    }
+    console.log();
+  } catch (error2) {
+    if (error2 instanceof KabanError14) {
+      if (json)
+        outputError(error2.code, error2.message);
+      console.error(`Error: ${error2.message}`);
+      process.exit(error2.code);
+    }
+    throw error2;
+  }
+});
+
 // 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) => {
+import { KabanError as KabanError15 } from "@kaban-board/core";
+import { Command as Command19 } from "commander";
+var searchCommand = new Command19("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();
@@ -1832,7 +2681,7 @@ var searchCommand = new Command11("search").description("Search tasks").argument
       console.log(`  Column: ${task.columnId} | By: ${task.createdBy}`);
     }
   } catch (error2) {
-    if (error2 instanceof KabanError7) {
+    if (error2 instanceof KabanError15) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -1843,9 +2692,9 @@ var searchCommand = new Command11("search").description("Search tasks").argument
 });
 
 // src/commands/status.ts
-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) => {
+import { KabanError as KabanError16 } from "@kaban-board/core";
+import { Command as Command20 } from "commander";
+var statusCommand2 = new Command20("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();
@@ -1888,7 +2737,7 @@ var statusCommand2 = new Command12("status").description("Show board status summ
     }
     console.log();
   } catch (error2) {
-    if (error2 instanceof KabanError8) {
+    if (error2 instanceof KabanError16) {
       if (json)
         outputError(error2.code, error2.message);
       console.error(`Error: ${error2.message}`);
@@ -1899,7 +2748,7 @@ var statusCommand2 = new Command12("status").description("Show board status summ
 });
 
 // src/commands/sync.ts
-import { Command as Command13 } from "commander";
+import { Command as Command21 } from "commander";
 
 // src/hook/constants.ts
 var STATUS_PRIORITY = {
@@ -2241,7 +3090,7 @@ class SyncLogger {
 }
 
 // src/commands/sync.ts
-var syncCommand = new Command13("sync").description("Sync TodoWrite input to Kaban board (reads from stdin)").option("--no-log", "Disable sync logging").action(async (options) => {
+var syncCommand = new Command21("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 {
@@ -2293,11 +3142,11 @@ 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";
+import { Command as Command22 } from "commander";
 // package.json
 var package_default = {
   name: "@kaban-board/cli",
-  version: "0.3.0",
+  version: "0.3.2",
   description: "Terminal Kanban for AI Code Agents - CLI and MCP server",
   type: "module",
   bin: {
@@ -2381,7 +3230,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 Command14("tui").description("Start interactive Terminal UI").action(async () => {
+var tuiCommand = new Command22("tui").description("Start interactive Terminal UI").action(async () => {
   const cwd = process.cwd();
   const args = process.argv.slice(3);
   const useBun = hasBun();
@@ -2415,18 +3264,24 @@ var tuiCommand = new Command14("tui").description("Start interactive Terminal UI
 // src/index.ts
 var require3 = createRequire2(import.meta.url);
 var pkg = require3("../package.json");
-var program = new Command15;
+var program = new Command23;
 program.name("kaban").description("Terminal Kanban for AI Code Agents").version(pkg.version);
 program.addCommand(initCommand);
 program.addCommand(addCommand);
+program.addCommand(auditCommand);
 program.addCommand(listCommand);
 program.addCommand(moveCommand);
 program.addCommand(assignCommand);
+program.addCommand(deleteCommand);
 program.addCommand(doneCommand);
+program.addCommand(editCommand);
+program.addCommand(getCommand);
 program.addCommand(statusCommand2);
 program.addCommand(schemaCommand);
 program.addCommand(searchCommand);
 program.addCommand(mcpCommand);
+program.addCommand(nextCommand);
+program.addCommand(statsCommand);
 program.addCommand(tuiCommand);
 program.addCommand(hookCommand);
 program.addCommand(syncCommand);
@@ -2434,4 +3289,6 @@ program.addCommand(archiveCommand);
 program.addCommand(restoreCommand);
 program.addCommand(purgeCommand);
 program.addCommand(resetCommand);
+program.addCommand(exportCommand);
+program.addCommand(importCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaban-board/cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Terminal Kanban for AI Code Agents - CLI and MCP server",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "@kaban-board/core": "0.3.0",
+    "@kaban-board/core": "0.3.1",
     "@modelcontextprotocol/sdk": "^1.25.3",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",