@task-mcp/cli 1.0.17 → 1.0.19

package/package.json

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

package/src/__tests__/dashboard.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import type { Task, Project, InboxItem } from "../storage.js";
+import type { Task, InboxItem, WorkspaceInfo } from "../storage.js";
 
 // Helper to create test tasks
 function createTask(overrides: Partial<Task> = {}): Task {
@@ -8,21 +8,19 @@ function createTask(overrides: Partial<Task> = {}): Task {
     title: "Test Task",
     status: "pending",
     priority: "medium",
-    projectId: "proj_test",
+    workspace: "test-workspace",
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
     ...overrides,
   };
 }
 
-// Helper to create test projects
-function createProject(overrides: Partial<Project> = {}): Project {
+// Helper to create test workspaces
+function createWorkspace(overrides: Partial<WorkspaceInfo> = {}): WorkspaceInfo {
   return {
-    id: `proj_${Math.random().toString(36).slice(2, 10)}`,
-    name: "Test Project",
-    status: "active",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
+    name: "Test Workspace",
+    taskCount: 0,
+    completedCount: 0,
     ...overrides,
   };
 }
@@ -40,130 +38,130 @@ function createInboxItem(overrides: Partial<InboxItem> = {}): InboxItem {
 }
 
 describe("dashboard command - unit tests", () => {
-  describe("project lookup logic", () => {
-    test("finds project by exact ID", () => {
-      const projects = [
-        createProject({ id: "proj_abc123", name: "Project A" }),
-        createProject({ id: "proj_xyz789", name: "Project B" }),
+  describe("workspace lookup logic", () => {
+    test("finds workspace by exact name", () => {
+      const workspaces = [
+        createWorkspace({ name: "workspace-a" }),
+        createWorkspace({ name: "workspace-b" }),
       ];
 
-      const projectId = "proj_abc123";
-      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+      const workspaceName = "workspace-a";
+      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
 
-      expect(project).toBeDefined();
-      expect(project?.name).toBe("Project A");
+      expect(workspace).toBeDefined();
+      expect(workspace?.name).toBe("workspace-a");
     });
 
-    test("finds project by partial ID prefix", () => {
-      const projects = [
-        createProject({ id: "proj_abc123456789", name: "Project A" }),
-        createProject({ id: "proj_xyz789012345", name: "Project B" }),
+    test("finds workspace by partial name prefix", () => {
+      const workspaces = [
+        createWorkspace({ name: "workspace-abc123" }),
+        createWorkspace({ name: "workspace-xyz789" }),
       ];
 
-      const projectId = "proj_abc";
-      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+      const workspaceName = "workspace-abc";
+      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
 
-      expect(project).toBeDefined();
-      expect(project?.name).toBe("Project A");
+      expect(workspace).toBeDefined();
+      expect(workspace?.name).toBe("workspace-abc123");
     });
 
-    test("returns undefined for non-matching ID", () => {
-      const projects = [
-        createProject({ id: "proj_abc123", name: "Project A" }),
-        createProject({ id: "proj_xyz789", name: "Project B" }),
+    test("returns undefined for non-matching name", () => {
+      const workspaces = [
+        createWorkspace({ name: "workspace-a" }),
+        createWorkspace({ name: "workspace-b" }),
       ];
 
-      const projectId = "proj_nonexistent";
-      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+      const workspaceName = "workspace-nonexistent";
+      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
 
-      expect(project).toBeUndefined();
+      expect(workspace).toBeUndefined();
     });
 
-    test("returns first match when multiple projects share prefix", () => {
-      const projects = [
-        createProject({ id: "proj_abc111", name: "Project First" }),
-        createProject({ id: "proj_abc222", name: "Project Second" }),
+    test("returns first match when multiple workspaces share prefix", () => {
+      const workspaces = [
+        createWorkspace({ name: "workspace-abc111" }),
+        createWorkspace({ name: "workspace-abc222" }),
       ];
 
-      const projectId = "proj_abc";
-      const project = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+      const workspaceName = "workspace-abc";
+      const workspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
 
-      expect(project).toBeDefined();
-      expect(project?.name).toBe("Project First");
+      expect(workspace).toBeDefined();
+      expect(workspace?.name).toBe("workspace-abc111");
     });
   });
 
   describe("dashboard mode selection", () => {
-    test("single project mode when only one project exists", () => {
-      const projects = [createProject({ id: "proj_only", name: "Only Project" })];
+    test("single workspace mode when only one workspace exists", () => {
+      const workspaces = [createWorkspace({ name: "only-workspace" })];
 
-      const hasSingleProject = projects.length === 1;
-      const shouldShowGlobal = projects.length > 1;
+      const hasSingleWorkspace = workspaces.length === 1;
+      const shouldShowGlobal = workspaces.length > 1;
 
-      expect(hasSingleProject).toBe(true);
+      expect(hasSingleWorkspace).toBe(true);
       expect(shouldShowGlobal).toBe(false);
     });
 
-    test("global mode when multiple projects exist", () => {
-      const projects = [
-        createProject({ id: "proj_1", name: "Project 1" }),
-        createProject({ id: "proj_2", name: "Project 2" }),
+    test("global mode when multiple workspaces exist", () => {
+      const workspaces = [
+        createWorkspace({ name: "workspace-1" }),
+        createWorkspace({ name: "workspace-2" }),
       ];
 
-      const hasSingleProject = projects.length === 1;
-      const shouldShowGlobal = projects.length > 1;
+      const hasSingleWorkspace = workspaces.length === 1;
+      const shouldShowGlobal = workspaces.length > 1;
 
-      expect(hasSingleProject).toBe(false);
+      expect(hasSingleWorkspace).toBe(false);
       expect(shouldShowGlobal).toBe(true);
     });
 
-    test("project mode when specific projectId provided", () => {
-      const projects = [
-        createProject({ id: "proj_1", name: "Project 1" }),
-        createProject({ id: "proj_2", name: "Project 2" }),
+    test("workspace mode when specific workspace provided", () => {
+      const workspaces = [
+        createWorkspace({ name: "workspace-1" }),
+        createWorkspace({ name: "workspace-2" }),
       ];
 
-      const projectId = "proj_1";
-      const targetProject = projects.find((p) => p.id === projectId || p.id.startsWith(projectId));
+      const workspaceName = "workspace-1";
+      const targetWorkspace = workspaces.find((w) => w.name === workspaceName || w.name.startsWith(workspaceName));
 
-      expect(targetProject).toBeDefined();
-      expect(targetProject?.name).toBe("Project 1");
+      expect(targetWorkspace).toBeDefined();
+      expect(targetWorkspace?.name).toBe("workspace-1");
     });
   });
 
-  describe("task grouping by project", () => {
-    test("builds task map for each project", () => {
-      const projects = [
-        createProject({ id: "proj_1" }),
-        createProject({ id: "proj_2" }),
+  describe("task grouping by workspace", () => {
+    test("builds task map for each workspace", () => {
+      const workspaces = [
+        createWorkspace({ name: "workspace-1" }),
+        createWorkspace({ name: "workspace-2" }),
       ];
 
       const allTasks = [
-        createTask({ id: "task_1", projectId: "proj_1" }),
-        createTask({ id: "task_2", projectId: "proj_1" }),
-        createTask({ id: "task_3", projectId: "proj_2" }),
+        createTask({ id: "task_1", workspace: "workspace-1" }),
+        createTask({ id: "task_2", workspace: "workspace-1" }),
+        createTask({ id: "task_3", workspace: "workspace-2" }),
       ];
 
-      const tasksByProject = new Map<string, Task[]>();
-      for (const project of projects) {
-        tasksByProject.set(
-          project.id,
-          allTasks.filter((t) => t.projectId === project.id)
+      const tasksByWorkspace = new Map<string, Task[]>();
+      for (const ws of workspaces) {
+        tasksByWorkspace.set(
+          ws.name,
+          allTasks.filter((t) => t.workspace === ws.name)
         );
       }
 
-      expect(tasksByProject.get("proj_1")?.length).toBe(2);
-      expect(tasksByProject.get("proj_2")?.length).toBe(1);
+      expect(tasksByWorkspace.get("workspace-1")?.length).toBe(2);
+      expect(tasksByWorkspace.get("workspace-2")?.length).toBe(1);
     });
 
-    test("returns empty array for project with no tasks", () => {
-      const tasksByProject = new Map<string, Task[]>();
-      tasksByProject.set("proj_1", []);
+    test("returns empty array for workspace with no tasks", () => {
+      const tasksByWorkspace = new Map<string, Task[]>();
+      tasksByWorkspace.set("workspace-1", []);
 
-      const getProjectTasks = (pid: string) => tasksByProject.get(pid) ?? [];
+      const getWorkspaceTasks = (name: string) => tasksByWorkspace.get(name) ?? [];
 
-      expect(getProjectTasks("proj_1")).toEqual([]);
-      expect(getProjectTasks("proj_nonexistent")).toEqual([]);
+      expect(getWorkspaceTasks("workspace-1")).toEqual([]);
+      expect(getWorkspaceTasks("workspace-nonexistent")).toEqual([]);
     });
   });
 
@@ -184,12 +182,12 @@ describe("dashboard command - unit tests", () => {
   });
 
   describe("empty state handling", () => {
-    test("detects when no projects exist", () => {
-      const projects: Project[] = [];
+    test("detects when no workspaces exist", () => {
+      const workspaces: WorkspaceInfo[] = [];
 
-      const hasProjects = projects.length > 0;
+      const hasWorkspaces = workspaces.length > 0;
 
-      expect(hasProjects).toBe(false);
+      expect(hasWorkspaces).toBe(false);
     });
 
     test("detects when tasks are empty", () => {

package/src/__tests__/list.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test, mock, beforeEach, afterEach, spyOn } from "bun:test";
-import type { Task, Project } from "../storage.js";
+import type { Task, WorkspaceInfo } from "../storage.js";
 
 // Helper to create test tasks
 function createTask(overrides: Partial<Task> = {}): Task {
@@ -8,21 +8,19 @@ function createTask(overrides: Partial<Task> = {}): Task {
     title: "Test Task",
     status: "pending",
     priority: "medium",
-    projectId: "proj_test",
+    workspace: "test-workspace",
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
     ...overrides,
   };
 }
 
-// Helper to create test projects
-function createProject(overrides: Partial<Project> = {}): Project {
+// Helper to create test workspaces
+function createWorkspace(overrides: Partial<WorkspaceInfo> = {}): WorkspaceInfo {
   return {
-    id: `proj_${Math.random().toString(36).slice(2, 10)}`,
-    name: "Test Project",
-    status: "active",
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
+    name: "Test Workspace",
+    taskCount: 0,
+    completedCount: 0,
     ...overrides,
   };
 }
@@ -317,9 +315,9 @@ describe("list commands - exports", () => {
     expect(typeof listTasksCmd).toBe("function");
   });
 
-  test("listProjectsCmd is exported", async () => {
-    const { listProjectsCmd } = await import("../commands/list.js");
-    expect(typeof listProjectsCmd).toBe("function");
+  test("listWorkspacesCmd is exported", async () => {
+    const { listWorkspacesCmd } = await import("../commands/list.js");
+    expect(typeof listWorkspacesCmd).toBe("function");
   });
 
   test("listTasksCmd accepts options object", async () => {
@@ -327,26 +325,23 @@ describe("list commands - exports", () => {
 
     // Verify the function signature accepts the expected options
     const options = {
-      projectId: "proj_123",
+      workspace: "test-workspace",
       status: "pending",
       priority: "high",
       all: true,
     };
 
     // Type check passes if this compiles
-    expect(options.projectId).toBeDefined();
+    expect(options.workspace).toBeDefined();
     expect(options.status).toBeDefined();
     expect(options.priority).toBeDefined();
     expect(options.all).toBeDefined();
   });
 
-  test("listProjectsCmd accepts options object", async () => {
-    const { listProjectsCmd } = await import("../commands/list.js");
+  test("listWorkspacesCmd accepts no options", async () => {
+    const { listWorkspacesCmd } = await import("../commands/list.js");
 
-    const options = {
-      all: true,
-    };
-
-    expect(options.all).toBeDefined();
+    // listWorkspacesCmd takes no options
+    expect(typeof listWorkspacesCmd).toBe("function");
   });
 });

package/src/__tests__/storage.test.ts

@@ -13,7 +13,7 @@ function createTask(overrides: Partial<Task> = {}): Task {
     title: "Test Task",
     status: "pending",
     priority: "medium",
-    projectId: "proj_test",
+    workspace: "test-workspace",
     createdAt: new Date().toISOString(),
     updatedAt: new Date().toISOString(),
     ...overrides,

package/src/commands/dashboard.ts

@@ -1,5 +1,5 @@
 /**
- * Dashboard command - displays project overview with unified widgets
+ * Dashboard command - displays workspace overview with unified widgets
  * Uses shared dashboard renderer from @task-mcp/shared
  */
 
@@ -7,81 +7,83 @@ import { VERSION } from "../index.js";
 import { c } from "../ansi.js";
 import {
   renderGlobalDashboard,
-  renderProjectDashboard,
+  renderWorkspaceDashboard,
   type Task as SharedTask,
-  type Project as SharedProject,
+  type WorkspaceInfo,
 } from "@task-mcp/shared";
 import {
-  listProjects,
+  listWorkspaces,
   listTasks,
   listAllTasks,
   listInboxItems,
   getActiveTag,
+  getCurrentWorkspace,
   type Task,
-  type Project,
 } from "../storage.js";
 
 // =============================================================================
 // Main Dashboard
 // =============================================================================
 
-export async function dashboard(projectId?: string): Promise<void> {
-  // Get projects, tasks, and active tag
-  const projects = await listProjects();
+export async function dashboard(workspaceName?: string): Promise<void> {
+  // Get workspaces, tasks, and active tag
+  const workspaces = await listWorkspaces();
   const activeTag = await getActiveTag();
+  const currentWorkspace = getCurrentWorkspace();
 
-  if (projects.length === 0) {
-    console.log(c.yellow("No projects found. Create a project first using the MCP server."));
+  if (workspaces.length === 0) {
+    console.log(c.yellow("No tasks found. Create a task first using the MCP server."));
     return;
   }
 
-  // If projectId specified, show single project. Otherwise show all.
-  let project: Project | undefined;
+  // If workspace specified, show single workspace. Otherwise show all.
+  let selectedWorkspace: WorkspaceInfo | undefined;
   let tasks: Task[];
 
-  if (projectId) {
-    project = projects.find(p => p.id === projectId || p.id.startsWith(projectId));
-    if (!project) {
-      console.log(c.error(`Project not found: ${projectId}`));
+  if (workspaceName) {
+    selectedWorkspace = workspaces.find(w => w.name === workspaceName || w.name.startsWith(workspaceName));
+    if (!selectedWorkspace) {
+      console.log(c.error(`Workspace not found: ${workspaceName}`));
       return;
     }
-    tasks = await listTasks(project.id);
-  } else if (projects.length === 1) {
-    project = projects[0];
-    tasks = await listTasks(project!.id);
+    tasks = await listAllTasks();
+    tasks = tasks.filter(t => t.workspace === selectedWorkspace!.name);
+  } else if (workspaces.length === 1) {
+    selectedWorkspace = workspaces[0];
+    tasks = await listTasks();
   } else {
-    // Show all tasks across all projects
+    // Show all tasks across all workspaces
     tasks = await listAllTasks();
   }
 
   // Get inbox items
   const inboxItems = await listInboxItems("pending");
 
-  // Create task lookup for projects table (batch query to avoid N+1)
+  // Create task lookup for workspaces table (batch query to avoid N+1)
   const allTasksForLookup = await listAllTasks();
-  const tasksByProject = new Map<string, Task[]>();
+  const tasksByWorkspace = new Map<string, Task[]>();
   for (const task of allTasksForLookup) {
-    const projectTasks = tasksByProject.get(task.projectId) ?? [];
-    projectTasks.push(task);
-    tasksByProject.set(task.projectId, projectTasks);
+    const workspaceTasks = tasksByWorkspace.get(task.workspace) ?? [];
+    workspaceTasks.push(task);
+    tasksByWorkspace.set(task.workspace, workspaceTasks);
   }
-  const getProjectTasks = (pid: string) => tasksByProject.get(pid) ?? [];
+  const getWorkspaceTasks = (ws: string) => (tasksByWorkspace.get(ws) ?? []) as SharedTask[];
 
   // Render dashboard using shared renderer
   // Cast types - CLI types are compatible subset of shared types
   let output: string;
-  if (project) {
-    output = renderProjectDashboard(
-      project as SharedProject,
+  if (selectedWorkspace) {
+    output = renderWorkspaceDashboard(
+      selectedWorkspace.name,
       tasks as SharedTask[],
       { version: VERSION, activeTag }
     );
   } else {
     output = renderGlobalDashboard(
-      projects as SharedProject[],
+      workspaces,
       tasks as SharedTask[],
       inboxItems,
-      (pid) => (getProjectTasks(pid) as SharedTask[]),
+      getWorkspaceTasks,
       { version: VERSION, activeTag }
     );
   }

package/src/commands/inbox.ts

@@ -4,7 +4,7 @@
  */
 
 import { c, formatStatus, formatPriority } from "../ansi.js";
-import { InboxStore, TaskStore, ProjectStore } from "@task-mcp/mcp-server/storage";
+import { InboxStore, TaskStore } from "@task-mcp/mcp-server/storage";
 import { parseInboxInput } from "@task-mcp/shared";
 import {
   LIST_SEPARATOR_WIDTH,
@@ -15,7 +15,6 @@ import {
 
 const inboxStore = new InboxStore();
 const taskStore = new TaskStore();
-const projectStore = new ProjectStore();
 
 export interface InboxAddOptions {
   content: string;
@@ -29,7 +28,6 @@ export interface InboxListOptions {
 
 export interface InboxPromoteOptions {
   itemId: string;
-  projectId?: string;
   title?: string;
   priority?: "critical" | "high" | "medium" | "low";
 }
@@ -77,7 +75,7 @@ export async function inboxListCmd(options: InboxListOptions): Promise<void> {
   // Header
   const title = status ? `Inbox (${status})` : "Inbox (all)";
   console.log(c.bold(c.cyan(title)) + c.dim(` - ${items.length} items`));
-  console.log(c.dim("─".repeat(50)));
+  console.log(c.dim("─".repeat(LIST_SEPARATOR_WIDTH)));
   console.log();
 
   for (const item of items) {
@@ -116,7 +114,7 @@ export async function inboxGetCmd(itemId: string): Promise<void> {
 
   console.log();
   console.log(c.bold(c.cyan("Inbox Item")));
-  console.log(c.dim("─".repeat(40)));
+  console.log(c.dim("─".repeat(MENU_SEPARATOR_WIDTH)));
   console.log();
   console.log("  " + c.dim("ID:") + " " + item.id);
   console.log("  " + c.dim("Status:") + " " + formatStatus(item.status));
@@ -139,7 +137,7 @@ export async function inboxGetCmd(itemId: string): Promise<void> {
 }
 
 /**
- * Promote inbox item to task
+ * Promote inbox item to task in current workspace
  */
 export async function inboxPromoteCmd(options: InboxPromoteOptions): Promise<void> {
   const item = await inboxStore.get(options.itemId);
@@ -158,31 +156,9 @@ export async function inboxPromoteCmd(options: InboxPromoteOptions): Promise<voi
     return;
   }
 
-  // Get project
-  let projectId = options.projectId;
-  if (!projectId) {
-    const projects = await projectStore.list();
-    if (projects.length === 0) {
-      console.log();
-      console.log(c.error("No projects found. Create a project first."));
-      console.log();
-      return;
-    }
-    // Use first project if not specified
-    projectId = projects[0]!.id;
-  }
-
-  const project = await projectStore.get(projectId);
-  if (!project) {
-    console.log();
-    console.log(c.error(`Project not found: ${projectId}`));
-    console.log();
-    return;
-  }
-
-  // Create task
-  const task = await taskStore.create(projectId, {
-    title: options.title ?? item.content.slice(0, 100),
+  // Create task in current workspace (auto-detected)
+  const task = await taskStore.create({
+    title: options.title ?? item.content.slice(0, INBOX_PROMOTE_TITLE_MAX_LENGTH),
     description: item.content,
     priority: options.priority ?? "medium",
     tags: item.tags,
@@ -196,7 +172,7 @@ export async function inboxPromoteCmd(options: InboxPromoteOptions): Promise<voi
   console.log();
   console.log("  " + c.dim("Task ID:") + " " + c.cyan(task.id));
   console.log("  " + c.dim("Title:") + " " + task.title);
-  console.log("  " + c.dim("Project:") + " " + project.name);
+  console.log("  " + c.dim("Workspace:") + " " + task.workspace);
   console.log("  " + c.dim("Priority:") + " " + formatPriority(task.priority));
   console.log();
 }
@@ -215,7 +191,7 @@ export async function inboxDiscardCmd(itemId: string): Promise<void> {
   }
 
   console.log();
-  console.log(c.dim("×") + " Discarded: " + item.content.slice(0, 50) + "...");
+  console.log(c.dim("×") + " Discarded: " + item.content.slice(0, INBOX_DISCARD_PREVIEW_LENGTH) + "...");
   console.log();
 }
 
@@ -251,4 +227,3 @@ export async function inboxCountCmd(): Promise<void> {
   }
   console.log();
 }
-

package/src/commands/list.ts

@@ -1,14 +1,15 @@
 /**
- * List commands - list tasks and projects
+ * List commands - list tasks and workspaces
  */
 
 import { c, table, formatStatus, formatPriority, type TableColumn } from "../ansi.js";
 import {
-  listProjects,
+  listWorkspaces,
   listTasks,
   listAllTasks,
+  getCurrentWorkspace,
   type Task,
-  type Project,
+  type WorkspaceInfo,
 } from "../storage.js";
 import {
   COLUMN_WIDTH_ID,
@@ -17,18 +18,9 @@ import {
   COLUMN_WIDTH_STATUS,
   COLUMN_WIDTH_PRIORITY,
   COLUMN_WIDTH_DATE,
+  ID_DISPLAY_LENGTH,
 } from "../constants.js";
 
-function formatProjectStatus(status: Project["status"]): string {
-  const statusMap: Record<string, string> = {
-    active: c.green("● active"),
-    on_hold: c.yellow("◐ on_hold"),
-    completed: c.blue("✓ completed"),
-    archived: c.gray("⊘ archived"),
-  };
-  return statusMap[status] ?? status;
-}
-
 function formatDate(dateStr?: string): string {
   if (!dateStr) return c.gray("-");
   const date = new Date(dateStr);
@@ -36,17 +28,20 @@ function formatDate(dateStr?: string): string {
 }
 
 export async function listTasksCmd(options: {
-  projectId?: string;
+  workspace?: string;
   status?: string;
   priority?: string;
   all?: boolean;
 }): Promise<void> {
   let tasks: Task[];
 
-  if (options.projectId) {
-    tasks = await listTasks(options.projectId);
+  if (options.workspace) {
+    // Filter by specific workspace
+    const allTasks = await listAllTasks();
+    tasks = allTasks.filter(t => t.workspace === options.workspace || t.workspace.startsWith(options.workspace!));
   } else {
-    tasks = await listAllTasks();
+    // Current workspace
+    tasks = await listTasks();
   }
 
   // Apply filters
@@ -68,10 +63,11 @@ export async function listTasksCmd(options: {
     return;
   }
 
-  console.log(c.bold(`\nTasks (${tasks.length})\n`));
+  const currentWorkspace = getCurrentWorkspace();
+  console.log(c.bold(`\nTasks (${tasks.length}) - ${c.cyan(currentWorkspace)}\n`));
 
   const columns: TableColumn[] = [
-    { header: "ID", key: "id", width: COLUMN_WIDTH_ID, format: (v) => c.cyan(String(v).slice(0, 4)) },
+    { header: "ID", key: "id", width: COLUMN_WIDTH_ID, format: (v) => c.cyan(String(v).slice(0, ID_DISPLAY_LENGTH)) },
     { header: "Title", key: "title", width: COLUMN_WIDTH_TITLE },
     { header: "Status", key: "status", width: COLUMN_WIDTH_STATUS, format: (v) => formatStatus(v as Task["status"]) },
     { header: "Priority", key: "priority", width: COLUMN_WIDTH_PRIORITY, format: (v) => formatPriority(v as Task["priority"]) },
@@ -82,40 +78,29 @@ export async function listTasksCmd(options: {
   console.log();
 }
 
-export async function listProjectsCmd(options: {
-  all?: boolean;
-}): Promise<void> {
-  const projects = await listProjects(options.all);
+export async function listWorkspacesCmd(): Promise<void> {
+  const workspaces = await listWorkspaces();
+  const currentWorkspace = getCurrentWorkspace();
 
-  if (projects.length === 0) {
-    console.log(c.gray("No projects found."));
+  if (workspaces.length === 0) {
+    console.log(c.gray("No workspaces found."));
     return;
   }
 
-  console.log(c.bold(`\nProjects (${projects.length})\n`));
-
-  // Get task counts for each project
-  const projectsWithStats = await Promise.all(
-    projects.map(async p => {
-      const tasks = await listTasks(p.id);
-      const completed = tasks.filter(t => t.status === "completed").length;
-      const total = tasks.filter(t => t.status !== "cancelled").length;
-      return {
-        ...p,
-        taskCount: tasks.length,
-        progress: total > 0 ? `${completed}/${total}` : "0/0",
-      };
-    })
-  );
+  console.log(c.bold(`\nWorkspaces (${workspaces.length})\n`));
+
+  const workspacesWithCurrent = workspaces.map(ws => ({
+    ...ws,
+    current: ws.name === currentWorkspace ? c.green("●") : "",
+    progress: `${ws.completedCount}/${ws.taskCount}`,
+  }));
 
   const columns: TableColumn[] = [
-    { header: "ID", key: "id", width: COLUMN_WIDTH_ID, format: (v) => c.cyan(String(v).slice(0, 4)) },
-    { header: "Name", key: "name", width: COLUMN_WIDTH_PROJECT_NAME },
-    { header: "Status", key: "status", width: COLUMN_WIDTH_STATUS, format: (v) => formatProjectStatus(v as Project["status"]) },
+    { header: "", key: "current", width: 2 },
+    { header: "Name", key: "name", width: COLUMN_WIDTH_PROJECT_NAME, format: (v) => c.cyan(String(v)) },
     { header: "Tasks", key: "progress", width: COLUMN_WIDTH_PRIORITY },
-    { header: "Updated", key: "updatedAt", width: COLUMN_WIDTH_DATE, format: (v) => formatDate(v as string) },
   ];
 
-  console.log(table(projectsWithStats, columns));
+  console.log(table(workspacesWithCurrent, columns));
   console.log();
 }

package/src/constants.ts

@@ -54,3 +54,6 @@ export const INBOX_PROMOTE_TITLE_MAX_LENGTH = 100;
 
 /** Maximum length for content preview when discarding inbox item */
 export const INBOX_DISCARD_PREVIEW_LENGTH = 50;
+
+/** Number of characters to show for truncated task/project IDs */
+export const ID_DISPLAY_LENGTH = 4;

package/src/index.ts

@@ -4,18 +4,18 @@
  *
  * Usage:
  *   task                    # Show dashboard (default)
- *   task dashboard [id]     # Show project dashboard
- *   task d [id]             # Alias for dashboard
+ *   task dashboard [ws]     # Show workspace dashboard
+ *   task d [ws]             # Alias for dashboard
  *   task list               # List tasks
  *   task ls                 # Alias for list
- *   task projects           # List projects
- *   task p                  # Alias for projects
+ *   task workspaces         # List workspaces
+ *   task ws                 # Alias for workspaces
  *   task help               # Show help
  */
 
 import { c, banner } from "./ansi.js";
 import { dashboard } from "./commands/dashboard.js";
-import { listTasksCmd, listProjectsCmd } from "./commands/list.js";
+import { listTasksCmd, listWorkspacesCmd } from "./commands/list.js";
 import { startInteractive } from "./interactive.js";
 import {
   inboxAddCmd,
@@ -167,12 +167,11 @@ async function handleInboxCommand(
 
     case "promote":
       if (!args[1]) {
-        console.log(c.error("Usage: task inbox promote <item-id> [--project <id>] [--priority <p>]"));
+        console.log(c.error("Usage: task inbox promote <item-id> [--priority <p>]"));
         return;
       }
       await inboxPromoteCmd({
         itemId: args[1],
-        projectId: flags.project as string | undefined,
         title: flags.title as string | undefined,
         priority: flags.priority as "critical" | "high" | "medium" | "low" | undefined,
       });
@@ -224,18 +223,16 @@ async function main(): Promise<void> {
       case "list":
       case "ls":
         await listTasksCmd({
-          projectId: args[0],
+          workspace: args[0],
           status: flags.status as string | undefined,
           priority: flags.priority as string | undefined,
           all: flags.all === true,
         });
         break;
 
-      case "projects":
-      case "p":
-        await listProjectsCmd({
-          all: flags.all === true,
-        });
+      case "workspaces":
+      case "ws":
+        await listWorkspacesCmd();
         break;
 
       case "interactive":

package/src/interactive.ts

@@ -5,7 +5,7 @@
 
 import { c, banner } from "./ansi.js";
 import { dashboard } from "./commands/dashboard.js";
-import { listTasksCmd, listProjectsCmd } from "./commands/list.js";
+import { listTasksCmd, listWorkspacesCmd } from "./commands/list.js";
 import * as readline from "node:readline";
 import {
   MENU_SEPARATOR_WIDTH,
@@ -87,17 +87,17 @@ async function mainMenu(): Promise<boolean> {
     {
       key: "d",
       label: "Dashboard",
-      description: "View project dashboard",
+      description: "View workspace dashboard",
       action: async () => {
         await dashboardMenu();
       },
     },
     {
-      key: "p",
-      label: "Projects",
-      description: "List and manage projects",
+      key: "w",
+      label: "Workspaces",
+      description: "List workspaces",
       action: async () => {
-        await projectsMenu();
+        await workspacesMenu();
       },
     },
     {
@@ -132,35 +132,25 @@ async function dashboardMenu(): Promise<void> {
   console.log(c.dim("─".repeat(MENU_SEPARATOR_WIDTH)));
   console.log();
 
-  const projectId = await prompt(c.cyan("Project ID (Enter for all): "));
+  const workspace = await prompt(c.cyan("Workspace name (Enter for current): "));
 
   console.log();
-  await dashboard(projectId || undefined);
+  await dashboard(workspace || undefined);
   console.log();
   await waitForKey();
 }
 
 /**
- * Projects Menu
+ * Workspaces Menu
  */
-async function projectsMenu(): Promise<void> {
+async function workspacesMenu(): Promise<void> {
   const options: MenuOption[] = [
     {
       key: "l",
-      label: "List Projects",
-      action: async () => {
-        console.clear();
-        await listProjectsCmd({ all: false });
-        console.log();
-        await waitForKey();
-      },
-    },
-    {
-      key: "a",
-      label: "List All (include archived)",
+      label: "List Workspaces",
       action: async () => {
         console.clear();
-        await listProjectsCmd({ all: true });
+        await listWorkspacesCmd();
         console.log();
         await waitForKey();
       },
@@ -172,7 +162,7 @@ async function projectsMenu(): Promise<void> {
     },
   ];
 
-  await showMenu("Projects", options);
+  await showMenu("Workspaces", options);
 }
 
 /**

package/src/storage.ts

@@ -3,20 +3,19 @@
  * Wrapper functions for store access and pure functions for task statistics
  */
 
-import type { Task, Project, InboxItem } from "@task-mcp/shared";
+import type { Task, InboxItem } from "@task-mcp/shared";
+import type { WorkspaceInfo } from "@task-mcp/shared";
 import {
   TaskStore,
-  ProjectStore,
   InboxStore,
   StateStore,
 } from "@task-mcp/mcp-server/storage";
 
 // Re-export types from shared for consumers of this module
-export type { Task, Project, InboxItem };
+export type { Task, InboxItem, WorkspaceInfo };
 
 // Initialize stores
 const taskStore = new TaskStore();
-const projectStore = new ProjectStore();
 const inboxStore = new InboxStore();
 const stateStore = new StateStore();
 
@@ -25,25 +24,40 @@ const stateStore = new StateStore();
 // =============================================================================
 
 /**
- * List all projects
+ * Get current workspace name
  */
-export async function listProjects(includeArchived = false): Promise<Project[]> {
-  const projects = await projectStore.list();
-  if (includeArchived) {
-    return projects;
+export function getCurrentWorkspace(): string {
+  return taskStore.currentWorkspace;
+}
+
+/**
+ * List all workspaces
+ */
+export async function listWorkspaces(): Promise<WorkspaceInfo[]> {
+  const workspaceNames = await taskStore.listWorkspaces();
+  const workspaces: WorkspaceInfo[] = [];
+
+  for (const name of workspaceNames) {
+    const tasks = await taskStore.list({ workspaces: [name] });
+    workspaces.push({
+      name,
+      taskCount: tasks.length,
+      completedCount: tasks.filter(t => t.status === "completed").length,
+    });
   }
-  return projects.filter((p) => p.status !== "archived");
+
+  return workspaces;
 }
 
 /**
- * List tasks for a specific project
+ * List tasks for current workspace
  */
-export async function listTasks(projectId: string): Promise<Task[]> {
-  return taskStore.list(projectId);
+export async function listTasks(): Promise<Task[]> {
+  return taskStore.list();
 }
 
 /**
- * List all tasks across all projects
+ * List all tasks across all workspaces
  */
 export async function listAllTasks(): Promise<Task[]> {
   return taskStore.listAll();
@@ -66,9 +80,9 @@ export async function getActiveTag(): Promise<string> {
 }
 
 /**
- * Get project statistics
+ * Get workspace statistics
  */
-export interface ProjectStats {
+export interface WorkspaceStats {
   total: number;
   completed: number;
   inProgress: number;
@@ -79,8 +93,8 @@ export interface ProjectStats {
   completionPercent: number;
 }
 
-export function calculateStats(tasks: Task[]): ProjectStats {
-  const stats: ProjectStats = {
+export function calculateStats(tasks: Task[]): WorkspaceStats {
+  const stats: WorkspaceStats = {
     total: tasks.length,
     completed: 0,
     inProgress: 0,