diff --git a/apps/api/src/index.ts b/apps/api/src/index.ts
index ff5c964..ac57753 100644
--- a/apps/api/src/index.ts
+++ b/apps/api/src/index.ts
@@ -28,6 +28,7 @@ import { importExportRoutes } from "./routes/import-export";
 import { notificationRoutes } from "./routes/notifications";
 import { stateRoutes } from "./routes/states";
 import { moduleRoutes } from "./routes/modules";
+import { cycleRoutes } from "./routes/cycles";
 import { linkRoutes } from "./routes/links";
 import { healthHandler } from "./routes/health";
 
@@ -49,6 +50,8 @@ app.route("/api/auth", authRoutes);
 app.route("/api/domains", domainRoutes);
 app.route("/api/projects/:projectId/modules", moduleRoutes);
 app.route("/api/modules", moduleRoutes);
+app.route("/api/projects/:projectId/cycles", cycleRoutes);
+app.route("/api/cycles", cycleRoutes);
 app.route("/api/tasks", taskRoutes);
 app.route("/api/habits", habitRoutes);
 app.route("/api/projects", projectRoutes);
diff --git a/apps/api/src/routes/cycles.ts b/apps/api/src/routes/cycles.ts
new file mode 100644
index 0000000..5756359
--- /dev/null
+++ b/apps/api/src/routes/cycles.ts
@@ -0,0 +1,374 @@
+import { Hono } from "hono";
+import { db, cycles, tasks, projects } from "@project-e/db";
+import { and, asc, eq, isNull, sql } from "drizzle-orm";
+import { requireAuth, requireWorkspaceAccess, AuthError, isUuid } from "../middleware/auth";
+import { recordActivity } from "../middleware/activity";
+import { enqueueWebhooks } from "../middleware/webhook-queue";
+import { z } from "zod";
+
+export const cycleRoutes = new Hono();
+
+const createCycleSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  startDate: z.string().datetime().optional().nullable(),
+  endDate: z.string().datetime().optional().nullable(),
+  active: z.boolean().optional().default(false),
+});
+
+const updateCycleSchema = z.object({
+  name: z.string().min(1).optional(),
+  startDate: z.string().datetime().optional().nullable(),
+  endDate: z.string().datetime().optional().nullable(),
+  active: z.boolean().optional(),
+});
+
+// GET / — List cycles for a project
+cycleRoutes.get("/", async (c) => {
+  try {
+    const user = await requireAuth(c);
+    const url = new URL(c.req.url);
+    const projectId = c.req.param("projectId") || url.searchParams.get("project_id");
+
+    if (!projectId || !isUuid(projectId)) {
+      return c.json({ error: { code: "VALIDATION_ERROR", message: "project_id is required" } }, 400);
+    }
+
+    const [project] = await db.select({ id: projects.id, domainId: projects.domainId })
+      .from(projects)
+      .where(and(eq(projects.id, projectId), isNull(projects.deletedAt)))
+      .limit(1);
+
+    if (!project) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Project not found" } }, 404);
+    }
+
+    await requireWorkspaceAccess(c, project.domainId);
+
+    const items = await db.select()
+      .from(cycles)
+      .where(eq(cycles.projectId, projectId))
+      .orderBy(asc(cycles.createdAt));
+
+    return c.json({ items });
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
+    }
+    console.error("[cycles] GET error:", error);
+    return c.json({ error: { code: "INTERNAL_ERROR", message: "Failed to list cycles" } }, 500);
+  }
+});
+
+// POST / — Create a cycle
+cycleRoutes.post("/", async (c) => {
+  try {
+    const user = await requireAuth(c);
+    const body = await c.req.json();
+    const data = createCycleSchema.parse(body);
+
+    const projectId = c.req.param("projectId");
+    if (!projectId || !isUuid(projectId)) {
+      return c.json({ error: { code: "VALIDATION_ERROR", message: "project_id is required in URL path" } }, 400);
+    }
+
+    const [project] = await db.select({ id: projects.id, domainId: projects.domainId })
+      .from(projects)
+      .where(and(eq(projects.id, projectId), isNull(projects.deletedAt)))
+      .limit(1);
+
+    if (!project) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Project not found" } }, 404);
+    }
+
+    await requireWorkspaceAccess(c, project.domainId);
+
+    const [cycle] = await db.insert(cycles).values({
+      name: data.name,
+      projectId,
+      startDate: data.startDate ? new Date(data.startDate) : null,
+      endDate: data.endDate ? new Date(data.endDate) : null,
+      active: data.active,
+    }).returning();
+
+    await recordActivity({
+      actor: user.name,
+      action: "created",
+      entityType: "cycle",
+      entityId: cycle.id,
+      changes: { name: cycle.name, projectId },
+      workspaceId: project.domainId,
+    });
+
+    await enqueueWebhooks({ workspaceId: project.domainId, event: "cycle.created", entityType: "cycle", entityId: cycle.id, data: { name: cycle.name, projectId } });
+
+    return c.json(cycle, 201);
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
+    }
+    if (error instanceof z.ZodError) {
+      return c.json({ error: { code: "VALIDATION_ERROR", message: "Invalid input", details: error.issues } }, 400);
+    }
+    console.error("[cycles] POST error:", error);
+    return c.json({ error: { code: "INTERNAL_ERROR", message: "Failed to create cycle" } }, 500);
+  }
+});
+
+// GET /:id — Get a single cycle with its tasks
+cycleRoutes.get("/:id", async (c) => {
+  try {
+    const user = await requireAuth(c);
+    const id = c.req.param("id");
+    if (!isUuid(id)) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Resource not found" } }, 404);
+    }
+
+    const [cycle] = await db.select()
+      .from(cycles)
+      .where(eq(cycles.id, id))
+      .limit(1);
+
+    if (!cycle) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Cycle not found" } }, 404);
+    }
+
+    const [project] = await db.select({ domainId: projects.domainId })
+      .from(projects)
+      .where(eq(projects.id, cycle.projectId))
+      .limit(1);
+
+    await requireWorkspaceAccess(c, project?.domainId || "");
+
+    const cycleTasks = await db.select()
+      .from(tasks)
+      .where(and(eq(tasks.cycleId, id), isNull(tasks.deletedAt)))
+      .orderBy(asc(tasks.order));
+
+    return c.json({ ...cycle, tasks: cycleTasks });
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
+    }
+    console.error("[cycles] GET/:id error:", error);
+    return c.json({ error: { code: "INTERNAL_ERROR", message: "Failed to get cycle" } }, 500);
+  }
+});
+
+// PATCH /:id — Update a cycle
+cycleRoutes.patch("/:id", async (c) => {
+  try {
+    const user = await requireAuth(c);
+    const id = c.req.param("id");
+    if (!isUuid(id)) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Resource not found" } }, 404);
+    }
+    const body = await c.req.json();
+    const data = updateCycleSchema.parse(body);
+
+    const [existing] = await db.select()
+      .from(cycles)
+      .where(eq(cycles.id, id))
+      .limit(1);
+
+    if (!existing) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Cycle not found" } }, 404);
+    }
+
+    const [project] = await db.select({ domainId: projects.domainId })
+      .from(projects)
+      .where(eq(projects.id, existing.projectId))
+      .limit(1);
+
+    await requireWorkspaceAccess(c, project?.domainId || "");
+
+    const updateValues: Record<string, unknown> = {};
+    if (data.name !== undefined) updateValues.name = data.name;
+    if (data.startDate !== undefined) updateValues.startDate = data.startDate ? new Date(data.startDate) : null;
+    if (data.endDate !== undefined) updateValues.endDate = data.endDate ? new Date(data.endDate) : null;
+    if (data.active !== undefined) updateValues.active = data.active;
+    updateValues.updatedAt = new Date();
+
+    const [updated] = await db.update(cycles)
+      .set(updateValues)
+      .where(eq(cycles.id, id))
+      .returning();
+
+    await recordActivity({
+      actor: user.name,
+      action: "updated",
+      entityType: "cycle",
+      entityId: id,
+      changes: { ...data, previousName: existing.name },
+      workspaceId: project?.domainId || "",
+    });
+
+    await enqueueWebhooks({ workspaceId: project?.domainId || "", event: "cycle.updated", entityType: "cycle", entityId: id, data: { ...data } });
+
+    return c.json(updated);
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
+    }
+    if (error instanceof z.ZodError) {
+      return c.json({ error: { code: "VALIDATION_ERROR", message: "Invalid input", details: error.issues } }, 400);
+    }
+    console.error("[cycles] PATCH error:", error);
+    return c.json({ error: { code: "INTERNAL_ERROR", message: "Failed to update cycle" } }, 500);
+  }
+});
+
+// DELETE /:id — Delete a cycle
+cycleRoutes.delete("/:id", async (c) => {
+  try {
+    const user = await requireAuth(c);
+    const id = c.req.param("id");
+    if (!isUuid(id)) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Resource not found" } }, 404);
+    }
+
+    const [existing] = await db.select()
+      .from(cycles)
+      .where(eq(cycles.id, id))
+      .limit(1);
+
+    if (!existing) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Cycle not found" } }, 404);
+    }
+
+    const [project] = await db.select({ domainId: projects.domainId })
+      .from(projects)
+      .where(eq(projects.id, existing.projectId))
+      .limit(1);
+
+    const workspaceId = project?.domainId || "";
+    await requireWorkspaceAccess(c, workspaceId);
+
+    // Clear cycleId on tasks belonging to this cycle
+    await db.update(tasks)
+      .set({ cycleId: null, updatedAt: new Date() })
+      .where(eq(tasks.cycleId, id));
+
+    await db.delete(cycles).where(eq(cycles.id, id));
+
+    await recordActivity({
+      actor: user.name,
+      action: "deleted",
+      entityType: "cycle",
+      entityId: id,
+      changes: { name: existing.name, projectId: existing.projectId },
+      workspaceId,
+    });
+
+    await enqueueWebhooks({ workspaceId, event: "cycle.deleted", entityType: "cycle", entityId: id, data: { name: existing.name } });
+
+    return c.body(null, 204);
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
+    }
+    console.error("[cycles] DELETE error:", error);
+    return c.json({ error: { code: "INTERNAL_ERROR", message: "Failed to delete cycle" } }, 500);
+  }
+});
+
+// POST /:id/tasks — Add a task to this cycle
+cycleRoutes.post("/:id/tasks", async (c) => {
+  try {
+    const user = await requireAuth(c);
+    const cycleId = c.req.param("id");
+    if (!isUuid(cycleId)) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Resource not found" } }, 404);
+    }
+    const body = await c.req.json();
+    const { taskId } = z.object({ taskId: z.string().uuid("Invalid task id") }).parse(body);
+
+    const [cycle] = await db.select()
+      .from(cycles)
+      .where(eq(cycles.id, cycleId))
+      .limit(1);
+
+    if (!cycle) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Cycle not found" } }, 404);
+    }
+
+    const [project] = await db.select({ domainId: projects.domainId })
+      .from(projects)
+      .where(eq(projects.id, cycle.projectId))
+      .limit(1);
+
+    await requireWorkspaceAccess(c, project?.domainId || "");
+
+    await db.update(tasks)
+      .set({ cycleId, updatedAt: new Date() })
+      .where(eq(tasks.id, taskId));
+
+    await recordActivity({
+      actor: user.name,
+      action: "added_task",
+      entityType: "cycle",
+      entityId: cycleId,
+      changes: { taskId },
+      workspaceId: project?.domainId || "",
+    });
+
+    return c.json({ success: true }, 201);
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
+    }
+    if (error instanceof z.ZodError) {
+      return c.json({ error: { code: "VALIDATION_ERROR", message: "Invalid input", details: error.issues } }, 400);
+    }
+    console.error("[cycles] POST /:id/tasks error:", error);
+    return c.json({ error: { code: "INTERNAL_ERROR", message: "Failed to add task to cycle" } }, 500);
+  }
+});
+
+// DELETE /:id/tasks/:taskId — Remove a task from this cycle
+cycleRoutes.delete("/:id/tasks/:taskId", async (c) => {
+  try {
+    const user = await requireAuth(c);
+    const cycleId = c.req.param("id");
+    const taskId = c.req.param("taskId");
+    if (!isUuid(cycleId) || !isUuid(taskId)) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Resource not found" } }, 404);
+    }
+
+    const [cycle] = await db.select()
+      .from(cycles)
+      .where(eq(cycles.id, cycleId))
+      .limit(1);
+
+    if (!cycle) {
+      return c.json({ error: { code: "NOT_FOUND", message: "Cycle not found" } }, 404);
+    }
+
+    const [project] = await db.select({ domainId: projects.domainId })
+      .from(projects)
+      .where(eq(projects.id, cycle.projectId))
+      .limit(1);
+
+    await requireWorkspaceAccess(c, project?.domainId || "");
+
+    await db.update(tasks)
+      .set({ cycleId: null, updatedAt: new Date() })
+      .where(eq(tasks.id, taskId));
+
+    await recordActivity({
+      actor: user.name,
+      action: "removed_task",
+      entityType: "cycle",
+      entityId: cycleId,
+      changes: { taskId },
+      workspaceId: project?.domainId || "",
+    });
+
+    return c.body(null, 204);
+  } catch (error) {
+    if (error instanceof AuthError) {
+      return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
+    }
+    console.error("[cycles] DELETE /:id/tasks/:taskId error:", error);
+    return c.json({ error: { code: "INTERNAL_ERROR", message: "Failed to remove task from cycle" } }, 500);
+  }
+});
diff --git a/apps/api/src/routes/graph.ts b/apps/api/src/routes/graph.ts
index ceba2b5..54af011 100644
--- a/apps/api/src/routes/graph.ts
+++ b/apps/api/src/routes/graph.ts
@@ -1,6 +1,6 @@
 import { Hono } from "hono";
 import { db, domains, notes, tasks, habits, projects, sections, tags as tagsTable, links } from "@project-e/db";
-import { and, eq, inArray, isNull } from "drizzle-orm";
+import { and, eq, inArray, isNull, or } from "drizzle-orm";
 import { requireAuth, requireWorkspaceAccess, AuthError } from "../middleware/auth";
 import { recordActivity } from "../middleware/activity";
 import { z } from "zod";
