@hasna/todos 0.3.6 → 0.4.0

package/dist/index.js

@@ -4,19 +4,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 });
@@ -98,6 +133,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;
@@ -111,6 +177,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) {
@@ -126,6 +193,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 closeDatabase() {
   if (_db) {
     _db.close();
@@ -148,6 +244,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);
@@ -176,6 +280,7 @@ var TASK_PRIORITIES = [
   "high",
   "critical"
 ];
+var PLAN_STATUSES = ["active", "completed", "archived"];
 
 class VersionConflictError extends Error {
   taskId;
@@ -208,6 +313,15 @@ class ProjectNotFoundError extends Error {
   }
 }
 
+class PlanNotFoundError extends Error {
+  planId;
+  constructor(planId) {
+    super(`Plan not found: ${planId}`);
+    this.planId = planId;
+    this.name = "PlanNotFoundError";
+  }
+}
+
 class LockError extends Error {
   taskId;
   lockedBy;
@@ -240,15 +354,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",
@@ -257,11 +386,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) {
@@ -299,6 +431,7 @@ function getTaskWithRelations(id, db) {
 }
 function listTasks(filter = {}, db) {
   const d = db || getDatabase();
+  clearExpiredLocks(d);
   const conditions = [];
   const params = [];
   if (filter.project_id) {
@@ -344,9 +477,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
@@ -396,12 +533,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) {
@@ -411,15 +555,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) {
@@ -440,20 +587,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) {
@@ -511,12 +664,16 @@ function wouldCreateCycle(taskId, dependsOn, db) {
   return false;
 }
 // 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) {
@@ -548,6 +705,10 @@ function updateProject(id, input, db) {
     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);
@@ -564,6 +725,63 @@ function ensureProject(name, path, db) {
     return existing;
   return createProject({ name, path }, d);
 }
+// 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/db/comments.ts
 function addComment(input, db) {
   const d = db || getDatabase();
@@ -652,8 +870,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 = ?";
@@ -665,20 +884,609 @@ function searchTasks(query, projectId, db) {
   const rows = d.query(sql).all(...params);
   return rows.map(rowToTask2);
 }
+// src/lib/claude-tasks.ts
+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 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");
+  if (!existsSync2(path))
+    return 1;
+  const val = parseInt(readFileSync(path, "utf-8").trim(), 10);
+  return isNaN(val) ? 1 : val;
+}
+function writeHighWaterMark(dir, value) {
+  writeFileSync(join2(dir, ".highwatermark"), String(value));
+}
+function getFileMtimeMs(path) {
+  try {
+    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) {
+  writeJsonFile(join3(dir, `${task.id}.json`), task);
+}
+function toClaudeStatus(status) {
+  if (status === "pending" || status === "in_progress" || status === "completed") {
+    return status;
+  }
+  return "completed";
+}
+function toSqliteStatus(status) {
+  return status;
+}
+function taskToClaudeTask(task, claudeTaskId, existingMeta) {
+  return {
+    id: claudeTaskId,
+    subject: task.title,
+    description: task.description || "",
+    activeForm: "",
+    status: toClaudeStatus(task.status),
+    owner: task.assigned_to || task.agent_id || "",
+    blocks: [],
+    blockedBy: [],
+    metadata: {
+      ...existingMeta || {},
+      todos_id: task.id,
+      priority: task.priority,
+      todos_updated_at: task.updated_at,
+      todos_version: task.version
+    }
+  };
+}
+function pushToClaudeTaskList(taskListId, projectId, options = {}) {
+  const dir = getTaskListDir(taskListId);
+  if (!existsSync3(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 = join3(dir, f);
+    const ct = readClaudeTask(dir, f);
+    if (ct?.metadata?.["todos_id"]) {
+      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 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++;
+        const ct = taskToClaudeTask(task, claudeId);
+        writeClaudeTask(dir, ct);
+        const current = getTask(task.id);
+        if (current) {
+          const newMeta = { ...current.metadata, claude_task_id: claudeId };
+          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 pullFromClaudeTaskList(taskListId, projectId, options = {}) {
+  const dir = getTaskListDir(taskListId);
+  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) {
+    const cid = t.metadata["claude_task_id"];
+    if (cid)
+      byClaudeId.set(String(cid), t);
+  }
+  const byTodosId = new Map;
+  for (const t of allTasks) {
+    byTodosId.set(t.id, t);
+  }
+  for (const f of files) {
+    try {
+      const filePath = join3(dir, f);
+      const ct = readClaudeTask(dir, f);
+      if (!ct)
+        continue;
+      if (ct.metadata?.["_internal"])
+        continue;
+      const todosId = ct.metadata?.["todos_id"];
+      const existingByMapping = byClaudeId.get(ct.id);
+      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: { ...conflictMeta || existing.metadata, claude_task_id: ct.id, ...ct.metadata }
+        });
+      } else {
+        createTask({
+          title: ct.subject,
+          description: ct.description || undefined,
+          status: toSqliteStatus(ct.status),
+          assigned_to: ct.owner || undefined,
+          project_id: projectId,
+          metadata: { ...ct.metadata, claude_task_id: ct.id },
+          priority: ct.metadata?.["priority"] || "medium"
+        });
+      }
+      pulled++;
+    } catch (e) {
+      errors.push(`pull ${f}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  return { pushed: 0, pulled, errors };
+}
+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]
+  };
+}
+
+// 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 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 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]
+  };
+}
+
+// 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 };
+}
 export {
   updateTask,
   updateSessionActivity,
   updateProject,
+  updatePlan,
   unlockTask,
+  syncWithAgents,
+  syncWithAgent,
   startTask,
+  slugify,
   searchTasks,
   resolvePartialId,
   resetDatabase,
   removeDependency,
   lockTask,
+  loadConfig,
   listTasks,
   listSessions,
   listProjects,
+  listPlans,
   listComments,
   getTaskWithRelations,
   getTaskDependents,
@@ -687,16 +1495,20 @@ export {
   getSession,
   getProjectByPath,
   getProject,
+  getPlan,
   getDatabase,
   getComment,
   ensureProject,
   deleteTask,
   deleteSession,
   deleteProject,
+  deletePlan,
   deleteComment,
+  defaultSyncAgents,
   createTask,
   createSession,
   createProject,
+  createPlan,
   completeTask,
   closeDatabase,
   addDependency,
@@ -706,6 +1518,8 @@ export {
   TASK_STATUSES,
   TASK_PRIORITIES,
   ProjectNotFoundError,
+  PlanNotFoundError,
+  PLAN_STATUSES,
   LockError,
   DependencyCycleError
 };