merge: fix/ux-leaf-a-tasks into integration/ux-28-gaps

apps/web/app/api/domains/[domainId]/tasks/bulk/route.ts

@@ -21,6 +21,10 @@ const bulkUpdateSchema = z.object({
   }),
 });
 
+const bulkDeleteSchema = z.object({
+  ids: z.array(z.string().uuid()).min(1).max(200),
+});
+
 type RouteContext = { params: Promise<{ domainId: string }> };
 
 // POST /api/domains/[domainId]/tasks/bulk — Bulk update tasks (order, status)
@@ -77,3 +81,51 @@ export const POST = withAuth<RouteContext>(async (request: NextRequest, user, co
     return createErrorResponse('INTERNAL_ERROR', 'Failed to bulk update tasks', 500);
   }
 });
+
+// DELETE /api/domains/[domainId]/tasks/bulk — Bulk soft-delete tasks
+export const DELETE = withAuth<RouteContext>(async (request: NextRequest, user, context) => {
+  const { domainId } = await context!.params;
+  await requireWorkspaceAccess(domainId);
+
+  try {
+    const body = await request.json();
+    const data = bulkDeleteSchema.parse(body);
+
+    // Verify all tasks belong to this domain
+    const existingTasks = await db.select({ id: tasks.id, title: tasks.title })
+      .from(tasks)
+      .where(and(inArray(tasks.id, data.ids), eq(tasks.domainId, domainId), isNull(tasks.deletedAt)));
+
+    if (existingTasks.length !== data.ids.length) {
+      return createErrorResponse('NOT_FOUND', 'One or more tasks not found', 404);
+    }
+
+    // Soft delete
+    await db.update(tasks)
+      .set({ deletedAt: new Date(), updatedAt: new Date() })
+      .where(inArray(tasks.id, data.ids));
+
+    // Record activity for each task
+    for (const task of existingTasks) {
+      await recordActivity({
+        actor: user.name,
+        action: 'bulk_deleted',
+        entityType: 'task',
+        entityId: task.id,
+        changes: { title: task.title },
+        workspaceId: domainId,
+      });
+    }
+
+    return NextResponse.json({ deleted: existingTasks.length });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return createErrorResponse('VALIDATION_ERROR', 'Invalid input', 400, error.issues);
+    }
+    if (error instanceof ApiError) {
+      return createErrorResponse(error.code, error.message, error.status);
+    }
+    console.error('[tasks bulk DELETE] error:', error);
+    return createErrorResponse('INTERNAL_ERROR', 'Failed to bulk delete tasks', 500);
+  }
+});

apps/web/components/tasks/tasks-kanban-view.tsx