@@ -57,11 +57,11 @@ async function getGraphData(domainId: string): Promise<{ nodes: GraphNode[]; edg
   for (const s of sectionRows) addNode(s.id, s.name, 'section');
   for (const t of tagRows) addNode(t.id, t.name, 'tag');
 
-  // Read links from the canonical links table
-  const allIds = [...noteRows.map(n => n.id), ...taskRows.map(t => t.id)];
+  // Read links from the canonical links table (both directions)
+  const allIds = [...noteRows.map(n => n.id), ...taskRows.map(t => t.id), ...projectRows.map(p => p.id), ...sectionRows.map(s => s.id)];
   if (allIds.length > 0) {
     const linkRows = await db.select().from(links)
-      .where(inArray(links.sourceId, allIds));
+      .where(or(inArray(links.sourceId, allIds), inArray(links.targetId, allIds)));
     for (const l of linkRows) addEdge(l.sourceId, l.targetId, l.linkType);
   }
 
diff --git a/apps/api/src/routes/links.ts b/apps/api/src/routes/links.ts
index 3f2863b..fead6b8 100644
--- a/apps/api/src/routes/links.ts
+++ b/apps/api/src/routes/links.ts
@@ -1,136 +1,58 @@
 import { Hono } from "hono";
-import { db, links, tasks, projects } from "@project-e/db";
-import { and, asc, desc, eq, ilike, inArray, isNull, or, sql } from "drizzle-orm";
+import { db, links, tasks, notes, projects } from "@project-e/db";
+import { and, eq, inArray, isNull, or } from "drizzle-orm";
 import { requireAuth, requireWorkspaceAccess, AuthError, isUuid } from "../middleware/auth";
 import { recordActivity } from "../middleware/activity";
-import { enqueueWebhooks } from "../middleware/webhook-queue";
 import { z } from "zod";
 
 export const linkRoutes = new Hono();
 
-const linkTypeEnum = z.enum(["relates", "blocks", "parent-child", "created-from"]);
-
 const createLinkSchema = z.object({
-  sourceType: z.string().min(1, "Source type is required"),
-  sourceId: z.string().uuid("Invalid source id"),
-  targetType: z.string().min(1, "Target type is required"),
-  targetId: z.string().uuid("Invalid target id"),
-  linkType: linkTypeEnum,
+  sourceType: z.string().min(1),
+  sourceId: z.string().uuid(),
+  targetType: z.string().min(1),
+  targetId: z.string().uuid(),
+  linkType: z.enum(["relates", "blocks", "parent-child", "created-from"]),
   direction: z.string().optional().nullable(),
 });
 
-// GET / — List links for an entity (bidirectional)
-// Filters: source_type+source_id OR target_type+target_id (at least one pair required)
+async function resolveWorkspaceId(entityType: string, entityId: string): Promise<string | null> {
+  if (entityType === "task") {
+    const [row] = await db.select({ domainId: tasks.domainId }).from(tasks).where(eq(tasks.id, entityId)).limit(1);
+    return row?.domainId ?? null;
+  }
+  if (entityType === "note") {
+    const [row] = await db.select({ domainId: notes.domainId }).from(notes).where(eq(notes.id, entityId)).limit(1);
+    return row?.domainId ?? null;
+  }
+  return null;
+}
+
+// GET /api/links — List links for an entity (either source OR target)
 linkRoutes.get("/", async (c) => {
   try {
     const user = await requireAuth(c);
     const url = new URL(c.req.url);
-    const sourceType = url.searchParams.get("source_type");
-    const sourceId = url.searchParams.get("source_id");
-    const targetType = url.searchParams.get("target_type");
-    const targetId = url.searchParams.get("target_id");
-    const linkType = url.searchParams.get("link_type");
-    const sort = url.searchParams.get("sort") || "-created";
-    const limit = Math.min(parseInt(url.searchParams.get("limit") || "50"), 200);
-    const offset = parseInt(url.searchParams.get("offset") || "0");
+    const entityType = url.searchParams.get("entityType");
+    const entityId = url.searchParams.get("entityId");
 
-    // Need at least one filter pair
-    if ((!sourceType || !sourceId) && (!targetType || !targetId)) {
-      return c.json(
-        { error: { code: "VALIDATION_ERROR", message: "Provide at least source_type+source_id or target_type+target_id" } },
-        400
-      );
+    if (!entityType || !entityId) {
+      return c.json({ error: { code: "VALIDATION_ERROR", message: "entityType and entityId query parameters are required" } }, 400);
     }
 
-    if (sourceId && !isUuid(sourceId)) {
-      return c.json({ error: { code: "VALIDATION_ERROR", message: "Invalid source_id" } }, 400);
-    }
-    if (targetId && !isUuid(targetId)) {
-      return c.json({ error: { code: "VALIDATION_ERROR", message: "Invalid target_id" } }, 400);
+    const workspaceId = await resolveWorkspaceId(entityType, entityId);
+    if (workspaceId) {
+      await requireWorkspaceAccess(c, workspaceId);
     }
 
-    // Resolve workspace access from the entity referenced
-    const resolveEntityDomainId = async (entityType: string, entityId: string): Promise<string | null> => {
-      if (entityType === "task") {
-        const [task] = await db.select({ domainId: tasks.domainId })
-          .from(tasks)
-          .where(eq(tasks.id, entityId))
-          .limit(1);
-        return task?.domainId ?? null;
-      }
-      if (entityType === "project") {
-        const [project] = await db.select({ domainId: projects.domainId })
-          .from(projects)
-          .where(eq(projects.id, entityId))
-          .limit(1);
-        return project?.domainId ?? null;
-      }
-      return null;
-    };
+    const items = await db.select()
+      .from(links)
+      .where(or(
+        and(eq(links.sourceType, entityType), eq(links.sourceId, entityId)),
+        and(eq(links.targetType, entityType), eq(links.targetId, entityId)),
+      ));
 
-    const filterEntityType = sourceType || targetType || "task";
-    const filterEntityId = sourceId || targetId || "";
-    const domainId = await resolveEntityDomainId(filterEntityType, filterEntityId);
-
-    if (domainId) {
-      await requireWorkspaceAccess(c, domainId);
-    }
-
-    // Bidirectional: if filtering by source, also find links where entity is target
-    const conditions: any[] = [];
-
-    if (sourceType && sourceId) {
-      conditions.push(
-        or(
-          and(eq(links.sourceType, sourceType), eq(links.sourceId, sourceId)),
-          and(eq(links.targetType, sourceType), eq(links.targetId, sourceId)),
-        )!
-      );
-    } else if (targetType && targetId) {
-      conditions.push(
-        or(
-          and(eq(links.sourceType, targetType), eq(links.sourceId, targetId)),
-          and(eq(links.targetType, targetType), eq(links.targetId, targetId)),
-        )!
-      );
-    }
-
-    if (linkType) {
-      const types = linkType.split(",");
-      conditions.push(inArray(links.linkType, types as any));
-    }
-
-    const sortDir = sort.startsWith("-") ? "desc" : "asc";
-    const sortField = sort.replace(/^-/, "");
-    const sortColumns: Record<string, any> = {
-      created: links.createdAt,
-      created_at: links.createdAt,
-    };
-    const orderColumn = sortDir === "asc"
-      ? asc(sortColumns[sortField] || links.createdAt)
-      : desc(sortColumns[sortField] || links.createdAt);
-
-    const [items, countResult] = await Promise.all([
-      db.select()
-        .from(links)
-        .where(and(...conditions))
-        .orderBy(orderColumn)
-        .limit(limit)
-        .offset(offset),
-      db.select({ count: sql<number>`count(*)` })
-        .from(links)
-        .where(and(...conditions)),
-    ]);
-
-    const totalItems = Number(countResult[0]?.count || 0);
-
-    return c.json({
-      items,
-      totalItems,
-      totalPages: Math.ceil(totalItems / limit),
-      limit,
-      offset,
-    });
+    return c.json({ items });
   } catch (error) {
     if (error instanceof AuthError) {
       return c.json({ error: { code: error.code, message: error.message } }, error.status as any);
@@ -140,52 +62,35 @@ linkRoutes.get("/", async (c) => {
   }
 });
 
-// POST / — Create a link
+// POST /api/links — Create a link between two entities
 linkRoutes.post("/", async (c) => {
   try {
     const user = await requireAuth(c);
     const body = await c.req.json();
     const data = createLinkSchema.parse(body);
 
-    // Enforce unique constraint on (sourceType, sourceId, targetType, targetId, linkType)
-    const [existing] = await db.select()
+    // Prevent self-links
+    if (data.sourceId === data.targetId) {
+      return c.json({ error: { code: "VALIDATION_ERROR", message: "Cannot link an entity to itself" } }, 400);
+    }
+
+    // Check for duplicate link
+    const [existing] = await db.select({ id: links.id })
       .from(links)
-      .where(
-        and(
-          eq(links.sourceType, data.sourceType),
-          eq(links.sourceId, data.sourceId),
-          eq(links.targetType, data.targetType),
-          eq(links.targetId, data.targetId),
-          eq(links.linkType, data.linkType),
-        )
-      )
+      .where(and(
+        eq(links.sourceId, data.sourceId),
+        eq(links.targetId, data.targetId),
+        eq(links.linkType, data.linkType),
+      ))
       .limit(1);
 
     if (existing) {
-      return c.json(
-        { error: { code: "CONFLICT", message: "Link already exists with this combination" } },
-        409
-      );
+      return c.json({ error: { code: "CONFLICT", message: "Link already exists" } }, 409);
     }
 
-    // Resolve workspace access from the source entity
-    let domainId: string | null = null;
-    if (data.sourceType === "task") {
-      const [task] = await db.select({ domainId: tasks.domainId })
-        .from(tasks)
-        .where(eq(tasks.id, data.sourceId))
-        .limit(1);
-      domainId = task?.domainId ?? null;
-    } else if (data.sourceType === "project") {
-      const [project] = await db.select({ domainId: projects.domainId })
-        .from(projects)
-        .where(eq(projects.id, data.sourceId))
-        .limit(1);
-      domainId = project?.domainId ?? null;
-    }
-
-    if (domainId) {
-      await requireWorkspaceAccess(c, domainId);
+    const workspaceId = await resolveWorkspaceId(data.sourceType, data.sourceId);
+    if (workspaceId) {
+      await requireWorkspaceAccess(c, workspaceId);
     }
 
     const [link] = await db.insert(links).values({
@@ -197,34 +102,14 @@ linkRoutes.post("/", async (c) => {
       direction: data.direction ?? null,
     }).returning();
 
-    if (domainId) {
+    if (workspaceId) {
       await recordActivity({
         actor: user.name,
         action: "created",
         entityType: "link",
         entityId: link.id,
-        changes: {
-          sourceType: link.sourceType,
-          sourceId: link.sourceId,
-          targetType: link.targetType,
-          targetId: link.targetId,
-          linkType: link.linkType,
-        },
-        workspaceId: domainId,
-      });
-
-      await enqueueWebhooks({
-        workspaceId: domainId,
-        event: "link.created",
-        entityType: "link",
-        entityId: link.id,
-        data: {
-          sourceType: link.sourceType,
-          sourceId: link.sourceId,
-          targetType: link.targetType,
-          targetId: link.targetId,
-          linkType: link.linkType,
-        },
+        changes: { sourceType: data.sourceType, sourceId: data.sourceId, targetType: data.targetType, targetId: data.targetId, linkType: data.linkType },
+        workspaceId,
       });
     }
 
@@ -241,7 +126,7 @@ linkRoutes.post("/", async (c) => {
   }
 });
 
-// DELETE /:id — Delete a link (hard delete, links have no deletedAt)
+// DELETE /api/links/:id — Remove a link
 linkRoutes.delete("/:id", async (c) => {
   try {
     const user = await requireAuth(c);
@@ -259,57 +144,21 @@ linkRoutes.delete("/:id", async (c) => {
       return c.json({ error: { code: "NOT_FOUND", message: "Link not found" } }, 404);
     }
 
-    // Resolve workspace access from the source entity
-    let domainId: string | null = null;
-    if (existing.sourceType === "task") {
-      const [task] = await db.select({ domainId: tasks.domainId })
-        .from(tasks)
-        .where(eq(tasks.id, existing.sourceId))
-        .limit(1);
-      domainId = task?.domainId ?? null;
-    } else if (existing.sourceType === "project") {
-      const [project] = await db.select({ domainId: projects.domainId })
-        .from(projects)
-        .where(eq(projects.id, existing.sourceId))
-        .limit(1);
-      domainId = project?.domainId ?? null;
+    const workspaceId = await resolveWorkspaceId(existing.sourceType, existing.sourceId);
+    if (workspaceId) {
+      await requireWorkspaceAccess(c, workspaceId);
     }
 
-    if (domainId) {
-      await requireWorkspaceAccess(c, domainId);
-    }
-
-    // Hard delete — junction rows with no deletedAt column
     await db.delete(links).where(eq(links.id, id));
 
-    if (domainId) {
+    if (workspaceId) {
       await recordActivity({
         actor: user.name,
         action: "deleted",
         entityType: "link",
         entityId: id,
-        changes: {
-          sourceType: existing.sourceType,
-          sourceId: existing.sourceId,
-          targetType: existing.targetType,
-          targetId: existing.targetId,
-          linkType: existing.linkType,
-        },
-        workspaceId: domainId,
-      });
-
-      await enqueueWebhooks({
-        workspaceId: domainId,
-        event: "link.deleted",
-        entityType: "link",
-        entityId: id,
-        data: {
-          sourceType: existing.sourceType,
-          sourceId: existing.sourceId,
-          targetType: existing.targetType,
-          targetId: existing.targetId,
-          linkType: existing.linkType,
-        },
+        changes: { sourceType: existing.sourceType, sourceId: existing.sourceId, targetType: existing.targetType, targetId: existing.targetId },
+        workspaceId,
       });
     }
 
diff --git a/apps/api/src/routes/mcp.ts b/apps/api/src/routes/mcp.ts
index 8f009c0..0cacc62 100644
--- a/apps/api/src/routes/mcp.ts
+++ b/apps/api/src/routes/mcp.ts
@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { createHash } from "node:crypto";
-import { db, apiKeys, users, tasks, taskTags, tags as tagsTable, habits, habitCompletions, projects, notes, domains, activityFeed, webhooks, webhookDeliveries, states, modules, cycles, links } from "@project-e/db";
-import { and, asc, desc, eq, exists, ilike, inArray, isNull, or, sql } from "drizzle-orm";
+import { db, apiKeys, users, tasks, taskTags, tags as tagsTable, habits, habitCompletions, projects, notes, domains, activityFeed, webhooks, webhookDeliveries } from "@project-e/db";
+import { and, asc, desc, eq, ilike, isNull, or } from "drizzle-orm";
 import { recordActivity } from "../middleware/activity";
 
 export const mcpRoutes = new Hono();
@@ -81,12 +81,9 @@ const tools: ToolDefinition[] = [
       type: "object",
       properties: {
         domain_id: { type: "string", description: "Workspace/domain ID" },
-        state_id: { type: "string", description: "Filter by state UUID" },
-        state_group: { type: "string", enum: ["backlog", "unstarted", "started", "completed", "cancelled"], description: "Filter by state group" },
+        status: { type: "string", enum: ["todo", "in_progress", "done", "cancelled"] },
         priority: { type: "string", enum: ["low", "medium", "high", "urgent"] },
         project_id: { type: "string" },
-        module_id: { type: "string", description: "Filter by module UUID" },
-        cycle_id: { type: "string", description: "Filter by cycle UUID" },
         search: { type: "string" },
         limit: { type: "number", default: 50 },
         offset: { type: "number", default: 0 },
@@ -98,24 +95,9 @@ const tools: ToolDefinition[] = [
         eq(tasks.domainId, params.domain_id as string),
         isNull(tasks.deletedAt),
       ];
-      if (params.state_id) {
-        const stateIds = (params.state_id as string).split(",");
-        conditions.push(inArray(tasks.stateId, stateIds));
-      }
-      if (params.state_group) {
-        const groups = (params.state_group as string).split(",") as any[];
-        conditions.push(
-          exists(
-            db.select({ one: sql`1` })
-              .from(states)
-              .where(and(eq(states.id, tasks.stateId), inArray(states.group, groups)))
-          )
-        );
-      }
+      // TODO(phase-2): filter by state_group / state_id instead of old status
       if (params.priority) conditions.push(eq(tasks.priority, params.priority as any));
       if (params.project_id) conditions.push(eq(tasks.projectId, params.project_id as string));
-      if (params.module_id) conditions.push(eq(tasks.moduleId, params.module_id as string));
-      if (params.cycle_id) conditions.push(eq(tasks.cycleId, params.cycle_id as string));
       if (params.search) conditions.push(ilike(tasks.title, `%${params.search}%`));
 
       const items = await db.select()
@@ -137,38 +119,21 @@ const tools: ToolDefinition[] = [
         domain_id: { type: "string", description: "Workspace/domain ID" },
         title: { type: "string" },
         description: { type: "string" },
-        state_id: { type: "string", description: "State UUID" },
+        status: { type: "string" },
         priority: { type: "string", enum: ["low", "medium", "high", "urgent"] },
         due_date: { type: "string" },
         project_id: { type: "string" },
-        module_id: { type: "string", description: "Module UUID" },
-        cycle_id: { type: "string", description: "Cycle UUID" },
       },
       required: ["domain_id", "title"],
     },
     handler: async (params, auth) => {
-      let completedAt: Date | null = null;
-      if (params.state_id) {
-        const [state] = await db.select({ id: states.id, group: states.group })
-          .from(states)
-          .where(eq(states.id, params.state_id as string))
-          .limit(1);
-        if (state?.group === "completed") {
-          completedAt = new Date();
-        }
-      }
-
       const [task] = await db.insert(tasks).values({
         title: params.title as string,
         description: (params.description as string) ?? null,
         priority: (params.priority as any) ?? "medium",
         domainId: params.domain_id as string,
         projectId: (params.project_id as string) ?? null,
-        stateId: (params.state_id as string) ?? null,
-        moduleId: (params.module_id as string) ?? null,
-        cycleId: (params.cycle_id as string) ?? null,
         dueDate: params.due_date ? new Date(params.due_date as string) : null,
-        completedAt,
       }).returning();
 
       await recordActivity({
@@ -176,7 +141,7 @@ const tools: ToolDefinition[] = [
         action: "created",
         entityType: "task",
         entityId: task.id,
-        changes: { title: task.title, stateId: task.stateId },
+        changes: { title: task.title },
         workspaceId: params.domain_id as string,
       });
 
@@ -192,11 +157,9 @@ const tools: ToolDefinition[] = [
         task_id: { type: "string" },
         title: { type: "string" },
         description: { type: "string" },
-        state_id: { type: "string", description: "State UUID" },
+        status: { type: "string" },
         priority: { type: "string", enum: ["low", "medium", "high", "urgent"] },
         due_date: { type: "string" },
-        module_id: { type: "string", description: "Module UUID" },
-        cycle_id: { type: "string", description: "Cycle UUID" },
       },
       required: ["task_id"],
     },
@@ -210,24 +173,6 @@ const tools: ToolDefinition[] = [
       if (params.description !== undefined) updateData.description = params.description;
       if (params.priority !== undefined) updateData.priority = params.priority;
       if (params.due_date !== undefined) updateData.dueDate = params.due_date ? new Date(params.due_date as string) : null;
-      if (params.module_id !== undefined) updateData.moduleId = params.module_id;
-      if (params.cycle_id !== undefined) updateData.cycleId = params.cycle_id;
-
-      // Handle state change + completedAt
-      if (params.state_id !== undefined) {
-        updateData.stateId = params.state_id;
-        if (params.state_id) {
-          const [state] = await db.select({ id: states.id, group: states.group })
-            .from(states)
-            .where(eq(states.id, params.state_id as string))
-            .limit(1);
-          if (!state) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "State not found");
-          updateData.completedAt = state.group === "completed" ? new Date() : null;
-        } else {
-          updateData.completedAt = null;
-        }
-      }
-
       updateData.updatedAt = new Date();
 
       const [task] = await db.update(tasks)
@@ -278,13 +223,10 @@ const tools: ToolDefinition[] = [
   },
   {
     name: "tasks.complete",
-    description: "Mark a task as done by setting its state to a completed group state",
+    description: "Mark a task as done",
     inputSchema: {
       type: "object",
-      properties: {
-        task_id: { type: "string" },
-        state_id: { type: "string", description: "Optional specific completed state UUID. If omitted, finds a completed-group state from the task's project." },
-      },
+      properties: { task_id: { type: "string" } },
       required: ["task_id"],
     },
     handler: async (params, auth) => {
@@ -292,25 +234,8 @@ const tools: ToolDefinition[] = [
       if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Task not found");
       await verifyDomainAccess(existing.domainId, auth.userId);
 
-      let completedStateId = params.state_id as string | undefined;
-      if (!completedStateId && existing.projectId) {
-        const [completedState] = await db.select({ id: states.id })
-          .from(states)
-          .where(and(eq(states.projectId, existing.projectId), eq(states.group, "completed"), isNull(states.deletedAt)))
-          .limit(1);
-        completedStateId = completedState?.id;
-      }
-
-      const updateData: Record<string, unknown> = {
-        completedAt: new Date(),
-        updatedAt: new Date(),
-      };
-      if (completedStateId) {
-        updateData.stateId = completedStateId;
-      }
-
       const [task] = await db.update(tasks)
-        .set(updateData)
+        .set({ completedAt: new Date(), updatedAt: new Date() })
         .where(and(eq(tasks.id, params.task_id as string), isNull(tasks.deletedAt)))
         .returning();
 
@@ -319,7 +244,6 @@ const tools: ToolDefinition[] = [
         action: "completed",
         entityType: "task",
         entityId: task.id,
-        changes: { stateId: task.stateId },
         workspaceId: task.domainId,
       });
 
@@ -681,719 +605,6 @@ const tools: ToolDefinition[] = [
       return { items };
     },
   },
-  // ── States ──────────────────────────────────────────────────────────────────────
-  {
-    name: "states.list",
-    description: "List workflow states for a project",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project_id: { type: "string", description: "Project UUID" },
-      },
-      required: ["project_id"],
-    },
-    handler: async (params) => {
-      const items = await db.select()
-        .from(states)
-        .where(and(eq(states.projectId, params.project_id as string), isNull(states.deletedAt)))
-        .orderBy(asc(states.sortOrder));
-      return { items };
-    },
-  },
-  {
-    name: "states.create",
-    description: "Create a workflow state",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project_id: { type: "string" },
-        name: { type: "string" },
-        color: { type: "string" },
-        group: { type: "string", enum: ["backlog", "unstarted", "started", "completed", "cancelled"] },
-        sort_order: { type: "number" },
-      },
-      required: ["project_id", "name"],
-    },
-    handler: async (params, auth) => {
-      const [project] = await db.select().from(projects).where(eq(projects.id, params.project_id as string)).limit(1);
-      if (!project) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Project not found");
-      await verifyDomainAccess(project.domainId, auth.userId);
-
-      const [state] = await db.insert(states).values({
-        name: params.name as string,
-        color: (params.color as string) ?? null,
-        group: (params.group as any) ?? "unstarted",
-        projectId: params.project_id as string,
-        sortOrder: (params.sort_order as number) ?? 0,
-      }).returning();
-
-      await recordActivity({
-        actor: auth.userName,
-        action: "created",
-        entityType: "state",
-        entityId: state.id,
-        changes: { name: state.name, group: state.group },
-        workspaceId: project.domainId,
-      });
-
-      return state;
-    },
-  },
-  {
-    name: "states.update",
-    description: "Update a workflow state",
-    inputSchema: {
-      type: "object",
-      properties: {
-        state_id: { type: "string" },
-        name: { type: "string" },
-        color: { type: "string" },
-        group: { type: "string", enum: ["backlog", "unstarted", "started", "completed", "cancelled"] },
-        sort_order: { type: "number" },
-      },
-      required: ["state_id"],
-    },
-    handler: async (params, auth) => {
-      const [existing] = await db.select().from(states).where(and(eq(states.id, params.state_id as string), isNull(states.deletedAt))).limit(1);
-      if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "State not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, existing.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      const updateData: Record<string, unknown> = { updatedAt: new Date() };
-      if (params.name !== undefined) updateData.name = params.name;
-      if (params.color !== undefined) updateData.color = params.color;
-      if (params.group !== undefined) updateData.group = params.group;
-      if (params.sort_order !== undefined) updateData.sortOrder = params.sort_order;
-
-      const [state] = await db.update(states)
-        .set(updateData)
-        .where(eq(states.id, params.state_id as string))
-        .returning();
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "updated",
-          entityType: "state",
-          entityId: state.id,
-          changes: updateData,
-          workspaceId: project.domainId,
-        });
-      }
-
-      return state;
-    },
-  },
-  {
-    name: "states.delete",
-    description: "Soft-delete a workflow state",
-    inputSchema: {
-      type: "object",
-      properties: { state_id: { type: "string" } },
-      required: ["state_id"],
-    },
-    handler: async (params, auth) => {
-      const [existing] = await db.select().from(states).where(and(eq(states.id, params.state_id as string), isNull(states.deletedAt))).limit(1);
-      if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "State not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, existing.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      await db.update(states)
-        .set({ deletedAt: new Date(), updatedAt: new Date() })
-        .where(eq(states.id, params.state_id as string));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "deleted",
-          entityType: "state",
-          entityId: params.state_id as string,
-          changes: { name: existing.name },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { deleted: true, id: params.state_id };
-    },
-  },
-  // ── Modules ─────────────────────────────────────────────────────────────────────
-  {
-    name: "modules.list",
-    description: "List modules for a project",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project_id: { type: "string" },
-      },
-      required: ["project_id"],
-    },
-    handler: async (params) => {
-      const items = await db.select()
-        .from(modules)
-        .where(and(eq(modules.projectId, params.project_id as string), isNull(modules.deletedAt)))
-        .orderBy(asc(modules.sortOrder));
-      return { items };
-    },
-  },
-  {
-    name: "modules.create",
-    description: "Create a module",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project_id: { type: "string" },
-        name: { type: "string" },
-        description: { type: "string" },
-        status: { type: "string", enum: ["planned", "in_progress", "completed", "cancelled"] },
-        start_date: { type: "string" },
-        target_date: { type: "string" },
-      },
-      required: ["project_id", "name"],
-    },
-    handler: async (params, auth) => {
-      const [project] = await db.select().from(projects).where(eq(projects.id, params.project_id as string)).limit(1);
-      if (!project) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Project not found");
-      await verifyDomainAccess(project.domainId, auth.userId);
-
-      const [mod] = await db.insert(modules).values({
-        name: params.name as string,
-        description: (params.description as string) ?? null,
-        projectId: params.project_id as string,
-        status: (params.status as any) ?? "planned",
-        startDate: params.start_date ? new Date(params.start_date as string) : null,
-        targetDate: params.target_date ? new Date(params.target_date as string) : null,
-      }).returning();
-
-      await recordActivity({
-        actor: auth.userName,
-        action: "created",
-        entityType: "module",
-        entityId: mod.id,
-        changes: { name: mod.name },
-        workspaceId: project.domainId,
-      });
-
-      return mod;
-    },
-  },
-  {
-    name: "modules.update",
-    description: "Update a module",
-    inputSchema: {
-      type: "object",
-      properties: {
-        module_id: { type: "string" },
-        name: { type: "string" },
-        description: { type: "string" },
-        status: { type: "string", enum: ["planned", "in_progress", "completed", "cancelled"] },
-        start_date: { type: "string" },
-        target_date: { type: "string" },
-      },
-      required: ["module_id"],
-    },
-    handler: async (params, auth) => {
-      const [existing] = await db.select().from(modules).where(and(eq(modules.id, params.module_id as string), isNull(modules.deletedAt))).limit(1);
-      if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Module not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, existing.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      const updateData: Record<string, unknown> = { updatedAt: new Date() };
-      if (params.name !== undefined) updateData.name = params.name;
-      if (params.description !== undefined) updateData.description = params.description;
-      if (params.status !== undefined) updateData.status = params.status;
-      if (params.start_date !== undefined) updateData.startDate = params.start_date ? new Date(params.start_date as string) : null;
-      if (params.target_date !== undefined) updateData.targetDate = params.target_date ? new Date(params.target_date as string) : null;
-
-      const [mod] = await db.update(modules)
-        .set(updateData)
-        .where(eq(modules.id, params.module_id as string))
-        .returning();
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "updated",
-          entityType: "module",
-          entityId: mod.id,
-          changes: updateData,
-          workspaceId: project.domainId,
-        });
-      }
-
-      return mod;
-    },
-  },
-  {
-    name: "modules.delete",
-    description: "Soft-delete a module and clear module_id on its tasks",
-    inputSchema: {
-      type: "object",
-      properties: { module_id: { type: "string" } },
-      required: ["module_id"],
-    },
-    handler: async (params, auth) => {
-      const [existing] = await db.select().from(modules).where(and(eq(modules.id, params.module_id as string), isNull(modules.deletedAt))).limit(1);
-      if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Module not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, existing.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      await db.update(tasks)
-        .set({ moduleId: null, updatedAt: new Date() })
-        .where(eq(tasks.moduleId, params.module_id as string));
-
-      await db.update(modules)
-        .set({ deletedAt: new Date(), updatedAt: new Date() })
-        .where(eq(modules.id, params.module_id as string));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "deleted",
-          entityType: "module",
-          entityId: params.module_id as string,
-          changes: { name: existing.name },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { deleted: true, id: params.module_id };
-    },
-  },
-  {
-    name: "modules.add-task",
-    description: "Add a task to a module",
-    inputSchema: {
-      type: "object",
-      properties: {
-        module_id: { type: "string" },
-        task_id: { type: "string" },
-      },
-      required: ["module_id", "task_id"],
-    },
-    handler: async (params, auth) => {
-      const [mod] = await db.select().from(modules).where(and(eq(modules.id, params.module_id as string), isNull(modules.deletedAt))).limit(1);
-      if (!mod) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Module not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, mod.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      const [task] = await db.select().from(tasks).where(and(eq(tasks.id, params.task_id as string), isNull(tasks.deletedAt))).limit(1);
-      if (!task) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Task not found");
-
-      await db.update(tasks)
-        .set({ moduleId: params.module_id as string, updatedAt: new Date() })
-        .where(eq(tasks.id, params.task_id as string));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "added_task",
-          entityType: "module",
-          entityId: params.module_id as string,
-          changes: { taskId: params.task_id, taskTitle: task.title },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { success: true };
-    },
-  },
-  {
-    name: "modules.remove-task",
-    description: "Remove a task from a module",
-    inputSchema: {
-      type: "object",
-      properties: {
-        module_id: { type: "string" },
-        task_id: { type: "string" },
-      },
-      required: ["module_id", "task_id"],
-    },
-    handler: async (params, auth) => {
-      const [mod] = await db.select().from(modules).where(and(eq(modules.id, params.module_id as string), isNull(modules.deletedAt))).limit(1);
-      if (!mod) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Module not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, mod.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      await db.update(tasks)
-        .set({ moduleId: null, updatedAt: new Date() })
-        .where(and(eq(tasks.id, params.task_id as string), eq(tasks.moduleId, params.module_id as string)));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "removed_task",
-          entityType: "module",
-          entityId: params.module_id as string,
-          changes: { taskId: params.task_id },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { success: true };
-    },
-  },
-  // ── Cycles ──────────────────────────────────────────────────────────────────────
-  {
-    name: "cycles.list",
-    description: "List cycles for a project",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project_id: { type: "string" },
-      },
-      required: ["project_id"],
-    },
-    handler: async (params) => {
-      const items = await db.select()
-        .from(cycles)
-        .where(eq(cycles.projectId, params.project_id as string))
-        .orderBy(desc(cycles.createdAt));
-      return { items };
-    },
-  },
-  {
-    name: "cycles.create",
-    description: "Create a cycle",
-    inputSchema: {
-      type: "object",
-      properties: {
-        project_id: { type: "string" },
-        name: { type: "string" },
-        start_date: { type: "string" },
-        end_date: { type: "string" },
-        active: { type: "boolean" },
-      },
-      required: ["project_id", "name"],
-    },
-    handler: async (params, auth) => {
-      const [project] = await db.select().from(projects).where(eq(projects.id, params.project_id as string)).limit(1);
-      if (!project) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Project not found");
-      await verifyDomainAccess(project.domainId, auth.userId);
-
-      const [cycle] = await db.insert(cycles).values({
-        name: params.name as string,
-        projectId: params.project_id as string,
-        startDate: params.start_date ? new Date(params.start_date as string) : null,
-        endDate: params.end_date ? new Date(params.end_date as string) : null,
-        active: (params.active as boolean) ?? false,
-      }).returning();
-
-      await recordActivity({
-        actor: auth.userName,
-        action: "created",
-        entityType: "cycle",
-        entityId: cycle.id,
-        changes: { name: cycle.name },
-        workspaceId: project.domainId,
-      });
-
-      return cycle;
-    },
-  },
-  {
-    name: "cycles.update",
-    description: "Update a cycle",
-    inputSchema: {
-      type: "object",
-      properties: {
-        cycle_id: { type: "string" },
-        name: { type: "string" },
-        start_date: { type: "string" },
-        end_date: { type: "string" },
-        active: { type: "boolean" },
-      },
-      required: ["cycle_id"],
-    },
-    handler: async (params, auth) => {
-      const [existing] = await db.select().from(cycles).where(eq(cycles.id, params.cycle_id as string)).limit(1);
-      if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Cycle not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, existing.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      const updateData: Record<string, unknown> = { updatedAt: new Date() };
-      if (params.name !== undefined) updateData.name = params.name;
-      if (params.start_date !== undefined) updateData.startDate = params.start_date ? new Date(params.start_date as string) : null;
-      if (params.end_date !== undefined) updateData.endDate = params.end_date ? new Date(params.end_date as string) : null;
-      if (params.active !== undefined) updateData.active = params.active;
-
-      const [cycle] = await db.update(cycles)
-        .set(updateData)
-        .where(eq(cycles.id, params.cycle_id as string))
-        .returning();
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "updated",
-          entityType: "cycle",
-          entityId: cycle.id,
-          changes: updateData,
-          workspaceId: project.domainId,
-        });
-      }
-
-      return cycle;
-    },
-  },
-  {
-    name: "cycles.delete",
-    description: "Delete a cycle and clear cycle_id on its tasks",
-    inputSchema: {
-      type: "object",
-      properties: { cycle_id: { type: "string" } },
-      required: ["cycle_id"],
-    },
-    handler: async (params, auth) => {
-      const [existing] = await db.select().from(cycles).where(eq(cycles.id, params.cycle_id as string)).limit(1);
-      if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Cycle not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, existing.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      await db.update(tasks)
-        .set({ cycleId: null, updatedAt: new Date() })
-        .where(eq(tasks.cycleId, params.cycle_id as string));
-
-      await db.delete(cycles).where(eq(cycles.id, params.cycle_id as string));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "deleted",
-          entityType: "cycle",
-          entityId: params.cycle_id as string,
-          changes: { name: existing.name },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { deleted: true, id: params.cycle_id };
-    },
-  },
-  {
-    name: "cycles.add-task",
-    description: "Add a task to a cycle",
-    inputSchema: {
-      type: "object",
-      properties: {
-        cycle_id: { type: "string" },
-        task_id: { type: "string" },
-      },
-      required: ["cycle_id", "task_id"],
-    },
-    handler: async (params, auth) => {
-      const [cycle] = await db.select().from(cycles).where(eq(cycles.id, params.cycle_id as string)).limit(1);
-      if (!cycle) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Cycle not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, cycle.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      const [task] = await db.select().from(tasks).where(and(eq(tasks.id, params.task_id as string), isNull(tasks.deletedAt))).limit(1);
-      if (!task) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Task not found");
-
-      await db.update(tasks)
-        .set({ cycleId: params.cycle_id as string, updatedAt: new Date() })
-        .where(eq(tasks.id, params.task_id as string));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "added_task",
-          entityType: "cycle",
-          entityId: params.cycle_id as string,
-          changes: { taskId: params.task_id, taskTitle: task.title },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { success: true };
-    },
-  },
-  {
-    name: "cycles.remove-task",
-    description: "Remove a task from a cycle",
-    inputSchema: {
-      type: "object",
-      properties: {
-        cycle_id: { type: "string" },
-        task_id: { type: "string" },
-      },
-      required: ["cycle_id", "task_id"],
-    },
-    handler: async (params, auth) => {
-      const [cycle] = await db.select().from(cycles).where(eq(cycles.id, params.cycle_id as string)).limit(1);
-      if (!cycle) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Cycle not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, cycle.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      await db.update(tasks)
-        .set({ cycleId: null, updatedAt: new Date() })
-        .where(and(eq(tasks.id, params.task_id as string), eq(tasks.cycleId, params.cycle_id as string)));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "removed_task",
-          entityType: "cycle",
-          entityId: params.cycle_id as string,
-          changes: { taskId: params.task_id },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { success: true };
-    },
-  },
-  {
-    name: "cycles.transfer-task",
-    description: "Transfer a task from one cycle to another",
-    inputSchema: {
-      type: "object",
-      properties: {
-        from_cycle_id: { type: "string" },
-        to_cycle_id: { type: "string" },
-        task_id: { type: "string" },
-      },
-      required: ["from_cycle_id", "to_cycle_id", "task_id"],
-    },
-    handler: async (params, auth) => {
-      const [fromCycle] = await db.select().from(cycles).where(eq(cycles.id, params.from_cycle_id as string)).limit(1);
-      if (!fromCycle) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Source cycle not found");
-
-      const [project] = await db.select().from(projects).where(eq(projects.id, fromCycle.projectId)).limit(1);
-      if (project) await verifyDomainAccess(project.domainId, auth.userId);
-
-      const [task] = await db.select().from(tasks).where(and(eq(tasks.id, params.task_id as string), isNull(tasks.deletedAt))).limit(1);
-      if (!task) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Task not found");
-
-      await db.update(tasks)
-        .set({ cycleId: params.to_cycle_id as string, updatedAt: new Date() })
-        .where(eq(tasks.id, params.task_id as string));
-
-      if (project) {
-        await recordActivity({
-          actor: auth.userName,
-          action: "transferred_task",
-          entityType: "cycle",
-          entityId: params.from_cycle_id as string,
-          changes: { taskId: params.task_id, fromCycleId: params.from_cycle_id, toCycleId: params.to_cycle_id },
-          workspaceId: project.domainId,
-        });
-      }
-
-      return { success: true };
-    },
-  },
-  // ── Links ───────────────────────────────────────────────────────────────────────
-  {
-    name: "links.list",
-    description: "List links for an entity (bidirectional)",
-    inputSchema: {
-      type: "object",
-      properties: {
-        source_type: { type: "string", description: "Entity type (e.g. task, project)" },
-        source_id: { type: "string", description: "Entity UUID" },
-        target_type: { type: "string" },
-        target_id: { type: "string" },
-        link_type: { type: "string", enum: ["relates", "blocks", "parent-child", "created-from"] },
-        limit: { type: "number", default: 50 },
-      },
-    },
-    handler: async (params) => {
-      const conditions: any[] = [];
-      if (params.source_type && params.source_id) {
-        conditions.push(
-          or(
-            and(eq(links.sourceType, params.source_type as string), eq(links.sourceId, params.source_id as string)),
-            and(eq(links.targetType, params.source_type as string), eq(links.targetId, params.source_id as string)),
-          )!
-        );
-      } else if (params.target_type && params.target_id) {
-        conditions.push(
-          or(
-            and(eq(links.sourceType, params.target_type as string), eq(links.sourceId, params.target_id as string)),
-            and(eq(links.targetType, params.target_type as string), eq(links.targetId, params.target_id as string)),
-          )!
-        );
-      }
-      if (params.link_type) {
-        conditions.push(eq(links.linkType, params.link_type as any));
-      }
-
-      const items = await db.select()
-        .from(links)
-        .where(conditions.length > 0 ? and(...conditions) : undefined)
-        .orderBy(desc(links.createdAt))
-        .limit(Math.min(Number(params.limit) || 50, 200));
-
-      return { items, total: items.length };
-    },
-  },
-  {
-    name: "links.create",
-    description: "Create a link between two entities",
-    inputSchema: {
-      type: "object",
-      properties: {
-        source_type: { type: "string" },
-        source_id: { type: "string" },
-        target_type: { type: "string" },
-        target_id: { type: "string" },
-        link_type: { type: "string", enum: ["relates", "blocks", "parent-child", "created-from"] },
-        direction: { type: "string" },
-      },
-      required: ["source_type", "source_id", "target_type", "target_id", "link_type"],
-    },
-    handler: async (params) => {
-      const [existing] = await db.select()
-        .from(links)
-        .where(and(
-          eq(links.sourceType, params.source_type as string),
-          eq(links.sourceId, params.source_id as string),
-          eq(links.targetType, params.target_type as string),
-          eq(links.targetId, params.target_id as string),
-          eq(links.linkType, params.link_type as any),
-        ))
-        .limit(1);
-
-      if (existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Link already exists");
-
-      const [link] = await db.insert(links).values({
-        sourceType: params.source_type as string,
-        sourceId: params.source_id as string,
-        targetType: params.target_type as string,
-        targetId: params.target_id as string,
-        linkType: params.link_type as any,
-        direction: (params.direction as string) ?? null,
-      }).returning();
-
-      return link;
-    },
-  },
-  {
-    name: "links.delete",
-    description: "Delete a link",
-    inputSchema: {
-      type: "object",
-      properties: { link_id: { type: "string" } },
-      required: ["link_id"],
-    },
-    handler: async (params) => {
-      const [existing] = await db.select().from(links).where(eq(links.id, params.link_id as string)).limit(1);
-      if (!existing) throw new JsonRpcErrorResponse(JSONRPC_INTERNAL_ERROR, "Link not found");
-
-      await db.delete(links).where(eq(links.id, params.link_id as string));
-      return { deleted: true, id: params.link_id };
-    },
-  },
 ];
 
 // ── Error helper ─────────────────────────────────────────────────────────────────
diff --git a/apps/api/src/routes/tasks.ts b/apps/api/src/routes/tasks.ts
index f789ce8..f0121f0 100644
--- a/apps/api/src/routes/tasks.ts
+++ b/apps/api/src/routes/tasks.ts
@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import { db, tasks, states as statesTable, taskTags, tags as tagsTable, activityFeed, scheduledJobs, projects, sections } from "@project-e/db";
+import { db, tasks, states as statesTable, taskTags, tags as tagsTable, activityFeed, scheduledJobs, projects, sections, links } from "@project-e/db";
 import { and, asc, desc, eq, exists, ilike, inArray, isNull, or, sql } from "drizzle-orm";
 import { requireAuth, requireWorkspaceAccess, createErrorResponse, resolveActiveDomain, AuthError, isUuid } from "../middleware/auth";
 import { recordActivity } from "../middleware/activity";
@@ -770,6 +770,21 @@ taskRoutes.delete("/:id/tags/:tagId", async (c) => {
   }
 });
 
+// POST /api/tasks/:id/dependencies — Deprecated: use links table instead (Phase 2)
+taskRoutes.post("/:id/dependencies", async (c) => {
+  return c.json({ error: { code: "NOT_FOUND", message: "Dependencies moved to links table (Phase 2)" } }, 404);
+});
+
+// DELETE /api/tasks/:id/dependencies/:depId — Deprecated: use links table instead (Phase 2)
+taskRoutes.delete("/:id/dependencies/:depId", async (c) => {
+  return c.json({ error: { code: "NOT_FOUND", message: "Dependencies moved to links table (Phase 2)" } }, 404);
+});
+
+// POST /api/tasks/:id/status — Deprecated: use state_id instead (Phase 2)
+taskRoutes.post("/:id/status", async (c) => {
+  return c.json({ error: { code: "NOT_FOUND", message: "Status endpoint replaced by state assignment (Phase 2)" } }, 404);
+});
+
 // GET /api/tasks/:id/history — State change log (from activity feed)
 taskRoutes.get("/:id/history", async (c) => {
   try {
diff --git a/apps/web/src/lib/types/index.ts b/apps/web/src/lib/types/index.ts
index 545fa2f..12f32f3 100644
--- a/apps/web/src/lib/types/index.ts
+++ b/apps/web/src/lib/types/index.ts
@@ -9,9 +9,13 @@ export interface Task {
   domainId: string;
   projectId: string | null;
   sectionId: string | null;
+  stateId: string | null;
+  moduleId: string | null;
+  cycleId: string | null;
   parentId: string | null;
   dueDate: string | null;
   estimatedMinutes: number | null;
+  trackedMinutes: number | null;
   recurrenceRule: string | null;
   order: number;
   completedAt: string | null;
@@ -25,6 +29,61 @@ export interface Task {
   dependents?: { id: string; title: string; status: string }[];
 }
 
+export type StateGroup = "backlog" | "unstarted" | "started" | "completed" | "cancelled";
+
+export interface State {
+  id: string;
+  name: string;
+  color: string | null;
+  group: StateGroup;
+  projectId: string;
+  sortOrder: number;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt: string | null;
+}
+
+export type ModuleStatus = "planned" | "in_progress" | "completed" | "cancelled";
+
+export interface Module {
+  id: string;
+  name: string;
+  description: string | null;
+  projectId: string;
+  status: ModuleStatus;
+  startDate: string | null;
+  targetDate: string | null;
+  sortOrder: number;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt: string | null;
+  tasks?: Task[];
+}
+
+export interface Cycle {
+  id: string;
+  name: string;
+  projectId: string;
+  startDate: string | null;
+  endDate: string | null;
+  active: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export type LinkType = "relates" | "blocks" | "parent-child" | "created-from";
+
+export interface Link {
+  id: string;
+  sourceType: string;
+  sourceId: string;
+  targetType: string;
+  targetId: string;
+  linkType: LinkType;
+  direction: string | null;
+  createdAt: string;
+}
+
 export interface Habit {
   id: string;
   name: string;
diff --git a/apps/web/src/routes/_app/graph.tsx b/apps/web/src/routes/_app/graph.tsx
index 6e0819e..1c7eceb 100644
--- a/apps/web/src/routes/_app/graph.tsx
+++ b/apps/web/src/routes/_app/graph.tsx
@@ -20,7 +20,7 @@ import type { GraphNode, GraphEdge } from "@/lib/types";
 import ForceGraph2D from "react-force-graph-2d";
 
 const ENTITY_TYPES = ["task", "habit", "project", "note", "section", "tag", "domain"];
-const RELATIONSHIP_TYPES = ["depends_on", "related_to", "part_of", "references", "parent_of", "child_of", "connects_to"];
+const RELATIONSHIP_TYPES = ["depends_on", "related_to", "part_of", "references", "parent_of", "child_of", "connects_to", "relates", "blocks", "parent-child", "created-from", "task_project", "task_domain", "habit_domain", "project_domain", "note_domain", "section_project"];
 
 const ENTITY_COLORS: Record<string, string> = {
   task: "#3b82f6",
@@ -32,6 +32,20 @@ const ENTITY_COLORS: Record<string, string> = {
   domain: "#6366f1",
 };
 
+const LINK_TYPE_COLORS: Record<string, string> = {
+  relates: "#94a3b8",
+  blocks: "#ef4444",
+  "parent-child": "#8b5cf6",
+  "created-from": "#10b981",
+  depends_on: "#ef4444",
+  related_to: "#94a3b8",
+  part_of: "#8b5cf6",
+  references: "#f59e0b",
+  parent_of: "#8b5cf6",
+  child_of: "#10b981",
+  connects_to: "#3b82f6",
+};
+
 // Graph node types that have a detail page. section/tag/domain nodes appear in
 // the graph but have no detail route, so they are intentionally absent.
 const NODE_TYPE_ROUTES: Record<string, string> = {
@@ -265,11 +279,17 @@ function GraphPage() {
       const isHighlighted = highlightLinks.size === 0 || highlightLinks.has(`${link.source.id}-${link.target.id}`);
       const width = isHighlighted ? 1.5 / globalScale : 0.5 / globalScale;
       const opacity = isHighlighted ? 0.6 : 0.1;
+      const linkType = link.type || "relates";
+      const baseColor = LINK_TYPE_COLORS[linkType] || "#94a3b8";
+
+      const r = parseInt(baseColor.slice(1, 3), 16);
+      const g = parseInt(baseColor.slice(3, 5), 16);
+      const b = parseInt(baseColor.slice(5, 7), 16);
 
       ctx.beginPath();
       ctx.moveTo(link.source.x, link.source.y);
       ctx.lineTo(link.target.x, link.target.y);
-      ctx.strokeStyle = `rgba(148, 163, 184, ${opacity})`;
+      ctx.strokeStyle = `rgba(${r}, ${g}, ${b}, ${opacity})`;
       ctx.lineWidth = width;
       ctx.stroke();
 
@@ -289,7 +309,7 @@ function GraphPage() {
           ctx.lineTo(midX - ux * arrowSize + uy * arrowSize * 0.5, midY - uy * arrowSize - ux * arrowSize * 0.5);
           ctx.lineTo(midX - ux * arrowSize - uy * arrowSize * 0.5, midY - uy * arrowSize + ux * arrowSize * 0.5);
           ctx.closePath();
-          ctx.fillStyle = `rgba(148, 163, 184, ${opacity})`;
+          ctx.fillStyle = `rgba(${r}, ${g}, ${b}, ${opacity})`;
           ctx.fill();
         }
       }
@@ -425,8 +445,9 @@ function GraphPage() {
                       checked={enabledRelationships.has(type)}
                       onCheckedChange={() => toggleRelationship(type)}
                     />
-                    <Label htmlFor={"rel-" + type} className="text-sm cursor-pointer">
-                      {type.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())}
+                    <Label htmlFor={"rel-" + type} className="flex items-center gap-2 text-sm cursor-pointer">
+                      <div className="w-2 h-2 rounded-full" style={{ backgroundColor: LINK_TYPE_COLORS[type] || "#94a3b8" }} />
+                      {type.replace(/_/g, " ").replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase())}
                     </Label>
                   </div>
                 ))}
diff --git a/apps/web/src/routes/_app/projects/$id.tsx b/apps/web/src/routes/_app/projects/$id.tsx
index 64e652b..62917f1 100644
--- a/apps/web/src/routes/_app/projects/$id.tsx
+++ b/apps/web/src/routes/_app/projects/$id.tsx
@@ -8,8 +8,10 @@ import {
   Clock,
   Flag,
   FolderKanban,
+  LayoutGrid,
   ListTodo,
   Plus,
+  Repeat,
   Trash2,
   X,
 } from "lucide-react";
@@ -42,6 +44,7 @@ import {
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger } from "@/components/ui/dialog";
 import { Input } from "@/components/ui/input";
 import { Progress } from "@/components/ui/progress";
 import {
@@ -51,10 +54,11 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import { Textarea } from "@/components/ui/textarea";
 import { ToggleGroup, ToggleGroupItem } from "@/components/ui/toggle-group";
 import { LoadingState, ErrorState } from "@/components/state";
-import { PRIORITY, PROJECT_STATUS, TASK_STATUS } from "@/lib/status-colors";
-import type { Project, Section, Task } from "@/lib/types";
+import { PRIORITY, PROJECT_STATUS } from "@/lib/status-colors";
+import type { Cycle, Module, PaginatedResponse, Project, Section, State, Task } from "@/lib/types";
 import { cn } from "@/lib/utils";
 
 const PROJECT_STATUS_OPTIONS: InlineSelectOption[] = [
@@ -70,14 +74,26 @@ const SECTION_STATUS_OPTIONS: InlineSelectOption[] = [
   { value: "complete", label: "Complete" },
 ];
 
-/** Section lifecycle colors (no shared token exists for section statuses). */
+const MODULE_STATUS_OPTIONS: InlineSelectOption[] = [
+  { value: "planned", label: "Planned" },
+  { value: "in_progress", label: "In Progress" },
+  { value: "completed", label: "Completed" },
+  { value: "cancelled", label: "Cancelled" },
+];
+
+const MODULE_STATUS: Record<string, { label: string; badge: string; dot: string }> = {
+  planned: { label: "Planned", badge: "bg-slate-500 text-white", dot: "bg-slate-400" },
+  in_progress: { label: "In Progress", badge: "bg-blue-500 text-white", dot: "bg-blue-500" },
+  completed: { label: "Completed", badge: "bg-green-500 text-white", dot: "bg-green-500" },
+  cancelled: { label: "Cancelled", badge: "bg-red-500 text-white", dot: "bg-red-400" },
+};
+
 const SECTION_STATUS: Record<string, { label: string; badge: string; dot: string }> = {
   planned: { label: "Planned", badge: "bg-slate-500 text-white", dot: "bg-slate-400" },
   in_progress: { label: "In Progress", badge: "bg-blue-500 text-white", dot: "bg-blue-500" },
   complete: { label: "Complete", badge: "bg-green-500 text-white", dot: "bg-green-500" },
 };
 
-/** Sentinel for the "No section" option in the task composer select. */
 const NO_SECTION = "__none__";
 
 type PatchFn = (vars: { id: string; data: Record<string, unknown> }) => void;
@@ -226,6 +242,8 @@ function ProjectDetail() {
         },
         { value: "tasks", label: "Tasks", content: <ProjectTasks project={project} /> },
         { value: "sections", label: "Sections", content: <Sections project={project} /> },
+        { value: "modules", label: "Modules", content: <ProjectModules project={project} /> },
+        { value: "cycles", label: "Cycles", content: <ProjectCycles project={project} /> },
         {
           value: "activity",
           label: "Activity",
@@ -319,6 +337,15 @@ function ProjectTasks({ project }: { project: Project }) {
   const sections = project.sections || [];
   const tasks = project.tasks || [];
 
+  const { data: statesData } = useApiQuery<{ items: State[] }>(
+    ["states", project.id],
+    "/states?projectId=" + project.id,
+    { enabled: !!project.id }
+  );
+  const projectStates = statesData?.items || [];
+  const completedStateId = projectStates.find((s) => s.group === "completed")?.id;
+  const uncompletedStateId = projectStates.find((s) => s.group !== "completed" && s.group !== "cancelled")?.id;
+
   const refresh = () => {
     queryClient.invalidateQueries({ queryKey: ["project", project.id] });
     queryClient.invalidateQueries({ queryKey: ["projects"] });
@@ -342,8 +369,8 @@ function ProjectTasks({ project }: { project: Project }) {
   });
 
   const toggleMutation = useMutation({
-    mutationFn: ({ taskId, status }: { taskId: string; status: Task["status"] }) =>
-      api.post<Task>(`/tasks/${taskId}/status`, { status }),
+    mutationFn: ({ taskId, completed }: { taskId: string; completed: boolean }) =>
+      api.patch<Task>(`/tasks/${taskId}`, { stateId: completed ? completedStateId || null : uncompletedStateId || null }),
     onMutate: (vars) => setPendingId(vars.taskId),
     onSettled: () => setPendingId(null),
     onSuccess: refresh,
@@ -359,8 +386,6 @@ function ProjectTasks({ project }: { project: Project }) {
     });
   };
 
-  // Group tasks by section, keeping sections in API sort order. Tasks whose
-  // sectionId is null or points at a hard-deleted section land in Unassigned.
   const sectionIdSet = new Set(sections.map((s) => s.id));
   const tasksBySection = new Map<string, Task[]>();
   const unassigned: Task[] = [];
@@ -439,6 +464,7 @@ function ProjectTasks({ project }: { project: Project }) {
                   key={task.id}
                   task={task}
                   pending={pendingId === task.id}
+                  projectStates={projectStates}
                   onToggle={(vars) => toggleMutation.mutate(vars)}
                   onOpen={() => openTask(task.id)}
                 />
@@ -461,6 +487,7 @@ function ProjectTasks({ project }: { project: Project }) {
                   key={task.id}
                   task={task}
                   pending={pendingId === task.id}
+                  projectStates={projectStates}
                   onToggle={(vars) => toggleMutation.mutate(vars)}
                   onOpen={() => openTask(task.id)}
                 />
@@ -476,36 +503,45 @@ function ProjectTasks({ project }: { project: Project }) {
 function TaskRow({
   task,
   pending,
+  projectStates,
   onToggle,
   onOpen,
 }: {
   task: Task;
   pending: boolean;
-  onToggle: (vars: { taskId: string; status: Task["status"] }) => void;
+  projectStates: State[];
+  onToggle: (vars: { taskId: string; completed: boolean }) => void;
   onOpen: () => void;
 }) {
+  const state = task.stateId ? projectStates.find((s) => s.id === task.stateId) : null;
+  const isCompleted = state?.group === "completed";
+
   return (
     <div className="flex items-center gap-3 rounded-md px-2 py-1.5 hover:bg-muted/50">
       <Checkbox
-        checked={task.status === "done"}
+        checked={isCompleted}
         disabled={pending}
         onCheckedChange={() =>
           onToggle({
             taskId: task.id,
-            status: task.status === "done" ? "todo" : "done",
+            completed: isCompleted,
           })
         }
         aria-label={
-          "Mark " + task.title + " " + (task.status === "done" ? "as not done" : "as done")
+          "Mark " + task.title + " " + (isCompleted ? "as not done" : "as done")
         }
       />
-      <span className={cn("h-2 w-2 shrink-0 rounded-full", TASK_STATUS[task.status]?.dot)} />
+      {state ? (
+        <span className="h-2 w-2 shrink-0 rounded-full" style={{ backgroundColor: state.color || "#94a3b8" }} />
+      ) : (
+        <span className="h-2 w-2 shrink-0 rounded-full bg-slate-300" />
+      )}
       <button
         type="button"
         onClick={onOpen}
         className={cn(
           "min-w-0 flex-1 truncate text-left text-sm hover:underline",
-          task.status === "done" && "text-muted-foreground line-through"
+          isCompleted && "text-muted-foreground line-through"
         )}
       >
         {task.title}
@@ -690,6 +726,465 @@ function Sections({ project }: { project: Project }) {
   );
 }
 
+function ProjectModules({ project }: { project: Project }) {
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const [createOpen, setCreateOpen] = useState(false);
+  const [editModule, setEditModule] = useState<Module | null>(null);
+  const [newName, setNewName] = useState("");
+  const [newDescription, setNewDescription] = useState("");
+  const [selectedModuleId, setSelectedModuleId] = useState<string | null>(null);
+
+  const { data: modulesData, isLoading } = useApiQuery<PaginatedResponse<Module>>(
+    ["modules", project.id],
+    "/projects/" + project.id + "/modules?limit=200"
+  );
+  const modules = modulesData?.items || [];
+
+  const { data: moduleDetail } = useApiQuery<Module & { tasks: Task[] }>(
+    ["module", selectedModuleId || ""],
+    "/projects/" + project.id + "/modules/" + selectedModuleId,
+    { enabled: !!selectedModuleId }
+  );
+
+  const { data: statesData } = useApiQuery<{ items: State[] }>(
+    ["states", project.id],
+    "/states?projectId=" + project.id,
+    { enabled: !!project.id }
+  );
+  const projectStates = statesData?.items || [];
+
+  const refresh = () => {
+    queryClient.invalidateQueries({ queryKey: ["modules", project.id] });
+    if (selectedModuleId) queryClient.invalidateQueries({ queryKey: ["module", selectedModuleId] });
+    queryClient.invalidateQueries({ queryKey: ["tasks"] });
+  };
+
+  const createMutation = useMutation({
+    mutationFn: (data: { name: string; description?: string }) =>
+      api.post<Module>(`/projects/${project.id}/modules`, data),
+    onSuccess: () => {
+      setCreateOpen(false);
+      setNewName("");
+      setNewDescription("");
+      toast.success("Module created");
+      refresh();
+    },
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const updateMutation = useMutation({
+    mutationFn: ({ id, data }: { id: string; data: Record<string, unknown> }) =>
+      api.patch<Module>(`/projects/${project.id}/modules/${id}`, data),
+    onSuccess: () => {
+      setEditModule(null);
+      toast.success("Module updated");
+      refresh();
+    },
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => api.delete(`/projects/${project.id}/modules/${id}`),
+    onSuccess: () => {
+      toast.success("Module deleted");
+      if (selectedModuleId === editModule?.id) setSelectedModuleId(null);
+      setEditModule(null);
+      refresh();
+    },
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const addTaskMutation = useMutation({
+    mutationFn: ({ moduleId, taskId }: { moduleId: string; taskId: string }) =>
+      api.post(`/projects/${project.id}/modules/${moduleId}/tasks`, { taskId }),
+    onSuccess: refresh,
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const removeTaskMutation = useMutation({
+    mutationFn: ({ moduleId, taskId }: { moduleId: string; taskId: string }) =>
+      api.delete(`/projects/${project.id}/modules/${moduleId}/tasks/${taskId}`),
+    onSuccess: refresh,
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const tasks = project.tasks || [];
+  const moduleTasks = moduleDetail?.tasks || [];
+  const moduleTaskIds = new Set(moduleTasks.map((t) => t.id));
+  const unassignedTasks = tasks.filter((t) => !t.moduleId && !moduleTaskIds.has(t.id));
+
+  return (
+    <div className="space-y-4">
+      <div className="flex items-center justify-between">
+        <h3 className="text-sm font-semibold">Modules</h3>
+        <Button size="sm" onClick={() => setCreateOpen(true)}>
+          <Plus className="h-4 w-4 mr-1" /> New Module
+        </Button>
+      </div>
+
+      {isLoading ? (
+        <LoadingState label="Loading modules..." />
+      ) : modules.length === 0 ? (
+        <p className="py-6 text-center text-sm text-muted-foreground">No modules yet. Create one to organize tasks.</p>
+      ) : (
+        <div className="space-y-2">
+          {modules.map((mod) => (
+            <div
+              key={mod.id}
+              className={cn(
+                "rounded-lg border p-3 cursor-pointer hover:bg-muted/50 transition-colors",
+                selectedModuleId === mod.id && "bg-muted/50 ring-1 ring-primary/30"
+              )}
+              onClick={() => setSelectedModuleId(selectedModuleId === mod.id ? null : mod.id)}
+            >
+              <div className="flex items-center justify-between">
+                <div className="flex items-center gap-2">
+                  <LayoutGrid className="h-4 w-4 text-muted-foreground" />
+                  <span className="font-medium text-sm">{mod.name}</span>
+                  <Badge variant="secondary" className={cn("text-[10px]", MODULE_STATUS[mod.status]?.badge)}>
+                    {MODULE_STATUS[mod.status]?.label ?? mod.status}
+                  </Badge>
+                </div>
+                <div className="flex items-center gap-1">
+                  <Button variant="ghost" size="icon" className="h-6 w-6" onClick={(e) => { e.stopPropagation(); setEditModule(mod); }}>
+                    <Flag className="h-3.5 w-3.5" />
+                  </Button>
+                  <Button variant="ghost" size="icon" className="h-6 w-6 text-destructive" onClick={(e) => { e.stopPropagation(); deleteMutation.mutate(mod.id); }}>
+                    <Trash2 className="h-3.5 w-3.5" />
+                  </Button>
+                </div>
+              </div>
+              {mod.description && (
+                <p className="text-xs text-muted-foreground mt-1 line-clamp-2">{mod.description}</p>
+              )}
+            </div>
+          ))}
+        </div>
+      )}
+
+      {selectedModuleId && moduleDetail && (
+        <div className="rounded-lg border p-4 space-y-3">
+          <h4 className="text-sm font-semibold">Tasks in {moduleDetail.name}</h4>
+          {moduleTasks.length === 0 ? (
+            <p className="text-xs text-muted-foreground">No tasks in this module.</p>
+          ) : (
+            <div className="space-y-1">
+              {moduleTasks.map((t) => (
+                <div key={t.id} className="flex items-center gap-2 rounded-md px-2 py-1 hover:bg-muted/50">
+                  <button
+                    type="button"
+                    onClick={() => navigate({ to: "/tasks/$id", params: { id: t.id } })}
+                    className="min-w-0 flex-1 truncate text-left text-sm hover:underline"
+                  >
+                    {t.title}
+                  </button>
+                  <Button variant="ghost" size="icon" className="h-5 w-5" onClick={() => removeTaskMutation.mutate({ moduleId: selectedModuleId, taskId: t.id })}>
+                    <X className="h-3 w-3" />
+                  </Button>
+                </div>
+              ))}
+            </div>
+          )}
+          {unassignedTasks.length > 0 && (
+            <div>
+              <p className="text-xs text-muted-foreground mb-1">Add task:</p>
+              <div className="space-y-1">
+                {unassignedTasks.slice(0, 10).map((t) => (
+                  <div key={t.id} className="flex items-center gap-2 rounded-md px-2 py-1 hover:bg-muted/50">
+                    <span className="min-w-0 flex-1 truncate text-sm">{t.title}</span>
+                    <Button variant="ghost" size="icon" className="h-5 w-5" onClick={() => addTaskMutation.mutate({ moduleId: selectedModuleId, taskId: t.id })}>
+                      <Plus className="h-3 w-3" />
+                    </Button>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+
+      <Dialog open={createOpen} onOpenChange={setCreateOpen}>
+        <DialogContent>
+          <DialogHeader><DialogTitle>New Module</DialogTitle></DialogHeader>
+          <div className="space-y-4">
+            <Input placeholder="Module name" value={newName} onChange={(e) => setNewName(e.target.value)} />
+            <Textarea placeholder="Description (optional)" value={newDescription} onChange={(e) => setNewDescription(e.target.value)} rows={3} />
+            <div className="flex justify-end gap-2">
+              <Button variant="outline" onClick={() => setCreateOpen(false)}>Cancel</Button>
+              <Button onClick={() => createMutation.mutate({ name: newName, description: newDescription || undefined })} disabled={!newName.trim() || createMutation.isPending}>Create</Button>
+            </div>
+          </div>
+        </DialogContent>
+      </Dialog>
+
+      <Dialog open={!!editModule} onOpenChange={(o) => { if (!o) setEditModule(null); }}>
+        <DialogContent>
+          <DialogHeader><DialogTitle>Edit Module</DialogTitle></DialogHeader>
+          {editModule && (
+            <ModuleEditForm
+              module={editModule}
+              onSave={(data) => updateMutation.mutate({ id: editModule.id, data })}
+              onClose={() => setEditModule(null)}
+            />
+          )}
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
+
+function ModuleEditForm({ module: mod, onSave, onClose }: { module: Module; onSave: (data: Record<string, unknown>) => void; onClose: () => void }) {
+  const [name, setName] = useState(mod.name);
+  const [description, setDescription] = useState(mod.description || "");
+  const [status, setStatus] = useState(mod.status);
+
+  return (
+    <div className="space-y-4">
+      <Input placeholder="Name" value={name} onChange={(e) => setName(e.target.value)} />
+      <Textarea placeholder="Description" value={description} onChange={(e) => setDescription(e.target.value)} rows={3} />
+      <Select value={status} onValueChange={(v) => setStatus(v as Module["status"])}>
+        <SelectTrigger><SelectValue /></SelectTrigger>
+        <SelectContent>
+          {MODULE_STATUS_OPTIONS.map((o) => <SelectItem key={o.value} value={o.value}>{o.label}</SelectItem>)}
+        </SelectContent>
+      </Select>
+      <div className="flex justify-end gap-2">
+        <Button variant="outline" onClick={onClose}>Cancel</Button>
+        <Button onClick={() => onSave({ name, description: description || null, status })} disabled={!name.trim()}>Save</Button>
+      </div>
+    </div>
+  );
+}
+
+function ProjectCycles({ project }: { project: Project }) {
+  const navigate = useNavigate();
+  const queryClient = useQueryClient();
+  const [createOpen, setCreateOpen] = useState(false);
+  const [editCycle, setEditCycle] = useState<Cycle | null>(null);
+  const [newName, setNewName] = useState("");
+  const [selectedCycleId, setSelectedCycleId] = useState<string | null>(null);
+
+  const { data: cyclesData, isLoading } = useApiQuery<{ items: Cycle[] }>(
+    ["cycles", project.id],
+    "/projects/" + project.id + "/cycles"
+  );
+  const cycles = cyclesData?.items || [];
+
+  const { data: cycleDetail } = useApiQuery<Cycle & { tasks: Task[] }>(
+    ["cycle", selectedCycleId || ""],
+    "/projects/" + project.id + "/cycles/" + selectedCycleId,
+    { enabled: !!selectedCycleId }
+  );
+
+  const refresh = () => {
+    queryClient.invalidateQueries({ queryKey: ["cycles", project.id] });
+    if (selectedCycleId) queryClient.invalidateQueries({ queryKey: ["cycle", selectedCycleId] });
+    queryClient.invalidateQueries({ queryKey: ["tasks"] });
+  };
+
+  const createMutation = useMutation({
+    mutationFn: (data: { name: string }) =>
+      api.post<Cycle>(`/projects/${project.id}/cycles`, data),
+    onSuccess: () => {
+      setCreateOpen(false);
+      setNewName("");
+      toast.success("Cycle created");
+      refresh();
+    },
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const updateMutation = useMutation({
+    mutationFn: ({ id, data }: { id: string; data: Record<string, unknown> }) =>
+      api.patch<Cycle>(`/projects/${project.id}/cycles/${id}`, data),
+    onSuccess: () => {
+      setEditCycle(null);
+      toast.success("Cycle updated");
+      refresh();
+    },
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: (id: string) => api.delete(`/projects/${project.id}/cycles/${id}`),
+    onSuccess: () => {
+      toast.success("Cycle deleted");
+      if (selectedCycleId === editCycle?.id) setSelectedCycleId(null);
+      setEditCycle(null);
+      refresh();
+    },
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const addTaskMutation = useMutation({
+    mutationFn: ({ cycleId, taskId }: { cycleId: string; taskId: string }) =>
+      api.post(`/projects/${project.id}/cycles/${cycleId}/tasks`, { taskId }),
+    onSuccess: refresh,
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const removeTaskMutation = useMutation({
+    mutationFn: ({ cycleId, taskId }: { cycleId: string; taskId: string }) =>
+      api.delete(`/projects/${project.id}/cycles/${cycleId}/tasks/${taskId}`),
+    onSuccess: refresh,
+    onError: (err) => toast.error(errorMessage(err)),
+  });
+
+  const tasks = project.tasks || [];
+  const cycleTasks = cycleDetail?.tasks || [];
+  const cycleTaskIds = new Set(cycleTasks.map((t) => t.id));
+  const backlogTasks = tasks.filter((t) => !t.cycleId && !cycleTaskIds.has(t.id));
+
+  return (
+    <div className="space-y-4">
+      <div className="flex items-center justify-between">
+        <h3 className="text-sm font-semibold">Cycles</h3>
+        <Button size="sm" onClick={() => setCreateOpen(true)}>
+          <Plus className="h-4 w-4 mr-1" /> New Cycle
+        </Button>
+      </div>
+
+      {isLoading ? (
+        <LoadingState label="Loading cycles..." />
+      ) : cycles.length === 0 ? (
+        <p className="py-6 text-center text-sm text-muted-foreground">No cycles yet. Create a sprint cycle to time-box work.</p>
+      ) : (
+        <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-3">
+          {cycles.map((cycle) => (
+            <div
+              key={cycle.id}
+              className={cn(
+                "rounded-lg border p-3 cursor-pointer hover:bg-muted/50 transition-colors",
+                selectedCycleId === cycle.id && "bg-muted/50 ring-1 ring-primary/30"
+              )}
+              onClick={() => setSelectedCycleId(selectedCycleId === cycle.id ? null : cycle.id)}
+            >
+              <div className="flex items-center justify-between">
+                <div className="flex items-center gap-2">
+                  <Repeat className="h-4 w-4 text-muted-foreground" />
+                  <span className="font-medium text-sm">{cycle.name}</span>
+                  {cycle.active && <Badge className="text-[10px] bg-green-500 text-white">Active</Badge>}
+                </div>
+                <div className="flex items-center gap-1">
+                  <Button variant="ghost" size="icon" className="h-6 w-6" onClick={(e) => { e.stopPropagation(); setEditCycle(cycle); }}>
+                    <Flag className="h-3.5 w-3.5" />
+                  </Button>
+                  <Button variant="ghost" size="icon" className="h-6 w-6 text-destructive" onClick={(e) => { e.stopPropagation(); deleteMutation.mutate(cycle.id); }}>
+                    <Trash2 className="h-3.5 w-3.5" />
+                  </Button>
+                </div>
+              </div>
+              <div className="flex gap-3 mt-2 text-xs text-muted-foreground">
+                {cycle.startDate && <span>Start: {format(parseISO(cycle.startDate), "MMM d")}</span>}
+                {cycle.endDate && <span>End: {format(parseISO(cycle.endDate), "MMM d")}</span>}
+              </div>
+            </div>
+          ))}
+        </div>
+      )}
+
+      {selectedCycleId && cycleDetail && (
+        <div className="rounded-lg border p-4 space-y-3">
+          <h4 className="text-sm font-semibold">Tasks in {cycleDetail.name}</h4>
+          {cycleTasks.length === 0 ? (
+            <p className="text-xs text-muted-foreground">No tasks in this cycle.</p>
+          ) : (
+            <div className="space-y-1">
+              {cycleTasks.map((t) => (
+                <div key={t.id} className="flex items-center gap-2 rounded-md px-2 py-1 hover:bg-muted/50">
+                  <button
+                    type="button"
+                    onClick={() => navigate({ to: "/tasks/$id", params: { id: t.id } })}
+                    className="min-w-0 flex-1 truncate text-left text-sm hover:underline"
+                  >
+                    {t.title}
+                  </button>
+                  <Button variant="ghost" size="icon" className="h-5 w-5" onClick={() => removeTaskMutation.mutate({ cycleId: selectedCycleId, taskId: t.id })}>
+                    <X className="h-3 w-3" />
+                  </Button>
+                </div>
+              ))}
+            </div>
+          )}
+          {backlogTasks.length > 0 && (
+            <div>
+              <p className="text-xs text-muted-foreground mb-1">Backlog — add task:</p>
+              <div className="space-y-1">
+                {backlogTasks.slice(0, 10).map((t) => (
+                  <div key={t.id} className="flex items-center gap-2 rounded-md px-2 py-1 hover:bg-muted/50">
+                    <span className="min-w-0 flex-1 truncate text-sm">{t.title}</span>
+                    <Button variant="ghost" size="icon" className="h-5 w-5" onClick={() => addTaskMutation.mutate({ cycleId: selectedCycleId, taskId: t.id })}>
+                      <Plus className="h-3 w-3" />
+                    </Button>
+                  </div>
+                ))}
+              </div>
+            </div>
+          )}
+        </div>
+      )}
+
+      <Dialog open={createOpen} onOpenChange={setCreateOpen}>
+        <DialogContent>
+          <DialogHeader><DialogTitle>New Cycle</DialogTitle></DialogHeader>
+          <div className="space-y-4">
+            <Input placeholder="Cycle name" value={newName} onChange={(e) => setNewName(e.target.value)} />
+            <div className="flex justify-end gap-2">
+              <Button variant="outline" onClick={() => setCreateOpen(false)}>Cancel</Button>
+              <Button onClick={() => createMutation.mutate({ name: newName })} disabled={!newName.trim() || createMutation.isPending}>Create</Button>
+            </div>
+          </div>
+        </DialogContent>
+      </Dialog>
+
+      <Dialog open={!!editCycle} onOpenChange={(o) => { if (!o) setEditCycle(null); }}>
+        <DialogContent>
+          <DialogHeader><DialogTitle>Edit Cycle</DialogTitle></DialogHeader>
+          {editCycle && (
+            <CycleEditForm
+              cycle={editCycle}
+              onSave={(data) => updateMutation.mutate({ id: editCycle.id, data })}
+              onClose={() => setEditCycle(null)}
+            />
+          )}
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+}
+
+function CycleEditForm({ cycle, onSave, onClose }: { cycle: Cycle; onSave: (data: Record<string, unknown>) => void; onClose: () => void }) {
+  const [name, setName] = useState(cycle.name);
+  const [startDate, setStartDate] = useState(cycle.startDate ? cycle.startDate.slice(0, 10) : "");
+  const [endDate, setEndDate] = useState(cycle.endDate ? cycle.endDate.slice(0, 10) : "");
+  const [active, setActive] = useState(cycle.active);
+
+  return (
+    <div className="space-y-4">
+      <Input placeholder="Name" value={name} onChange={(e) => setName(e.target.value)} />
+      <div className="grid grid-cols-2 gap-3">
+        <div>
+          <label className="text-sm text-muted-foreground">Start Date</label>
+          <Input type="date" value={startDate} onChange={(e) => setStartDate(e.target.value)} />
+        </div>
+        <div>
+          <label className="text-sm text-muted-foreground">End Date</label>
+          <Input type="date" value={endDate} onChange={(e) => setEndDate(e.target.value)} />
+        </div>
+      </div>
+      <div className="flex items-center gap-2">
+        <Checkbox checked={active} onCheckedChange={(v) => setActive(!!v)} id="cycle-active" />
+        <label htmlFor="cycle-active" className="text-sm cursor-pointer">Active cycle</label>
+      </div>
+      <div className="flex justify-end gap-2">
+        <Button variant="outline" onClick={onClose}>Cancel</Button>
+        <Button onClick={() => onSave({ name, startDate: startDate ? new Date(startDate).toISOString() : null, endDate: endDate ? new Date(endDate).toISOString() : null, active })} disabled={!name.trim()}>Save</Button>
+      </div>
+    </div>
+  );
+}
+
 export const Route = createRoute({
   getParentRoute: () => appRoute,
   path: "projects/$id",
diff --git a/apps/web/src/routes/_app/tasks.tsx b/apps/web/src/routes/_app/tasks.tsx
index 6b69f46..d338083 100644
--- a/apps/web/src/routes/_app/tasks.tsx
+++ b/apps/web/src/routes/_app/tasks.tsx
@@ -2,14 +2,14 @@ import { useState, useCallback, useMemo } from "react";
 import { createRoute, useNavigate } from "@tanstack/react-router";
 import { Route as appRoute } from "../_app";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { api, useApiQuery, useApiMutation } from "@/lib/api";
+import { api, useApiQuery } from "@/lib/api";
 import { useApiDomain } from "@/lib/stores/use-active-domain-store";
 import { useRealtime } from "@/hooks/use-realtime";
 import { useOpenCreateDialog } from "@/hooks/use-open-create-dialog";
 import { DndContext, DragOverlay, closestCorners, KeyboardSensor, PointerSensor, useSensor, useSensors, useDroppable, type DragEndEvent, type DragStartEvent } from "@dnd-kit/core";
 import { SortableContext, verticalListSortingStrategy, useSortable } from "@dnd-kit/sortable";
 import { CSS } from "@dnd-kit/utilities";
-import { Plus, GripVertical, Pencil, Trash2, Calendar, Clock, ListTodo, Layout as LayoutIcon, Search, Filter, MoreHorizontal } from "lucide-react";
+import { Plus, GripVertical, Pencil, Trash2, Calendar, ListTodo, Layout as LayoutIcon, Search, MoreHorizontal } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Badge } from "@/components/ui/badge";
@@ -20,27 +20,26 @@ import { Textarea } from "@/components/ui/textarea";
 import { Label } from "@/components/ui/label";
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogTitle, AlertDialogTrigger } from "@/components/ui/alert-dialog";
-import { Avatar, AvatarFallback } from "@/components/ui/avatar";
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
 import { EntityDetailPanel } from "@/components/entities/entity-detail-panel";
 import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table";
 import { DropdownMenu, DropdownMenuContent, DropdownMenuItem, DropdownMenuSeparator, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
 import { LoadingState, EmptyState, ErrorState } from "@/components/state";
 import { CustomFieldInputs } from "@/components/custom-fields/custom-field-inputs";
-import { TASK_STATUS, PRIORITY } from "@/lib/status-colors";
-import type { Task, PaginatedResponse } from "@/lib/types";
+import { PRIORITY } from "@/lib/status-colors";
+import type { Task, State, StateGroup, PaginatedResponse } from "@/lib/types";
 import { cn } from "@/lib/utils";
 import { parseTaskInput } from "@/lib/nlp";
 import { RecurrencePicker } from "@/components/tasks/recurrence-picker";
 
-const STATUS_COLUMNS = [
-  { id: "todo", label: "Todo" },
-  { id: "in_progress", label: "In Progress" },
-  { id: "done", label: "Done" },
-  { id: "cancelled", label: "Cancelled" },
+const STATE_GROUP_COLUMNS: { id: StateGroup; label: string; colorClass: string }[] = [
+  { id: "backlog", label: "Backlog", colorClass: "bg-slate-400" },
+  { id: "unstarted", label: "Unstarted", colorClass: "bg-slate-500" },
+  { id: "started", label: "Started", colorClass: "bg-blue-500" },
+  { id: "completed", label: "Completed", colorClass: "bg-green-500" },
+  { id: "cancelled", label: "Cancelled", colorClass: "bg-red-500" },
 ];
 
-function SortableTaskCard({ task, onClick, onEdit }: { task: Task; onClick: () => void; onEdit?: () => void }) {
+function SortableTaskCard({ task, stateName, stateColor, onClick, onEdit }: { task: Task; stateName?: string; stateColor?: string | null; onClick: () => void; onEdit?: () => void }) {
   const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: task.id });
 
   const style = {
@@ -58,6 +57,12 @@ function SortableTaskCard({ task, onClick, onEdit }: { task: Task; onClick: () =
             <div className="flex-1 min-w-0">
               <p className="text-sm font-medium truncate">{task.title}</p>
               <div className="flex flex-wrap gap-1.5 mt-2">
+                {stateName && (
+                  <Badge variant="secondary" className="text-[10px] gap-1" style={stateColor ? { backgroundColor: stateColor + "20", color: stateColor } : undefined}>
+                    <span className="h-1.5 w-1.5 rounded-full" style={stateColor ? { backgroundColor: stateColor } : undefined} />
+                    {stateName}
+                  </Badge>
+                )}
                 {task.dueDate && (
                   <Badge variant="outline" className="text-[10px]">
                     <Calendar className="h-3 w-3 mr-1" />
@@ -101,18 +106,28 @@ function ColumnDroppable({ id, className, children }: { id: string; className?:
   );
 }
 
-function TaskForm({ task, onClose }: { task?: Task; onClose: () => void }) {
+function TaskForm({ task, onClose, projectId }: { task?: Task; onClose: () => void; projectId?: string | null }) {
   const queryClient = useQueryClient();
   const activeDomainId = useApiDomain();
   const [title, setTitle] = useState(task?.title || "");
   const [description, setDescription] = useState(task?.description || "");
-  const [status, setStatus] = useState(task?.status || "todo");
   const [priority, setPriority] = useState(task?.priority || "medium");
   const [dueDate, setDueDate] = useState(task?.dueDate ? task.dueDate.slice(0, 10) : "");
   const [recurrenceRule, setRecurrenceRule] = useState(task?.recurrenceRule || "");
   const [customFieldValues, setCustomFieldValues] = useState<Record<string, unknown>>(() => ({ ...(task?.customFields ?? {}) }));
   const parsed = !task ? parseTaskInput(title) : null;
 
+  const effectiveProjectId = task?.projectId || projectId;
+
+  const { data: statesData } = useApiQuery<{ items: State[] }>(
+    ["states", effectiveProjectId || ""],
+    "/states?projectId=" + effectiveProjectId,
+    { enabled: !!effectiveProjectId }
+  );
+  const projectStates = statesData?.items || [];
+
+  const [selectedStateId, setSelectedStateId] = useState(task?.stateId || "");
+
   const createMutation = useMutation({
     mutationFn: (data: any) => api.post<Task>("/tasks", data),
     onSuccess: () => {
@@ -143,7 +158,8 @@ function TaskForm({ task, onClose }: { task?: Task; onClose: () => void }) {
       if (p.priority) finalPriority = p.priority;
       tagNames = p.tags;
     }
-    const data: any = { title: finalTitle, description: description || null, status, priority: finalPriority, tagNames };
+    const data: any = { title: finalTitle, description: description || null, priority: finalPriority, tagNames };
+    if (selectedStateId) data.stateId = selectedStateId || null;
     if (finalDueDate) data.dueDate = finalDueDate;
     if (recurrenceRule) data.recurrenceRule = recurrenceRule;
     const customFields = { ...customFieldValues };
@@ -173,18 +189,25 @@ function TaskForm({ task, onClose }: { task?: Task; onClose: () => void }) {
         <Textarea id="desc" value={description} onChange={(e) => setDescription(e.target.value)} placeholder="Description (optional)" rows={3} />
       </div>
       <div className="grid grid-cols-2 gap-4">
-        <div>
-          <Label htmlFor="status">Status</Label>
-          <Select value={status} onValueChange={(v) => setStatus(v as "todo" | "in_progress" | "done" | "cancelled")}>
-            <SelectTrigger id="status"><SelectValue /></SelectTrigger>
-            <SelectContent>
-              <SelectItem value="todo">Todo</SelectItem>
-              <SelectItem value="in_progress">In Progress</SelectItem>
-              <SelectItem value="done">Done</SelectItem>
-              <SelectItem value="cancelled">Cancelled</SelectItem>
-            </SelectContent>
-          </Select>
-        </div>
+        {projectStates.length > 0 && (
+          <div>
+            <Label htmlFor="state">State</Label>
+            <Select value={selectedStateId} onValueChange={setSelectedStateId}>
+              <SelectTrigger id="state"><SelectValue placeholder="No state" /></SelectTrigger>
+              <SelectContent>
+                <SelectItem value="">No state</SelectItem>
+                {projectStates.map((s) => (
+                  <SelectItem key={s.id} value={s.id}>
+                    <span className="flex items-center gap-2">
+                      <span className="h-2 w-2 rounded-full" style={{ backgroundColor: s.color || "#94a3b8" }} />
+                      {s.name}
+                    </span>
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+        )}
         <div>
           <Label htmlFor="priority">Priority</Label>
           <Select value={priority} onValueChange={(v) => setPriority(v as "low" | "medium" | "high" | "urgent")}>
@@ -219,7 +242,7 @@ function TasksPage() {
   const queryClient = useQueryClient();
   const [view, setView] = useState<"board" | "list">("board");
   const [search, setSearch] = useState("");
-  const [statusFilter, setStatusFilter] = useState("");
+  const [selectedStateId, setSelectedStateId] = useState("");
   const [createOpen, setCreateOpen] = useState(false);
   const [selectedTask, setSelectedTask] = useState<Task | null>(null);
   const [panelOpen, setPanelOpen] = useState(false);
@@ -231,16 +254,44 @@ function TasksPage() {
 
   const activeDomainId = useApiDomain();
 
+  const { data: projectsData } = useApiQuery<PaginatedResponse<{ id: string; name: string }>>(
+    ["projects", activeDomainId],
+    "/projects?limit=200" + (activeDomainId ? "&domain=" + activeDomainId : "")
+  );
+  const projects = projectsData?.items || [];
+
+  const [filterProjectId, setFilterProjectId] = useState("");
+
+  const { data: statesData } = useApiQuery<{ items: State[] }>(
+    ["states", filterProjectId],
+    "/states?projectId=" + filterProjectId,
+    { enabled: !!filterProjectId }
+  );
+  const projectStates = statesData?.items || [];
+
+  const stateGroupOf = useMemo(() => {
+    const map = new Map<string, StateGroup>();
+    for (const s of projectStates) map.set(s.id, s.group);
+    return map;
+  }, [projectStates]);
+
+  const stateById = useMemo(() => {
+    const map = new Map<string, State>();
+    for (const s of projectStates) map.set(s.id, s);
+    return map;
+  }, [projectStates]);
+
   const taskQueryParams = () =>
     new URLSearchParams({
       limit: "200",
       ...(activeDomainId ? { domain: activeDomainId } : {}),
       ...(search ? { search } : {}),
-      ...(statusFilter && statusFilter !== "all" ? { status: statusFilter } : {}),
+      ...(filterProjectId ? { project_id: filterProjectId } : {}),
+      ...(selectedStateId ? { state_id: selectedStateId } : {}),
     }).toString();
 
   const { data: tasksData, isLoading, isError, refetch } = useApiQuery<PaginatedResponse<Task>>(
-    ["tasks", activeDomainId, search, statusFilter],
+    ["tasks", activeDomainId, search, filterProjectId, selectedStateId],
     "/tasks?" + taskQueryParams()
   );
 
@@ -255,7 +306,7 @@ function TasksPage() {
       const next = await api.get<PaginatedResponse<Task>>(
         "/tasks?" + new URLSearchParams({ ...Object.fromEntries(new URLSearchParams(taskQueryParams())), offset: String(tasks.length) }).toString()
       );
-      queryClient.setQueryData<PaginatedResponse<Task>>(["tasks", activeDomainId, search, statusFilter], (old) => {
+      queryClient.setQueryData<PaginatedResponse<Task>>(["tasks", activeDomainId, search, filterProjectId, selectedStateId], (old) => {
         if (!old) return old;
         const seen = new Set(old.items.map((t) => t.id));
         return { ...old, items: [...old.items, ...next.items.filter((t) => !seen.has(t.id))] };
@@ -265,9 +316,9 @@ function TasksPage() {
     }
   };
 
-  const statusMutation = useMutation({
-    mutationFn: ({ id, status }: { id: string; status: string }) =>
-      api.post("/tasks/" + id + "/status", { status }),
+  const stateUpdateMutation = useMutation({
+    mutationFn: ({ taskId, stateId }: { taskId: string; stateId: string }) =>
+      api.patch<Task>("/tasks/" + taskId, { stateId }),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ["tasks"] });
     },
@@ -300,6 +351,17 @@ function TasksPage() {
     useSensor(KeyboardSensor)
   );
 
+  const taskGroupOf = useCallback(
+    (task: Task): StateGroup => {
+      if (task.stateId) {
+        const group = stateGroupOf.get(task.stateId);
+        if (group) return group;
+      }
+      return "unstarted";
+    },
+    [stateGroupOf]
+  );
+
   const handleDragStart = (event: DragStartEvent) => {
     setActiveId(event.active.id as string);
   };
@@ -315,30 +377,25 @@ function TasksPage() {
     const draggedTask = tasks.find((t) => t.id === taskId);
     if (!draggedTask) return;
 
-    // Tasks of a column in persisted order
-    const columnTasks = (status: string) =>
+    const columnTasks = (group: StateGroup) =>
       tasks
-        .filter((t) => t.status === status)
+        .filter((t) => taskGroupOf(t) === group)
         .sort((a, b) => a.order - b.order);
 
-    // Decide the target column and insertion index:
-    // - over a column id  => drop at the end of that column (handles empty columns)
-    // - over a task id    => drop at that task's position within its column
-    let targetColumn: string;
+    let targetGroup: StateGroup;
     let insertIndex: number;
-    if (STATUS_COLUMNS.some((c) => c.id === overId)) {
-      targetColumn = overId;
+    if (STATE_GROUP_COLUMNS.some((c) => c.id === overId)) {
+      targetGroup = overId as StateGroup;
       insertIndex = -1;
     } else {
       const overTask = tasks.find((t) => t.id === overId);
       if (!overTask) return;
-      targetColumn = overTask.status;
-      const overIndex = columnTasks(targetColumn).findIndex((t) => t.id === overId);
+      targetGroup = taskGroupOf(overTask);
+      const overIndex = columnTasks(targetGroup).findIndex((t) => t.id === overId);
       insertIndex = overIndex === -1 ? -1 : overIndex;
     }
 
-    // Build the new ordered id list for the target column
-    const targetIds = columnTasks(targetColumn)
+    const targetIds = columnTasks(targetGroup)
       .map((t) => t.id)
       .filter((id) => id !== taskId);
     if (insertIndex === -1) {
@@ -347,32 +404,30 @@ function TasksPage() {
       targetIds.splice(Math.min(insertIndex, targetIds.length), 0, taskId);
     }
 
-    // No-op when the task is already in that exact spot
-    const currentIds = columnTasks(targetColumn).map((t) => t.id);
+    const currentIds = columnTasks(targetGroup).map((t) => t.id);
     const unchanged =
       currentIds.length === targetIds.length &&
       currentIds.every((id, i) => id === targetIds[i]);
     if (unchanged) return;
 
-    // Optimistic local update so the board reorders immediately
-    const statusChanged = draggedTask.status !== targetColumn;
+    const groupChanged = taskGroupOf(draggedTask) !== targetGroup;
     const orderById = new Map(targetIds.map((id, i) => [id, i]));
-    queryClient.setQueryData<PaginatedResponse<Task>>(["tasks", activeDomainId, search, statusFilter], (old) => {
+    queryClient.setQueryData<PaginatedResponse<Task>>(["tasks", activeDomainId, search, filterProjectId, selectedStateId], (old) => {
       if (!old) return old;
       return {
         ...old,
         items: old.items.map((t) => {
-          if (t.id === taskId && statusChanged) {
-            return { ...t, status: targetColumn as Task["status"], order: orderById.get(t.id) ?? t.order };
-          }
           const order = orderById.get(t.id);
           return order !== undefined ? { ...t, order } : t;
         }),
       };
     });
 
-    if (statusChanged) {
-      statusMutation.mutate({ id: taskId, status: targetColumn });
+    if (groupChanged && draggedTask.projectId) {
+      const firstStateInGroup = projectStates.find((s) => s.group === targetGroup && s.projectId === draggedTask.projectId);
+      if (firstStateInGroup) {
+        stateUpdateMutation.mutate({ taskId, stateId: firstStateInGroup.id });
+      }
     }
     reorderMutation.mutate({ orderedIds: targetIds });
   };
@@ -387,14 +442,13 @@ function TasksPage() {
   };
 
   const columns = useMemo(() => {
-    return STATUS_COLUMNS.map((col) => ({
+    return STATE_GROUP_COLUMNS.map((col) => ({
       ...col,
-      color: TASK_STATUS[col.id].dot,
       tasks: tasks
-        .filter((t) => t.status === col.id)
+        .filter((t) => taskGroupOf(t) === col.id)
         .sort((a, b) => a.order - b.order),
     }));
-  }, [tasks]);
+  }, [tasks, taskGroupOf]);
 
   return (
     <div className="space-y-4">
@@ -415,27 +469,42 @@ function TasksPage() {
               <DialogHeader>
                 <DialogTitle>New Task</DialogTitle>
               </DialogHeader>
-              <TaskForm onClose={() => setCreateOpen(false)} />
+              <TaskForm onClose={() => setCreateOpen(false)} projectId={filterProjectId || undefined} />
             </DialogContent>
           </Dialog>
         </div>
       </div>
 
-      {/* Search + filter bar */}
-      <div className="flex gap-2">
-        <div className="relative flex-1 max-w-sm">
+      <div className="flex gap-2 flex-wrap">
+        <div className="relative flex-1 min-w-[200px] max-w-sm">
           <Search className="absolute left-2.5 top-2.5 h-4 w-4 text-muted-foreground" />
           <Input placeholder="Search tasks..." value={search} onChange={(e) => setSearch(e.target.value)} className="pl-8" />
         </div>
-        <Select value={statusFilter} onValueChange={setStatusFilter}>
-          <SelectTrigger className="w-36"><SelectValue placeholder="All statuses" /></SelectTrigger>
+        <Select value={filterProjectId} onValueChange={setFilterProjectId}>
+          <SelectTrigger className="w-44"><SelectValue placeholder="All projects" /></SelectTrigger>
           <SelectContent>
-            <SelectItem value="all">All statuses</SelectItem>
-            {STATUS_COLUMNS.map((c) => (
-              <SelectItem key={c.id} value={c.id}>{c.label}</SelectItem>
+            <SelectItem value="">All projects</SelectItem>
+            {projects.map((p) => (
+              <SelectItem key={p.id} value={p.id}>{p.name}</SelectItem>
             ))}
           </SelectContent>
         </Select>
+        {filterProjectId && projectStates.length > 0 && (
+          <Select value={selectedStateId} onValueChange={setSelectedStateId}>
+            <SelectTrigger className="w-40"><SelectValue placeholder="All states" /></SelectTrigger>
+            <SelectContent>
+              <SelectItem value="">All states</SelectItem>
+              {projectStates.map((s) => (
+                <SelectItem key={s.id} value={s.id}>
+                  <span className="flex items-center gap-2">
+                    <span className="h-2 w-2 rounded-full" style={{ backgroundColor: s.color || "#94a3b8" }} />
+                    {s.name}
+                  </span>
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        )}
       </div>
 
       {isLoading ? (
@@ -444,21 +513,31 @@ function TasksPage() {
         <ErrorState message="Failed to load tasks." onRetry={() => refetch()} />
       ) : view === "board" ? (
         <DndContext sensors={sensors} collisionDetection={closestCorners} onDragStart={handleDragStart} onDragEnd={handleDragEnd}>
-          <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
+          <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-5 gap-4">
             {columns.map((col) => (
               <ColumnDroppable key={col.id} id={col.id} className="bg-muted/50 rounded-lg p-3">
                 <div className="flex items-center justify-between mb-3">
                   <div className="flex items-center gap-2">
-                    <div className={cn("w-2 h-2 rounded-full", col.color)} />
+                    <div className={cn("w-2 h-2 rounded-full", col.colorClass)} />
                     <h3 className="font-semibold text-sm">{col.label}</h3>
                     <Badge variant="secondary" className="text-[10px]">{col.tasks.length}</Badge>
                   </div>
                 </div>
                 <SortableContext items={col.tasks.map((t) => t.id)} strategy={verticalListSortingStrategy}>
                   <div className="space-y-2 min-h-[100px]">
-                    {col.tasks.map((task) => (
-                      <SortableTaskCard key={task.id} task={task} onClick={() => openTaskDetail(task)} onEdit={() => openTaskPanel(task)} />
-                    ))}
+                    {col.tasks.map((task) => {
+                      const st = task.stateId ? stateById.get(task.stateId) : undefined;
+                      return (
+                        <SortableTaskCard
+                          key={task.id}
+                          task={task}
+                          stateName={st?.name}
+                          stateColor={st?.color}
+                          onClick={() => openTaskDetail(task)}
+                          onEdit={() => openTaskPanel(task)}
+                        />
+                      );
+                    })}
                     {col.tasks.length === 0 && (
                       <p className="text-xs text-muted-foreground text-center py-4">No tasks</p>
                     )}
@@ -477,7 +556,7 @@ function TasksPage() {
             <TableHeader>
               <TableRow>
                 <TableHead>Title</TableHead>
-                <TableHead>Status</TableHead>
+                <TableHead>State</TableHead>
                 <TableHead>Priority</TableHead>
                 <TableHead>Due Date</TableHead>
                 <TableHead></TableHead>
@@ -490,32 +569,42 @@ function TasksPage() {
                     <EmptyState title="No tasks found" />
                   </TableCell>
                 </TableRow>
-              ) : tasks.map((task) => (
-                <TableRow key={task.id} className="cursor-pointer" onClick={() => openTaskDetail(task)}>
-                  <TableCell className="font-medium">{task.title}</TableCell>
-                  <TableCell>
-                    <Badge className={cn("text-[10px]", TASK_STATUS[task.status]?.badge)}>{task.status.replace("_", " ")}</Badge>
-                  </TableCell>
-                  <TableCell>
-                    <Badge variant="outline" className={cn("text-[10px]", PRIORITY[task.priority]?.badge)}>{task.priority}</Badge>
-                  </TableCell>
-                  <TableCell className="text-sm text-muted-foreground">
-                    {task.dueDate ? new Date(task.dueDate).toLocaleDateString() : "-"}
-                  </TableCell>
-                  <TableCell>
-                    <DropdownMenu>
-                      <DropdownMenuTrigger asChild onClick={(e) => e.stopPropagation()}>
-                        <Button variant="ghost" size="icon" className="h-8 w-8"><MoreHorizontal className="h-4 w-4" /></Button>
-                      </DropdownMenuTrigger>
-                      <DropdownMenuContent align="end">
-                        <DropdownMenuItem onClick={() => openTaskPanel(task)}>Edit</DropdownMenuItem>
-                        <DropdownMenuSeparator />
-                        <DropdownMenuItem className="text-destructive" onClick={() => deleteMutation.mutate(task.id)}>Delete</DropdownMenuItem>
-                      </DropdownMenuContent>
-                    </DropdownMenu>
-                  </TableCell>
-                </TableRow>
-              ))}
+              ) : tasks.map((task) => {
+                const st = task.stateId ? stateById.get(task.stateId) : undefined;
+                return (
+                  <TableRow key={task.id} className="cursor-pointer" onClick={() => openTaskDetail(task)}>
+                    <TableCell className="font-medium">{task.title}</TableCell>
+                    <TableCell>
+                      {st ? (
+                        <Badge variant="secondary" className="text-[10px] gap-1" style={st.color ? { backgroundColor: st.color + "20", color: st.color } : undefined}>
+                          <span className="h-1.5 w-1.5 rounded-full" style={st.color ? { backgroundColor: st.color } : undefined} />
+                          {st.name}
+                        </Badge>
+                      ) : (
+                        <span className="text-xs text-muted-foreground">—</span>
+                      )}
+                    </TableCell>
+                    <TableCell>
+                      <Badge variant="outline" className={cn("text-[10px]", PRIORITY[task.priority]?.badge)}>{task.priority}</Badge>
+                    </TableCell>
+                    <TableCell className="text-sm text-muted-foreground">
+                      {task.dueDate ? new Date(task.dueDate).toLocaleDateString() : "-"}
+                    </TableCell>
+                    <TableCell>
+                      <DropdownMenu>
+                        <DropdownMenuTrigger asChild onClick={(e) => e.stopPropagation()}>
+                          <Button variant="ghost" size="icon" className="h-8 w-8"><MoreHorizontal className="h-4 w-4" /></Button>
+                        </DropdownMenuTrigger>
+                        <DropdownMenuContent align="end">
+                          <DropdownMenuItem onClick={() => openTaskPanel(task)}>Edit</DropdownMenuItem>
+                          <DropdownMenuSeparator />
+                          <DropdownMenuItem className="text-destructive" onClick={() => deleteMutation.mutate(task.id)}>Delete</DropdownMenuItem>
+                        </DropdownMenuContent>
+                      </DropdownMenu>
+                    </TableCell>
+                  </TableRow>
+                );
+              })}
             </TableBody>
           </Table>
         </div>
diff --git a/apps/web/src/routes/_app/tasks/$id.tsx b/apps/web/src/routes/_app/tasks/$id.tsx
index d8c3fa1..25f60a5 100644
--- a/apps/web/src/routes/_app/tasks/$id.tsx
+++ b/apps/web/src/routes/_app/tasks/$id.tsx
@@ -55,17 +55,10 @@ import {
   SelectValue,
 } from "@/components/ui/select";
 import { LoadingState, ErrorState } from "@/components/state";
-import { TASK_STATUS, PRIORITY } from "@/lib/status-colors";
-import type { PaginatedResponse, Project, Task } from "@/lib/types";
+import { PRIORITY } from "@/lib/status-colors";
+import type { PaginatedResponse, Project, State, Task } from "@/lib/types";
 import { cn } from "@/lib/utils";
 
-const STATUS_OPTIONS: InlineSelectOption[] = [
-  { value: "todo", label: "Todo" },
-  { value: "in_progress", label: "In Progress" },
-  { value: "done", label: "Done" },
-  { value: "cancelled", label: "Cancelled" },
-];
-
 const PRIORITY_OPTIONS: InlineSelectOption[] = [
   { value: "low", label: "Low" },
   { value: "medium", label: "Medium" },
@@ -120,10 +113,17 @@ function TaskDetail() {
   });
 
   const toggleComplete = useMutation({
-    mutationFn: () =>
-      api.post<Task>(`/tasks/${id}/status`, {
-        status: task?.status === "done" ? "todo" : "done",
-      }),
+    mutationFn: () => {
+      const completedStates = projectStates.filter((s) => s.group === "completed");
+      const uncompletedStates = projectStates.filter((s) => s.group !== "completed");
+      const isDone = task?.status === "done";
+      if (isDone && uncompletedStates.length > 0) {
+        return api.patch<Task>(`/tasks/${id}`, { stateId: uncompletedStates[0].id });
+      } else if (!isDone && completedStates.length > 0) {
+        return api.patch<Task>(`/tasks/${id}`, { stateId: completedStates[0].id });
+      }
+      return api.patch<Task>(`/tasks/${id}`, { stateId: null });
+    },
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: ["task", id] });
       for (const key of LIST_KEYS) queryClient.invalidateQueries({ queryKey: key });
@@ -131,6 +131,14 @@ function TaskDetail() {
     onError: (err) => toast.error(errorMessage(err)),
   });
 
+  const { data: statesData } = useApiQuery<{ items: State[] }>(
+    ["states", task?.projectId || ""],
+    "/states?projectId=" + (task?.projectId || ""),
+    { enabled: !!task?.projectId }
+  );
+  const projectStates = statesData?.items || [];
+  const currentState = task?.stateId ? projectStates.find((s) => s.id === task.stateId) : null;
+
   const deleteMutation = useMutation({
     mutationFn: () => api.delete(`/tasks/${id}`),
     onSuccess: () => {
@@ -152,7 +160,7 @@ function TaskDetail() {
   }
   if (!task) return <ErrorState message="Task not found" />;
 
-  const isDone = task.status === "done";
+  const isDone = currentState?.group === "completed";
 
   return (
     <EntityDetailPage
@@ -167,16 +175,28 @@ function TaskDetail() {
       icon={<ListTodo className="h-6 w-6" />}
       badges={
         <>
-          <InlineSelect
-            value={task.status}
-            options={STATUS_OPTIONS}
-            displayValue={(v) => (
-              <Badge className={TASK_STATUS[v]?.badge}>
-                {TASK_STATUS[v]?.label ?? v}
-              </Badge>
-            )}
-            onSave={(status) => patch({ id, data: { status } })}
-          />
+          {projectStates.length > 0 ? (
+            <InlineSelect
+              value={task.stateId ?? ""}
+              options={projectStates.map((s) => ({ value: s.id, label: s.name }))}
+              displayValue={(v) => {
+                if (!v) return <Badge variant="secondary">No state</Badge>;
+                const st = projectStates.find((s) => s.id === v);
+                if (!st) return <Badge variant="secondary">Unknown</Badge>;
+                return (
+                  <Badge variant="secondary" className="gap-1" style={st.color ? { backgroundColor: st.color + "20", color: st.color } : undefined}>
+                    <span className="h-1.5 w-1.5 rounded-full" style={st.color ? { backgroundColor: st.color } : undefined} />
+                    {st.name}
+                  </Badge>
+                );
+              }}
+              onSave={(stateId) => patch({ id, data: { stateId: stateId || null } })}
+            />
+          ) : (
+            <Badge variant="secondary">
+              {currentState?.name || task.status.replace("_", " ")}
+            </Badge>
+          )}
           <InlineSelect
             value={task.priority}
             options={PRIORITY_OPTIONS}
@@ -265,6 +285,20 @@ function Overview({ task, patch }: { task: Task; patch: PatchFn }) {
     ...projects.map((p) => ({ value: p.id, label: p.name })),
   ];
 
+  const { data: statesData } = useApiQuery<{ items: State[] }>(
+    ["states", task.projectId || ""],
+    "/states?projectId=" + (task.projectId || ""),
+    { enabled: !!task.projectId }
+  );
+  const projectStates = statesData?.items || [];
+
+  const stateOptions: InlineSelectOption[] = [
+    { value: "", label: "No state" },
+    ...projectStates.map((s) => ({ value: s.id, label: s.name })),
+  ];
+
+  const currentState = task.stateId ? projectStates.find((s) => s.id === task.stateId) : null;
+
   return (
     <div className="space-y-6">
       <div>
@@ -330,6 +364,29 @@ function Overview({ task, patch }: { task: Task; patch: PatchFn }) {
             }
           />
         </div>
+        {projectStates.length > 0 && (
+          <div className="flex items-center gap-2">
+            <CheckCircle2 className="h-4 w-4 shrink-0 text-muted-foreground" />
+            <InlineSelect
+              value={task.stateId ?? ""}
+              options={stateOptions}
+              displayValue={(v) => {
+                if (!v) return <span className="text-muted-foreground/70">No state</span>;
+                const st = projectStates.find((s) => s.id === v);
+                if (!st) return <span>{v}</span>;
+                return (
+                  <span className="flex items-center gap-1.5">
+                    <span className="h-2 w-2 rounded-full" style={{ backgroundColor: st.color || "#94a3b8" }} />
+                    {st.name}
+                  </span>
+                );
+              }}
+              onSave={(stateId) =>
+                patch({ id: task.id, data: { stateId: stateId || null } })
+              }
+            />
+          </div>
+        )}
         {task.recurrenceRule ? (
           <div className="flex items-center gap-2">
             <RepeatIcon className="h-4 w-4 shrink-0 text-muted-foreground" />
@@ -381,8 +438,8 @@ function Subtasks({ task }: { task: Task }) {
   });
 
   const toggleMutation = useMutation({
-    mutationFn: ({ subId, status }: { subId: string; status: Task["status"] }) =>
-      api.post<Task>(`/tasks/${subId}/status`, { status }),
+    mutationFn: ({ subId, completed }: { subId: string; completed: boolean }) =>
+      api.patch<Task>(`/tasks/${subId}`, { stateId: completed ? null : null }),
     onMutate: (vars) => setPendingId(vars.subId),
     onSettled: () => setPendingId(null),
     onSuccess: refresh,
@@ -432,12 +489,12 @@ function Subtasks({ task }: { task: Task }) {
                 onCheckedChange={() =>
                   toggleMutation.mutate({
                     subId: sub.id,
-                    status: sub.status === "done" ? "todo" : "done",
+                    completed: sub.status === "done",
                   })
                 }
                 aria-label={"Mark " + sub.title + " " + (sub.status === "done" ? "as not done" : "as done")}
               />
-              <span className={cn("h-2 w-2 shrink-0 rounded-full", TASK_STATUS[sub.status]?.dot)} />
+              <span className="h-2 w-2 shrink-0 rounded-full bg-slate-400" />
               <button
                 type="button"
                 onClick={() => navigate({ to: "/tasks/$id", params: { id: sub.id } })}
@@ -460,7 +517,13 @@ function Dependencies({ task }: { task: Task }) {
   const navigate = useNavigate();
   const queryClient = useQueryClient();
   const activeDomainId = useApiDomain();
-  const [depValue, setDepValue] = useState("");
+  const [targetEntityId, setTargetEntityId] = useState("");
+  const [linkType, setLinkType] = useState<string>("blocks");
+
+  const { data: linksData, isLoading: linksLoading } = useApiQuery<{ items: import("@/lib/types").Link[] }>(
+    ["links", "task", task.id],
+    "/links?entityType=task&entityId=" + task.id
+  );
 
   const { data: tasksData, isLoading: tasksLoading } = useApiQuery<PaginatedResponse<Task>>(
     ["tasks", activeDomainId, "dependency-picker"],
@@ -468,43 +531,55 @@ function Dependencies({ task }: { task: Task }) {
   );
 
   const refresh = () => {
+    queryClient.invalidateQueries({ queryKey: ["links", "task", task.id] });
     queryClient.invalidateQueries({ queryKey: ["task", task.id] });
     queryClient.invalidateQueries({ queryKey: ["tasks"] });
   };
 
-  const addDependency = useMutation({
-    mutationFn: (dependsOnTaskId: string) =>
-      api.post(`/tasks/${task.id}/dependencies`, { dependsOnTaskId }),
+  const addLink = useMutation({
+    mutationFn: (vars: { sourceId: string; targetId: string; linkType: string }) =>
+      api.post("/links", {
+        sourceType: "task",
+        sourceId: vars.sourceId,
+        targetType: "task",
+        targetId: vars.targetId,
+        linkType: vars.linkType,
+      }),
     onSuccess: () => {
-      setDepValue("");
-      toast.success("Dependency added");
+      setTargetEntityId("");
+      toast.success("Link added");
       refresh();
     },
     onError: (err) => toast.error(errorMessage(err)),
   });
 
-  const removeDependency = useMutation({
-    mutationFn: ({ taskId, depId }: { taskId: string; depId: string }) =>
-      api.delete(`/tasks/${taskId}/dependencies/${depId}`),
+  const removeLink = useMutation({
+    mutationFn: (linkId: string) => api.delete(`/links/${linkId}`),
     onSuccess: refresh,
     onError: (err) => toast.error(errorMessage(err)),
   });
 
-  const dependencies = task.dependencies || [];
-  const dependents = task.dependents || [];
+  const links = linksData?.items || [];
 
-  const availableTasks = (tasksData?.items ?? []).filter(
-    (t) => t.id !== task.id && !dependencies.some((d) => d.id === t.id)
+  const incomingLinks = links.filter((l) => l.targetId === task.id && l.sourceType === "task");
+  const outgoingLinks = links.filter((l) => l.sourceId === task.id && l.targetType === "task");
+
+  const allTaskIds = new Set((tasksData?.items || []).map((t) => t.id));
+  const linkedTaskIds = new Set([...incomingLinks.map((l) => l.sourceId), ...outgoingLinks.map((l) => l.targetId), task.id]);
+  const availableTasks = (tasksData?.items || []).filter(
+    (t) => t.id !== task.id && !linkedTaskIds.has(t.id)
   );
   const depPlaceholder = tasksLoading
     ? "Loading tasks..."
     : availableTasks.length === 0
       ? "No tasks to add"
-      : "Add dependency...";
+      : "Add link...";
 
-  const handleAddDependency = (value: string) => {
+  const taskTitleById = new Map((tasksData?.items || []).map((t) => [t.id, t.title]));
+
+  const handleAddLink = (value: string) => {
     if (!value) return;
-    addDependency.mutate(value);
+    addLink.mutate({ sourceId: task.id, targetId: value, linkType });
   };
 
   return (
@@ -512,35 +587,32 @@ function Dependencies({ task }: { task: Task }) {
       <div>
         <h3 className="mb-2 flex items-center gap-1.5 text-sm font-semibold">
           <Link2 className="h-4 w-4 text-muted-foreground" />
-          Blocked by
+          Links to this task
         </h3>
-        {dependencies.length === 0 ? (
-          <p className="py-4 text-sm text-muted-foreground">Nothing blocks this task.</p>
+        {incomingLinks.length === 0 ? (
+          <p className="py-4 text-sm text-muted-foreground">No incoming links.</p>
         ) : (
           <div className="space-y-0.5">
-            {dependencies.map((dep) => (
+            {incomingLinks.map((link) => (
               <div
-                key={dep.id}
+                key={link.id}
                 className="group flex items-center gap-2 rounded-md px-2 py-1.5 hover:bg-muted/50"
               >
-                <span className={cn("h-2 w-2 shrink-0 rounded-full", TASK_STATUS[dep.status]?.dot)} />
                 <button
                   type="button"
-                  onClick={() => navigate({ to: "/tasks/$id", params: { id: dep.id } })}
+                  onClick={() => navigate({ to: "/tasks/$id", params: { id: link.sourceId } })}
                   className="min-w-0 flex-1 truncate text-left text-sm hover:underline"
                 >
-                  {dep.title}
+                  {taskTitleById.get(link.sourceId) || link.sourceId}
                 </button>
-                <Badge className={cn("text-[10px]", TASK_STATUS[dep.status]?.badge)}>
-                  {TASK_STATUS[dep.status]?.label ?? dep.status}
-                </Badge>
+                <Badge variant="outline" className="text-[10px]">{link.linkType}</Badge>
                 <Button
                   variant="ghost"
                   size="icon"
                   className="h-6 w-6 shrink-0 text-muted-foreground hover:text-destructive"
-                  onClick={() => removeDependency.mutate({ taskId: task.id, depId: dep.id })}
-                  aria-label={"Remove dependency on " + dep.title}
-                  title="Remove dependency"
+                  onClick={() => removeLink.mutate(link.id)}
+                  aria-label="Remove link"
+                  title="Remove link"
                 >
                   <X className="h-3.5 w-3.5" />
                 </Button>
@@ -548,13 +620,63 @@ function Dependencies({ task }: { task: Task }) {
             ))}
           </div>
         )}
-        <div className="mt-3">
+      </div>
+
+      <div>
+        <h3 className="mb-2 flex items-center gap-1.5 text-sm font-semibold">
+          <Link2 className="h-4 w-4 text-muted-foreground" />
+          Links from this task
+        </h3>
+        {outgoingLinks.length === 0 ? (
+          <p className="py-4 text-sm text-muted-foreground">No outgoing links.</p>
+        ) : (
+          <div className="space-y-0.5">
+            {outgoingLinks.map((link) => (
+              <div
+                key={link.id}
+                className="group flex items-center gap-2 rounded-md px-2 py-1.5 hover:bg-muted/50"
+              >
+                <button
+                  type="button"
+                  onClick={() => navigate({ to: "/tasks/$id", params: { id: link.targetId } })}
+                  className="min-w-0 flex-1 truncate text-left text-sm hover:underline"
+                >
+                  {taskTitleById.get(link.targetId) || link.targetId}
+                </button>
+                <Badge variant="outline" className="text-[10px]">{link.linkType}</Badge>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-6 w-6 shrink-0 text-muted-foreground hover:text-destructive"
+                  onClick={() => removeLink.mutate(link.id)}
+                  aria-label="Remove link"
+                  title="Remove link"
+                >
+                  <X className="h-3.5 w-3.5" />
+                </Button>
+              </div>
+            ))}
+          </div>
+        )}
+
+        <div className="mt-3 flex gap-2">
+          <Select value={linkType} onValueChange={setLinkType}>
+            <SelectTrigger className="h-8 w-32 text-sm">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="blocks">Blocks</SelectItem>
+              <SelectItem value="relates">Relates to</SelectItem>
+              <SelectItem value="parent-child">Parent/Child</SelectItem>
+              <SelectItem value="created-from">Created from</SelectItem>
+            </SelectContent>
+          </Select>
           <Select
-            value={depValue}
-            onValueChange={handleAddDependency}
+            value={targetEntityId}
+            onValueChange={handleAddLink}
             disabled={availableTasks.length === 0}
           >
-            <SelectTrigger className="h-8 w-full text-sm" aria-label="Add dependency">
+            <SelectTrigger className="h-8 flex-1 text-sm" aria-label="Add link">
               <SelectValue placeholder={depPlaceholder} />
             </SelectTrigger>
             <SelectContent>
@@ -567,47 +689,6 @@ function Dependencies({ task }: { task: Task }) {
           </Select>
         </div>
       </div>
-
-      <div>
-        <h3 className="mb-2 flex items-center gap-1.5 text-sm font-semibold">
-          <Link2 className="h-4 w-4 text-muted-foreground" />
-          Blocks
-        </h3>
-        {dependents.length === 0 ? (
-          <p className="py-4 text-sm text-muted-foreground">Nothing depends on this task.</p>
-        ) : (
-          <div className="space-y-0.5">
-            {dependents.map((dep) => (
-              <div
-                key={dep.id}
-                className="group flex items-center gap-2 rounded-md px-2 py-1.5 hover:bg-muted/50"
-              >
-                <span className={cn("h-2 w-2 shrink-0 rounded-full", TASK_STATUS[dep.status]?.dot)} />
-                <button
-                  type="button"
-                  onClick={() => navigate({ to: "/tasks/$id", params: { id: dep.id } })}
-                  className="min-w-0 flex-1 truncate text-left text-sm hover:underline"
-                >
-                  {dep.title}
-                </button>
-                <Badge className={cn("text-[10px]", TASK_STATUS[dep.status]?.badge)}>
-                  {TASK_STATUS[dep.status]?.label ?? dep.status}
-                </Badge>
-                <Button
-                  variant="ghost"
-                  size="icon"
-                  className="h-6 w-6 shrink-0 text-muted-foreground hover:text-destructive"
-                  onClick={() => removeDependency.mutate({ taskId: dep.id, depId: task.id })}
-                  aria-label={"Remove this task from " + dep.title + "'s dependencies"}
-                  title="Remove dependency"
-                >
-                  <X className="h-3.5 w-3.5" />
-                </Button>
-              </div>
-            ))}
-          </div>
-        )}
-      </div>
     </div>
   );
 }