feat(#37-41): Add domains, ideas, relationships, agents, widgets schema

Schema additions for issues #37-41:

New models:
- Domain (#37): Life domains (work, marriage, homelab, etc.)
- Idea (#38): Brain dumps with pgvector embeddings
- Relationship (#39): Generic entity linking (blocks, depends_on)
- Agent (#40): ClawdBot agent tracking with metrics
- AgentSession (#40): Conversation session tracking
- WidgetDefinition (#41): HUD widget registry
- UserLayout (#41): Per-user dashboard configuration

Updated models:
- Task, Event, Project: Added domainId foreign key
- User, Workspace: Added new relations

New enums:
- IdeaStatus: CAPTURED, PROCESSING, ACTIONABLE, ARCHIVED, DISCARDED
- RelationshipType: BLOCKS, BLOCKED_BY, DEPENDS_ON, etc.
- AgentStatus: IDLE, WORKING, WAITING, ERROR, TERMINATED
- EntityType: Added IDEA, DOMAIN

Migration: 20260129182803_add_domains_ideas_agents_widgets

apps/web/src/lib/api/tasks.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { fetchTasks } from "./tasks";
+import type { Task } from "@mosaic/shared";
+
+// Mock the API client
+vi.mock("./client", () => ({
+  apiGet: vi.fn(),
+}));
+
+const { apiGet } = await import("./client");
+
+describe("Task API Client", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should fetch tasks successfully", async () => {
+    const mockTasks: Task[] = [
+      {
+        id: "task-1",
+        title: "Complete project setup",
+        description: "Set up the development environment",
+        status: "active",
+        priority: "high",
+        dueDate: new Date("2026-02-01"),
+        creatorId: "user-1",
+        assigneeId: "user-1",
+        workspaceId: "workspace-1",
+        projectId: null,
+        parentId: null,
+        sortOrder: 0,
+        metadata: {},
+        completedAt: null,
+        createdAt: new Date("2026-01-28"),
+        updatedAt: new Date("2026-01-28"),
+      },
+      {
+        id: "task-2",
+        title: "Review documentation",
+        description: "Review and update project docs",
+        status: "upcoming",
+        priority: "medium",
+        dueDate: new Date("2026-02-05"),
+        creatorId: "user-1",
+        assigneeId: "user-1",
+        workspaceId: "workspace-1",
+        projectId: null,
+        parentId: null,
+        sortOrder: 1,
+        metadata: {},
+        completedAt: null,
+        createdAt: new Date("2026-01-28"),
+        updatedAt: new Date("2026-01-28"),
+      },
+    ];
+
+    vi.mocked(apiGet).mockResolvedValueOnce({ data: mockTasks });
+
+    const result = await fetchTasks();
+
+    expect(apiGet).toHaveBeenCalledWith("/api/tasks");
+    expect(result).toEqual(mockTasks);
+  });
+
+  it("should handle errors when fetching tasks", async () => {
+    vi.mocked(apiGet).mockRejectedValueOnce(new Error("Network error"));
+
+    await expect(fetchTasks()).rejects.toThrow("Network error");
+  });
+
+  it("should fetch tasks with filters", async () => {
+    const mockTasks: Task[] = [];
+    vi.mocked(apiGet).mockResolvedValueOnce({ data: mockTasks });
+
+    await fetchTasks({ status: "active" });
+
+    expect(apiGet).toHaveBeenCalledWith("/api/tasks?status=active");
+  });
+
+  it("should fetch tasks with multiple filters", async () => {
+    const mockTasks: Task[] = [];
+    vi.mocked(apiGet).mockResolvedValueOnce({ data: mockTasks });
+
+    await fetchTasks({ status: "active", priority: "high" });
+
+    expect(apiGet).toHaveBeenCalledWith(
+      "/api/tasks?status=active&priority=high"
+    );
+  });
+
+  describe("error handling", () => {
+    it("should handle network errors when fetching tasks", async () => {
+      vi.mocked(apiGet).mockRejectedValueOnce(
+        new Error("Network request failed")
+      );
+
+      await expect(fetchTasks()).rejects.toThrow("Network request failed");
+    });
+
+    it("should handle API returning malformed data", async () => {
+      vi.mocked(apiGet).mockResolvedValueOnce({
+        data: null,
+      });
+
+      const result = await fetchTasks();
+
+      expect(result).toBeNull();
+    });
+
+    it("should handle auth token expiration (401 error)", async () => {
+      vi.mocked(apiGet).mockRejectedValueOnce(
+        new Error("Authentication required")
+      );
+
+      await expect(fetchTasks()).rejects.toThrow("Authentication required");
+    });
+
+    it("should handle server 500 errors", async () => {
+      vi.mocked(apiGet).mockRejectedValueOnce(
+        new Error("Internal server error")
+      );
+
+      await expect(fetchTasks()).rejects.toThrow("Internal server error");
+    });
+
+    it("should handle forbidden access (403 error)", async () => {
+      vi.mocked(apiGet).mockRejectedValueOnce(new Error("Access denied"));
+
+      await expect(fetchTasks()).rejects.toThrow("Access denied");
+    });
+
+    it("should handle rate limiting errors", async () => {
+      vi.mocked(apiGet).mockRejectedValueOnce(
+        new Error("Too many requests. Please try again later.")
+      );
+
+      await expect(fetchTasks()).rejects.toThrow(
+        "Too many requests. Please try again later."
+      );
+    });
+
+    it("should ignore malformed filter parameters", async () => {
+      const mockTasks: Task[] = [];
+      vi.mocked(apiGet).mockResolvedValueOnce({ data: mockTasks });
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await fetchTasks({ invalidFilter: "value" } as any);
+
+      // Function should ignore invalid filters and call without query params
+      expect(apiGet).toHaveBeenCalledWith("/api/tasks");
+    });
+
+    it("should handle empty response data", async () => {
+      vi.mocked(apiGet).mockResolvedValueOnce({});
+
+      const result = await fetchTasks();
+
+      expect(result).toBeUndefined();
+    });
+
+    it("should handle timeout errors", async () => {
+      vi.mocked(apiGet).mockRejectedValueOnce(new Error("Request timeout"));
+
+      await expect(fetchTasks()).rejects.toThrow("Request timeout");
+    });
+  });
+});