@hasna/todos 0.3.6 → 0.4.0

package/dist/mcp/index.js

@@ -4010,6 +4010,15 @@ class TaskNotFoundError extends Error {
     this.name = "TaskNotFoundError";
   }
 }
+class PlanNotFoundError extends Error {
+  planId;
+  constructor(planId) {
+    super(`Plan not found: ${planId}`);
+    this.planId = planId;
+    this.name = "PlanNotFoundError";
+  }
+}
+
 class LockError extends Error {
   taskId;
   lockedBy;
@@ -4037,19 +4046,54 @@ import { Database } from "bun:sqlite";
 import { existsSync, mkdirSync } from "fs";
 import { dirname, join, resolve } from "path";
 var LOCK_EXPIRY_MINUTES = 30;
+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 });
@@ -4131,6 +4175,37 @@ var MIGRATIONS = [
   );
 
   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);
   `
 ];
 var _db = null;
@@ -4144,6 +4219,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) {
@@ -4159,6 +4235,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();
 }
@@ -4172,6 +4277,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);
@@ -4197,15 +4310,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",
@@ -4214,11 +4342,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) {
@@ -4256,6 +4387,7 @@ function getTaskWithRelations(id, db) {
 }
 function listTasks(filter = {}, db) {
   const d = db || getDatabase();
+  clearExpiredLocks(d);
   const conditions = [];
   const params = [];
   if (filter.project_id) {
@@ -4301,9 +4433,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
@@ -4353,12 +4489,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) {
@@ -4368,15 +4511,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) {
@@ -4397,20 +4543,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) {
@@ -4485,12 +4637,16 @@ function getComment(id, db) {
 }
 
 // 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) {
@@ -4503,6 +4659,64 @@ function listProjects(db) {
   return d.query("SELECT * FROM projects ORDER BY name").all();
 }
 
+// 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;
+}
+
 // src/lib/search.ts
 function rowToTask2(row) {
   return {
@@ -4515,8 +4729,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 = ?";
@@ -4530,11 +4745,32 @@ function searchTasks(query, projectId, db) {
 }
 
 // src/lib/claude-tasks.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, readdirSync, writeFileSync } from "fs";
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+
+// 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";
 var HOME = process.env["HOME"] || process.env["USERPROFILE"] || "~";
-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");
@@ -4546,17 +4782,34 @@ 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 };
+}
+
+// src/lib/claude-tasks.ts
+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") {
@@ -4567,7 +4820,7 @@ function toClaudeStatus(status) {
 function toSqliteStatus(status) {
   return status;
 }
-function taskToClaudeTask(task, claudeTaskId) {
+function taskToClaudeTask(task, claudeTaskId, existingMeta) {
   return {
     id: claudeTaskId,
     subject: task.title,
@@ -4578,39 +4831,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 errors2 = [];
+  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 });
+            errors2.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++;
@@ -4630,14 +4924,15 @@ function pushToClaudeTaskList(taskListId, projectId) {
   writeHighWaterMark(dir, hwm);
   return { pushed, pulled: 0, errors: errors2 };
 }
-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 errors2 = [];
+  const prefer = options.prefer || "remote";
   const allTasks = listTasks({});
   const byClaudeId = new Map;
   for (const t of allTasks) {
@@ -4651,6 +4946,7 @@ function pullFromClaudeTaskList(taskListId, projectId) {
   }
   for (const f of files) {
     try {
+      const filePath = join3(dir, f);
       const ct = readClaudeTask(dir, f);
       if (!ct)
         continue;
@@ -4661,13 +4957,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 });
+            errors2.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({
@@ -4676,7 +4992,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"
         });
       }
@@ -4687,9 +5003,9 @@ function pullFromClaudeTaskList(taskListId, projectId) {
   }
   return { pushed: 0, pulled, errors: errors2 };
 }
-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,
@@ -4697,6 +5013,326 @@ function syncClaudeTaskList(taskListId, projectId) {
   };
 }
 
+// src/lib/agent-tasks.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+
+// src/lib/config.ts
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+var CONFIG_PATH = join4(HOME, ".todos", "config.json");
+var cached = null;
+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;
+}
+
+// src/lib/agent-tasks.ts
+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 errors2 = [];
+  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 });
+            errors2.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) {
+      errors2.push(`push ${task.id}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  writeHighWaterMark(dir, hwm);
+  return { pushed, pulled: 0, errors: errors2 };
+}
+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 errors2 = [];
+  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 });
+            errors2.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) {
+      errors2.push(`pull ${f}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return { pushed: 0, pulled, errors: errors2 };
+}
+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]
+  };
+}
+
+// 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 errors2 = [];
+  const normalized = agents.map(normalizeAgent2);
+  if (direction === "pull" || direction === "both") {
+    for (const agent of normalized) {
+      const listId = taskListIdByAgent(agent);
+      if (!listId) {
+        errors2.push(`sync ${agent}: missing task list id`);
+        continue;
+      }
+      const result = syncWithAgent(agent, listId, projectId, "pull", options);
+      pushed += result.pushed;
+      pulled += result.pulled;
+      errors2.push(...result.errors.map((e) => `${agent}: ${e}`));
+    }
+  }
+  if (direction === "push" || direction === "both") {
+    for (const agent of normalized) {
+      const listId = taskListIdByAgent(agent);
+      if (!listId) {
+        errors2.push(`sync ${agent}: missing task list id`);
+        continue;
+      }
+      const result = syncWithAgent(agent, listId, projectId, "push", options);
+      pushed += result.pushed;
+      pulled += result.pulled;
+      errors2.push(...result.errors.map((e) => `${agent}: ${e}`));
+    }
+  }
+  return { pushed, pulled, errors: errors2 };
+}
+
 // src/mcp/index.ts
 var server = new McpServer({
   name: "todos",
@@ -4707,6 +5343,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)
@@ -4722,6 +5360,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}`,
@@ -4741,6 +5389,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}`);
@@ -4761,6 +5411,7 @@ server.tool("create_task", "Create a new task", {
   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) => {
@@ -4770,6 +5421,8 @@ server.tool("create_task", "Create a new task", {
       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)}` }] };
@@ -4788,12 +5441,15 @@ server.tool("list_tasks", "List tasks with optional filters", {
     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." }] };
@@ -4867,7 +5523,8 @@ server.tool("update_task", "Update task fields (requires version for optimistic
   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);
@@ -4998,7 +5655,10 @@ server.tool("list_projects", "List all registered projects", {}, async () => {
     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(`
+    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}` }] };
@@ -5009,14 +5669,117 @@ ${text}` }] };
 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")
+  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}`
+        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(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("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 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("delete_plan", "Delete a plan", {
+  id: exports_external.string().describe("Plan ID (full or partial)")
+}, async ({ id }) => {
+  try {
+    const resolvedId = resolveId(id, "plans");
+    const deleted = deletePlan(resolvedId);
+    return {
+      content: [{
+        type: "text",
+        text: deleted ? `Plan ${id} deleted.` : `Plan ${id} not found.`
       }]
     };
   } catch (e) {
@@ -5041,27 +5804,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.");
     }