@task-mcp/cli 1.0.8 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@task-mcp/cli",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Zero-dependency CLI for task-mcp with Bun native visualization",
   "type": "module",
   "bin": {

package/src/ansi.ts

@@ -378,6 +378,50 @@ export const icons = {
   info: c.cyan("ℹ"),
 };
 
+/**
+ * Place multiple boxes side by side
+ * Each box is a multi-line string
+ */
+export function sideBySide(boxes: string[], gap: number = 2): string {
+  // Split each box into lines
+  const boxLines = boxes.map(b => b.split("\n"));
+
+  // Find max height
+  const maxHeight = Math.max(...boxLines.map(lines => lines.length));
+
+  // Find width of each box (using first line as reference)
+  const boxWidths = boxLines.map(lines => {
+    return Math.max(...lines.map(l => displayWidth(l)));
+  });
+
+  // Pad each box to max height
+  const paddedBoxLines = boxLines.map((lines, i) => {
+    const width = boxWidths[i];
+    while (lines.length < maxHeight) {
+      lines.push(" ".repeat(width));
+    }
+    // Ensure each line is padded to box width
+    return lines.map(line => {
+      const lineWidth = displayWidth(line);
+      if (lineWidth < width) {
+        return line + " ".repeat(width - lineWidth);
+      }
+      return line;
+    });
+  });
+
+  // Combine lines horizontally
+  const result: string[] = [];
+  const gapStr = " ".repeat(gap);
+
+  for (let i = 0; i < maxHeight; i++) {
+    const lineParts = paddedBoxLines.map(lines => lines[i] ?? "");
+    result.push(lineParts.join(gapStr));
+  }
+
+  return result.join("\n");
+}
+
 /**
  * ASCII art text (simple implementation)
  */

package/src/commands/dashboard.ts

@@ -1,5 +1,6 @@
 /**
- * Dashboard command - displays project overview with multiple widgets
+ * Dashboard command - displays project overview with unified widgets
+ * Inspired by TaskMaster CLI design
  */
 
 import { VERSION } from "../index.js";
@@ -10,10 +11,11 @@ import {
   table,
   icons,
   banner,
-  hline,
   pad,
   truncate,
   stripAnsi,
+  sideBySide,
+  displayWidth,
   type TableColumn,
 } from "../ansi.js";
 import {
@@ -24,28 +26,16 @@ import {
   calculateDependencyMetrics,
   suggestNextTask,
   getTodayTasks,
-  getThisWeekTasks,
   getOverdueTasks,
-  buildTaskTree,
-  countTreeNodes,
-  calculateCriticalPath,
-  calculateAnalysisStats,
   listInboxItems,
   type Task,
   type Project,
-  type TaskTreeNode,
-  type InboxItem,
 } from "../storage.js";
 
 // =============================================================================
 // Formatters
 // =============================================================================
 
-function formatStatus(status: Task["status"]): string {
-  const icon = icons[status] ?? icons.pending;
-  return `${icon} ${status}`;
-}
-
 function formatPriority(priority: Task["priority"]): string {
   const colors: Record<string, (s: string) => string> = {
     critical: c.red,
@@ -56,322 +46,170 @@ function formatPriority(priority: Task["priority"]): string {
   return (colors[priority] ?? c.gray)(priority);
 }
 
-function formatDependencies(deps: Task["dependencies"]): string {
-  if (!deps || deps.length === 0) return c.gray("None");
-  return c.cyan(deps.map(d => d.taskId.slice(0, 4)).join(", "));
-}
-
-function formatDate(dateStr: string): string {
-  const date = new Date(dateStr);
-  const now = new Date();
-  const diffDays = Math.floor((date.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
-
-  if (diffDays < 0) return c.red(`${Math.abs(diffDays)}d overdue`);
-  if (diffDays === 0) return c.yellow("Today");
-  if (diffDays === 1) return c.yellow("Tomorrow");
-  if (diffDays <= 7) return c.blue(`${diffDays}d`);
-  return c.gray(date.toLocaleDateString());
-}
-
 // =============================================================================
-// Widget: Project Overview
+// Widget: Unified Status (combines Overview + Schedule + Dependencies)
 // =============================================================================
 
-function renderProjectOverview(tasks: Task[], project?: Project): string {
+function renderStatusWidget(tasks: Task[], projects: Project[]): string {
   const stats = calculateStats(tasks);
-  const activeTasks = stats.total - stats.cancelled;
-
-  const lines = [
-    c.bold("Progress"),
-    progressBar(stats.completed, activeTasks, { width: 28 }),
-    "",
-    `${c.green("Done")}: ${stats.completed}  ${c.blue("In Progress")}: ${stats.inProgress}`,
-    `${c.yellow("Pending")}: ${stats.pending}  ${c.red("Blocked")}: ${stats.blocked}`,
-    stats.cancelled > 0 ? c.gray(`Cancelled: ${stats.cancelled}`) : "",
-    "",
-    c.bold("Priority"),
-    `${c.red("Critical")}: ${stats.byPriority.critical}  ${c.yellow("High")}: ${stats.byPriority.high}`,
-    `${c.blue("Medium")}: ${stats.byPriority.medium}  ${c.gray("Low")}: ${stats.byPriority.low}`,
-  ].filter(Boolean);
-
-  return box(lines.join("\n"), { title: "Overview", borderColor: "cyan" });
-}
-
-// =============================================================================
-// Widget: Time-based View
-// =============================================================================
-
-function renderTimeWidget(tasks: Task[]): string {
+  const depMetrics = calculateDependencyMetrics(tasks);
   const today = getTodayTasks(tasks);
   const overdue = getOverdueTasks(tasks);
-  const thisWeek = getThisWeekTasks(tasks);
-
-  const lines = [
-    c.bold("Due Dates"),
-    "",
-    `${c.red(icons.warning)} ${c.red("Overdue")}: ${overdue.length}`,
-    `${c.yellow("!")} ${c.yellow("Today")}: ${today.length}`,
-    `${c.blue(">")} ${c.blue("This Week")}: ${thisWeek.length}`,
-  ];
-
-  // Show up to 3 urgent tasks
-  const urgent = [...overdue, ...today.filter(t => !overdue.includes(t))].slice(0, 3);
-  if (urgent.length > 0) {
-    lines.push("", c.dim("Urgent:"));
-    for (const t of urgent) {
-      const due = t.dueDate ? formatDate(t.dueDate) : "";
-      lines.push(`  ${truncate(t.title, 20)} ${due}`);
-    }
-  }
-
-  return box(lines.join("\n"), { title: "Schedule", borderColor: "yellow" });
-}
-
-// =============================================================================
-// Widget: Dependencies & Next Task
-// =============================================================================
+  const activeTasks = stats.total - stats.cancelled;
+  const percent = activeTasks > 0 ? Math.round((stats.completed / activeTasks) * 100) : 0;
 
-function renderDependencyWidget(tasks: Task[]): string {
-  const depMetrics = calculateDependencyMetrics(tasks);
-  const nextTask = suggestNextTask(tasks);
+  const lines: string[] = [];
 
-  const lines = [
-    c.bold("Dependencies"),
-    "",
-    `${c.green("Ready")}: ${depMetrics.readyToWork}  ${c.red("Blocked")}: ${depMetrics.blockedByDependencies}`,
-    `${c.gray("No deps")}: ${depMetrics.noDependencies}`,
-  ];
+  // Progress bar with fraction
+  const bar = progressBar(stats.completed, activeTasks, { width: 24 });
+  lines.push(`${bar}  ${c.bold(`${percent}%`)}  ${stats.completed}/${activeTasks} tasks`);
+  lines.push("");
 
-  if (depMetrics.mostDependedOn) {
-    lines.push(
-      "",
-      c.dim("Bottleneck:"),
-      `  ${truncate(depMetrics.mostDependedOn.title, 18)} (${depMetrics.mostDependedOn.count})`
-    );
+  // Status counts (2 rows)
+  lines.push(
+    `${c.green("Done")}: ${stats.completed}  ` +
+    `${c.blue("Progress")}: ${stats.inProgress}  ` +
+    `${c.yellow("Pending")}: ${stats.pending}  ` +
+    `${c.red("Blocked")}: ${stats.blocked}`
+  );
+
+  // Schedule info
+  const scheduleInfo = [];
+  if (overdue.length > 0) scheduleInfo.push(c.red(`Overdue: ${overdue.length}`));
+  if (today.length > 0) scheduleInfo.push(c.yellow(`Today: ${today.length}`));
+  if (scheduleInfo.length > 0) {
+    lines.push(scheduleInfo.join("  "));
   }
 
-  lines.push("", c.bold("Next Task"));
-  if (nextTask) {
-    lines.push(
-      `  ${truncate(nextTask.title, 22)}`,
-      `  ${formatPriority(nextTask.priority)}`
-    );
-  } else {
-    lines.push(c.gray("  No tasks available"));
-  }
+  lines.push("");
 
-  return box(lines.join("\n"), { title: "Work Queue", borderColor: "green" });
+  // Priority breakdown
+  lines.push(
+    `${c.red("Critical")}: ${stats.byPriority.critical}  ` +
+    `${c.yellow("High")}: ${stats.byPriority.high}  ` +
+    `${c.blue("Medium")}: ${stats.byPriority.medium}  ` +
+    `${c.gray("Low")}: ${stats.byPriority.low}`
+  );
+
+  // Dependencies summary
+  lines.push(
+    `${c.green("Ready")}: ${depMetrics.readyToWork}  ` +
+    `${c.red("Blocked")}: ${depMetrics.blockedByDependencies}` +
+    (depMetrics.mostDependedOn
+      ? `  ${c.dim("Bottleneck:")} ${truncate(depMetrics.mostDependedOn.title, 15)}`
+      : "")
+  );
+
+  return box(lines.join("\n"), {
+    title: "Status",
+    borderColor: "cyan",
+    padding: 1,
+  });
 }
 
 // =============================================================================
-// Widget: Inbox Summary
+// Widget: Next Actions (combines Next Task + Inbox)
 // =============================================================================
 
-async function renderInboxWidget(): Promise<string> {
+async function renderActionsWidget(tasks: Task[]): Promise<string> {
+  const nextTask = suggestNextTask(tasks);
   const pendingItems = await listInboxItems("pending");
 
-  const lines = [
-    c.bold("Quick Capture Inbox"),
-    "",
-  ];
-
-  if (pendingItems.length === 0) {
-    lines.push(c.dim("No pending items"));
-    lines.push(c.dim("Use 'task inbox add' to capture"));
-  } else {
-    lines.push(`${c.yellow("Pending")}: ${pendingItems.length} items`);
-    lines.push("");
-
-    // Show recent items
-    const recent = pendingItems.slice(0, 4);
-    for (const item of recent) {
-      const date = new Date(item.capturedAt);
-      const ago = getTimeAgo(date);
-      const tags = item.tags?.length ? c.dim(` #${item.tags[0]}`) : "";
-      lines.push(`${c.yellow("○")} ${truncate(item.content, 22)}${tags}`);
-      lines.push(`  ${c.dim(ago)}`);
-    }
-
-    if (pendingItems.length > 4) {
-      lines.push(c.gray(`+${pendingItems.length - 4} more`));
+  const lines: string[] = [];
+
+  // Next tasks (top 2 suggestions)
+  const readyTasks = tasks
+    .filter(t => t.status === "pending" && (!t.dependencies || t.dependencies.length === 0))
+    .sort((a, b) => {
+      const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+      return (priorityOrder[a.priority] ?? 2) - (priorityOrder[b.priority] ?? 2);
+    })
+    .slice(0, 3);
+
+  if (readyTasks.length > 0) {
+    for (const task of readyTasks) {
+      const deps = task.dependencies?.length ?? 0;
+      const depsInfo = deps > 0 ? `${deps} deps` : c.green("ready");
+      lines.push(`${c.cyan("→")} ${truncate(task.title, 22)}`);
+      lines.push(`  ${formatPriority(task.priority)}, ${depsInfo}`);
     }
-  }
-
-  return box(lines.join("\n"), { title: "Inbox", borderColor: "yellow" });
-}
-
-function getTimeAgo(date: Date): string {
-  const now = new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffMins = Math.floor(diffMs / 60000);
-  const diffHours = Math.floor(diffMins / 60);
-  const diffDays = Math.floor(diffHours / 24);
-
-  if (diffMins < 60) return `${diffMins}m ago`;
-  if (diffHours < 24) return `${diffHours}h ago`;
-  if (diffDays < 7) return `${diffDays}d ago`;
-  return date.toLocaleDateString();
-}
-
-// =============================================================================
-// Widget: Critical Path
-// =============================================================================
-
-function renderCriticalPathWidget(tasks: Task[]): string {
-  const cpm = calculateCriticalPath(tasks);
-
-  const lines = [
-    c.bold("Critical Path Analysis"),
-    "",
-  ];
-
-  if (cpm.criticalPath.length === 0) {
-    lines.push(c.gray("No critical path detected."));
-    lines.push(c.dim("(Tasks have no dependencies)"));
+  } else if (nextTask) {
+    const deps = nextTask.dependencies?.length ?? 0;
+    const depsInfo = deps > 0 ? `${deps} deps` : c.green("ready");
+    lines.push(`${c.cyan("→")} ${truncate(nextTask.title, 22)}`);
+    lines.push(`  ${formatPriority(nextTask.priority)}, ${depsInfo}`);
   } else {
-    lines.push(`${c.red("Path length")}: ${cpm.criticalPath.length} tasks`);
-    lines.push(`${c.yellow("Est. duration")}: ~${cpm.totalDuration}m`);
-    lines.push("");
-
-    // Show critical tasks
-    lines.push(c.dim("Critical tasks:"));
-    for (const task of cpm.criticalPath.slice(0, 3)) {
-      const status = icons[task.status] ?? icons.pending;
-      lines.push(`  ${status} ${truncate(task.title, 20)}`);
-    }
-    if (cpm.criticalPath.length > 3) {
-      lines.push(c.gray(`  +${cpm.criticalPath.length - 3} more`));
-    }
+    lines.push(c.dim("No tasks ready"));
   }
 
-  // Bottlenecks
-  if (cpm.bottlenecks.length > 0) {
-    lines.push("", c.dim("Bottlenecks:"));
-    for (const b of cpm.bottlenecks.slice(0, 2)) {
-      lines.push(`  ${truncate(b.task.title, 16)} ${c.red(`(${b.blocksCount})`)}`);
+  // Inbox summary
+  lines.push("");
+  if (pendingItems.length > 0) {
+    lines.push(`${c.yellow("Inbox")}: ${pendingItems.length} items`);
+    // Show first item preview
+    const first = pendingItems[0];
+    if (first) {
+      lines.push(`  ${c.dim(truncate(first.content, 20))}`);
     }
+  } else {
+    lines.push(c.dim("Inbox empty"));
   }
 
-  return box(lines.join("\n"), { title: "Critical Path", borderColor: "red" });
+  return box(lines.join("\n"), {
+    title: "Next Actions",
+    borderColor: "green",
+    padding: 1,
+  });
 }
 
 // =============================================================================
-// Widget: Hierarchy Tree
+// Projects Table
 // =============================================================================
 
-function renderHierarchyWidget(tasks: Task[]): string {
-  const activeTasks = tasks.filter(t => t.status !== "completed" && t.status !== "cancelled");
-  const tree = buildTaskTree(activeTasks);
-  const totalNodes = countTreeNodes(tree);
-  const rootCount = tree.length;
-  const subtaskCount = totalNodes - rootCount;
-
-  const lines = [
-    c.bold("Task Hierarchy"),
-    "",
-    `${c.cyan("Root tasks")}: ${rootCount}`,
-    `${c.magenta("Subtasks")}: ${subtaskCount}`,
-    "",
-  ];
-
-  // Render first few root tasks with their immediate children
-  const maxRoots = 4;
-  for (let i = 0; i < Math.min(tree.length, maxRoots); i++) {
-    const node = tree[i]!;
-    const status = icons[node.task.status] ?? icons.pending;
-    lines.push(`${status} ${truncate(node.task.title, 22)}`);
-
-    // Show up to 2 children
-    for (let j = 0; j < Math.min(node.children.length, 2); j++) {
-      const child = node.children[j]!;
-      const childStatus = icons[child.task.status] ?? icons.pending;
-      lines.push(`  ${c.gray("└")} ${childStatus} ${truncate(child.task.title, 18)}`);
-    }
-    if (node.children.length > 2) {
-      lines.push(`  ${c.gray(`  +${node.children.length - 2} more`)}`);
-    }
+async function renderProjectsTable(projects: Project[]): Promise<string> {
+  if (projects.length === 0) {
+    return c.gray("No projects found.");
   }
 
-  if (tree.length > maxRoots) {
-    lines.push(c.gray(`+${tree.length - maxRoots} more root tasks`));
+  const rows: {
+    name: string;
+    progress: string;
+    ready: number;
+    blocked: number;
+    total: number;
+  }[] = [];
+
+  for (const project of projects.slice(0, 10)) {
+    const tasks = await listTasks(project.id);
+    const stats = calculateStats(tasks);
+    const depMetrics = calculateDependencyMetrics(tasks);
+    const activeTasks = stats.total - stats.cancelled;
+    const percent = activeTasks > 0 ? Math.round((stats.completed / activeTasks) * 100) : 0;
+
+    // Create mini progress bar
+    const barWidth = 8;
+    const filled = Math.round((percent / 100) * barWidth);
+    const empty = barWidth - filled;
+    const miniBar = c.green("█".repeat(filled)) + c.gray("░".repeat(empty));
+
+    rows.push({
+      name: truncate(project.name, 20),
+      progress: `${miniBar} ${pad(String(percent) + "%", 4, "right")}`,
+      ready: depMetrics.readyToWork,
+      blocked: depMetrics.blockedByDependencies,
+      total: activeTasks,
+    });
   }
 
-  return box(lines.join("\n"), { title: "Hierarchy", borderColor: "magenta" });
-}
-
-// =============================================================================
-// Widget: Complexity & Tech Stack Analysis
-// =============================================================================
-
-function renderAnalysisWidget(tasks: Task[]): string {
-  const stats = calculateAnalysisStats(tasks);
-
-  const lines = [
-    c.bold("Analysis Overview"),
-    "",
+  const columns: TableColumn[] = [
+    { header: "Project", key: "name", width: 22 },
+    { header: "Progress", key: "progress", width: 16 },
+    { header: "Tasks", key: "total", width: 6, align: "right" },
+    { header: "Ready", key: "ready", width: 6, align: "right", format: (v) => c.green(String(v)) },
+    { header: "Blocked", key: "blocked", width: 8, align: "right", format: (v) => Number(v) > 0 ? c.red(String(v)) : c.gray(String(v)) },
   ];
 
-  // Complexity section
-  if (stats.complexity.analyzed > 0) {
-    lines.push(c.cyan("Complexity"));
-    lines.push(`  Analyzed: ${stats.complexity.analyzed} tasks`);
-    lines.push(`  Avg Score: ${c.yellow(String(stats.complexity.avgScore))}/10`);
-
-    const dist = stats.complexity.distribution;
-    const distBar = [
-      c.green(`■`.repeat(Math.min(dist.low, 5))),
-      c.yellow(`■`.repeat(Math.min(dist.medium, 5))),
-      c.red(`■`.repeat(Math.min(dist.high, 5))),
-    ].join("");
-    lines.push(`  ${distBar} L:${dist.low} M:${dist.medium} H:${dist.high}`);
-
-    if (stats.complexity.topFactors.length > 0) {
-      lines.push("");
-      lines.push(c.dim("Top factors:"));
-      for (const f of stats.complexity.topFactors.slice(0, 3)) {
-        lines.push(`  ${c.gray("•")} ${truncate(f.factor, 16)} (${f.count})`);
-      }
-    }
-  } else {
-    lines.push(c.gray("No complexity data"));
-    lines.push(c.dim("Use save_complexity_analysis"));
-  }
-
-  lines.push("");
-
-  // Tech Stack section
-  if (stats.techStack.analyzed > 0) {
-    lines.push(c.magenta("Tech Stack"));
-    lines.push(`  Analyzed: ${stats.techStack.analyzed} tasks`);
-
-    // Risk distribution
-    const risk = stats.techStack.byRisk;
-    const riskItems = [];
-    if (risk.critical > 0) riskItems.push(c.red(`Crit:${risk.critical}`));
-    if (risk.high > 0) riskItems.push(c.yellow(`High:${risk.high}`));
-    if (risk.medium > 0) riskItems.push(c.blue(`Med:${risk.medium}`));
-    if (risk.low > 0) riskItems.push(c.green(`Low:${risk.low}`));
-    lines.push(`  Risk: ${riskItems.join(" ")}`);
-
-    if (stats.techStack.breakingChanges > 0) {
-      lines.push(`  ${c.red(icons.warning)} ${stats.techStack.breakingChanges} breaking change(s)`);
-    }
-
-    // Top areas
-    const areas = Object.entries(stats.techStack.byArea)
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 4);
-    if (areas.length > 0) {
-      lines.push("");
-      lines.push(c.dim("Areas:"));
-      lines.push(`  ${areas.map(([a, n]) => `${a}(${n})`).join(" ")}`);
-    }
-  } else {
-    lines.push(c.gray("No tech stack data"));
-    lines.push(c.dim("Use save_tech_stack_analysis"));
-  }
-
-  return box(lines.join("\n"), { title: "Analysis", borderColor: "blue" });
+  return table(rows as unknown as Record<string, unknown>[], columns);
 }
 
 // =============================================================================
@@ -416,57 +254,49 @@ export async function dashboard(projectId?: string): Promise<void> {
     ? `${c.bold("Project:")} ${project.name}`
     : `${c.bold("All Projects")} (${projects.length} projects)`;
 
-  console.log(c.dim(`Version: ${VERSION}  ${projectInfo}`));
+  console.log(c.dim(`v${VERSION}  ${projectInfo}`));
   console.log();
 
-  // Render widgets in grid layout
-  const overview = renderProjectOverview(tasks, project);
-  const timeWidget = renderTimeWidget(tasks);
-  const depWidget = renderDependencyWidget(tasks);
-  const criticalPathWidget = renderCriticalPathWidget(tasks);
-  const hierarchyWidget = renderHierarchyWidget(tasks);
-  const analysisWidget = renderAnalysisWidget(tasks);
-  const inboxWidget = await renderInboxWidget();
-
-  // Print widgets (2 column layout simulation)
-  console.log(overview);
-  console.log();
-  console.log(timeWidget);
-  console.log();
-  console.log(inboxWidget);
-  console.log();
-  console.log(depWidget);
-  console.log();
-  console.log(criticalPathWidget);
-  console.log();
-  console.log(analysisWidget);
-  console.log();
-  console.log(hierarchyWidget);
+  // Render widgets
+  const statusWidget = renderStatusWidget(tasks, projects);
+  const actionsWidget = await renderActionsWidget(tasks);
+
+  // Print widgets side by side
+  console.log(sideBySide([statusWidget, actionsWidget], 2));
   console.log();
 
-  // Task table
-  if (tasks.length > 0) {
+  // Projects table (only if showing all projects)
+  if (!project && projects.length > 1) {
+    console.log(c.bold("Projects"));
+    console.log();
+    console.log(await renderProjectsTable(projects));
+    console.log();
+  }
+
+  // Task list for single project view
+  if (project || projects.length === 1) {
     const activeTasks = tasks.filter(t => t.status !== "completed" && t.status !== "cancelled");
-    const displayTasks = activeTasks.slice(0, 15); // Limit to 15 rows
+    if (activeTasks.length > 0) {
+      const displayTasks = activeTasks.slice(0, 10);
 
-    console.log(c.bold(`Active Tasks (${activeTasks.length})`));
-    console.log();
+      console.log(c.bold(`Tasks (${activeTasks.length})`));
+      console.log();
 
-    const columns: TableColumn[] = [
-      { header: "ID", key: "id", width: 6, format: (v) => c.cyan(String(v).slice(0, 4)) },
-      { header: "Title", key: "title", width: 45 },
-      { header: "Status", key: "status", width: 14, format: (v) => formatStatus(v as Task["status"]) },
-      { header: "Priority", key: "priority", width: 10, format: (v) => formatPriority(v as Task["priority"]) },
-      { header: "Due", key: "dueDate", width: 12, format: (v) => v ? formatDate(String(v)) : c.gray("-") },
-    ];
+      const columns: TableColumn[] = [
+        { header: "Title", key: "title", width: 40 },
+        { header: "Status", key: "status", width: 12, format: (v) => {
+          const icon = icons[v as Task["status"]] ?? icons.pending;
+          return `${icon} ${v}`;
+        }},
+        { header: "Priority", key: "priority", width: 10, format: (v) => formatPriority(v as Task["priority"]) },
+      ];
 
-    console.log(table(displayTasks as unknown as Record<string, unknown>[], columns));
+      console.log(table(displayTasks as unknown as Record<string, unknown>[], columns));
 
-    if (activeTasks.length > 15) {
-      console.log(c.gray(`\n(Showing 15 of ${activeTasks.length} active tasks)`));
+      if (activeTasks.length > 10) {
+        console.log(c.gray(`\n(+${activeTasks.length - 10} more tasks)`));
+      }
     }
-  } else {
-    console.log(c.gray("No tasks found."));
   }
 
   console.log();