@@ -13,10 +13,17 @@ import {
 import { Card, CardContent } from '@/components/ui/card';
 import { Badge } from '@/components/ui/badge';
 import { Button } from '@/components/ui/button';
-import { Calendar, GripVertical, Plus } from 'lucide-react';
+import { Input } from '@/components/ui/input';
+import { Calendar, GripVertical, Link2, Loader2, Plus } from 'lucide-react';
 import { toast } from 'sonner';
 import { TaskDetailPanel } from './task-detail-panel';
 import { useRealtimeContext } from '@/components/realtime-provider';
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from '@/components/ui/tooltip';
 
 interface Task {
   id: string;
@@ -59,15 +66,15 @@ function TaskCard({
   task,
   domainName,
   domainColor,
+  depCount,
   onClick,
 }: {
   task: Task;
   domainName: string;
   domainColor: string | null;
+  depCount: number;
   onClick: () => void;
 }) {
-  const subtaskCount = 0; // Will be populated from API
-
   return (
     <Card className="mb-2 cursor-pointer hover:shadow-md transition-shadow" onClick={onClick}>
       <CardContent className="p-3">
@@ -75,6 +82,20 @@ function TaskCard({
           <span className="flex-1 text-sm font-medium leading-tight">
             {task.title}
           </span>
+          {depCount > 0 && (
+            <TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <span className="inline-flex items-center text-xs text-muted-foreground shrink-0">
+                    <Link2 className="h-3 w-3" />
+                  </span>
+                </TooltipTrigger>
+                <TooltipContent side="top">
+                  <p>{depCount} {depCount === 1 ? 'dependency' : 'dependencies'}</p>
+                </TooltipContent>
+              </Tooltip>
+            </TooltipProvider>
+          )}
         </div>
         <div className="flex items-center gap-2 flex-wrap">
           <Badge
@@ -128,16 +149,24 @@ function DroppableColumn({
   color,
   tasks,
   domainMap,
+  depCounts,
   onTaskClick,
-  onAddTask,
+  inlineInput,
+  onInlineInputChange,
+  onInlineSubmit,
+  inlineLoading,
 }: {
   id: string;
   title: string;
   color: string;
   tasks: Task[];
   domainMap: Map<string, { name: string; color: string | null }>;
+  depCounts: Map<string, number>;
   onTaskClick: (task: Task) => void;
-  onAddTask: () => void;
+  inlineInput: string;
+  onInlineInputChange: (value: string) => void;
+  onInlineSubmit: () => void;
+  inlineLoading: boolean;
 }) {
   return (
     <div className="flex flex-col">
@@ -147,15 +176,6 @@ function DroppableColumn({
           <h3 className="font-semibold text-sm">{title}</h3>
           <span className="text-sm text-muted-foreground">({tasks.length})</span>
         </div>
-        <Button
-          variant="ghost"
-          size="icon"
-          className="h-7 w-7"
-          onClick={onAddTask}
-          aria-label={`Add task to ${title}`}
-        >
-          <Plus className="h-4 w-4" />
-        </Button>
       </div>
       <div
         role="list"
@@ -173,11 +193,35 @@ function DroppableColumn({
               task={task}
               domainName={domainMap.get(task.domainId)?.name || ''}
               domainColor={domainMap.get(task.domainId)?.color || null}
+              depCount={depCounts.get(task.id) || 0}
               onClick={() => onTaskClick(task)}
             />
           ))
         )}
       </div>
+      {/* Inline task creation input */}
+      <div className="mt-2 flex items-center gap-2">
+        <Input
+          placeholder="New task title..."
+          value={inlineInput}
+          onChange={(e) => onInlineInputChange(e.target.value)}
+          onKeyDown={(e) => {
+            if (e.key === 'Enter' && !inlineLoading) {
+              onInlineSubmit();
+            }
+          }}
+          className="h-8 text-sm"
+          disabled={inlineLoading}
+        />
+        <Button
+          size="sm"
+          className="h-8 shrink-0"
+          onClick={onInlineSubmit}
+          disabled={!inlineInput.trim() || inlineLoading}
+        >
+          {inlineLoading ? <Loader2 className="h-3 w-3 animate-spin" /> : 'Add'}
+        </Button>
+      </div>
     </div>
   );
 }
@@ -193,6 +237,9 @@ export function TasksKanbanView({
   const [domainMap, setDomainMap] = useState<Map<string, { name: string; color: string | null }>>(new Map());
   const [loading, setLoading] = useState(true);
   const [selectedTask, setSelectedTask] = useState<Task | null>(null);
+  const [inlineInputs, setInlineInputs] = useState<Record<string, string>>({});
+  const [inlineLoading, setInlineLoading] = useState<Record<string, boolean>>({});
+  const [depCounts, setDepCounts] = useState<Map<string, number>>(new Map());
   const { subscribe } = useRealtimeContext();
 
   const sensors = useSensors(
@@ -248,6 +295,37 @@ export function TasksKanbanView({
     return unsubscribe;
   }, [domainId, subscribe, fetchTasks, onRefresh]);
 
+  // Fetch dependency counts for visible tasks
+  useEffect(() => {
+    if (tasks.length === 0 || !domainId) return;
+    const controller = new AbortController();
+    let cancelled = false;
+
+    (async () => {
+      const counts = new Map<string, number>();
+      // Fetch task details in parallel to get dependency counts
+      const results = await Promise.allSettled(
+        tasks.map((t) =>
+          fetch(`/api/domains/${domainId}/tasks/${t.id}`, { signal: controller.signal })
+            .then((r) => (r.ok ? r.json() : null))
+        )
+      );
+      if (cancelled) return;
+      for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        if (r.status === 'fulfilled' && r.value?.dependencies?.length > 0) {
+          counts.set(tasks[i].id, r.value.dependencies.length);
+        }
+      }
+      setDepCounts(counts);
+    })();
+
+    return () => {
+      cancelled = true;
+      controller.abort();
+    };
+  }, [tasks, domainId]);
+
   async function handleDragEnd(event: DragEndEvent) {
     const { active, over } = event;
     if (!over) return;
@@ -279,11 +357,30 @@ export function TasksKanbanView({
     }
   }
 
-  function handleAddTask(status: string) {
+  async function handleInlineCreate(status: string) {
-    // Open create dialog with pre-filled status
+    const title = inlineInputs[status]?.trim();
-    document.dispatchEvent(
+    if (!title) return;
-      new CustomEvent('open-create-task', { detail: { status, domainId } })
+
-    );
+    setInlineLoading((prev) => ({ ...prev, [status]: true }));
+
+    try {
+      const response = await fetch(`/api/domains/${domainId}/tasks`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ title, status }),
+      });
+      if (!response.ok) throw new Error('Unable to create task');
+      const newTask = await response.json();
+      // Prepend the new task to the list
+      setTasks((prev) => [{ ...newTask, tags: [] }, ...prev]);
+      setInlineInputs((prev) => ({ ...prev, [status]: '' }));
+      toast.success(`Created "${title}"`);
+    } catch (error) {
+      console.error('Failed to create task:', error);
+      toast.error('Unable to create task');
+    } finally {
+      setInlineLoading((prev) => ({ ...prev, [status]: false }));
+    }
   }
 
   if (loading) {
@@ -301,8 +398,14 @@ export function TasksKanbanView({
             color={column.color}
             tasks={tasks.filter((t) => t.status === column.id)}
             domainMap={domainMap}
+            depCounts={depCounts}
             onTaskClick={setSelectedTask}
-            onAddTask={() => handleAddTask(column.id)}
+            inlineInput={inlineInputs[column.id] || ''}
+            onInlineInputChange={(value) =>
+              setInlineInputs((prev) => ({ ...prev, [column.id]: value }))
+            }
+            onInlineSubmit={() => handleInlineCreate(column.id)}
+            inlineLoading={inlineLoading[column.id] || false}
           />
         ))}
       </div>

apps/web/components/tasks/tasks-list-view.tsx

@@ -1,6 +1,7 @@
 'use client';
 
-import { useEffect, useState, useCallback } from 'react';
+import { useEffect, useState, useCallback, useMemo } from 'react';
+import { useRouter, useSearchParams, usePathname } from 'next/navigation';
 import {
   Table,
   TableBody,
@@ -12,8 +13,19 @@ import {
 import { Badge } from '@/components/ui/badge';
 import { Button } from '@/components/ui/button';
 import { Checkbox } from '@/components/ui/checkbox';
+import { Input } from '@/components/ui/input';
 import { ScrollArea, ScrollBar } from '@/components/ui/scroll-area';
-import { Calendar, MoreHorizontal, Pencil, Trash2 } from 'lucide-react';
+import {
+  Calendar,
+  MoreHorizontal,
+  Pencil,
+  Trash2,
+  ArrowUpDown,
+  ArrowUp,
+  ArrowDown,
+  Search,
+  X,
+} from 'lucide-react';
 import { toast } from 'sonner';
 import { TaskDetailPanel } from './task-detail-panel';
 import {
@@ -32,6 +44,18 @@ import {
   AlertDialogHeader,
   AlertDialogTitle,
 } from '@/components/ui/alert-dialog';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from '@/components/ui/popover';
 import { useRealtimeContext } from '@/components/realtime-provider';
 
 interface Task {
@@ -54,6 +78,89 @@ const priorityColors: Record<string, string> = {
   low: 'secondary',
 };
 
+const statusOptions = ['todo', 'in_progress', 'done', 'cancelled'] as const;
+const priorityOptions = ['low', 'medium', 'high', 'urgent'] as const;
+
+const sortableColumns = [
+  { key: 'title', label: 'Task' },
+  { key: 'status', label: 'Status' },
+  { key: 'priority', label: 'Priority' },
+  { key: 'due_date', label: 'Due Date' },
+] as const;
+
+function useDebounce<T>(value: T, delay: number): T {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(() => setDebounced(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debounced;
+}
+
+function MultiSelectFilter({
+  label,
+  options,
+  selected,
+  onChange,
+}: {
+  label: string;
+  options: readonly string[];
+  selected: string[];
+  onChange: (values: string[]) => void;
+}) {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <Popover open={open} onOpenChange={setOpen}>
+      <PopoverTrigger asChild>
+        <Button variant="outline" size="sm" className="h-9">
+          {label}
+          {selected.length > 0 && (
+            <span className="ml-1 rounded bg-primary/10 px-1.5 text-xs font-medium">
+              {selected.length}
+            </span>
+          )}
+        </Button>
+      </PopoverTrigger>
+      <PopoverContent className="w-48 p-2" align="start">
+        <div className="space-y-1">
+          {options.map((opt) => {
+            const checked = selected.includes(opt);
+            return (
+              <label
+                key={opt}
+                className="flex cursor-pointer items-center gap-2 rounded px-2 py-1.5 text-sm hover:bg-accent"
+              >
+                <Checkbox
+                  checked={checked}
+                  onCheckedChange={() => {
+                    onChange(
+                      checked
+                        ? selected.filter((s) => s !== opt)
+                        : [...selected, opt]
+                    );
+                  }}
+                />
+                <span className="capitalize">{opt.replace('_', ' ')}</span>
+              </label>
+            );
+          })}
+        </div>
+        {selected.length > 0 && (
+          <Button
+            variant="ghost"
+            size="sm"
+            className="mt-2 w-full text-xs"
+            onClick={() => onChange([])}
+          >
+            Clear
+          </Button>
+        )}
+      </PopoverContent>
+    </Popover>
+  );
+}
+
 export function TasksListView({
   domainId,
   onRefresh,
@@ -61,6 +168,10 @@ export function TasksListView({
   domainId: string;
   onRefresh?: () => void;
 }) {
+  const router = useRouter();
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+
   const [tasks, setTasks] = useState<Task[]>([]);
   const [loading, setLoading] = useState(true);
   const [selectedTask, setSelectedTask] = useState<Task | null>(null);
@@ -69,10 +180,59 @@ export function TasksListView({
   const [domainMap, setDomainMap] = useState<Map<string, string>>(new Map());
   const { subscribe } = useRealtimeContext();
 
+  // Filter/sort state from URL params
+  const statusFilter = searchParams.get('status')?.split(',').filter(Boolean) || [];
+  const priorityFilter = searchParams.get('priority')?.split(',').filter(Boolean) || [];
+  const domainFilter = searchParams.get('domain') || '';
+  const searchQuery = searchParams.get('search') || '';
+  const sort = searchParams.get('sort') || 'order';
+  const order = searchParams.get('order') || 'asc';
+
+  // Local search input (debounced)
+  const [searchInput, setSearchInput] = useState(searchQuery);
+  const debouncedSearch = useDebounce(searchInput, 300);
+
+  // Bulk selection
+  const [selectedIds, setSelectedIds] = useState<Set<string>>(new Set());
+  const [bulkStatusOpen, setBulkStatusOpen] = useState(false);
+  const [bulkPriorityOpen, setBulkPriorityOpen] = useState(false);
+  const [bulkDeleting, setBulkDeleting] = useState(false);
+
+  // Sync debounced search to URL
+  useEffect(() => {
+    if (debouncedSearch !== searchQuery) {
+      const params = new URLSearchParams(searchParams.toString());
+      if (debouncedSearch) {
+        params.set('search', debouncedSearch);
+      } else {
+        params.delete('search');
+      }
+      router.replace(`${pathname}?${params.toString()}`, { scroll: false });
+    }
+  }, [debouncedSearch, searchQuery, searchParams, pathname, router]);
+
+  const updateURLParam = useCallback(
+    (key: string, value: string | null) => {
+      const params = new URLSearchParams(searchParams.toString());
+      if (value) {
+        params.set(key, value);
+      } else {
+        params.delete(key);
+      }
+      router.replace(`${pathname}?${params.toString()}`, { scroll: false });
+    },
+    [searchParams, pathname, router]
+  );
+
   const fetchTasks = useCallback(async () => {
     if (!domainId) return;
     try {
-      const response = await fetch(`/api/domains/${domainId}/tasks?sort=order&limit=200`);
+      const params = new URLSearchParams({ sort, order, limit: '200' });
+      if (statusFilter.length > 0) params.set('status', statusFilter.join(','));
+      if (priorityFilter.length > 0) params.set('priority', priorityFilter.join(','));
+      if (searchQuery) params.set('search', searchQuery);
+
+      const response = await fetch(`/api/domains/${domainId}/tasks?${params.toString()}`);
       if (!response.ok) throw new Error('Unable to load tasks');
       const data = await response.json();
       setTasks(data.items || []);
@@ -82,7 +242,7 @@ export function TasksListView({
     } finally {
       setLoading(false);
     }
-  }, [domainId]);
+  }, [domainId, sort, order, statusFilter, priorityFilter, searchQuery]);
 
   const fetchDomains = useCallback(async () => {
     try {
@@ -115,6 +275,11 @@ export function TasksListView({
     return unsubscribe;
   }, [domainId, subscribe, fetchTasks, onRefresh]);
 
+  // Clear selection when tasks change
+  useEffect(() => {
+    setSelectedIds(new Set());
+  }, [tasks]);
+
   async function toggleTaskComplete(task: Task) {
     const newStatus = task.status === 'done' ? 'todo' : 'done';
     try {
@@ -134,110 +299,329 @@ export function TasksListView({
     }
   }
 
+  function toggleSort(column: string) {
+    if (sort === column) {
+      updateURLParam('order', order === 'asc' ? 'desc' : 'asc');
+    } else {
+      updateURLParam('sort', column);
+      updateURLParam('order', 'asc');
+    }
+  }
+
+  function getSortIcon(column: string) {
+    if (sort !== column) return <ArrowUpDown className="ml-1 h-3 w-3 opacity-40" />;
+    return order === 'asc' ? (
+      <ArrowUp className="ml-1 h-3 w-3" />
+    ) : (
+      <ArrowDown className="ml-1 h-3 w-3" />
+    );
+  }
+
+  // Bulk actions
+  const allSelected = tasks.length > 0 && selectedIds.size === tasks.length;
+
+  function toggleSelectAll() {
+    if (allSelected) {
+      setSelectedIds(new Set());
+    } else {
+      setSelectedIds(new Set(tasks.map((t) => t.id)));
+    }
+  }
+
+  function toggleSelect(id: string) {
+    setSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+  }
+
+  async function handleBulkStatus(newStatus: string) {
+    if (selectedIds.size === 0) return;
+    setBulkStatusOpen(false);
+    try {
+      const res = await fetch(`/api/domains/${domainId}/tasks/bulk`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          ids: Array.from(selectedIds),
+          updates: { status: newStatus },
+        }),
+      });
+      if (!res.ok) throw new Error();
+      toast.success(`Marked ${selectedIds.size} tasks as ${newStatus.replace('_', ' ')}`);
+      setSelectedIds(new Set());
+      fetchTasks();
+    } catch {
+      toast.error('Unable to update tasks');
+    }
+  }
+
+  async function handleBulkPriority(newPriority: string) {
+    if (selectedIds.size === 0) return;
+    setBulkPriorityOpen(false);
+    try {
+      const res = await fetch(`/api/domains/${domainId}/tasks/bulk`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          ids: Array.from(selectedIds),
+          updates: { priority: newPriority },
+        }),
+      });
+      if (!res.ok) throw new Error();
+      toast.success(`Set priority for ${selectedIds.size} tasks`);
+      setSelectedIds(new Set());
+      fetchTasks();
+    } catch {
+      toast.error('Unable to update tasks');
+    }
+  }
+
+  async function handleBulkDelete() {
+    if (selectedIds.size === 0) return;
+    setBulkDeleting(true);
+    try {
+      const res = await fetch(`/api/domains/${domainId}/tasks/bulk`, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ids: Array.from(selectedIds) }),
+      });
+      if (!res.ok) throw new Error();
+      toast.success(`Deleted ${selectedIds.size} tasks`);
+      setSelectedIds(new Set());
+      fetchTasks();
+    } catch {
+      toast.error('Unable to delete tasks');
+    } finally {
+      setBulkDeleting(false);
+    }
+  }
+
   if (loading) {
     return <p className="text-muted-foreground">Loading tasks...</p>;
   }
 
-  if (tasks.length === 0) {
-    return (
-      <div className="py-12 text-center">
-        <p className="text-muted-foreground">No tasks yet. Create your first task to get started!</p>
-      </div>
-    );
-  }
-
   return (
     <>
-      <ScrollArea className="w-full">
+      {/* Filter bar */}
-        <div className="min-w-[700px]">
+      <div className="mb-4 flex flex-wrap items-center gap-2">
-          <Table>
+        <MultiSelectFilter
-            <TableHeader>
+          label="Status"
-              <TableRow>
+          options={statusOptions}
-                <TableHead className="w-[50px]"></TableHead>
+          selected={statusFilter}
-                <TableHead>Task</TableHead>
+          onChange={(values) =>
-                <TableHead>Status</TableHead>
+            updateURLParam('status', values.length > 0 ? values.join(',') : null)
-                <TableHead>Priority</TableHead>
+          }
-                <TableHead>Domain</TableHead>
+        />
-                <TableHead>Due Date</TableHead>
+        <MultiSelectFilter
-                <TableHead className="w-[50px]"></TableHead>
+          label="Priority"
-              </TableRow>
+          options={priorityOptions}
-            </TableHeader>
+          selected={priorityFilter}
-            <TableBody>
+          onChange={(values) =>
-              {tasks.map((task) => (
+            updateURLParam('priority', values.length > 0 ? values.join(',') : null)
-                <TableRow key={task.id}>
+          }
-                  <TableCell>
+        />
-                    <Checkbox
+        <Select
-                      checked={task.status === 'done'}
+          value={domainFilter}
-                      onCheckedChange={() => toggleTaskComplete(task)}
+          onValueChange={(v) => updateURLParam('domain', v || null)}
-                      aria-label={`Mark "${task.title}" as ${task.status === 'done' ? 'incomplete' : 'complete'}`}
+        >
-                    />
+          <SelectTrigger className="h-9 w-40">
-                  </TableCell>
+            <SelectValue placeholder="All domains" />
-                  <TableCell>
+          </SelectTrigger>
-                    <button
+          <SelectContent>
-                      onClick={() => setSelectedTask(task)}
+            <SelectItem value=" ">All domains</SelectItem>
-                      className={`text-left font-medium hover:underline ${
+            {Array.from(domainMap.entries()).map(([id, name]) => (
-                        task.status === 'done'
+              <SelectItem key={id} value={id}>
-                          ? 'line-through text-muted-foreground'
+                {name}
-                          : ''
+              </SelectItem>
-                      }`}
+            ))}
-                    >
+          </SelectContent>
-                      {task.title}
+        </Select>
-                    </button>
+        <div className="relative flex-1 max-w-xs">
-                  </TableCell>
+          <Search className="absolute left-2.5 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground" />
-                  <TableCell>
+          <Input
-                    <Badge variant="outline" className="text-xs capitalize">
+            placeholder="Search tasks..."
-                      {task.status.replace('_', ' ')}
+            value={searchInput}
-                    </Badge>
+            onChange={(e) => setSearchInput(e.target.value)}
-                  </TableCell>
+            className="h-9 pl-8 pr-8"
-                  <TableCell>
+          />
-                    <Badge
+          {searchInput && (
-                      variant={(priorityColors[task.priority] as any) || 'secondary'}
+            <button
-                    >
+              onClick={() => setSearchInput('')}
-                      {task.priority}
+              className="absolute right-2 top-1/2 -translate-y-1/2 text-muted-foreground hover:text-foreground"
-                    </Badge>
+            >
-                  </TableCell>
+              <X className="h-4 w-4" />
-                  <TableCell>
+            </button>
-                    <Badge variant="outline">{domainMap.get(task.domainId) || task.domainId.slice(0, 8)}</Badge>
+          )}
-                  </TableCell>
-                  <TableCell>
-                    {task.dueDate && (
-                      <span className="flex items-center gap-1 text-sm text-muted-foreground">
-                        <Calendar className="h-3 w-3" />
-                        {new Date(task.dueDate).toLocaleDateString()}
-                      </span>
-                    )}
-                  </TableCell>
-                  <TableCell>
-                    <DropdownMenu>
-                      <DropdownMenuTrigger asChild>
-                        <Button
-                          variant="ghost"
-                          size="icon"
-                          className="h-11 w-11"
-                          aria-label={`More options for ${task.title}`}
-                        >
-                          <MoreHorizontal className="h-4 w-4" aria-hidden="true" />
-                        </Button>
-                      </DropdownMenuTrigger>
-                      <DropdownMenuContent align="end">
-                        <DropdownMenuItem onClick={() => setSelectedTask(task)}>
-                          <Pencil className="mr-2 h-4 w-4" />
-                          Edit
-                        </DropdownMenuItem>
-                        <DropdownMenuItem className="text-destructive" onClick={() => setDeleteId(task.id)}>
-                          <Trash2 className="mr-2 h-4 w-4" />
-                          Delete
-                        </DropdownMenuItem>
-                      </DropdownMenuContent>
-                    </DropdownMenu>
-                  </TableCell>
-                </TableRow>
-              ))}
-            </TableBody>
-          </Table>
         </div>
-        <ScrollBar orientation="horizontal" />
+      </div>
-      </ScrollArea>
+
+      {/* Bulk action bar */}
+      {selectedIds.size > 0 && (
+        <div className="sticky top-0 z-10 mb-2 flex items-center gap-2 rounded-md border bg-background/95 p-2 backdrop-blur">
+          <span className="text-sm font-medium text-muted-foreground">
+            {selectedIds.size} selected
+          </span>
+          <div className="ml-2 flex items-center gap-1">
+            <Button
+              variant="secondary"
+              size="sm"
+              onClick={() => handleBulkStatus('done')}
+            >
+              Mark done
+            </Button>
+            <DropdownMenu open={bulkStatusOpen} onOpenChange={setBulkStatusOpen}>
+              <DropdownMenuTrigger asChild>
+                <Button variant="outline" size="sm">
+                  Set status
+                </Button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align="start">
+                {statusOptions.map((s) => (
+                  <DropdownMenuItem key={s} onClick={() => handleBulkStatus(s)}>
+                    <span className="capitalize">{s.replace('_', ' ')}</span>
+                  </DropdownMenuItem>
+                ))}
+              </DropdownMenuContent>
+            </DropdownMenu>
+            <DropdownMenu open={bulkPriorityOpen} onOpenChange={setBulkPriorityOpen}>
+              <DropdownMenuTrigger asChild>
+                <Button variant="outline" size="sm">
+                  Set priority
+                </Button>
+              </DropdownMenuTrigger>
+              <DropdownMenuContent align="start">
+                {priorityOptions.map((p) => (
+                  <DropdownMenuItem key={p} onClick={() => handleBulkPriority(p)}>
+                    <span className="capitalize">{p}</span>
+                  </DropdownMenuItem>
+                ))}
+              </DropdownMenuContent>
+            </DropdownMenu>
+            <Button
+              variant="destructive"
+              size="sm"
+              onClick={handleBulkDelete}
+              disabled={bulkDeleting}
+            >
+              {bulkDeleting ? 'Deleting...' : 'Delete'}
+            </Button>
+          </div>
+        </div>
+      )}
+
+      {tasks.length === 0 ? (
+        <div className="py-12 text-center">
+          <p className="text-muted-foreground">No tasks yet. Create your first task to get started!</p>
+        </div>
+      ) : (
+        <ScrollArea className="w-full">
+          <div className="min-w-[800px]">
+            <Table>
+              <TableHeader>
+                <TableRow>
+                  <TableHead className="w-[40px]">
+                    <Checkbox
+                      checked={allSelected}
+                      onCheckedChange={toggleSelectAll}
+                      aria-label="Select all tasks"
+                    />
+                  </TableHead>
+                  {sortableColumns.map((col) => (
+                    <TableHead
+                      key={col.key}
+                      className="cursor-pointer select-none"
+                      onClick={() => toggleSort(col.key)}
+                    >
+                      <span className="inline-flex items-center">
+                        {col.label}
+                        {getSortIcon(col.key)}
+                      </span>
+                    </TableHead>
+                  ))}
+                  <TableHead>Domain</TableHead>
+                  <TableHead className="w-[50px]"></TableHead>
+                </TableRow>
+              </TableHeader>
+              <TableBody>
+                {tasks.map((task) => (
+                  <TableRow key={task.id}>
+                    <TableCell>
+                      <Checkbox
+                        checked={selectedIds.has(task.id)}
+                        onCheckedChange={() => toggleSelect(task.id)}
+                        aria-label={`Select "${task.title}"`}
+                      />
+                    </TableCell>
+                    <TableCell>
+                      <button
+                        onClick={() => setSelectedTask(task)}
+                        className={`text-left font-medium hover:underline ${
+                          task.status === 'done'
+                            ? 'line-through text-muted-foreground'
+                            : ''
+                        }`}
+                      >
+                        {task.title}
+                      </button>
+                    </TableCell>
+                    <TableCell>
+                      <Badge variant="outline" className="text-xs capitalize">
+                        {task.status.replace('_', ' ')}
+                      </Badge>
+                    </TableCell>
+                    <TableCell>
+                      <Badge
+                        variant={(priorityColors[task.priority] as any) || 'secondary'}
+                      >
+                        {task.priority}
+                      </Badge>
+                    </TableCell>
+                    <TableCell>
+                      {task.dueDate && (
+                        <span className="flex items-center gap-1 text-sm text-muted-foreground">
+                          <Calendar className="h-3 w-3" />
+                          {new Date(task.dueDate).toLocaleDateString()}
+                        </span>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <Badge variant="outline">{domainMap.get(task.domainId) || task.domainId.slice(0, 8)}</Badge>
+                    </TableCell>
+                    <TableCell>
+                      <DropdownMenu>
+                        <DropdownMenuTrigger asChild>
+                          <Button
+                            variant="ghost"
+                            size="icon"
+                            className="h-11 w-11"
+                            aria-label={`More options for ${task.title}`}
+                          >
+                            <MoreHorizontal className="h-4 w-4" aria-hidden="true" />
+                          </Button>
+                        </DropdownMenuTrigger>
+                        <DropdownMenuContent align="end">
+                          <DropdownMenuItem onClick={() => setSelectedTask(task)}>
+                            <Pencil className="mr-2 h-4 w-4" />
+                            Edit
+                          </DropdownMenuItem>
+                          <DropdownMenuItem className="text-destructive" onClick={() => setDeleteId(task.id)}>
+                            <Trash2 className="mr-2 h-4 w-4" />
+                            Delete
+                          </DropdownMenuItem>
+                        </DropdownMenuContent>
+                      </DropdownMenu>
+                    </TableCell>
+                  </TableRow>
+                ))}
+              </TableBody>
+            </Table>
+          </div>
+          <ScrollBar orientation="horizontal" />
+        </ScrollArea>
+      )}
 
       <AlertDialog open={!!deleteId} onOpenChange={(o) => !o && setDeleteId(null)}>
         <AlertDialogContent>