@hasna/todos 0.3.6 → 0.4.0

package/dist/cli/index.js

@@ -2067,19 +2067,54 @@ var require_commander = __commonJS((exports) => {
 import { Database } from "bun:sqlite";
 import { existsSync, mkdirSync } from "fs";
 import { dirname, join, resolve } from "path";
+function isInMemoryDb(path) {
+  return path === ":memory:" || path.startsWith("file::memory:");
+}
+function findNearestTodosDb(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    const candidate = join(dir, ".todos", "todos.db");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
+function findGitRoot(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    if (existsSync(join(dir, ".git")))
+      return dir;
+    const parent = dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  return null;
+}
 function getDbPath() {
   if (process.env["TODOS_DB_PATH"]) {
     return process.env["TODOS_DB_PATH"];
   }
   const cwd = process.cwd();
-  const localDb = join(cwd, ".todos", "todos.db");
-  if (existsSync(localDb)) {
-    return localDb;
+  const nearest = findNearestTodosDb(cwd);
+  if (nearest)
+    return nearest;
+  if (process.env["TODOS_DB_SCOPE"] === "project") {
+    const gitRoot = findGitRoot(cwd);
+    if (gitRoot) {
+      return join(gitRoot, ".todos", "todos.db");
+    }
   }
   const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
   return join(home, ".todos", "todos.db");
 }
 function ensureDir(filePath) {
+  if (isInMemoryDb(filePath))
+    return;
   const dir = dirname(resolve(filePath));
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
@@ -2095,6 +2130,7 @@ function getDatabase(dbPath) {
   _db.run("PRAGMA busy_timeout = 5000");
   _db.run("PRAGMA foreign_keys = ON");
   runMigrations(_db);
+  backfillTaskTags(_db);
   return _db;
 }
 function runMigrations(db) {
@@ -2110,6 +2146,35 @@ function runMigrations(db) {
     }
   }
 }
+function backfillTaskTags(db) {
+  try {
+    const count = db.query("SELECT COUNT(*) as count FROM task_tags").get();
+    if (count && count.count > 0)
+      return;
+  } catch {
+    return;
+  }
+  try {
+    const rows = db.query("SELECT id, tags FROM tasks WHERE tags IS NOT NULL AND tags != '[]'").all();
+    if (rows.length === 0)
+      return;
+    const insert = db.prepare("INSERT OR IGNORE INTO task_tags (task_id, tag) VALUES (?, ?)");
+    for (const row of rows) {
+      if (!row.tags)
+        continue;
+      let tags = [];
+      try {
+        tags = JSON.parse(row.tags);
+      } catch {
+        continue;
+      }
+      for (const tag of tags) {
+        if (tag)
+          insert.run(row.id, tag);
+      }
+    }
+  } catch {}
+}
 function now() {
   return new Date().toISOString();
 }
@@ -2123,6 +2188,14 @@ function isLockExpired(lockedAt) {
   const expiryMs = LOCK_EXPIRY_MINUTES * 60 * 1000;
   return Date.now() - lockTime > expiryMs;
 }
+function lockExpiryCutoff(nowMs = Date.now()) {
+  const expiryMs = LOCK_EXPIRY_MINUTES * 60 * 1000;
+  return new Date(nowMs - expiryMs).toISOString();
+}
+function clearExpiredLocks(db) {
+  const cutoff = lockExpiryCutoff();
+  db.run("UPDATE tasks SET locked_by = NULL, locked_at = NULL WHERE locked_at IS NOT NULL AND locked_at < ?", [cutoff]);
+}
 function resolvePartialId(db, table, partialId) {
   if (partialId.length >= 36) {
     const row = db.query(`SELECT id FROM ${table} WHERE id = ?`).get(partialId);
@@ -2215,12 +2288,43 @@ var init_database = __esm(() => {
   );
 
   INSERT OR IGNORE INTO _migrations (id) VALUES (1);
+  `,
+    `
+  ALTER TABLE projects ADD COLUMN task_list_id TEXT;
+  INSERT OR IGNORE INTO _migrations (id) VALUES (2);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_tags (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    tag TEXT NOT NULL,
+    PRIMARY KEY (task_id, tag)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_tags_tag ON task_tags(tag);
+  CREATE INDEX IF NOT EXISTS idx_task_tags_task ON task_tags(task_id);
+
+  INSERT OR IGNORE INTO _migrations (id) VALUES (3);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS plans (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    name TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'completed', 'archived')),
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_plans_project ON plans(project_id);
+  CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
+  ALTER TABLE tasks ADD COLUMN plan_id TEXT REFERENCES plans(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_plan ON tasks(plan_id);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (4);
   `
   ];
 });
 
 // src/types/index.ts
-var VersionConflictError, TaskNotFoundError, LockError, DependencyCycleError;
+var VersionConflictError, TaskNotFoundError, ProjectNotFoundError, PlanNotFoundError, LockError, DependencyCycleError;
 var init_types = __esm(() => {
   VersionConflictError = class VersionConflictError extends Error {
     taskId;
@@ -2242,6 +2346,22 @@ var init_types = __esm(() => {
       this.name = "TaskNotFoundError";
     }
   };
+  ProjectNotFoundError = class ProjectNotFoundError extends Error {
+    projectId;
+    constructor(projectId) {
+      super(`Project not found: ${projectId}`);
+      this.projectId = projectId;
+      this.name = "ProjectNotFoundError";
+    }
+  };
+  PlanNotFoundError = class PlanNotFoundError extends Error {
+    planId;
+    constructor(planId) {
+      super(`Plan not found: ${planId}`);
+      this.planId = planId;
+      this.name = "PlanNotFoundError";
+    }
+  };
   LockError = class LockError extends Error {
     taskId;
     lockedBy;
@@ -2274,15 +2394,30 @@ function rowToTask(row) {
     priority: row.priority
   };
 }
+function insertTaskTags(taskId, tags, db) {
+  if (tags.length === 0)
+    return;
+  const stmt = db.prepare("INSERT OR IGNORE INTO task_tags (task_id, tag) VALUES (?, ?)");
+  for (const tag of tags) {
+    if (tag)
+      stmt.run(taskId, tag);
+  }
+}
+function replaceTaskTags(taskId, tags, db) {
+  db.run("DELETE FROM task_tags WHERE task_id = ?", [taskId]);
+  insertTaskTags(taskId, tags, db);
+}
 function createTask(input, db) {
   const d = db || getDatabase();
   const id = uuid();
   const timestamp = now();
-  d.run(`INSERT INTO tasks (id, project_id, parent_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`, [
+  const tags = input.tags || [];
+  d.run(`INSERT INTO tasks (id, project_id, parent_id, plan_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`, [
     id,
     input.project_id || null,
     input.parent_id || null,
+    input.plan_id || null,
     input.title,
     input.description || null,
     input.status || "pending",
@@ -2291,11 +2426,14 @@ function createTask(input, db) {
     input.assigned_to || null,
     input.session_id || null,
     input.working_dir || null,
-    JSON.stringify(input.tags || []),
+    JSON.stringify(tags),
     JSON.stringify(input.metadata || {}),
     timestamp,
     timestamp
   ]);
+  if (tags.length > 0) {
+    insertTaskTags(id, tags, d);
+  }
   return getTask(id, d);
 }
 function getTask(id, db) {
@@ -2333,6 +2471,7 @@ function getTaskWithRelations(id, db) {
 }
 function listTasks(filter = {}, db) {
   const d = db || getDatabase();
+  clearExpiredLocks(d);
   const conditions = [];
   const params = [];
   if (filter.project_id) {
@@ -2378,9 +2517,13 @@ function listTasks(filter = {}, db) {
     params.push(filter.session_id);
   }
   if (filter.tags && filter.tags.length > 0) {
-    const tagConditions = filter.tags.map(() => "tags LIKE ?");
-    conditions.push(`(${tagConditions.join(" OR ")})`);
-    params.push(...filter.tags.map((t) => `%"${t}"%`));
+    const placeholders = filter.tags.map(() => "?").join(",");
+    conditions.push(`id IN (SELECT task_id FROM task_tags WHERE tag IN (${placeholders}))`);
+    params.push(...filter.tags);
+  }
+  if (filter.plan_id) {
+    conditions.push("plan_id = ?");
+    params.push(filter.plan_id);
   }
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
   const rows = d.query(`SELECT * FROM tasks ${where} ORDER BY
@@ -2430,12 +2573,19 @@ function updateTask(id, input, db) {
     sets.push("metadata = ?");
     params.push(JSON.stringify(input.metadata));
   }
+  if (input.plan_id !== undefined) {
+    sets.push("plan_id = ?");
+    params.push(input.plan_id);
+  }
   params.push(id, input.version);
   const result = d.run(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ? AND version = ?`, params);
   if (result.changes === 0) {
     const current = getTask(id, d);
     throw new VersionConflictError(id, input.version, current?.version ?? -1);
   }
+  if (input.tags !== undefined) {
+    replaceTaskTags(id, input.tags, d);
+  }
   return getTask(id, d);
 }
 function deleteTask(id, db) {
@@ -2445,15 +2595,18 @@ function deleteTask(id, db) {
 }
 function startTask(id, agentId, db) {
   const d = db || getDatabase();
-  const task = getTask(id, d);
-  if (!task)
-    throw new TaskNotFoundError(id);
-  if (task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
-    throw new LockError(id, task.locked_by);
-  }
+  const cutoff = lockExpiryCutoff();
   const timestamp = now();
-  d.run(`UPDATE tasks SET status = 'in_progress', assigned_to = ?, locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
-     WHERE id = ?`, [agentId, agentId, timestamp, timestamp, id]);
+  const result = d.run(`UPDATE tasks SET status = 'in_progress', assigned_to = ?, locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ? AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, agentId, timestamp, timestamp, id, agentId, cutoff]);
+  if (result.changes === 0) {
+    const current = getTask(id, d);
+    if (!current)
+      throw new TaskNotFoundError(id);
+    if (current.locked_by && current.locked_by !== agentId && !isLockExpired(current.locked_at)) {
+      throw new LockError(id, current.locked_by);
+    }
+  }
   return getTask(id, d);
 }
 function completeTask(id, agentId, db) {
@@ -2474,20 +2627,26 @@ function lockTask(id, agentId, db) {
   const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
-  if (task.locked_by === agentId) {
+  if (task.locked_by === agentId && !isLockExpired(task.locked_at)) {
     return { success: true, locked_by: agentId, locked_at: task.locked_at };
   }
-  if (task.locked_by && !isLockExpired(task.locked_at)) {
-    return {
-      success: false,
-      locked_by: task.locked_by,
-      locked_at: task.locked_at,
-      error: `Task is locked by ${task.locked_by}`
-    };
-  }
+  const cutoff = lockExpiryCutoff();
   const timestamp = now();
-  d.run(`UPDATE tasks SET locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
-     WHERE id = ?`, [agentId, timestamp, timestamp, id]);
+  const result = d.run(`UPDATE tasks SET locked_by = ?, locked_at = ?, version = version + 1, updated_at = ?
+     WHERE id = ? AND (locked_by IS NULL OR locked_by = ? OR locked_at < ?)`, [agentId, timestamp, timestamp, id, agentId, cutoff]);
+  if (result.changes === 0) {
+    const current = getTask(id, d);
+    if (!current)
+      throw new TaskNotFoundError(id);
+    if (current.locked_by && !isLockExpired(current.locked_at)) {
+      return {
+        success: false,
+        locked_by: current.locked_by,
+        locked_at: current.locked_at,
+        error: `Task is locked by ${current.locked_by}`
+      };
+    }
+  }
   return { success: true, locked_by: agentId, locked_at: timestamp };
 }
 function unlockTask(id, agentId, db) {
@@ -2542,12 +2701,16 @@ var init_tasks = __esm(() => {
 });
 
 // src/db/projects.ts
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
 function createProject(input, db) {
   const d = db || getDatabase();
   const id = uuid();
   const timestamp = now();
-  d.run(`INSERT INTO projects (id, name, path, description, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?)`, [id, input.name, input.path, input.description || null, timestamp, timestamp]);
+  const taskListId = input.task_list_id ?? `todos-${slugify(input.name)}`;
+  d.run(`INSERT INTO projects (id, name, path, description, task_list_id, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, [id, input.name, input.path, input.description || null, taskListId, timestamp, timestamp]);
   return getProject(id, d);
 }
 function getProject(id, db) {
@@ -2564,6 +2727,34 @@ function listProjects(db) {
   const d = db || getDatabase();
   return d.query("SELECT * FROM projects ORDER BY name").all();
 }
+function updateProject(id, input, db) {
+  const d = db || getDatabase();
+  const project = getProject(id, d);
+  if (!project)
+    throw new ProjectNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.task_list_id !== undefined) {
+    sets.push("task_list_id = ?");
+    params.push(input.task_list_id);
+  }
+  params.push(id);
+  d.run(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getProject(id, d);
+}
+function deleteProject(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM projects WHERE id = ?", [id]);
+  return result.changes > 0;
+}
 function ensureProject(name, path, db) {
   const d = db || getDatabase();
   const existing = getProjectByPath(path, d);
@@ -2576,6 +2767,68 @@ var init_projects = __esm(() => {
   init_database();
 });
 
+// src/db/plans.ts
+function createPlan(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO plans (id, project_id, name, description, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.project_id || null,
+    input.name,
+    input.description || null,
+    input.status || "active",
+    timestamp,
+    timestamp
+  ]);
+  return getPlan(id, d);
+}
+function getPlan(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM plans WHERE id = ?").get(id);
+  return row;
+}
+function listPlans(projectId, db) {
+  const d = db || getDatabase();
+  if (projectId) {
+    return d.query("SELECT * FROM plans WHERE project_id = ? ORDER BY created_at DESC").all(projectId);
+  }
+  return d.query("SELECT * FROM plans ORDER BY created_at DESC").all();
+}
+function updatePlan(id, input, db) {
+  const d = db || getDatabase();
+  const plan = getPlan(id, d);
+  if (!plan)
+    throw new PlanNotFoundError(id);
+  const sets = ["updated_at = ?"];
+  const params = [now()];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.description !== undefined) {
+    sets.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  params.push(id);
+  d.run(`UPDATE plans SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getPlan(id, d);
+}
+function deletePlan(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM plans WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+var init_plans = __esm(() => {
+  init_types();
+  init_database();
+});
+
 // src/db/comments.ts
 function addComment(input, db) {
   const d = db || getDatabase();
@@ -2621,8 +2874,9 @@ function rowToTask2(row) {
 }
 function searchTasks(query, projectId, db) {
   const d = db || getDatabase();
+  clearExpiredLocks(d);
   const pattern = `%${query}%`;
-  let sql = `SELECT * FROM tasks WHERE (title LIKE ? OR description LIKE ? OR tags LIKE ?)`;
+  let sql = `SELECT * FROM tasks WHERE (title LIKE ? OR description LIKE ? OR EXISTS (SELECT 1 FROM task_tags WHERE task_tags.task_id = tasks.id AND tag LIKE ?))`;
   const params = [pattern, pattern, pattern];
   if (projectId) {
     sql += " AND project_id = ?";
@@ -2638,11 +2892,28 @@ var init_search = __esm(() => {
   init_database();
 });
 
-// src/lib/claude-tasks.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, writeFileSync } from "fs";
+// src/lib/sync-utils.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync as readdirSync2, statSync, writeFileSync } from "fs";
 import { join as join2 } from "path";
-function getTaskListDir(taskListId) {
-  return join2(HOME, ".claude", "tasks", taskListId);
+function ensureDir2(dir) {
+  if (!existsSync2(dir))
+    mkdirSync2(dir, { recursive: true });
+}
+function listJsonFiles(dir) {
+  if (!existsSync2(dir))
+    return [];
+  return readdirSync2(dir).filter((f) => f.endsWith(".json"));
+}
+function readJsonFile(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeJsonFile(path, data) {
+  writeFileSync(path, JSON.stringify(data, null, 2) + `
+`);
 }
 function readHighWaterMark(dir) {
   const path = join2(dir, ".highwatermark");
@@ -2654,17 +2925,40 @@ function readHighWaterMark(dir) {
 function writeHighWaterMark(dir, value) {
   writeFileSync(join2(dir, ".highwatermark"), String(value));
 }
-function readClaudeTask(dir, filename) {
+function getFileMtimeMs(path) {
   try {
-    const content = readFileSync(join2(dir, filename), "utf-8");
-    return JSON.parse(content);
+    return statSync(path).mtimeMs;
   } catch {
     return null;
   }
 }
+function parseTimestamp(value) {
+  if (typeof value !== "string")
+    return null;
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function appendSyncConflict(metadata, conflict, limit = 5) {
+  const current = Array.isArray(metadata["sync_conflicts"]) ? metadata["sync_conflicts"] : [];
+  const next = [conflict, ...current].slice(0, limit);
+  return { ...metadata, sync_conflicts: next };
+}
+var HOME;
+var init_sync_utils = __esm(() => {
+  HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+});
+
+// src/lib/claude-tasks.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function getTaskListDir(taskListId) {
+  return join3(HOME, ".claude", "tasks", taskListId);
+}
+function readClaudeTask(dir, filename) {
+  return readJsonFile(join3(dir, filename));
+}
 function writeClaudeTask(dir, task) {
-  writeFileSync(join2(dir, `${task.id}.json`), JSON.stringify(task, null, 2) + `
-`);
+  writeJsonFile(join3(dir, `${task.id}.json`), task);
 }
 function toClaudeStatus(status) {
   if (status === "pending" || status === "in_progress" || status === "completed") {
@@ -2675,7 +2969,7 @@ function toClaudeStatus(status) {
 function toSqliteStatus(status) {
   return status;
 }
-function taskToClaudeTask(task, claudeTaskId) {
+function taskToClaudeTask(task, claudeTaskId, existingMeta) {
   return {
     id: claudeTaskId,
     subject: task.title,
@@ -2686,39 +2980,80 @@ function taskToClaudeTask(task, claudeTaskId) {
     blocks: [],
     blockedBy: [],
     metadata: {
+      ...existingMeta || {},
       todos_id: task.id,
-      priority: task.priority
+      priority: task.priority,
+      todos_updated_at: task.updated_at,
+      todos_version: task.version
     }
   };
 }
-function pushToClaudeTaskList(taskListId, projectId) {
+function pushToClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync2(dir))
-    mkdirSync2(dir, { recursive: true });
+  if (!existsSync3(dir))
+    ensureDir2(dir);
   const filter = {};
   if (projectId)
     filter["project_id"] = projectId;
   const tasks = listTasks(filter);
   const existingByTodosId = new Map;
-  const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const files = listJsonFiles(dir);
   for (const f of files) {
+    const path = join3(dir, f);
     const ct = readClaudeTask(dir, f);
     if (ct?.metadata?.["todos_id"]) {
-      existingByTodosId.set(ct.metadata["todos_id"], ct);
+      existingByTodosId.set(ct.metadata["todos_id"], { task: ct, mtimeMs: getFileMtimeMs(path) });
     }
   }
   let hwm = readHighWaterMark(dir);
   let pushed = 0;
   const errors = [];
+  const prefer = options.prefer || "remote";
   for (const task of tasks) {
     try {
       const existing = existingByTodosId.get(task.id);
       if (existing) {
-        const updated = taskToClaudeTask(task, existing.id);
-        updated.blocks = existing.blocks;
-        updated.blockedBy = existing.blockedBy;
-        updated.activeForm = existing.activeForm;
+        const lastSyncedAt = parseTimestamp(existing.task.metadata?.["todos_updated_at"]);
+        const localUpdatedAt = parseTimestamp(task.updated_at);
+        const remoteUpdatedAt = existing.mtimeMs;
+        let recordConflict = false;
+        if (lastSyncedAt && localUpdatedAt && remoteUpdatedAt && localUpdatedAt > lastSyncedAt && remoteUpdatedAt > lastSyncedAt) {
+          if (prefer === "remote") {
+            const conflict = {
+              agent: "claude",
+              direction: "push",
+              prefer,
+              local_updated_at: task.updated_at,
+              remote_updated_at: new Date(remoteUpdatedAt).toISOString(),
+              detected_at: new Date().toISOString()
+            };
+            const newMeta = appendSyncConflict(task.metadata, conflict);
+            updateTask(task.id, { version: task.version, metadata: newMeta });
+            errors.push(`conflict push ${task.id}: remote newer`);
+            continue;
+          }
+          recordConflict = true;
+        }
+        const updated = taskToClaudeTask(task, existing.task.id, existing.task.metadata);
+        updated.blocks = existing.task.blocks;
+        updated.blockedBy = existing.task.blockedBy;
+        updated.activeForm = existing.task.activeForm;
         writeClaudeTask(dir, updated);
+        if (recordConflict) {
+          const latest = getTask(task.id);
+          if (latest) {
+            const conflict = {
+              agent: "claude",
+              direction: "push",
+              prefer,
+              local_updated_at: latest.updated_at,
+              remote_updated_at: remoteUpdatedAt ? new Date(remoteUpdatedAt).toISOString() : undefined,
+              detected_at: new Date().toISOString()
+            };
+            const newMeta = appendSyncConflict(latest.metadata, conflict);
+            updateTask(latest.id, { version: latest.version, metadata: newMeta });
+          }
+        }
       } else {
         const claudeId = String(hwm);
         hwm++;
@@ -2738,14 +3073,15 @@ function pushToClaudeTaskList(taskListId, projectId) {
   writeHighWaterMark(dir, hwm);
   return { pushed, pulled: 0, errors };
 }
-function pullFromClaudeTaskList(taskListId, projectId) {
+function pullFromClaudeTaskList(taskListId, projectId, options = {}) {
   const dir = getTaskListDir(taskListId);
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
   }
   const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
   let pulled = 0;
   const errors = [];
+  const prefer = options.prefer || "remote";
   const allTasks = listTasks({});
   const byClaudeId = new Map;
   for (const t of allTasks) {
@@ -2759,6 +3095,7 @@ function pullFromClaudeTaskList(taskListId, projectId) {
   }
   for (const f of files) {
     try {
+      const filePath = join3(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -2769,13 +3106,33 @@ function pullFromClaudeTaskList(taskListId, projectId) {
       const existingByTodos = todosId ? byTodosId.get(todosId) : undefined;
       const existing = existingByMapping || existingByTodos;
       if (existing) {
+        const lastSyncedAt = parseTimestamp(ct.metadata?.["todos_updated_at"]);
+        const localUpdatedAt = parseTimestamp(existing.updated_at);
+        const remoteUpdatedAt = getFileMtimeMs(filePath);
+        let conflictMeta = null;
+        if (lastSyncedAt && localUpdatedAt && remoteUpdatedAt && localUpdatedAt > lastSyncedAt && remoteUpdatedAt > lastSyncedAt) {
+          const conflict = {
+            agent: "claude",
+            direction: "pull",
+            prefer,
+            local_updated_at: existing.updated_at,
+            remote_updated_at: new Date(remoteUpdatedAt).toISOString(),
+            detected_at: new Date().toISOString()
+          };
+          conflictMeta = appendSyncConflict(existing.metadata, conflict);
+          if (prefer === "local") {
+            updateTask(existing.id, { version: existing.version, metadata: conflictMeta });
+            errors.push(`conflict pull ${existing.id}: local newer`);
+            continue;
+          }
+        }
         updateTask(existing.id, {
           version: existing.version,
           title: ct.subject,
           description: ct.description || undefined,
           status: toSqliteStatus(ct.status),
           assigned_to: ct.owner || undefined,
-          metadata: { ...existing.metadata, claude_task_id: ct.id }
+          metadata: { ...conflictMeta || existing.metadata, claude_task_id: ct.id, ...ct.metadata }
         });
       } else {
         createTask({
@@ -2784,7 +3141,7 @@ function pullFromClaudeTaskList(taskListId, projectId) {
           status: toSqliteStatus(ct.status),
           assigned_to: ct.owner || undefined,
           project_id: projectId,
-          metadata: { claude_task_id: ct.id },
+          metadata: { ...ct.metadata, claude_task_id: ct.id },
           priority: ct.metadata?.["priority"] || "medium"
         });
       }
@@ -2795,19 +3152,349 @@ function pullFromClaudeTaskList(taskListId, projectId) {
   }
   return { pushed: 0, pulled, errors };
 }
-function syncClaudeTaskList(taskListId, projectId) {
-  const pullResult = pullFromClaudeTaskList(taskListId, projectId);
-  const pushResult = pushToClaudeTaskList(taskListId, projectId);
+function syncClaudeTaskList(taskListId, projectId, options = {}) {
+  const pullResult = pullFromClaudeTaskList(taskListId, projectId, options);
+  const pushResult = pushToClaudeTaskList(taskListId, projectId, options);
   return {
     pushed: pushResult.pushed,
     pulled: pullResult.pulled,
     errors: [...pullResult.errors, ...pushResult.errors]
   };
 }
-var HOME;
 var init_claude_tasks = __esm(() => {
   init_tasks();
-  HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  init_sync_utils();
+});
+
+// src/lib/config.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+function normalizeAgent(agent) {
+  return agent.trim().toLowerCase();
+}
+function loadConfig() {
+  if (cached)
+    return cached;
+  if (!existsSync4(CONFIG_PATH)) {
+    cached = {};
+    return cached;
+  }
+  const config = readJsonFile(CONFIG_PATH) || {};
+  if (typeof config.sync_agents === "string") {
+    config.sync_agents = config.sync_agents.split(",").map((a) => a.trim()).filter(Boolean);
+  }
+  cached = config;
+  return cached;
+}
+function getSyncAgentsFromConfig() {
+  const config = loadConfig();
+  const agents = config.sync_agents;
+  if (Array.isArray(agents) && agents.length > 0)
+    return agents.map(normalizeAgent);
+  return null;
+}
+function getAgentTaskListId(agent) {
+  const config = loadConfig();
+  const key = normalizeAgent(agent);
+  return config.agents?.[key]?.task_list_id || config.task_list_id || null;
+}
+function getAgentTasksDir(agent) {
+  const config = loadConfig();
+  const key = normalizeAgent(agent);
+  return config.agents?.[key]?.tasks_dir || config.agent_tasks_dir || null;
+}
+var CONFIG_PATH, cached = null;
+var init_config = __esm(() => {
+  init_sync_utils();
+  CONFIG_PATH = join4(HOME, ".todos", "config.json");
+});
+
+// src/lib/agent-tasks.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+function agentBaseDir(agent) {
+  const key = `TODOS_${agent.toUpperCase()}_TASKS_DIR`;
+  return process.env[key] || getAgentTasksDir(agent) || process.env["TODOS_AGENT_TASKS_DIR"] || join5(HOME, ".todos", "agents");
+}
+function getTaskListDir2(agent, taskListId) {
+  return join5(agentBaseDir(agent), agent, taskListId);
+}
+function readAgentTask(dir, filename) {
+  return readJsonFile(join5(dir, filename));
+}
+function writeAgentTask(dir, task) {
+  writeJsonFile(join5(dir, `${task.id}.json`), task);
+}
+function taskToAgentTask(task, externalId, existingMeta) {
+  return {
+    id: externalId,
+    title: task.title,
+    description: task.description || "",
+    status: task.status,
+    priority: task.priority,
+    assigned_to: task.assigned_to || task.agent_id || "",
+    tags: task.tags || [],
+    metadata: {
+      ...existingMeta || {},
+      ...task.metadata,
+      todos_id: task.id,
+      todos_updated_at: task.updated_at,
+      todos_version: task.version
+    }
+  };
+}
+function metadataKey(agent) {
+  return `${agent}_task_id`;
+}
+function pushToAgentTaskList(agent, taskListId, projectId, options = {}) {
+  const dir = getTaskListDir2(agent, taskListId);
+  if (!existsSync5(dir))
+    ensureDir2(dir);
+  const filter = {};
+  if (projectId)
+    filter["project_id"] = projectId;
+  const tasks = listTasks(filter);
+  const existingByTodosId = new Map;
+  const files = listJsonFiles(dir);
+  for (const f of files) {
+    const path = join5(dir, f);
+    const at = readAgentTask(dir, f);
+    if (at?.metadata?.["todos_id"]) {
+      existingByTodosId.set(at.metadata["todos_id"], { task: at, mtimeMs: getFileMtimeMs(path) });
+    }
+  }
+  let hwm = readHighWaterMark(dir);
+  let pushed = 0;
+  const errors = [];
+  const metaKey = metadataKey(agent);
+  const prefer = options.prefer || "remote";
+  for (const task of tasks) {
+    try {
+      const existing = existingByTodosId.get(task.id);
+      if (existing) {
+        const lastSyncedAt = parseTimestamp(existing.task.metadata?.["todos_updated_at"]);
+        const localUpdatedAt = parseTimestamp(task.updated_at);
+        const remoteUpdatedAt = existing.mtimeMs;
+        let recordConflict = false;
+        if (lastSyncedAt && localUpdatedAt && remoteUpdatedAt && localUpdatedAt > lastSyncedAt && remoteUpdatedAt > lastSyncedAt) {
+          if (prefer === "remote") {
+            const conflict = {
+              agent,
+              direction: "push",
+              prefer,
+              local_updated_at: task.updated_at,
+              remote_updated_at: new Date(remoteUpdatedAt).toISOString(),
+              detected_at: new Date().toISOString()
+            };
+            const newMeta = appendSyncConflict(task.metadata, conflict);
+            updateTask(task.id, { version: task.version, metadata: newMeta });
+            errors.push(`conflict push ${task.id}: remote newer`);
+            continue;
+          }
+          recordConflict = true;
+        }
+        const updated = taskToAgentTask(task, existing.task.id, existing.task.metadata);
+        writeAgentTask(dir, updated);
+        if (recordConflict) {
+          const latest = getTask(task.id);
+          if (latest) {
+            const conflict = {
+              agent,
+              direction: "push",
+              prefer,
+              local_updated_at: latest.updated_at,
+              remote_updated_at: remoteUpdatedAt ? new Date(remoteUpdatedAt).toISOString() : undefined,
+              detected_at: new Date().toISOString()
+            };
+            const newMeta = appendSyncConflict(latest.metadata, conflict);
+            updateTask(latest.id, { version: latest.version, metadata: newMeta });
+          }
+        }
+      } else {
+        const externalId = String(hwm);
+        hwm++;
+        const at = taskToAgentTask(task, externalId);
+        writeAgentTask(dir, at);
+        const current = getTask(task.id);
+        if (current) {
+          const newMeta = { ...current.metadata, [metaKey]: externalId };
+          updateTask(task.id, { version: current.version, metadata: newMeta });
+        }
+      }
+      pushed++;
+    } catch (e) {
+      errors.push(`push ${task.id}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  writeHighWaterMark(dir, hwm);
+  return { pushed, pulled: 0, errors };
+}
+function pullFromAgentTaskList(agent, taskListId, projectId, options = {}) {
+  const dir = getTaskListDir2(agent, taskListId);
+  if (!existsSync5(dir)) {
+    return { pushed: 0, pulled: 0, errors: [`Task list directory not found: ${dir}`] };
+  }
+  const files = listJsonFiles(dir);
+  let pulled = 0;
+  const errors = [];
+  const metaKey = metadataKey(agent);
+  const prefer = options.prefer || "remote";
+  const allTasks = listTasks({});
+  const byExternalId = new Map;
+  const byTodosId = new Map;
+  for (const t of allTasks) {
+    const extId = t.metadata[metaKey];
+    if (extId)
+      byExternalId.set(String(extId), t);
+    byTodosId.set(t.id, t);
+  }
+  for (const f of files) {
+    try {
+      const filePath = join5(dir, f);
+      const at = readAgentTask(dir, f);
+      if (!at)
+        continue;
+      if (at.metadata?.["_internal"])
+        continue;
+      const todosId = at.metadata?.["todos_id"];
+      const existingByMapping = byExternalId.get(at.id);
+      const existingByTodos = todosId ? byTodosId.get(todosId) : undefined;
+      const existing = existingByMapping || existingByTodos;
+      if (existing) {
+        const lastSyncedAt = parseTimestamp(at.metadata?.["todos_updated_at"]);
+        const localUpdatedAt = parseTimestamp(existing.updated_at);
+        const remoteUpdatedAt = getFileMtimeMs(filePath);
+        let conflictMeta = null;
+        if (lastSyncedAt && localUpdatedAt && remoteUpdatedAt && localUpdatedAt > lastSyncedAt && remoteUpdatedAt > lastSyncedAt) {
+          const conflict = {
+            agent,
+            direction: "pull",
+            prefer,
+            local_updated_at: existing.updated_at,
+            remote_updated_at: new Date(remoteUpdatedAt).toISOString(),
+            detected_at: new Date().toISOString()
+          };
+          conflictMeta = appendSyncConflict(existing.metadata, conflict);
+          if (prefer === "local") {
+            updateTask(existing.id, { version: existing.version, metadata: conflictMeta });
+            errors.push(`conflict pull ${existing.id}: local newer`);
+            continue;
+          }
+        }
+        updateTask(existing.id, {
+          version: existing.version,
+          title: at.title,
+          description: at.description || undefined,
+          status: at.status,
+          priority: at.priority,
+          assigned_to: at.assigned_to || undefined,
+          tags: at.tags || [],
+          metadata: { ...conflictMeta || existing.metadata, ...at.metadata, [metaKey]: at.id }
+        });
+      } else {
+        createTask({
+          title: at.title,
+          description: at.description || undefined,
+          status: at.status,
+          priority: at.priority || "medium",
+          assigned_to: at.assigned_to || undefined,
+          tags: at.tags || [],
+          project_id: projectId,
+          metadata: { ...at.metadata, [metaKey]: at.id }
+        });
+      }
+      pulled++;
+    } catch (e) {
+      errors.push(`pull ${f}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return { pushed: 0, pulled, errors };
+}
+function syncAgentTaskList(agent, taskListId, projectId, options = {}) {
+  const pullResult = pullFromAgentTaskList(agent, taskListId, projectId, options);
+  const pushResult = pushToAgentTaskList(agent, taskListId, projectId, options);
+  return {
+    pushed: pushResult.pushed,
+    pulled: pullResult.pulled,
+    errors: [...pullResult.errors, ...pushResult.errors]
+  };
+}
+var init_agent_tasks = __esm(() => {
+  init_tasks();
+  init_sync_utils();
+  init_config();
+});
+
+// src/lib/sync.ts
+function normalizeAgent2(agent) {
+  return agent.trim().toLowerCase();
+}
+function isClaudeAgent(agent) {
+  const a = normalizeAgent2(agent);
+  return a === "claude" || a === "claude-code" || a === "claude_code";
+}
+function defaultSyncAgents() {
+  const env = process.env["TODOS_SYNC_AGENTS"];
+  if (env) {
+    return env.split(",").map((a) => a.trim()).filter(Boolean);
+  }
+  const fromConfig = getSyncAgentsFromConfig();
+  if (fromConfig && fromConfig.length > 0)
+    return fromConfig;
+  return ["claude", "codex", "gemini"];
+}
+function syncWithAgent(agent, taskListId, projectId, direction = "both", options = {}) {
+  const normalized = normalizeAgent2(agent);
+  if (isClaudeAgent(normalized)) {
+    if (direction === "push")
+      return pushToClaudeTaskList(taskListId, projectId, options);
+    if (direction === "pull")
+      return pullFromClaudeTaskList(taskListId, projectId, options);
+    return syncClaudeTaskList(taskListId, projectId, options);
+  }
+  if (direction === "push")
+    return pushToAgentTaskList(normalized, taskListId, projectId, options);
+  if (direction === "pull")
+    return pullFromAgentTaskList(normalized, taskListId, projectId, options);
+  return syncAgentTaskList(normalized, taskListId, projectId, options);
+}
+function syncWithAgents(agents, taskListIdByAgent, projectId, direction = "both", options = {}) {
+  let pushed = 0;
+  let pulled = 0;
+  const errors = [];
+  const normalized = agents.map(normalizeAgent2);
+  if (direction === "pull" || direction === "both") {
+    for (const agent of normalized) {
+      const listId = taskListIdByAgent(agent);
+      if (!listId) {
+        errors.push(`sync ${agent}: missing task list id`);
+        continue;
+      }
+      const result = syncWithAgent(agent, listId, projectId, "pull", options);
+      pushed += result.pushed;
+      pulled += result.pulled;
+      errors.push(...result.errors.map((e) => `${agent}: ${e}`));
+    }
+  }
+  if (direction === "push" || direction === "both") {
+    for (const agent of normalized) {
+      const listId = taskListIdByAgent(agent);
+      if (!listId) {
+        errors.push(`sync ${agent}: missing task list id`);
+        continue;
+      }
+      const result = syncWithAgent(agent, listId, projectId, "push", options);
+      pushed += result.pushed;
+      pulled += result.pulled;
+      errors.push(...result.errors.map((e) => `${agent}: ${e}`));
+    }
+  }
+  return { pushed, pulled, errors };
+}
+var init_sync = __esm(() => {
+  init_claude_tasks();
+  init_agent_tasks();
+  init_config();
 });
 
 // node_modules/zod/v3/helpers/util.js
@@ -6785,6 +7472,8 @@ function formatError(error) {
     return `Version conflict: ${error.message}`;
   if (error instanceof TaskNotFoundError)
     return `Not found: ${error.message}`;
+  if (error instanceof PlanNotFoundError)
+    return `Not found: ${error.message}`;
   if (error instanceof LockError)
     return `Lock error: ${error.message}`;
   if (error instanceof DependencyCycleError)
@@ -6800,6 +7489,16 @@ function resolveId(partialId, table = "tasks") {
     throw new Error(`Could not resolve ID: ${partialId}`);
   return id;
 }
+function resolveTaskListId(agent, explicit) {
+  if (explicit)
+    return explicit;
+  const normalized = agent.trim().toLowerCase();
+  if (normalized === "claude" || normalized === "claude-code" || normalized === "claude_code") {
+    return process.env["TODOS_CLAUDE_TASK_LIST"] || process.env["CLAUDE_CODE_TASK_LIST_ID"] || process.env["CLAUDE_CODE_SESSION_ID"] || getAgentTaskListId(normalized) || null;
+  }
+  const key = `TODOS_${normalized.toUpperCase()}_TASK_LIST`;
+  return process.env[key] || process.env["TODOS_TASK_LIST_ID"] || getAgentTaskListId(normalized) || "default";
+}
 function formatTask(task) {
   const parts = [
     `ID: ${task.id}`,
@@ -6819,6 +7518,8 @@ function formatTask(task) {
     parts.push(`Parent: ${task.parent_id}`);
   if (task.project_id)
     parts.push(`Project: ${task.project_id}`);
+  if (task.plan_id)
+    parts.push(`Plan: ${task.plan_id}`);
   if (task.tags.length > 0)
     parts.push(`Tags: ${task.tags.join(", ")}`);
   parts.push(`Version: ${task.version}`);
@@ -6838,8 +7539,10 @@ var init_mcp = __esm(() => {
   init_tasks();
   init_comments();
   init_projects();
+  init_plans();
   init_search();
-  init_claude_tasks();
+  init_sync();
+  init_config();
   init_database();
   init_types();
   server = new McpServer({
@@ -6857,6 +7560,7 @@ var init_mcp = __esm(() => {
     assigned_to: exports_external.string().optional().describe("Assigned agent ID"),
     session_id: exports_external.string().optional().describe("Session ID"),
     working_dir: exports_external.string().optional().describe("Working directory context"),
+    plan_id: exports_external.string().optional().describe("Plan ID to assign task to"),
     tags: exports_external.array(exports_external.string()).optional().describe("Task tags"),
     metadata: exports_external.record(exports_external.unknown()).optional().describe("Arbitrary metadata")
   }, async (params) => {
@@ -6866,6 +7570,8 @@ var init_mcp = __esm(() => {
         resolved.project_id = resolveId(resolved.project_id, "projects");
       if (resolved.parent_id)
         resolved.parent_id = resolveId(resolved.parent_id);
+      if (resolved.plan_id)
+        resolved.plan_id = resolveId(resolved.plan_id, "plans");
       const task = createTask(resolved);
       return { content: [{ type: "text", text: `Task created:
 ${formatTask(task)}` }] };
@@ -6884,12 +7590,15 @@ ${formatTask(task)}` }] };
       exports_external.array(exports_external.enum(["low", "medium", "high", "critical"]))
     ]).optional().describe("Filter by priority"),
     assigned_to: exports_external.string().optional().describe("Filter by assigned agent"),
-    tags: exports_external.array(exports_external.string()).optional().describe("Filter by tags (any match)")
+    tags: exports_external.array(exports_external.string()).optional().describe("Filter by tags (any match)"),
+    plan_id: exports_external.string().optional().describe("Filter by plan")
   }, async (params) => {
     try {
       const resolved = { ...params };
       if (resolved.project_id)
         resolved.project_id = resolveId(resolved.project_id, "projects");
+      if (resolved.plan_id)
+        resolved.plan_id = resolveId(resolved.plan_id, "plans");
       const tasks = listTasks(resolved);
       if (tasks.length === 0) {
         return { content: [{ type: "text", text: "No tasks found." }] };
@@ -6963,7 +7672,8 @@ Parent: ${task.parent.id.slice(0, 8)} | ${task.parent.title}`);
     priority: exports_external.enum(["low", "medium", "high", "critical"]).optional().describe("New priority"),
     assigned_to: exports_external.string().optional().describe("Assign to agent"),
     tags: exports_external.array(exports_external.string()).optional().describe("New tags"),
-    metadata: exports_external.record(exports_external.unknown()).optional().describe("New metadata")
+    metadata: exports_external.record(exports_external.unknown()).optional().describe("New metadata"),
+    plan_id: exports_external.string().optional().describe("Plan ID to assign task to")
   }, async ({ id, ...rest }) => {
     try {
       const resolvedId = resolveId(id);
@@ -7074,45 +7784,151 @@ ${formatTask(task)}` }] };
       return { content: [{ type: "text", text: formatError(e) }], isError: true };
     }
   });
-  server.tool("add_comment", "Add a comment/note to a task", {
-    task_id: exports_external.string().describe("Task ID (full or partial)"),
-    content: exports_external.string().describe("Comment content"),
-    agent_id: exports_external.string().optional().describe("Agent adding comment"),
-    session_id: exports_external.string().optional().describe("Session ID")
-  }, async ({ task_id, ...rest }) => {
+  server.tool("add_comment", "Add a comment/note to a task", {
+    task_id: exports_external.string().describe("Task ID (full or partial)"),
+    content: exports_external.string().describe("Comment content"),
+    agent_id: exports_external.string().optional().describe("Agent adding comment"),
+    session_id: exports_external.string().optional().describe("Session ID")
+  }, async ({ task_id, ...rest }) => {
+    try {
+      const resolvedId = resolveId(task_id);
+      const comment = addComment({ task_id: resolvedId, ...rest });
+      return { content: [{ type: "text", text: `Comment added (${comment.id.slice(0, 8)}) at ${comment.created_at}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+  server.tool("list_projects", "List all registered projects", {}, async () => {
+    try {
+      const projects = listProjects();
+      if (projects.length === 0) {
+        return { content: [{ type: "text", text: "No projects registered." }] };
+      }
+      const text = projects.map((p) => {
+        const taskList = p.task_list_id ? ` [${p.task_list_id}]` : "";
+        return `${p.id.slice(0, 8)} | ${p.name} | ${p.path}${taskList}${p.description ? ` - ${p.description}` : ""}`;
+      }).join(`
+`);
+      return { content: [{ type: "text", text: `${projects.length} project(s):
+${text}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+  server.tool("create_project", "Register a new project", {
+    name: exports_external.string().describe("Project name"),
+    path: exports_external.string().describe("Absolute path to project"),
+    description: exports_external.string().optional().describe("Project description"),
+    task_list_id: exports_external.string().optional().describe("Custom task list ID for Claude Code sync (defaults to todos-<slugified-name>)")
+  }, async (params) => {
+    try {
+      const project = createProject(params);
+      const taskList = project.task_list_id ? ` [${project.task_list_id}]` : "";
+      return {
+        content: [{
+          type: "text",
+          text: `Project created: ${project.id.slice(0, 8)} | ${project.name} | ${project.path}${taskList}`
+        }]
+      };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+  server.tool("create_plan", "Create a new plan", {
+    name: exports_external.string().describe("Plan name"),
+    project_id: exports_external.string().optional().describe("Project ID"),
+    description: exports_external.string().optional().describe("Plan description"),
+    status: exports_external.enum(["active", "completed", "archived"]).optional().describe("Plan status")
+  }, async (params) => {
+    try {
+      const resolved = { ...params };
+      if (resolved.project_id)
+        resolved.project_id = resolveId(resolved.project_id, "projects");
+      const plan = createPlan(resolved);
+      return {
+        content: [{
+          type: "text",
+          text: `Plan created: ${plan.id.slice(0, 8)} | ${plan.name} | ${plan.status}`
+        }]
+      };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+  server.tool("list_plans", "List plans with optional project filter", {
+    project_id: exports_external.string().optional().describe("Filter by project")
+  }, async ({ project_id }) => {
+    try {
+      const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
+      const plans = listPlans(resolvedProjectId);
+      if (plans.length === 0) {
+        return { content: [{ type: "text", text: "No plans found." }] };
+      }
+      const text = plans.map((p) => {
+        const project = p.project_id ? ` (project: ${p.project_id.slice(0, 8)})` : "";
+        return `[${p.status}] ${p.id.slice(0, 8)} | ${p.name}${project}`;
+      }).join(`
+`);
+      return { content: [{ type: "text", text: `${plans.length} plan(s):
+${text}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+  server.tool("get_plan", "Get plan details", {
+    id: exports_external.string().describe("Plan ID (full or partial)")
+  }, async ({ id }) => {
     try {
-      const resolvedId = resolveId(task_id);
-      const comment = addComment({ task_id: resolvedId, ...rest });
-      return { content: [{ type: "text", text: `Comment added (${comment.id.slice(0, 8)}) at ${comment.created_at}` }] };
+      const resolvedId = resolveId(id, "plans");
+      const plan = getPlan(resolvedId);
+      if (!plan)
+        return { content: [{ type: "text", text: `Plan not found: ${id}` }], isError: true };
+      const parts = [
+        `ID: ${plan.id}`,
+        `Name: ${plan.name}`,
+        `Status: ${plan.status}`
+      ];
+      if (plan.description)
+        parts.push(`Description: ${plan.description}`);
+      if (plan.project_id)
+        parts.push(`Project: ${plan.project_id}`);
+      parts.push(`Created: ${plan.created_at}`);
+      parts.push(`Updated: ${plan.updated_at}`);
+      return { content: [{ type: "text", text: parts.join(`
+`) }] };
     } catch (e) {
       return { content: [{ type: "text", text: formatError(e) }], isError: true };
     }
   });
-  server.tool("list_projects", "List all registered projects", {}, async () => {
+  server.tool("update_plan", "Update a plan", {
+    id: exports_external.string().describe("Plan ID (full or partial)"),
+    name: exports_external.string().optional().describe("New name"),
+    description: exports_external.string().optional().describe("New description"),
+    status: exports_external.enum(["active", "completed", "archived"]).optional().describe("New status")
+  }, async ({ id, ...rest }) => {
     try {
-      const projects = listProjects();
-      if (projects.length === 0) {
-        return { content: [{ type: "text", text: "No projects registered." }] };
-      }
-      const text = projects.map((p) => `${p.id.slice(0, 8)} | ${p.name} | ${p.path}${p.description ? ` - ${p.description}` : ""}`).join(`
-`);
-      return { content: [{ type: "text", text: `${projects.length} project(s):
-${text}` }] };
+      const resolvedId = resolveId(id, "plans");
+      const plan = updatePlan(resolvedId, rest);
+      return {
+        content: [{
+          type: "text",
+          text: `Plan updated: ${plan.id.slice(0, 8)} | ${plan.name} | ${plan.status}`
+        }]
+      };
     } catch (e) {
       return { content: [{ type: "text", text: formatError(e) }], isError: true };
     }
   });
-  server.tool("create_project", "Register a new project", {
-    name: exports_external.string().describe("Project name"),
-    path: exports_external.string().describe("Absolute path to project"),
-    description: exports_external.string().optional().describe("Project description")
-  }, async (params) => {
+  server.tool("delete_plan", "Delete a plan", {
+    id: exports_external.string().describe("Plan ID (full or partial)")
+  }, async ({ id }) => {
     try {
-      const project = createProject(params);
+      const resolvedId = resolveId(id, "plans");
+      const deleted = deletePlan(resolvedId);
       return {
         content: [{
           type: "text",
-          text: `Project created: ${project.id.slice(0, 8)} | ${project.name} | ${project.path}`
+          text: deleted ? `Plan ${id} deleted.` : `Plan ${id} not found.`
         }]
       };
     } catch (e) {
@@ -7137,27 +7953,42 @@ ${text}` }] };
       return { content: [{ type: "text", text: formatError(e) }], isError: true };
     }
   });
-  server.tool("sync", "Sync tasks with a Claude Code task list. Writes SQLite tasks as JSON files to ~/.claude/tasks/<task_list_id>/ so they appear in Claude Code's native task UI. The task_list_id is your Claude Code session ID (visible in the conversation or via CLAUDE_CODE_SESSION_ID).", {
-    task_list_id: exports_external.string().describe("Claude Code task list ID \u2014 use your session ID"),
-    project_id: exports_external.string().optional().describe("Limit sync to a project"),
-    direction: exports_external.enum(["push", "pull", "both"]).optional().describe("Sync direction: push (SQLite->Claude), pull (Claude->SQLite), or both (default)")
-  }, async ({ task_list_id, project_id, direction }) => {
+  server.tool("sync", "Sync tasks with an agent task list (Claude uses native task list; others use JSON lists).", {
+    task_list_id: exports_external.string().optional().describe("Task list ID (required for Claude)"),
+    agent: exports_external.string().optional().describe("Agent/provider name (default: claude)"),
+    all_agents: exports_external.boolean().optional().describe("Sync across all configured agents"),
+    project_id: exports_external.string().optional().describe("Project ID \u2014 its task_list_id will be used for Claude if task_list_id is not provided"),
+    direction: exports_external.enum(["push", "pull", "both"]).optional().describe("Sync direction: push (SQLite->agent), pull (agent->SQLite), or both (default)"),
+    prefer: exports_external.enum(["local", "remote"]).optional().describe("Conflict strategy")
+  }, async ({ task_list_id, agent, all_agents, project_id, direction, prefer }) => {
     try {
       const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
-      const taskListId = task_list_id;
+      const project = resolvedProjectId ? getProject(resolvedProjectId) : undefined;
+      const dir = direction ?? "both";
+      const options = { prefer: prefer ?? "remote" };
       let result;
-      if (direction === "push") {
-        result = pushToClaudeTaskList(taskListId, resolvedProjectId);
-      } else if (direction === "pull") {
-        result = pullFromClaudeTaskList(taskListId, resolvedProjectId);
+      if (all_agents) {
+        const agents = defaultSyncAgents();
+        result = syncWithAgents(agents, (a) => resolveTaskListId(a, task_list_id || project?.task_list_id || undefined), resolvedProjectId, dir, options);
       } else {
-        result = syncClaudeTaskList(taskListId, resolvedProjectId);
+        const resolvedAgent = agent || "claude";
+        const taskListId = resolveTaskListId(resolvedAgent, task_list_id || project?.task_list_id || undefined);
+        if (!taskListId) {
+          return {
+            content: [{
+              type: "text",
+              text: `Could not determine task list ID for ${resolvedAgent}. Provide task_list_id or set task_list_id on the project.`
+            }],
+            isError: true
+          };
+        }
+        result = syncWithAgent(resolvedAgent, taskListId, resolvedProjectId, dir, options);
       }
       const parts = [];
       if (result.pulled > 0)
-        parts.push(`Pulled ${result.pulled} task(s) from Claude task list.`);
+        parts.push(`Pulled ${result.pulled} task(s).`);
       if (result.pushed > 0)
-        parts.push(`Pushed ${result.pushed} task(s) to Claude task list.`);
+        parts.push(`Pushed ${result.pushed} task(s).`);
       if (result.pulled === 0 && result.pushed === 0 && result.errors.length === 0) {
         parts.push("Nothing to sync.");
       }
@@ -7187,30 +8018,34 @@ ${text}` }] };
 // src/server/serve.ts
 var exports_serve = {};
 __export(exports_serve, {
-  startServer: () => startServer
+  startServer: () => startServer,
+  createFetchHandler: () => createFetchHandler
 });
 import { execSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join3, dirname as dirname2, extname } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import { join as join6, dirname as dirname2, extname } from "path";
 import { fileURLToPath } from "url";
 function resolveDashboardDir() {
   const candidates = [];
   try {
     const scriptDir = dirname2(fileURLToPath(import.meta.url));
-    candidates.push(join3(scriptDir, "..", "dashboard", "dist"));
-    candidates.push(join3(scriptDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join6(scriptDir, "..", "dashboard", "dist"));
+    candidates.push(join6(scriptDir, "..", "..", "dashboard", "dist"));
   } catch {}
   if (process.argv[1]) {
     const mainDir = dirname2(process.argv[1]);
-    candidates.push(join3(mainDir, "..", "dashboard", "dist"));
-    candidates.push(join3(mainDir, "..", "..", "dashboard", "dist"));
+    candidates.push(join6(mainDir, "..", "dashboard", "dist"));
+    candidates.push(join6(mainDir, "..", "..", "dashboard", "dist"));
   }
-  candidates.push(join3(process.cwd(), "dashboard", "dist"));
+  candidates.push(join6(process.cwd(), "dashboard", "dist"));
   for (const candidate of candidates) {
-    if (existsSync3(candidate))
+    if (existsSync6(candidate))
       return candidate;
   }
-  return join3(process.cwd(), "dashboard", "dist");
+  return join6(process.cwd(), "dashboard", "dist");
+}
+function randomPort() {
+  return 20000 + Math.floor(Math.random() * 20000);
 }
 function json(data, status = 200, port) {
   return new Response(JSON.stringify(data), {
@@ -7224,14 +8059,21 @@ function json(data, status = 200, port) {
 }
 function getPackageVersion() {
   try {
-    const pkgPath = join3(dirname2(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    const pkgPath = join6(dirname2(fileURLToPath(import.meta.url)), "..", "..", "package.json");
     return JSON.parse(readFileSync2(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
   }
 }
+async function parseJsonBody(req) {
+  try {
+    return await req.json();
+  } catch {
+    return null;
+  }
+}
 function serveStaticFile(filePath) {
-  if (!existsSync3(filePath))
+  if (!existsSync6(filePath))
     return null;
   const ext = extname(filePath);
   const contentType = MIME_TYPES[ext] || "application/octet-stream";
@@ -7239,299 +8081,474 @@ function serveStaticFile(filePath) {
     headers: { "Content-Type": contentType }
   });
 }
-async function startServer(port, options) {
-  const shouldOpen = options?.open ?? true;
-  const dashboardDir = resolveDashboardDir();
-  const dashboardExists = existsSync3(dashboardDir);
-  if (!dashboardExists) {
-    console.error(`
-Dashboard not found at: ${dashboardDir}`);
-    console.error(`Run this to build it:
-`);
-    console.error(`  cd dashboard && bun install && bun run build
-`);
-    console.error(`Or from the project root:
-`);
-    console.error(`  bun run build:dashboard
-`);
-  }
-  const server2 = Bun.serve({
-    port,
-    async fetch(req) {
-      const url = new URL(req.url);
-      const path = url.pathname;
-      const method = req.method;
-      if (path === "/api/tasks" && method === "GET") {
-        try {
-          const filter = {};
-          const status = url.searchParams.get("status");
-          const priority = url.searchParams.get("priority");
-          const projectId = url.searchParams.get("project_id");
-          if (status)
-            filter.status = status;
-          if (priority)
-            filter.priority = priority;
-          if (projectId)
-            filter.project_id = projectId;
-          const tasks = listTasks(filter);
-          const projectCache = new Map;
-          const enriched = tasks.map((t) => {
-            let projectName;
-            if (t.project_id) {
-              if (projectCache.has(t.project_id)) {
-                projectName = projectCache.get(t.project_id);
-              } else {
-                const p = getProject(t.project_id);
-                projectName = p?.name;
-                if (projectName)
-                  projectCache.set(t.project_id, projectName);
-              }
-            }
-            return { ...t, project_name: projectName };
-          });
-          return json(enriched, 200, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to list tasks" }, 500, port);
-        }
-      }
-      const taskGetMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
-      if (taskGetMatch && method === "GET") {
-        try {
-          const id = taskGetMatch[1];
-          const task = getTaskWithRelations(id);
-          if (!task)
-            return json({ error: "Task not found" }, 404, port);
+function createFetchHandler(getPort, dashboardDir, dashboardExists) {
+  const dir = dashboardDir || resolveDashboardDir();
+  const hasDashboard = dashboardExists ?? existsSync6(dir);
+  return async (req) => {
+    const url = new URL(req.url);
+    let path = url.pathname;
+    if (path.startsWith("/api/v1/")) {
+      path = path.replace("/api/v1", "/api");
+    }
+    const method = req.method;
+    const port = getPort();
+    if (path === "/api/tasks" && method === "GET") {
+      try {
+        const filter = {};
+        const status = url.searchParams.get("status");
+        const priority = url.searchParams.get("priority");
+        const projectId = url.searchParams.get("project_id");
+        if (status)
+          filter.status = status;
+        if (priority)
+          filter.priority = priority;
+        if (projectId)
+          filter.project_id = projectId;
+        const tasks = listTasks(filter);
+        const projectCache = new Map;
+        const planCache = new Map;
+        const enriched = tasks.map((t) => {
           let projectName;
-          if (task.project_id) {
-            const p = getProject(task.project_id);
-            projectName = p?.name;
+          if (t.project_id) {
+            if (projectCache.has(t.project_id)) {
+              projectName = projectCache.get(t.project_id);
+            } else {
+              const p = getProject(t.project_id);
+              projectName = p?.name;
+              if (projectName)
+                projectCache.set(t.project_id, projectName);
+            }
           }
-          return json({ ...task, project_name: projectName }, 200, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to get task" }, 500, port);
-        }
-      }
-      if (path === "/api/tasks" && method === "POST") {
-        try {
-          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
-          if (contentLength > MAX_BODY_SIZE)
-            return json({ error: "Request body too large" }, 413, port);
-          const body = await req.json();
-          if (!body.title || typeof body.title !== "string") {
-            return json({ error: "Missing required field: title" }, 400, port);
+          let planName;
+          if (t.plan_id) {
+            if (planCache.has(t.plan_id)) {
+              planName = planCache.get(t.plan_id);
+            } else {
+              const pl = getPlan(t.plan_id);
+              planName = pl?.name;
+              if (planName)
+                planCache.set(t.plan_id, planName);
+            }
           }
-          const task = createTask({
-            title: body.title,
-            description: body.description,
-            priority: body.priority,
-            project_id: body.project_id,
-            parent_id: body.parent_id,
-            tags: body.tags,
-            assigned_to: body.assigned_to,
-            agent_id: body.agent_id,
-            status: body.status
-          });
-          return json(task, 201, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to create task" }, 500, port);
-        }
+          return { ...t, project_name: projectName, plan_name: planName };
+        });
+        return json(enriched, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to list tasks" }, 500, port);
       }
-      const taskPatchMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
-      if (taskPatchMatch && method === "PATCH") {
-        try {
-          const id = taskPatchMatch[1];
-          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
-          if (contentLength > MAX_BODY_SIZE)
-            return json({ error: "Request body too large" }, 413, port);
-          const body = await req.json();
-          if (typeof body.version !== "number") {
-            return json({ error: "Missing required field: version" }, 400, port);
-          }
-          const task = updateTask(id, {
-            version: body.version,
-            title: body.title,
-            description: body.description,
-            status: body.status,
-            priority: body.priority,
-            assigned_to: body.assigned_to,
-            tags: body.tags,
-            metadata: body.metadata
-          });
-          return json(task, 200, port);
-        } catch (e) {
-          const status = e instanceof Error && e.name === "VersionConflictError" ? 409 : 500;
-          return json({ error: e instanceof Error ? e.message : "Failed to update task" }, status, port);
+    }
+    const taskGetMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
+    if (taskGetMatch && method === "GET") {
+      try {
+        const id = taskGetMatch[1];
+        const task = getTaskWithRelations(id);
+        if (!task)
+          return json({ error: "Task not found" }, 404, port);
+        let projectName;
+        if (task.project_id) {
+          const p = getProject(task.project_id);
+          projectName = p?.name;
         }
+        return json({ ...task, project_name: projectName }, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to get task" }, 500, port);
       }
-      const taskDeleteMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
-      if (taskDeleteMatch && method === "DELETE") {
-        try {
-          const id = taskDeleteMatch[1];
-          const deleted = deleteTask(id);
-          if (!deleted)
-            return json({ error: "Task not found" }, 404, port);
-          return json({ deleted: true }, 200, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to delete task" }, 500, port);
-        }
+    }
+    if (path === "/api/tasks" && method === "POST") {
+      try {
+        const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+        if (contentLength > MAX_BODY_SIZE)
+          return json({ error: "Request body too large" }, 413, port);
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        if (!body.title || typeof body.title !== "string") {
+          return json({ error: "Missing required field: title" }, 400, port);
+        }
+        const parsed = createTaskSchema.safeParse(body);
+        if (!parsed.success) {
+          return json({ error: "Invalid request body" }, 400, port);
+        }
+        const task = createTask({
+          title: parsed.data.title,
+          description: parsed.data.description,
+          priority: parsed.data.priority,
+          project_id: parsed.data.project_id,
+          parent_id: parsed.data.parent_id,
+          plan_id: parsed.data.plan_id,
+          tags: parsed.data.tags,
+          assigned_to: parsed.data.assigned_to,
+          agent_id: parsed.data.agent_id,
+          status: parsed.data.status
+        });
+        return json(task, 201, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to create task" }, 500, port);
       }
-      const taskStartMatch = path.match(/^\/api\/tasks\/([^/]+)\/start$/);
-      if (taskStartMatch && method === "POST") {
-        try {
-          const id = taskStartMatch[1];
-          const body = await req.json();
-          const agentId = body.agent_id || "dashboard";
-          const task = startTask(id, agentId);
-          return json(task, 200, port);
-        } catch (e) {
-          const status = e instanceof Error && e.name === "TaskNotFoundError" ? 404 : e instanceof Error && e.name === "LockError" ? 409 : 500;
-          return json({ error: e instanceof Error ? e.message : "Failed to start task" }, status, port);
-        }
-      }
-      const taskCompleteMatch = path.match(/^\/api\/tasks\/([^/]+)\/complete$/);
-      if (taskCompleteMatch && method === "POST") {
-        try {
-          const id = taskCompleteMatch[1];
-          const body = await req.json();
-          const agentId = body.agent_id;
-          const task = completeTask(id, agentId);
-          return json(task, 200, port);
-        } catch (e) {
-          const status = e instanceof Error && e.name === "TaskNotFoundError" ? 404 : e instanceof Error && e.name === "LockError" ? 409 : 500;
-          return json({ error: e instanceof Error ? e.message : "Failed to complete task" }, status, port);
-        }
-      }
-      const commentsGetMatch = path.match(/^\/api\/tasks\/([^/]+)\/comments$/);
-      if (commentsGetMatch && method === "GET") {
-        try {
-          const taskId = commentsGetMatch[1];
-          const comments = listComments(taskId);
-          return json(comments, 200, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to list comments" }, 500, port);
-        }
+    }
+    const taskPatchMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
+    if (taskPatchMatch && method === "PATCH") {
+      try {
+        const id = taskPatchMatch[1];
+        const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+        if (contentLength > MAX_BODY_SIZE)
+          return json({ error: "Request body too large" }, 413, port);
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        if (typeof body.version !== "number") {
+          return json({ error: "Missing required field: version" }, 400, port);
+        }
+        const parsed = updateTaskSchema.safeParse(body);
+        if (!parsed.success) {
+          return json({ error: "Invalid request body" }, 400, port);
+        }
+        const task = updateTask(id, {
+          version: parsed.data.version,
+          title: parsed.data.title,
+          description: parsed.data.description,
+          status: parsed.data.status,
+          priority: parsed.data.priority,
+          assigned_to: parsed.data.assigned_to,
+          plan_id: parsed.data.plan_id,
+          tags: parsed.data.tags,
+          metadata: parsed.data.metadata
+        });
+        return json(task, 200, port);
+      } catch (e) {
+        const status = e instanceof Error && e.name === "VersionConflictError" ? 409 : 500;
+        return json({ error: e instanceof Error ? e.message : "Failed to update task" }, status, port);
       }
-      const commentsPostMatch = path.match(/^\/api\/tasks\/([^/]+)\/comments$/);
-      if (commentsPostMatch && method === "POST") {
-        try {
-          const taskId = commentsPostMatch[1];
-          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
-          if (contentLength > MAX_BODY_SIZE)
-            return json({ error: "Request body too large" }, 413, port);
-          const body = await req.json();
-          if (!body.content || typeof body.content !== "string") {
-            return json({ error: "Missing required field: content" }, 400, port);
-          }
-          const comment = addComment({
-            task_id: taskId,
-            content: body.content,
-            agent_id: body.agent_id,
-            session_id: body.session_id
-          });
-          return json(comment, 201, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to add comment" }, 500, port);
-        }
+    }
+    const taskDeleteMatch = path.match(/^\/api\/tasks\/([^/]+)$/);
+    if (taskDeleteMatch && method === "DELETE") {
+      try {
+        const id = taskDeleteMatch[1];
+        const deleted = deleteTask(id);
+        if (!deleted)
+          return json({ error: "Task not found" }, 404, port);
+        return json({ deleted: true }, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to delete task" }, 500, port);
       }
-      if (path === "/api/projects" && method === "GET") {
-        try {
-          const projects = listProjects();
-          return json(projects, 200, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to list projects" }, 500, port);
-        }
+    }
+    const taskStartMatch = path.match(/^\/api\/tasks\/([^/]+)\/start$/);
+    if (taskStartMatch && method === "POST") {
+      try {
+        const id = taskStartMatch[1];
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        const parsed = agentSchema.safeParse(body);
+        if (!parsed.success)
+          return json({ error: "Invalid request body" }, 400, port);
+        const agentId = parsed.data.agent_id || "dashboard";
+        const task = startTask(id, agentId);
+        return json(task, 200, port);
+      } catch (e) {
+        const status = e instanceof Error && e.name === "TaskNotFoundError" ? 404 : e instanceof Error && e.name === "LockError" ? 409 : 500;
+        return json({ error: e instanceof Error ? e.message : "Failed to start task" }, status, port);
+      }
+    }
+    const taskCompleteMatch = path.match(/^\/api\/tasks\/([^/]+)\/complete$/);
+    if (taskCompleteMatch && method === "POST") {
+      try {
+        const id = taskCompleteMatch[1];
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        const parsed = agentSchema.safeParse(body);
+        if (!parsed.success)
+          return json({ error: "Invalid request body" }, 400, port);
+        const agentId = parsed.data.agent_id;
+        const task = completeTask(id, agentId);
+        return json(task, 200, port);
+      } catch (e) {
+        const status = e instanceof Error && e.name === "TaskNotFoundError" ? 404 : e instanceof Error && e.name === "LockError" ? 409 : 500;
+        return json({ error: e instanceof Error ? e.message : "Failed to complete task" }, status, port);
+      }
+    }
+    const commentsGetMatch = path.match(/^\/api\/tasks\/([^/]+)\/comments$/);
+    if (commentsGetMatch && method === "GET") {
+      try {
+        const taskId = commentsGetMatch[1];
+        const comments = listComments(taskId);
+        return json(comments, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to list comments" }, 500, port);
       }
-      if (path === "/api/projects" && method === "POST") {
-        try {
-          const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
-          if (contentLength > MAX_BODY_SIZE)
-            return json({ error: "Request body too large" }, 413, port);
-          const body = await req.json();
-          if (!body.name || typeof body.name !== "string") {
-            return json({ error: "Missing required field: name" }, 400, port);
-          }
-          const project = createProject({
-            name: body.name,
-            path: body.path || process.cwd(),
-            description: body.description
-          });
-          return json(project, 201, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Failed to create project" }, 500, port);
-        }
+    }
+    const commentsPostMatch = path.match(/^\/api\/tasks\/([^/]+)\/comments$/);
+    if (commentsPostMatch && method === "POST") {
+      try {
+        const taskId = commentsPostMatch[1];
+        const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+        if (contentLength > MAX_BODY_SIZE)
+          return json({ error: "Request body too large" }, 413, port);
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        if (!body.content || typeof body.content !== "string") {
+          return json({ error: "Missing required field: content" }, 400, port);
+        }
+        const parsed = createCommentSchema.safeParse(body);
+        if (!parsed.success) {
+          return json({ error: "Invalid request body" }, 400, port);
+        }
+        const comment = addComment({
+          task_id: taskId,
+          content: parsed.data.content,
+          agent_id: parsed.data.agent_id,
+          session_id: parsed.data.session_id
+        });
+        return json(comment, 201, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to add comment" }, 500, port);
       }
-      if (path === "/api/search" && method === "GET") {
-        try {
-          const q = url.searchParams.get("q");
-          if (!q)
-            return json({ error: "Missing query parameter: q" }, 400, port);
-          const projectId = url.searchParams.get("project_id") || undefined;
-          const results = searchTasks(q, projectId);
-          return json(results, 200, port);
-        } catch (e) {
-          return json({ error: e instanceof Error ? e.message : "Search failed" }, 500, port);
-        }
+    }
+    if (path === "/api/projects" && method === "GET") {
+      try {
+        const projects = listProjects();
+        return json(projects, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to list projects" }, 500, port);
       }
-      if (path === "/api/system/version" && method === "GET") {
-        try {
-          const current = getPackageVersion();
-          const npmRes = await fetch("https://registry.npmjs.org/@hasna/todos/latest");
-          if (!npmRes.ok) {
-            return json({ current, latest: current, updateAvailable: false }, 200, port);
-          }
-          const data = await npmRes.json();
-          const latest = data.version;
-          return json({ current, latest, updateAvailable: current !== latest }, 200, port);
-        } catch {
-          const current = getPackageVersion();
+    }
+    if (path === "/api/projects" && method === "POST") {
+      try {
+        const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+        if (contentLength > MAX_BODY_SIZE)
+          return json({ error: "Request body too large" }, 413, port);
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        if (!body.name || typeof body.name !== "string") {
+          return json({ error: "Missing required field: name" }, 400, port);
+        }
+        const parsed = createProjectSchema.safeParse(body);
+        if (!parsed.success) {
+          return json({ error: "Invalid request body" }, 400, port);
+        }
+        const project = createProject({
+          name: parsed.data.name,
+          path: parsed.data.path || process.cwd(),
+          description: parsed.data.description,
+          task_list_id: parsed.data.task_list_id
+        });
+        return json(project, 201, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to create project" }, 500, port);
+      }
+    }
+    if (path === "/api/search" && method === "GET") {
+      try {
+        const q = url.searchParams.get("q");
+        if (!q)
+          return json({ error: "Missing query parameter: q" }, 400, port);
+        const projectId = url.searchParams.get("project_id") || undefined;
+        const results = searchTasks(q, projectId);
+        return json(results, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Search failed" }, 500, port);
+      }
+    }
+    if (path === "/api/system/version" && method === "GET") {
+      try {
+        const current = getPackageVersion();
+        const npmRes = await fetch("https://registry.npmjs.org/@hasna/todos/latest");
+        if (!npmRes.ok) {
           return json({ current, latest: current, updateAvailable: false }, 200, port);
         }
+        const data = await npmRes.json();
+        const latest = data.version;
+        return json({ current, latest, updateAvailable: current !== latest }, 200, port);
+      } catch {
+        const current = getPackageVersion();
+        return json({ current, latest: current, updateAvailable: false }, 200, port);
       }
-      if (path === "/api/system/update" && method === "POST") {
+    }
+    if (path === "/api/system/update" && method === "POST") {
+      try {
+        let useBun = false;
         try {
-          let useBun = false;
-          try {
-            execSync("which bun", { stdio: "ignore" });
-            useBun = true;
-          } catch {}
-          const cmd = useBun ? "bun add -g @hasna/todos@latest" : "npm install -g @hasna/todos@latest";
-          execSync(cmd, { stdio: "ignore", timeout: 60000 });
-          return json({ success: true, message: "Updated! Restart the server to use the new version." }, 200, port);
-        } catch (e) {
-          return json({ success: false, message: e instanceof Error ? e.message : "Update failed" }, 500, port);
-        }
-      }
-      if (method === "OPTIONS") {
-        return new Response(null, {
-          headers: {
-            "Access-Control-Allow-Origin": `http://localhost:${port}`,
-            "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
-            "Access-Control-Allow-Headers": "Content-Type"
+          execSync("which bun", { stdio: "ignore" });
+          useBun = true;
+        } catch {}
+        const cmd = useBun ? "bun add -g @hasna/todos@latest" : "npm install -g @hasna/todos@latest";
+        execSync(cmd, { stdio: "ignore", timeout: 60000 });
+        return json({ success: true, message: "Updated! Restart the server to use the new version." }, 200, port);
+      } catch (e) {
+        return json({ success: false, message: e instanceof Error ? e.message : "Update failed" }, 500, port);
+      }
+    }
+    if (path === "/api/plans" && method === "GET") {
+      try {
+        const projectId = url.searchParams.get("project_id") || undefined;
+        const plans = listPlans(projectId);
+        const enriched = plans.map((p) => {
+          const db = getDatabase();
+          const row = db.query("SELECT COUNT(*) as count FROM tasks WHERE plan_id = ?").get(p.id);
+          let projectName;
+          if (p.project_id) {
+            const proj = getProject(p.project_id);
+            projectName = proj?.name;
           }
+          return { ...p, task_count: row?.count ?? 0, project_name: projectName };
         });
+        return json(enriched, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to list plans" }, 500, port);
+      }
+    }
+    if (path === "/api/plans" && method === "POST") {
+      try {
+        const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+        if (contentLength > MAX_BODY_SIZE)
+          return json({ error: "Request body too large" }, 413, port);
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        if (!body.name || typeof body.name !== "string") {
+          return json({ error: "Missing required field: name" }, 400, port);
+        }
+        const parsed = createPlanSchema.safeParse(body);
+        if (!parsed.success) {
+          return json({ error: "Invalid request body" }, 400, port);
+        }
+        const plan = createPlan(parsed.data);
+        return json(plan, 201, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to create plan" }, 500, port);
+      }
+    }
+    const planGetMatch = path.match(/^\/api\/plans\/([^/]+)$/);
+    if (planGetMatch && method === "GET") {
+      try {
+        const id = planGetMatch[1];
+        const plan = getPlan(id);
+        if (!plan)
+          return json({ error: "Plan not found" }, 404, port);
+        return json(plan, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to get plan" }, 500, port);
+      }
+    }
+    const planPatchMatch = path.match(/^\/api\/plans\/([^/]+)$/);
+    if (planPatchMatch && method === "PATCH") {
+      try {
+        const id = planPatchMatch[1];
+        const contentLength = parseInt(req.headers.get("content-length") || "0", 10);
+        if (contentLength > MAX_BODY_SIZE)
+          return json({ error: "Request body too large" }, 413, port);
+        const body = await parseJsonBody(req);
+        if (!body)
+          return json({ error: "Invalid JSON" }, 400, port);
+        const parsed = updatePlanSchema.safeParse(body);
+        if (!parsed.success) {
+          return json({ error: "Invalid request body" }, 400, port);
+        }
+        const plan = updatePlan(id, parsed.data);
+        return json(plan, 200, port);
+      } catch (e) {
+        const status = e instanceof Error && e.name === "PlanNotFoundError" ? 404 : 500;
+        return json({ error: e instanceof Error ? e.message : "Failed to update plan" }, status, port);
+      }
+    }
+    const planDeleteMatch = path.match(/^\/api\/plans\/([^/]+)$/);
+    if (planDeleteMatch && method === "DELETE") {
+      try {
+        const id = planDeleteMatch[1];
+        const deleted = deletePlan(id);
+        if (!deleted)
+          return json({ error: "Plan not found" }, 404, port);
+        return json({ deleted: true }, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to delete plan" }, 500, port);
       }
-      if (dashboardExists && (method === "GET" || method === "HEAD")) {
-        if (path !== "/") {
-          const filePath = join3(dashboardDir, path);
-          const res2 = serveStaticFile(filePath);
-          if (res2)
-            return res2;
+    }
+    const projectDeleteMatch = path.match(/^\/api\/projects\/([^/]+)$/);
+    if (projectDeleteMatch && method === "DELETE") {
+      try {
+        const id = projectDeleteMatch[1];
+        const deleted = deleteProject(id);
+        if (!deleted)
+          return json({ error: "Project not found" }, 404, port);
+        return json({ deleted: true }, 200, port);
+      } catch (e) {
+        return json({ error: e instanceof Error ? e.message : "Failed to delete project" }, 500, port);
+      }
+    }
+    if (method === "OPTIONS") {
+      return new Response(null, {
+        headers: {
+          "Access-Control-Allow-Origin": `http://localhost:${port}`,
+          "Access-Control-Allow-Methods": "GET, POST, PATCH, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type"
         }
-        const indexPath = join3(dashboardDir, "index.html");
-        const res = serveStaticFile(indexPath);
-        if (res)
-          return res;
+      });
+    }
+    if (hasDashboard && (method === "GET" || method === "HEAD")) {
+      if (path !== "/") {
+        const filePath = join6(dir, path);
+        const res2 = serveStaticFile(filePath);
+        if (res2)
+          return res2;
       }
-      return json({ error: "Not found" }, 404, port);
+      const indexPath = join6(dir, "index.html");
+      const res = serveStaticFile(indexPath);
+      if (res)
+        return res;
     }
-  });
+    return json({ error: "Not found" }, 404, port);
+  };
+}
+async function startServer(port, options) {
+  const shouldOpen = options?.open ?? true;
+  const dashboardDir = resolveDashboardDir();
+  const dashboardExists = existsSync6(dashboardDir);
+  if (!dashboardExists) {
+    console.error(`
+Dashboard not found at: ${dashboardDir}`);
+    console.error(`Run this to build it:
+`);
+    console.error(`  cd dashboard && bun install && bun run build
+`);
+    console.error(`Or from the project root:
+`);
+    console.error(`  bun run build:dashboard
+`);
+  }
+  let actualPort = port;
+  const fetchHandler = createFetchHandler(() => actualPort, dashboardDir, dashboardExists);
+  const attempts = port === 0 ? 20 : 1;
+  let server2 = null;
+  let lastError;
+  for (let i = 0;i < attempts; i++) {
+    const candidate = port === 0 ? randomPort() : port;
+    try {
+      server2 = Bun.serve({
+        port: candidate,
+        fetch: fetchHandler
+      });
+      actualPort = server2.port;
+      break;
+    } catch (e) {
+      lastError = e;
+      if (port !== 0) {
+        throw e;
+      }
+    }
+  }
+  if (!server2) {
+    throw lastError;
+  }
   const shutdown = () => {
     server2.stop();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  const serverUrl = `http://localhost:${port}`;
+  const serverUrl = `http://localhost:${actualPort}`;
   console.log(`Todos Dashboard running at ${serverUrl}`);
   if (shouldOpen) {
     try {
@@ -7542,10 +8559,13 @@ Dashboard not found at: ${dashboardDir}`);
   }
   return server2;
 }
-var MIME_TYPES, SECURITY_HEADERS, MAX_BODY_SIZE;
+var MIME_TYPES, SECURITY_HEADERS, MAX_BODY_SIZE, createTaskSchema, updateTaskSchema, createProjectSchema, createCommentSchema, createPlanSchema, updatePlanSchema, agentSchema;
 var init_serve = __esm(() => {
+  init_zod();
   init_tasks();
   init_projects();
+  init_plans();
+  init_database();
   init_comments();
   init_search();
   MIME_TYPES = {
@@ -7565,6 +8585,54 @@ var init_serve = __esm(() => {
     "X-Frame-Options": "DENY"
   };
   MAX_BODY_SIZE = 1024 * 1024;
+  createTaskSchema = exports_external.object({
+    title: exports_external.string(),
+    description: exports_external.string().optional(),
+    status: exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional(),
+    priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+    project_id: exports_external.string().optional(),
+    parent_id: exports_external.string().optional(),
+    plan_id: exports_external.string().optional(),
+    tags: exports_external.array(exports_external.string()).optional(),
+    assigned_to: exports_external.string().optional(),
+    agent_id: exports_external.string().optional()
+  });
+  updateTaskSchema = exports_external.object({
+    version: exports_external.number(),
+    title: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    status: exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional(),
+    priority: exports_external.enum(["low", "medium", "high", "critical"]).optional(),
+    assigned_to: exports_external.string().optional(),
+    plan_id: exports_external.string().optional(),
+    tags: exports_external.array(exports_external.string()).optional(),
+    metadata: exports_external.record(exports_external.unknown()).optional()
+  });
+  createProjectSchema = exports_external.object({
+    name: exports_external.string(),
+    path: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    task_list_id: exports_external.string().optional()
+  });
+  createCommentSchema = exports_external.object({
+    content: exports_external.string(),
+    agent_id: exports_external.string().optional(),
+    session_id: exports_external.string().optional()
+  });
+  createPlanSchema = exports_external.object({
+    name: exports_external.string(),
+    project_id: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    status: exports_external.enum(["active", "completed", "archived"]).optional()
+  });
+  updatePlanSchema = exports_external.object({
+    name: exports_external.string().optional(),
+    description: exports_external.string().optional(),
+    status: exports_external.enum(["active", "completed", "archived"]).optional()
+  });
+  agentSchema = exports_external.object({
+    agent_id: exports_external.string().optional()
+  });
 });
 
 // src/cli/components/Header.tsx
@@ -8644,17 +9712,19 @@ var {
 init_database();
 init_tasks();
 init_projects();
+init_plans();
 init_comments();
 init_search();
-init_claude_tasks();
+init_sync();
+init_config();
 import chalk from "chalk";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { basename, dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { basename, dirname as dirname3, join as join7, resolve as resolve2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getPackageVersion2() {
   try {
-    const pkgPath = join4(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
+    const pkgPath = join7(dirname3(fileURLToPath2(import.meta.url)), "..", "..", "package.json");
     return JSON.parse(readFileSync3(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -8681,20 +9751,21 @@ function detectGitRoot() {
     return null;
   }
 }
-function autoProject(opts) {
+function autoDetectProject(opts) {
   if (opts.project) {
-    const p = getProjectByPath(resolve2(opts.project));
-    return p?.id;
+    return getProjectByPath(resolve2(opts.project)) ?? undefined;
   }
   if (process.env["TODOS_AUTO_PROJECT"] === "false")
     return;
   const gitRoot = detectGitRoot();
   if (gitRoot) {
-    const p = ensureProject(basename(gitRoot), gitRoot);
-    return p.id;
+    return ensureProject(basename(gitRoot), gitRoot);
   }
   return;
 }
+function autoProject(opts) {
+  return autoDetectProject(opts)?.id;
+}
 function output(data, jsonMode) {
   if (jsonMode) {
     console.log(JSON.stringify(data, null, 2));
@@ -8719,10 +9790,11 @@ function formatTaskLine(t) {
   const lock = t.locked_by ? chalk.magenta(` [locked:${t.locked_by}]`) : "";
   const assigned = t.assigned_to ? chalk.cyan(` -> ${t.assigned_to}`) : "";
   const tags = t.tags.length > 0 ? chalk.dim(` [${t.tags.join(",")}]`) : "";
-  return `${chalk.dim(t.id.slice(0, 8))} ${statusFn(t.status.padEnd(11))} ${priorityFn(t.priority.padEnd(8))} ${t.title}${assigned}${lock}${tags}`;
+  const plan = t.plan_id ? chalk.magenta(` [plan:${t.plan_id.slice(0, 8)}]`) : "";
+  return `${chalk.dim(t.id.slice(0, 8))} ${statusFn(t.status.padEnd(11))} ${priorityFn(t.priority.padEnd(8))} ${t.title}${assigned}${lock}${tags}${plan}`;
 }
 program2.name("todos").description("Universal task management for AI coding agents").version(getPackageVersion2()).option("--project <path>", "Project path").option("--json", "Output as JSON").option("--agent <name>", "Agent name").option("--session <id>", "Session ID");
-program2.command("add <title>").description("Create a new task").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("--parent <id>", "Parent task ID").option("--tags <tags>", "Comma-separated tags").option("--assign <agent>", "Assign to agent").option("--status <status>", "Initial status").action((title, opts) => {
+program2.command("add <title>").description("Create a new task").option("-d, --description <text>", "Task description").option("-p, --priority <level>", "Priority: low, medium, high, critical").option("--parent <id>", "Parent task ID").option("--tags <tags>", "Comma-separated tags").option("--plan <id>", "Assign to a plan").option("--assign <agent>", "Assign to agent").option("--status <status>", "Initial status").action((title, opts) => {
   const globalOpts = program2.opts();
   const projectId = autoProject(globalOpts);
   const task = createTask({
@@ -8731,6 +9803,15 @@ program2.command("add <title>").description("Create a new task").option("-d, --d
     priority: opts.priority,
     parent_id: opts.parent ? resolveTaskId(opts.parent) : undefined,
     tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : undefined,
+    plan_id: opts.plan ? (() => {
+      const db = getDatabase();
+      const id = resolvePartialId(db, "plans", opts.plan);
+      if (!id) {
+        console.error(chalk.red(`Could not resolve plan ID: ${opts.plan}`));
+        process.exit(1);
+      }
+      return id;
+    })() : undefined,
     assigned_to: opts.assign,
     status: opts.status,
     agent_id: globalOpts.agent,
@@ -8807,6 +9888,8 @@ program2.command("show <id>").description("Show full task details").action((id)
     console.log(`  ${chalk.dim("Locked:")}   ${task.locked_by} (at ${task.locked_at})`);
   if (task.project_id)
     console.log(`  ${chalk.dim("Project:")}  ${task.project_id}`);
+  if (task.plan_id)
+    console.log(`  ${chalk.dim("Plan:")}     ${task.plan_id}`);
   if (task.working_dir)
     console.log(`  ${chalk.dim("WorkDir:")}  ${task.working_dir}`);
   if (task.parent)
@@ -8955,45 +10038,114 @@ program2.command("delete <id>").description("Delete a task").action((id) => {
     process.exit(1);
   }
 });
-program2.command("plan <title>").description("Create a plan with subtasks").option("-d, --description <text>", "Plan description").option("--tasks <tasks>", "Comma-separated subtask titles").option("-p, --priority <priority>", "Priority").action((title, opts) => {
+program2.command("plans").description("List and manage plans").option("--add <name>", "Create a plan").option("-d, --description <text>", "Plan description (with --add)").option("--show <id>", "Show plan details with its tasks").option("--delete <id>", "Delete a plan").option("--complete <id>", "Mark a plan as completed").action((opts) => {
   const globalOpts = program2.opts();
   const projectId = autoProject(globalOpts);
-  const parent = createTask({
-    title,
-    description: opts.description,
-    priority: opts.priority,
-    agent_id: globalOpts.agent,
-    session_id: globalOpts.session,
-    project_id: projectId,
-    working_dir: process.cwd()
-  });
-  const subtasks = [];
-  if (opts.tasks) {
-    const taskTitles = opts.tasks.split(",").map((t) => t.trim());
-    for (const st of taskTitles) {
-      subtasks.push(createTask({
-        title: st,
-        parent_id: parent.id,
-        priority: opts.priority,
-        agent_id: globalOpts.agent,
-        session_id: globalOpts.session,
-        project_id: projectId,
-        working_dir: process.cwd()
-      }));
+  if (opts.add) {
+    const plan = createPlan({
+      name: opts.add,
+      description: opts.description,
+      project_id: projectId
+    });
+    if (globalOpts.json) {
+      output(plan, true);
+    } else {
+      console.log(chalk.green("Plan created:"));
+      console.log(`${chalk.dim(plan.id.slice(0, 8))} ${chalk.bold(plan.name)} ${chalk.cyan(`[${plan.status}]`)}`);
     }
+    return;
   }
-  if (globalOpts.json) {
-    output({ parent, subtasks }, true);
-  } else {
-    console.log(chalk.green("Plan created:"));
-    console.log(formatTaskLine(parent));
-    if (subtasks.length > 0) {
+  if (opts.show) {
+    const db = getDatabase();
+    const resolvedId = resolvePartialId(db, "plans", opts.show);
+    if (!resolvedId) {
+      console.error(chalk.red(`Could not resolve plan ID: ${opts.show}`));
+      process.exit(1);
+    }
+    const plan = getPlan(resolvedId);
+    if (!plan) {
+      console.error(chalk.red(`Plan not found: ${opts.show}`));
+      process.exit(1);
+    }
+    const tasks = listTasks({ plan_id: resolvedId });
+    if (globalOpts.json) {
+      output({ plan, tasks }, true);
+      return;
+    }
+    console.log(chalk.bold(`Plan Details:
+`));
+    console.log(`  ${chalk.dim("ID:")}       ${plan.id}`);
+    console.log(`  ${chalk.dim("Name:")}     ${plan.name}`);
+    console.log(`  ${chalk.dim("Status:")}   ${chalk.cyan(plan.status)}`);
+    if (plan.description)
+      console.log(`  ${chalk.dim("Desc:")}     ${plan.description}`);
+    if (plan.project_id)
+      console.log(`  ${chalk.dim("Project:")}  ${plan.project_id}`);
+    console.log(`  ${chalk.dim("Created:")}  ${plan.created_at}`);
+    if (tasks.length > 0) {
       console.log(chalk.bold(`
-  Subtasks:`));
-      for (const st of subtasks) {
-        console.log(`  ${formatTaskLine(st)}`);
+  Tasks (${tasks.length}):`));
+      for (const t of tasks) {
+        console.log(`    ${formatTaskLine(t)}`);
+      }
+    } else {
+      console.log(chalk.dim(`
+  No tasks in this plan.`));
+    }
+    return;
+  }
+  if (opts.delete) {
+    const db = getDatabase();
+    const resolvedId = resolvePartialId(db, "plans", opts.delete);
+    if (!resolvedId) {
+      console.error(chalk.red(`Could not resolve plan ID: ${opts.delete}`));
+      process.exit(1);
+    }
+    const deleted = deletePlan(resolvedId);
+    if (globalOpts.json) {
+      output({ deleted }, true);
+    } else if (deleted) {
+      console.log(chalk.green("Plan deleted."));
+    } else {
+      console.error(chalk.red("Plan not found."));
+      process.exit(1);
+    }
+    return;
+  }
+  if (opts.complete) {
+    const db = getDatabase();
+    const resolvedId = resolvePartialId(db, "plans", opts.complete);
+    if (!resolvedId) {
+      console.error(chalk.red(`Could not resolve plan ID: ${opts.complete}`));
+      process.exit(1);
+    }
+    try {
+      const plan = updatePlan(resolvedId, { status: "completed" });
+      if (globalOpts.json) {
+        output(plan, true);
+      } else {
+        console.log(chalk.green("Plan completed:"));
+        console.log(`${chalk.dim(plan.id.slice(0, 8))} ${chalk.bold(plan.name)} ${chalk.cyan(`[${plan.status}]`)}`);
       }
+    } catch (e) {
+      handleError(e);
     }
+    return;
+  }
+  const plans = listPlans(projectId);
+  if (globalOpts.json) {
+    output(plans, true);
+    return;
+  }
+  if (plans.length === 0) {
+    console.log(chalk.dim("No plans found."));
+    return;
+  }
+  console.log(chalk.bold(`${plans.length} plan(s):
+`));
+  for (const p of plans) {
+    const desc = p.description ? chalk.dim(` - ${p.description}`) : "";
+    console.log(`${chalk.dim(p.id.slice(0, 8))} ${chalk.bold(p.name)} ${chalk.cyan(`[${p.status}]`)}${desc}`);
   }
 });
 program2.command("comment <id> <text>").description("Add a comment to a task").action((id, text) => {
@@ -9080,16 +10232,27 @@ program2.command("deps <id>").description("Manage task dependencies").option("--
     }
   }
 });
-program2.command("projects").description("List and manage projects").option("--add <path>", "Register a project by path").option("--name <name>", "Project name (with --add)").action((opts) => {
+program2.command("projects").description("List and manage projects").option("--add <path>", "Register a project by path").option("--name <name>", "Project name (with --add)").option("--task-list-id <id>", "Custom task list ID (with --add)").action((opts) => {
   const globalOpts = program2.opts();
   if (opts.add) {
     const projectPath = resolve2(opts.add);
     const name = opts.name || basename(projectPath);
-    const project = ensureProject(name, projectPath);
+    const existing = getProjectByPath(projectPath);
+    let project;
+    if (existing) {
+      project = existing;
+      if (opts.taskListId) {
+        project = updateProject(existing.id, { task_list_id: opts.taskListId });
+      }
+    } else {
+      project = createProject({ name, path: projectPath, task_list_id: opts.taskListId });
+    }
     if (globalOpts.json) {
       output(project, true);
     } else {
       console.log(chalk.green(`Project registered: ${project.name} (${project.path})`));
+      if (project.task_list_id)
+        console.log(chalk.dim(`  Task list: ${project.task_list_id}`));
     }
     return;
   }
@@ -9105,7 +10268,8 @@ program2.command("projects").description("List and manage projects").option("--a
   console.log(chalk.bold(`${projects.length} project(s):
 `));
   for (const p of projects) {
-    console.log(`${chalk.dim(p.id.slice(0, 8))} ${chalk.bold(p.name)} ${chalk.dim(p.path)}${p.description ? ` - ${p.description}` : ""}`);
+    const taskList = p.task_list_id ? chalk.cyan(` [${p.task_list_id}]`) : "";
+    console.log(`${chalk.dim(p.id.slice(0, 8))} ${chalk.bold(p.name)} ${chalk.dim(p.path)}${taskList}${p.description ? ` - ${p.description}` : ""}`);
   }
 });
 program2.command("export").description("Export tasks").option("-f, --format <format>", "Format: json or md", "json").action((opts) => {
@@ -9125,33 +10289,43 @@ program2.command("export").description("Export tasks").option("-f, --format <for
     console.log(JSON.stringify(tasks, null, 2));
   }
 });
-function resolveClaudeTaskListId(explicit) {
-  return explicit || process.env["TODOS_CLAUDE_TASK_LIST"] || process.env["CLAUDE_CODE_TASK_LIST_ID"] || process.env["CLAUDE_CODE_SESSION_ID"] || null;
+function resolveTaskListId2(agent, explicit, projectTaskListId) {
+  if (explicit)
+    return explicit;
+  const normalized = agent.trim().toLowerCase();
+  if (normalized === "claude" || normalized === "claude-code" || normalized === "claude_code") {
+    return process.env["TODOS_CLAUDE_TASK_LIST"] || process.env["CLAUDE_CODE_TASK_LIST_ID"] || process.env["CLAUDE_CODE_SESSION_ID"] || getAgentTaskListId(normalized) || projectTaskListId || null;
+  }
+  const key = `TODOS_${normalized.toUpperCase()}_TASK_LIST`;
+  return process.env[key] || process.env["TODOS_TASK_LIST_ID"] || getAgentTaskListId(normalized) || "default";
 }
-program2.command("sync").description("Sync tasks with a Claude Code task list").option("--task-list <id>", "Task list ID (auto-detects from CLAUDE_CODE_TASK_LIST_ID or CLAUDE_CODE_SESSION_ID)").option("--push", "One-way: push SQLite tasks to Claude task list").option("--pull", "One-way: pull Claude task list into SQLite").action((opts) => {
+program2.command("sync").description("Sync tasks with an agent task list (Claude uses native task list; others use JSON lists)").option("--task-list <id>", "Task list ID (Claude auto-detects from CLAUDE_CODE_TASK_LIST_ID or CLAUDE_CODE_SESSION_ID)").option("--agent <name>", "Agent/provider to sync (default: claude)").option("--all", "Sync across all configured agents (TODOS_SYNC_AGENTS or default: claude,codex,gemini)").option("--push", "One-way: push SQLite tasks to agent task list").option("--pull", "One-way: pull agent task list into SQLite").option("--prefer <side>", "Conflict strategy: local or remote", "remote").action((opts) => {
   const globalOpts = program2.opts();
-  const projectId = autoProject(globalOpts);
-  const taskListId = resolveClaudeTaskListId(opts.taskList);
-  if (!taskListId) {
-    console.error(chalk.red("Could not detect task list ID. Use --task-list <id>, or run inside a Claude Code session."));
-    process.exit(1);
-  }
+  const project = autoDetectProject(globalOpts);
+  const projectId = project?.id;
+  const direction = opts.push && !opts.pull ? "push" : opts.pull && !opts.push ? "pull" : "both";
   let result;
-  if (opts.push && !opts.pull) {
-    result = pushToClaudeTaskList(taskListId, projectId);
-  } else if (opts.pull && !opts.push) {
-    result = pullFromClaudeTaskList(taskListId, projectId);
+  const prefer = opts.prefer === "local" ? "local" : "remote";
+  if (opts.all) {
+    const agents = defaultSyncAgents();
+    result = syncWithAgents(agents, (agent) => resolveTaskListId2(agent, opts.taskList, project?.task_list_id), projectId, direction, { prefer });
   } else {
-    result = syncClaudeTaskList(taskListId, projectId);
+    const agent = opts.agent || "claude";
+    const taskListId = resolveTaskListId2(agent, opts.taskList, project?.task_list_id);
+    if (!taskListId) {
+      console.error(chalk.red(`Could not detect task list ID for ${agent}. Use --task-list <id> or set appropriate env vars.`));
+      process.exit(1);
+    }
+    result = syncWithAgent(agent, taskListId, projectId, direction, { prefer });
   }
   if (globalOpts.json) {
     output(result, true);
     return;
   }
   if (result.pulled > 0)
-    console.log(chalk.green(`Pulled ${result.pulled} task(s) from Claude task list.`));
+    console.log(chalk.green(`Pulled ${result.pulled} task(s).`));
   if (result.pushed > 0)
-    console.log(chalk.green(`Pushed ${result.pushed} task(s) to Claude task list.`));
+    console.log(chalk.green(`Pushed ${result.pushed} task(s).`));
   if (result.pulled === 0 && result.pushed === 0 && result.errors.length === 0) {
     console.log(chalk.dim("Nothing to sync."));
   }
@@ -9167,45 +10341,38 @@ hooks.command("install").description("Install Claude Code hooks for auto-sync").
     if (p)
       todosBin = p;
   } catch {}
-  const hooksDir = join4(process.cwd(), ".claude", "hooks");
-  if (!existsSync4(hooksDir))
+  const hooksDir = join7(process.cwd(), ".claude", "hooks");
+  if (!existsSync7(hooksDir))
     mkdirSync3(hooksDir, { recursive: true });
   const hookScript = `#!/usr/bin/env bash
 # Auto-generated by: todos hooks install
 # Syncs todos with Claude Code task list on tool use events.
-# Reads session_id and tool_name from the hook JSON stdin.
+# Uses session_id when available; falls back to project-based task_list_id.
 
 INPUT=$(cat)
 
-# Extract session_id from stdin JSON (hooks always receive this)
 SESSION_ID=$(echo "$INPUT" | grep -o '"session_id":"[^"]*"' | head -1 | cut -d'"' -f4 2>/dev/null || true)
-
-# Task list priority: env override > session ID from hook input
-TASK_LIST="\${TODOS_CLAUDE_TASK_LIST:-\${CLAUDE_CODE_TASK_LIST_ID:-$SESSION_ID}}"
-
-if [ -z "$TASK_LIST" ]; then
-  exit 0
-fi
+TASK_LIST="\${TODOS_CLAUDE_TASK_LIST:-\${SESSION_ID}}"
 
 TOOL_NAME=$(echo "$INPUT" | grep -o '"tool_name":"[^"]*"' | head -1 | cut -d'"' -f4 2>/dev/null || true)
 
 case "$TOOL_NAME" in
   TaskCreate|TaskUpdate)
-    ${todosBin} sync --pull --task-list "$TASK_LIST" 2>/dev/null || true
+    TODOS_CLAUDE_TASK_LIST="$TASK_LIST" ${todosBin} sync --all --pull 2>/dev/null || true
     ;;
   mcp__todos__*)
-    ${todosBin} sync --push --task-list "$TASK_LIST" 2>/dev/null || true
+    TODOS_CLAUDE_TASK_LIST="$TASK_LIST" ${todosBin} sync --all --push 2>/dev/null || true
     ;;
 esac
 
 exit 0
 `;
-  const hookPath = join4(hooksDir, "todos-sync.sh");
+  const hookPath = join7(hooksDir, "todos-sync.sh");
   writeFileSync2(hookPath, hookScript);
   execSync2(`chmod +x "${hookPath}"`);
   console.log(chalk.green(`Hook script created: ${hookPath}`));
-  const settingsPath = join4(process.cwd(), ".claude", "settings.json");
-  const settings = readJsonFile(settingsPath);
+  const settingsPath = join7(process.cwd(), ".claude", "settings.json");
+  const settings = readJsonFile2(settingsPath);
   if (!settings["hooks"]) {
     settings["hooks"] = {};
   }
@@ -9229,9 +10396,9 @@ exit 0
     hooks: [{ type: "command", command: hookPath }]
   });
   hooksConfig["PostToolUse"] = filtered;
-  writeJsonFile(settingsPath, settings);
+  writeJsonFile2(settingsPath, settings);
   console.log(chalk.green(`Claude Code hooks configured in: ${settingsPath}`));
-  console.log(chalk.dim("Task list ID auto-detected from hook stdin session_id."));
+  console.log(chalk.dim("Task list ID auto-detected from project."));
 });
 program2.command("mcp").description("Start MCP server (stdio)").option("--register <agent>", "Register MCP server with an agent (claude, codex, gemini, all)").option("--unregister <agent>", "Unregister MCP server from an agent (claude, codex, gemini, all)").option("-g, --global", "Register/unregister globally (user-level) instead of project-level").action(async (opts) => {
   if (opts.register) {
@@ -9251,13 +10418,13 @@ function getMcpBinaryPath() {
     if (p)
       return p;
   } catch {}
-  const bunBin = join4(HOME2, ".bun", "bin", "todos-mcp");
-  if (existsSync4(bunBin))
+  const bunBin = join7(HOME2, ".bun", "bin", "todos-mcp");
+  if (existsSync7(bunBin))
     return bunBin;
   return "todos-mcp";
 }
-function readJsonFile(path) {
-  if (!existsSync4(path))
+function readJsonFile2(path) {
+  if (!existsSync7(path))
     return {};
   try {
     return JSON.parse(readFileSync3(path, "utf-8"));
@@ -9265,27 +10432,27 @@ function readJsonFile(path) {
     return {};
   }
 }
-function writeJsonFile(path, data) {
+function writeJsonFile2(path, data) {
   const dir = dirname3(path);
-  if (!existsSync4(dir))
+  if (!existsSync7(dir))
     mkdirSync3(dir, { recursive: true });
   writeFileSync2(path, JSON.stringify(data, null, 2) + `
 `);
 }
 function readTomlFile(path) {
-  if (!existsSync4(path))
+  if (!existsSync7(path))
     return "";
   return readFileSync3(path, "utf-8");
 }
 function writeTomlFile(path, content) {
   const dir = dirname3(path);
-  if (!existsSync4(dir))
+  if (!existsSync7(dir))
     mkdirSync3(dir, { recursive: true });
   writeFileSync2(path, content);
 }
 function registerClaude(binPath, global) {
-  const configPath = global ? join4(HOME2, ".claude", ".mcp.json") : join4(process.cwd(), ".mcp.json");
-  const config = readJsonFile(configPath);
+  const configPath = global ? join7(HOME2, ".claude", ".mcp.json") : join7(process.cwd(), ".mcp.json");
+  const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
   }
@@ -9294,25 +10461,25 @@ function registerClaude(binPath, global) {
     command: binPath,
     args: []
   };
-  writeJsonFile(configPath, config);
+  writeJsonFile2(configPath, config);
   const scope = global ? "global" : "project";
   console.log(chalk.green(`Claude Code (${scope}): registered in ${configPath}`));
 }
 function unregisterClaude(global) {
-  const configPath = global ? join4(HOME2, ".claude", ".mcp.json") : join4(process.cwd(), ".mcp.json");
-  const config = readJsonFile(configPath);
+  const configPath = global ? join7(HOME2, ".claude", ".mcp.json") : join7(process.cwd(), ".mcp.json");
+  const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
     console.log(chalk.dim(`Claude Code: todos not found in ${configPath}`));
     return;
   }
   delete servers["todos"];
-  writeJsonFile(configPath, config);
+  writeJsonFile2(configPath, config);
   const scope = global ? "global" : "project";
   console.log(chalk.green(`Claude Code (${scope}): unregistered from ${configPath}`));
 }
 function registerCodex(binPath) {
-  const configPath = join4(HOME2, ".codex", "config.toml");
+  const configPath = join7(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   content = removeTomlBlock(content, "mcp_servers.todos");
   const block = `
@@ -9326,7 +10493,7 @@ args = []
   console.log(chalk.green(`Codex CLI: registered in ${configPath}`));
 }
 function unregisterCodex() {
-  const configPath = join4(HOME2, ".codex", "config.toml");
+  const configPath = join7(HOME2, ".codex", "config.toml");
   let content = readTomlFile(configPath);
   if (!content.includes("[mcp_servers.todos]")) {
     console.log(chalk.dim(`Codex CLI: todos not found in ${configPath}`));
@@ -9359,8 +10526,8 @@ function removeTomlBlock(content, blockName) {
 `);
 }
 function registerGemini(binPath) {
-  const configPath = join4(HOME2, ".gemini", "settings.json");
-  const config = readJsonFile(configPath);
+  const configPath = join7(HOME2, ".gemini", "settings.json");
+  const config = readJsonFile2(configPath);
   if (!config["mcpServers"]) {
     config["mcpServers"] = {};
   }
@@ -9369,19 +10536,19 @@ function registerGemini(binPath) {
     command: binPath,
     args: []
   };
-  writeJsonFile(configPath, config);
+  writeJsonFile2(configPath, config);
   console.log(chalk.green(`Gemini CLI: registered in ${configPath}`));
 }
 function unregisterGemini() {
-  const configPath = join4(HOME2, ".gemini", "settings.json");
-  const config = readJsonFile(configPath);
+  const configPath = join7(HOME2, ".gemini", "settings.json");
+  const config = readJsonFile2(configPath);
   const servers = config["mcpServers"];
   if (!servers || !("todos" in servers)) {
     console.log(chalk.dim(`Gemini CLI: todos not found in ${configPath}`));
     return;
   }
   delete servers["todos"];
-  writeJsonFile(configPath, config);
+  writeJsonFile2(configPath, config);
   console.log(chalk.green(`Gemini CLI: unregistered from ${configPath}`));
 }
 function registerMcp(agent, global) {