@hasna/todos 0.11.32 → 0.11.34

package/dist/mcp/index.js

@@ -810,6 +810,26 @@ var init_migrations = __esm(() => {
   ALTER TABLE tasks ADD COLUMN current_step TEXT;
   ALTER TABLE tasks ADD COLUMN total_steps INTEGER;
   INSERT OR IGNORE INTO _migrations (id) VALUES (48);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS cycles (
+    id TEXT PRIMARY KEY,
+    project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+    number INTEGER NOT NULL,
+    start_date TEXT NOT NULL,
+    end_date TEXT NOT NULL,
+    duration_weeks INTEGER NOT NULL DEFAULT 1,
+    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_cycles_project ON cycles(project_id);
+  CREATE INDEX IF NOT EXISTS idx_cycles_number ON cycles(number);
+  CREATE INDEX IF NOT EXISTS idx_cycles_status ON cycles(status);
+  CREATE INDEX IF NOT EXISTS idx_cycles_dates ON cycles(start_date, end_date);
+  ALTER TABLE tasks ADD COLUMN cycle_id TEXT REFERENCES cycles(id) ON DELETE SET NULL;
+  CREATE INDEX IF NOT EXISTS idx_tasks_cycle ON tasks(cycle_id) WHERE cycle_id IS NOT NULL;
+  INSERT OR IGNORE INTO _migrations (id) VALUES (49);
   `
   ];
 });
@@ -13203,6 +13223,23 @@ function loadConfig() {
   cached = config;
   return cached;
 }
+function getAgentPoolForProject(workingDir) {
+  const config = loadConfig();
+  if (workingDir && config.project_pools) {
+    let bestKey = null;
+    let bestLen = 0;
+    for (const key of Object.keys(config.project_pools)) {
+      if (workingDir.startsWith(key) && key.length > bestLen) {
+        bestKey = key;
+        bestLen = key.length;
+      }
+    }
+    if (bestKey && config.project_pools[bestKey]) {
+      return config.project_pools[bestKey];
+    }
+  }
+  return config.agent_pool || null;
+}
 function getCompletionGuardConfig(projectPath) {
   const config = loadConfig();
   const global2 = { ...GUARD_DEFAULTS, ...config.completion_guard };
@@ -13224,6 +13261,27 @@ var init_config2 = __esm(() => {
 });
 
 // src/db/projects.ts
+var exports_projects = {};
+__export(exports_projects, {
+  updateProject: () => updateProject,
+  slugify: () => slugify,
+  setMachineLocalPath: () => setMachineLocalPath,
+  renameProject: () => renameProject,
+  removeProjectSource: () => removeProjectSource,
+  removeMachineLocalPath: () => removeMachineLocalPath,
+  nextTaskShortId: () => nextTaskShortId,
+  listProjects: () => listProjects,
+  listProjectSources: () => listProjectSources,
+  listMachineLocalPaths: () => listMachineLocalPaths,
+  getProjectWithSources: () => getProjectWithSources,
+  getProjectByPath: () => getProjectByPath,
+  getProject: () => getProject,
+  getMachineLocalPath: () => getMachineLocalPath,
+  ensureProject: () => ensureProject,
+  deleteProject: () => deleteProject,
+  createProject: () => createProject,
+  addProjectSource: () => addProjectSource
+});
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
@@ -13262,6 +13320,18 @@ function getProject(id, db) {
   const row = d.query("SELECT * FROM projects WHERE id = ?").get(id);
   return row;
 }
+function getProjectByPath(path, db) {
+  const d = db || getDatabase();
+  try {
+    const machineId = getMachineId(d);
+    const machineRow = d.query(`SELECT p.* FROM projects p
+       JOIN project_machine_paths pmp ON pmp.project_id = p.id
+       WHERE pmp.machine_id = ? AND pmp.path = ?`).get(machineId, path);
+    if (machineRow)
+      return machineRow;
+  } catch {}
+  return d.query("SELECT * FROM projects WHERE path = ?").get(path);
+}
 function listProjects(db) {
   const d = db || getDatabase();
   return d.query("SELECT * FROM projects ORDER BY name").all();
@@ -13293,11 +13363,141 @@ function updateProject(id, input, db) {
   d.run(`UPDATE projects SET ${sets.join(", ")} WHERE id = ?`, params);
   return getProject(id, d);
 }
+function renameProject(id, input, db) {
+  const d = db || getDatabase();
+  const project = getProject(id, d);
+  if (!project)
+    throw new ProjectNotFoundError(id);
+  let taskListsUpdated = 0;
+  const ts = now();
+  if (input.new_slug !== undefined) {
+    const normalised = input.new_slug.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-|-$/g, "");
+    if (!normalised)
+      throw new Error("Invalid slug \u2014 must be non-empty kebab-case");
+    const conflict = d.query("SELECT id FROM projects WHERE task_list_id = ? AND id != ?").get(normalised, id);
+    if (conflict)
+      throw new Error(`Slug "${normalised}" is already used by another project`);
+    const oldSlug = project.task_list_id;
+    d.run("UPDATE projects SET task_list_id = ?, updated_at = ? WHERE id = ?", [normalised, ts, id]);
+    if (oldSlug) {
+      const result = d.run("UPDATE task_lists SET slug = ?, name = COALESCE(?, name), updated_at = ? WHERE project_id = ? AND slug = ?", [normalised, input.name ?? null, ts, id, oldSlug]);
+      taskListsUpdated = result.changes;
+    }
+  }
+  if (input.name !== undefined) {
+    d.run("UPDATE projects SET name = ?, updated_at = ? WHERE id = ?", [input.name, ts, id]);
+  }
+  return { project: getProject(id, d), task_lists_updated: taskListsUpdated };
+}
 function deleteProject(id, db) {
   const d = db || getDatabase();
   const result = d.run("DELETE FROM projects WHERE id = ?", [id]);
   return result.changes > 0;
 }
+function rowToSource(row) {
+  return {
+    ...row,
+    metadata: row.metadata ? JSON.parse(row.metadata) : {}
+  };
+}
+function addProjectSource(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO project_sources (id, project_id, type, name, uri, description, metadata, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.project_id,
+    input.type,
+    input.name,
+    input.uri,
+    input.description || null,
+    JSON.stringify(input.metadata || {}),
+    timestamp,
+    timestamp
+  ]);
+  return rowToSource(d.query("SELECT * FROM project_sources WHERE id = ?").get(id));
+}
+function removeProjectSource(id, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM project_sources WHERE id = ?", [id]);
+  return result.changes > 0;
+}
+function listProjectSources(projectId, db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM project_sources WHERE project_id = ? ORDER BY name").all(projectId);
+  return rows.map(rowToSource);
+}
+function getProjectWithSources(id, db) {
+  const d = db || getDatabase();
+  const project = getProject(id, d);
+  if (!project)
+    return null;
+  project.sources = listProjectSources(id, d);
+  return project;
+}
+function nextTaskShortId(projectId, db) {
+  const d = db || getDatabase();
+  const project = getProject(projectId, d);
+  if (!project || !project.task_prefix)
+    return null;
+  d.run("UPDATE projects SET task_counter = task_counter + 1, updated_at = ? WHERE id = ?", [now(), projectId]);
+  const updated = getProject(projectId, d);
+  const padded = String(updated.task_counter).padStart(5, "0");
+  return `${updated.task_prefix}-${padded}`;
+}
+function ensureProject(name, path, db) {
+  const d = db || getDatabase();
+  const existing = getProjectByPath(path, d);
+  if (existing) {
+    if (!existing.task_prefix) {
+      const prefix = generatePrefix(existing.name, d);
+      d.run("UPDATE projects SET task_prefix = ?, updated_at = ? WHERE id = ?", [prefix, now(), existing.id]);
+      return getProject(existing.id, d);
+    }
+    setMachineLocalPath(existing.id, path, d);
+    return existing;
+  }
+  const project = createProject({ name, path }, d);
+  setMachineLocalPath(project.id, path, d);
+  return project;
+}
+function setMachineLocalPath(projectId, path, db) {
+  const d = db || getDatabase();
+  const machineId = getMachineId(d);
+  const ts = now();
+  const existing = d.query("SELECT * FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(projectId, machineId);
+  if (existing) {
+    if (existing.path !== path) {
+      d.run("UPDATE project_machine_paths SET path = ?, updated_at = ? WHERE id = ?", [path, ts, existing.id]);
+    }
+    return d.query("SELECT * FROM project_machine_paths WHERE id = ?").get(existing.id);
+  }
+  const id = uuid();
+  d.run("INSERT INTO project_machine_paths (id, project_id, machine_id, path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)", [id, projectId, machineId, path, ts, ts]);
+  return d.query("SELECT * FROM project_machine_paths WHERE id = ?").get(id);
+}
+function getMachineLocalPath(projectId, db) {
+  const d = db || getDatabase();
+  try {
+    const machineId = getMachineId(d);
+    const row = d.query("SELECT path FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(projectId, machineId);
+    if (row)
+      return row.path;
+  } catch {}
+  const project = getProject(projectId, d);
+  return project?.path ?? null;
+}
+function listMachineLocalPaths(projectId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM project_machine_paths WHERE project_id = ? ORDER BY machine_id").all(projectId);
+}
+function removeMachineLocalPath(projectId, machineId, db) {
+  const d = db || getDatabase();
+  const mid = machineId ?? getMachineId(d);
+  const result = d.run("DELETE FROM project_machine_paths WHERE project_id = ? AND machine_id = ?", [projectId, mid]);
+  return result.changes > 0;
+}
 var init_projects = __esm(() => {
   init_types2();
   init_database();
@@ -13558,8 +13758,8 @@ function createTask(input, db) {
   let id = uuid();
   for (let attempt = 0;attempt < 3; attempt++) {
     try {
-      d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, cycle_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at, estimated_minutes, requires_approval, approved_by, approved_at, recurrence_rule, recurrence_parent_id, spawns_template_id, reason, spawned_from_session, assigned_by, assigned_from_project, task_type)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+      d.run(`INSERT INTO tasks (id, short_id, project_id, parent_id, plan_id, task_list_id, cycle_id, title, description, status, priority, agent_id, assigned_to, session_id, working_dir, tags, metadata, version, created_at, updated_at, due_at, estimated_minutes, confidence, retry_count, max_retries, retry_after, requires_approval, approved_by, approved_at, recurrence_rule, recurrence_parent_id, spawns_template_id, reason, spawned_from_session, assigned_by, assigned_from_project, task_type)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
         id,
         null,
         input.project_id || null,
@@ -13581,6 +13781,10 @@ function createTask(input, db) {
         timestamp,
         input.due_at || null,
         input.estimated_minutes || null,
+        input.confidence ?? null,
+        input.retry_count ?? 0,
+        input.max_retries ?? 3,
+        input.retry_after ?? null,
         input.requires_approval ? 1 : 0,
         null,
         null,
@@ -13605,11 +13809,11 @@ function createTask(input, db) {
   if (tags.length > 0) {
     insertTaskTags(id, tags, d);
   }
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   dispatchWebhook("task.created", { id: task.id, short_id: task.short_id, title: task.title, status: task.status, priority: task.priority, project_id: task.project_id, assigned_to: task.assigned_to }, d).catch(() => {});
   return task;
 }
-function getTask2(id, db) {
+function getTask(id, db) {
   const d = db || getDatabase();
   const row = d.query("SELECT * FROM tasks WHERE id = ?").get(id);
   if (!row)
@@ -13618,7 +13822,7 @@ function getTask2(id, db) {
 }
 function getTaskWithRelations(id, db) {
   const d = db || getDatabase();
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   if (!task)
     return null;
   const subtaskRows = d.query("SELECT * FROM tasks WHERE parent_id = ? ORDER BY created_at").all(id);
@@ -13632,7 +13836,7 @@ function getTaskWithRelations(id, db) {
        WHERE td.depends_on = ?`).all(id);
   const blocked_by = blockedByRows.map(rowToTask);
   const comments = d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(id);
-  const parent = task.parent_id ? getTask2(task.parent_id, d) : null;
+  const parent = task.parent_id ? getTask(task.parent_id, d) : null;
   const checklist = getChecklist(id, d);
   return {
     ...task,
@@ -13819,14 +14023,16 @@ function countTasks(filter = {}, db) {
 }
 function updateTask(id, input, db) {
   const d = db || getDatabase();
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
   if (task.version !== input.version) {
     throw new VersionConflictError(id, input.version, task.version);
   }
+  const timestamp = now();
+  const completionTimestamp = input.completed_at ?? timestamp;
   const sets = ["version = version + 1", "updated_at = ?"];
-  const params = [now()];
+  const params = [timestamp];
   if (input.title !== undefined) {
     sets.push("title = ?");
     params.push(input.title);
@@ -13843,13 +14049,17 @@ function updateTask(id, input, db) {
     params.push(input.status);
     if (input.status === "completed") {
       sets.push("completed_at = ?");
-      params.push(now());
+      params.push(completionTimestamp);
     }
   }
   if (input.priority !== undefined) {
     sets.push("priority = ?");
     params.push(input.priority);
   }
+  if (input.project_id !== undefined) {
+    sets.push("project_id = ?");
+    params.push(input.project_id);
+  }
   if (input.assigned_to !== undefined) {
     sets.push("assigned_to = ?");
     params.push(input.assigned_to);
@@ -13878,6 +14088,30 @@ function updateTask(id, input, db) {
     sets.push("estimated_minutes = ?");
     params.push(input.estimated_minutes);
   }
+  if (input.actual_minutes !== undefined) {
+    sets.push("actual_minutes = ?");
+    params.push(input.actual_minutes);
+  }
+  if (input.completed_at !== undefined && input.status !== "completed") {
+    sets.push("completed_at = ?");
+    params.push(input.completed_at);
+  }
+  if (input.confidence !== undefined) {
+    sets.push("confidence = ?");
+    params.push(input.confidence);
+  }
+  if (input.retry_count !== undefined) {
+    sets.push("retry_count = ?");
+    params.push(input.retry_count);
+  }
+  if (input.max_retries !== undefined) {
+    sets.push("max_retries = ?");
+    params.push(input.max_retries);
+  }
+  if (input.retry_after !== undefined) {
+    sets.push("retry_after = ?");
+    params.push(input.retry_after);
+  }
   if (input.requires_approval !== undefined) {
     sets.push("requires_approval = ?");
     params.push(input.requires_approval ? 1 : 0);
@@ -13899,7 +14133,7 @@ function updateTask(id, input, db) {
   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 = getTask2(id, d);
+    const current = getTask(id, d);
     throw new VersionConflictError(id, input.version, current?.version ?? -1);
   }
   if (input.tags !== undefined) {
@@ -13928,11 +14162,16 @@ function updateTask(id, input, db) {
     tags: input.tags ?? task.tags,
     metadata: input.metadata ?? task.metadata,
     version: task.version + 1,
-    updated_at: now(),
-    completed_at: input.status === "completed" ? now() : task.completed_at,
+    updated_at: timestamp,
+    completed_at: input.status === "completed" ? completionTimestamp : input.completed_at !== undefined ? input.completed_at : task.completed_at,
+    actual_minutes: input.actual_minutes ?? task.actual_minutes,
+    confidence: input.confidence !== undefined ? input.confidence : task.confidence,
+    retry_count: input.retry_count ?? task.retry_count,
+    max_retries: input.max_retries ?? task.max_retries,
+    retry_after: input.retry_after !== undefined ? input.retry_after : task.retry_after,
     requires_approval: input.requires_approval !== undefined ? input.requires_approval : task.requires_approval,
     approved_by: input.approved_by ?? task.approved_by,
-    approved_at: input.approved_by ? now() : task.approved_at
+    approved_at: input.approved_by ? timestamp : task.approved_at
   };
 }
 function deleteTask(id, db) {
@@ -14085,9 +14324,9 @@ var init_templates = __esm(() => {
 // src/db/task-graph.ts
 function addDependency(taskId, dependsOn, db) {
   const d = db || getDatabase();
-  if (!getTask2(taskId, d))
+  if (!getTask(taskId, d))
     throw new TaskNotFoundError(taskId);
-  if (!getTask2(dependsOn, d))
+  if (!getTask(dependsOn, d))
     throw new TaskNotFoundError(dependsOn);
   if (wouldCreateCycle(taskId, dependsOn, d)) {
     throw new DependencyCycleError(taskId, dependsOn);
@@ -14109,7 +14348,7 @@ function getTaskDependents(taskId, db) {
 }
 function cloneTask(taskId, overrides, db) {
   const d = db || getDatabase();
-  const source = getTask2(taskId, d);
+  const source = getTask(taskId, d);
   if (!source)
     throw new TaskNotFoundError(taskId);
   const input = {
@@ -14132,13 +14371,13 @@ function cloneTask(taskId, overrides, db) {
 }
 function getTaskGraph(taskId, direction = "both", db) {
   const d = db || getDatabase();
-  const task = getTask2(taskId, d);
+  const task = getTask(taskId, d);
   if (!task)
     throw new TaskNotFoundError(taskId);
   function toNode(t) {
     const deps = getTaskDependencies(t.id, d);
     const hasUnfinishedDeps = deps.some((dep) => {
-      const depTask = getTask2(dep.depends_on, d);
+      const depTask = getTask(dep.depends_on, d);
       return depTask && depTask.status !== "completed";
     });
     return { id: t.id, short_id: t.short_id, title: t.title, status: t.status, priority: t.priority, is_blocked: hasUnfinishedDeps };
@@ -14149,7 +14388,7 @@ function getTaskGraph(taskId, direction = "both", db) {
     visited.add(id);
     const deps = d.query("SELECT depends_on FROM task_dependencies WHERE task_id = ?").all(id);
     return deps.map((dep) => {
-      const depTask = getTask2(dep.depends_on, d);
+      const depTask = getTask(dep.depends_on, d);
       if (!depTask)
         return null;
       return { task: toNode(depTask), depends_on: buildUp(dep.depends_on, visited), blocks: [] };
@@ -14161,7 +14400,7 @@ function getTaskGraph(taskId, direction = "both", db) {
     visited.add(id);
     const dependents = d.query("SELECT task_id FROM task_dependencies WHERE depends_on = ?").all(id);
     return dependents.map((dep) => {
-      const depTask = getTask2(dep.task_id, d);
+      const depTask = getTask(dep.task_id, d);
       if (!depTask)
         return null;
       return { task: toNode(depTask), depends_on: [], blocks: buildDown(dep.task_id, visited) };
@@ -14174,7 +14413,7 @@ function getTaskGraph(taskId, direction = "both", db) {
 }
 function moveTask(taskId, target, db) {
   const d = db || getDatabase();
-  const task = getTask2(taskId, d);
+  const task = getTask(taskId, d);
   if (!task)
     throw new TaskNotFoundError(taskId);
   const sets = ["updated_at = ?", "version = version + 1"];
@@ -14193,7 +14432,7 @@ function moveTask(taskId, target, db) {
   }
   params.push(taskId);
   d.run(`UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`, params);
-  return getTask2(taskId, d);
+  return getTask(taskId, d);
 }
 function wouldCreateCycle(taskId, dependsOn, db) {
   const visited = new Set;
@@ -14226,7 +14465,7 @@ function getBlockingDeps(id, db) {
     return [];
   const blocking = [];
   for (const dep of deps) {
-    const task = getTask2(dep.depends_on, d);
+    const task = getTask(dep.depends_on, d);
     if (task && task.status !== "completed")
       blocking.push(task);
   }
@@ -14234,7 +14473,7 @@ function getBlockingDeps(id, db) {
 }
 function startTask(id, agentId, db) {
   const d = db || getDatabase();
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
   const blocking = getBlockingDeps(id, d);
@@ -14257,7 +14496,7 @@ function startTask(id, agentId, db) {
 }
 function completeTask(id, agentId, db, options) {
   const d = db || getDatabase();
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
   if (agentId && task.locked_by && task.locked_by !== agentId && !isLockExpired(task.locked_at)) {
@@ -14273,14 +14512,14 @@ function completeTask(id, agentId, db, options) {
     completionMeta._completion = { confidence: options.confidence };
   }
   const hasMeta = Object.keys(completionMeta).length > 0;
-  const timestamp = now();
+  const timestamp = options?.completed_at || now();
   const confidence = options?.confidence !== undefined ? options.confidence : null;
   const tx = d.transaction(() => {
     if (hasMeta) {
       const meta2 = { ...task.metadata, ...completionMeta };
       const metaResult = d.run("UPDATE tasks SET metadata = ?, version = version + 1, updated_at = ? WHERE id = ? AND version = ?", [JSON.stringify(meta2), timestamp, id, task.version]);
       if (metaResult.changes === 0) {
-        const current = getTask2(id, d);
+        const current = getTask(id, d);
         throw new VersionConflictError(id, task.version, current?.version ?? -1);
       }
     }
@@ -14337,7 +14576,7 @@ function completeTask(id, agentId, db, options) {
 }
 function lockTask(id, agentId, db) {
   const d = db || getDatabase();
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
   if (task.locked_by === agentId && !isLockExpired(task.locked_at)) {
@@ -14348,7 +14587,7 @@ function lockTask(id, agentId, db) {
   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 = getTask2(id, d);
+    const current = getTask(id, d);
     if (!current)
       throw new TaskNotFoundError(id);
     if (current.locked_by && !isLockExpired(current.locked_at)) {
@@ -14364,7 +14603,7 @@ function lockTask(id, agentId, db) {
 }
 function unlockTask(id, agentId, db) {
   const d = db || getDatabase();
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
   if (agentId && task.locked_by && task.locked_by !== agentId) {
@@ -14465,7 +14704,7 @@ function getTasksChangedSince(since, filters, db) {
 }
 function failTask(id, agentId, reason, options, db) {
   const d = db || getDatabase();
-  const task = getTask2(id, d);
+  const task = getTask(id, d);
   if (!task)
     throw new TaskNotFoundError(id);
   const meta = {
@@ -14664,7 +14903,7 @@ function getStatus(filters, agentId, options, db) {
 }
 function decomposeTasks(parentId, subtasks, options, db) {
   const d = db || getDatabase();
-  const parent = getTask2(parentId, d);
+  const parent = getTask(parentId, d);
   if (!parent)
     throw new TaskNotFoundError(parentId);
   const created = [];
@@ -14695,7 +14934,7 @@ function decomposeTasks(parentId, subtasks, options, db) {
 function setTaskStatus(id, status, _agentId, db) {
   const d = db || getDatabase();
   for (let attempt = 0;attempt < 3; attempt++) {
-    const task = getTask2(id, d);
+    const task = getTask(id, d);
     if (!task)
       throw new TaskNotFoundError(id);
     if (task.status === status)
@@ -14713,7 +14952,7 @@ function setTaskStatus(id, status, _agentId, db) {
 function setTaskPriority(id, priority, _agentId, db) {
   const d = db || getDatabase();
   for (let attempt = 0;attempt < 3; attempt++) {
-    const task = getTask2(id, d);
+    const task = getTask(id, d);
     if (!task)
       throw new TaskNotFoundError(id);
     if (task.priority === priority)
@@ -14821,7 +15060,7 @@ function bulkUpdateTasks(taskIds, updates, db) {
   const tx = d.transaction(() => {
     for (const id of taskIds) {
       try {
-        const task = getTask2(id, d);
+        const task = getTask(id, d);
         if (!task) {
           failed.push({ id, error: "Task not found" });
           continue;
@@ -14836,6 +15075,30 @@ function bulkUpdateTasks(taskIds, updates, db) {
   tx();
   return { updated, failed };
 }
+function bulkDeleteTasks(taskIds, force = false, db) {
+  const d = db || getDatabase();
+  let deleted = 0;
+  let skipped = 0;
+  const failed = [];
+  const tx = d.transaction(() => {
+    for (const id of taskIds) {
+      try {
+        const childCount = d.query("SELECT COUNT(*) as count FROM tasks WHERE parent_id = ?").get(id);
+        if (!force && childCount.count > 0) {
+          skipped++;
+          continue;
+        }
+        const result = d.run("DELETE FROM tasks WHERE id = ?", [id]);
+        if (result.changes > 0)
+          deleted++;
+      } catch (e) {
+        failed.push({ id, error: e instanceof Error ? e.message : String(e) });
+      }
+    }
+  });
+  tx();
+  return { deleted, skipped, failed };
+}
 function archiveTasks(options, db) {
   const d = db || getDatabase();
   const conditions = ["archived_at IS NULL"];
@@ -14860,10 +15123,33 @@ function archiveTasks(options, db) {
   const result = d.run(`UPDATE tasks SET archived_at = ? WHERE ${conditions.join(" AND ")}`, [ts, ...params]);
   return { archived: result.changes };
 }
+function archiveCompletedTasks(days = 7, projectId, db) {
+  return archiveTasks({
+    project_id: projectId,
+    older_than_days: days,
+    status: ["completed"]
+  }, db).archived;
+}
+function getArchivedTasks(opts = {}, db) {
+  const d = db || getDatabase();
+  const conditions = ["archived_at IS NOT NULL"];
+  const params = [];
+  if (opts.project_id) {
+    conditions.push("project_id = ?");
+    params.push(opts.project_id);
+  }
+  let limitClause = "";
+  if (opts.limit) {
+    limitClause = " LIMIT ?";
+    params.push(opts.limit);
+  }
+  const rows = d.query(`SELECT * FROM tasks WHERE ${conditions.join(" AND ")} ORDER BY archived_at DESC${limitClause}`).all(...params);
+  return rows.map(rowToTask);
+}
 function unarchiveTask(id, db) {
   const d = db || getDatabase();
   d.run("UPDATE tasks SET archived_at = NULL WHERE id = ?", [id]);
-  return getTask2(id, d);
+  return getTask(id, d);
 }
 function getOverdueTasks(projectId, db) {
   const d = db || getDatabase();
@@ -14878,6 +15164,80 @@ function getOverdueTasks(projectId, db) {
   const rows = d.query(query).all(...params);
   return rows.map(rowToTask);
 }
+function notifyUpcomingDeadlines(opts = {}, db) {
+  const d = db || getDatabase();
+  const hours = opts.hours ?? 24;
+  const start = new Date().toISOString();
+  const end = new Date(Date.now() + hours * 60 * 60 * 1000).toISOString();
+  const conditions = [
+    "archived_at IS NULL",
+    "due_at IS NOT NULL",
+    "due_at >= ?",
+    "due_at <= ?",
+    "status NOT IN ('completed', 'cancelled', 'failed')"
+  ];
+  const params = [start, end];
+  if (opts.project_id) {
+    conditions.push("project_id = ?");
+    params.push(opts.project_id);
+  }
+  if (opts.agent_id) {
+    conditions.push("assigned_to = ?");
+    params.push(opts.agent_id);
+  }
+  const rows = d.query(`SELECT * FROM tasks WHERE ${conditions.join(" AND ")} ORDER BY due_at ASC`).all(...params);
+  return rows.map(rowToTask);
+}
+function getBlockedTasks(projectId, db) {
+  const d = db || getDatabase();
+  const params = [];
+  let projectClause = "";
+  if (projectId) {
+    projectClause = "AND t.project_id = ?";
+    params.push(projectId);
+  }
+  const rows = d.query(`
+    SELECT t.*, GROUP_CONCAT(dep.id) AS blocked_by_ids
+    FROM tasks t
+    JOIN task_dependencies td ON td.task_id = t.id
+    JOIN tasks dep ON dep.id = td.depends_on
+    WHERE t.archived_at IS NULL
+      AND t.status NOT IN ('completed', 'cancelled', 'failed')
+      AND dep.status NOT IN ('completed', 'cancelled')
+      ${projectClause}
+    GROUP BY t.id
+    ORDER BY t.priority DESC, t.created_at DESC
+  `).all(...params);
+  return rows.map((row) => ({
+    ...rowToTask(row),
+    blocked_by: row.blocked_by_ids ? row.blocked_by_ids.split(",") : []
+  }));
+}
+function getBlockingTasks(projectId, db) {
+  const d = db || getDatabase();
+  const params = [];
+  let projectClause = "";
+  if (projectId) {
+    projectClause = "AND blocker.project_id = ?";
+    params.push(projectId);
+  }
+  const rows = d.query(`
+    SELECT blocker.*, COUNT(DISTINCT blocked.id) AS blocking_count
+    FROM tasks blocker
+    JOIN task_dependencies td ON td.depends_on = blocker.id
+    JOIN tasks blocked ON blocked.id = td.task_id
+    WHERE blocker.archived_at IS NULL
+      AND blocker.status NOT IN ('completed', 'cancelled', 'failed')
+      AND blocked.status NOT IN ('completed', 'cancelled', 'failed')
+      ${projectClause}
+    GROUP BY blocker.id
+    ORDER BY blocking_count DESC, blocker.created_at DESC
+  `).all(...params);
+  return rows.map((row) => ({
+    ...rowToTask(row),
+    blocking_count: row.blocking_count
+  }));
+}
 function logTime(input, db) {
   const d = db || getDatabase();
   const id = uuid();
@@ -14958,6 +15318,7 @@ __export(exports_tasks, {
   removeDependency: () => removeDependency,
   redistributeStaleTasks: () => redistributeStaleTasks,
   notifyWatchers: () => notifyWatchers,
+  notifyUpcomingDeadlines: () => notifyUpcomingDeadlines,
   moveTask: () => moveTask,
   logTime: () => logTime,
   logCost: () => logCost,
@@ -14973,12 +15334,15 @@ __export(exports_tasks, {
   getTaskGraph: () => getTaskGraph,
   getTaskDependents: () => getTaskDependents,
   getTaskDependencies: () => getTaskDependencies,
-  getTask: () => getTask2,
+  getTask: () => getTask,
   getStatus: () => getStatus,
   getStaleTasks: () => getStaleTasks,
   getOverdueTasks: () => getOverdueTasks,
   getNextTask: () => getNextTask,
+  getBlockingTasks: () => getBlockingTasks,
   getBlockingDeps: () => getBlockingDeps,
+  getBlockedTasks: () => getBlockedTasks,
+  getArchivedTasks: () => getArchivedTasks,
   getActiveWork: () => getActiveWork,
   failTask: () => failTask,
   deleteTask: () => deleteTask,
@@ -14990,8 +15354,10 @@ __export(exports_tasks, {
   claimOrSteal: () => claimOrSteal,
   claimNextTask: () => claimNextTask,
   bulkUpdateTasks: () => bulkUpdateTasks,
+  bulkDeleteTasks: () => bulkDeleteTasks,
   bulkCreateTasks: () => bulkCreateTasks,
   archiveTasks: () => archiveTasks,
+  archiveCompletedTasks: () => archiveCompletedTasks,
   addDependency: () => addDependency
 });
 var init_tasks = __esm(() => {
@@ -15169,90 +15535,495 @@ var init_dispatch = __esm(() => {
   init_dispatch_formatter();
 });
 
-// src/db/task-files.ts
-var exports_task_files = {};
-__export(exports_task_files, {
-  updateTaskFileStatus: () => updateTaskFileStatus,
-  removeTaskFile: () => removeTaskFile,
-  listTaskFiles: () => listTaskFiles,
-  listActiveFiles: () => listActiveFiles,
-  getTaskFile: () => getTaskFile,
-  getFileHeatMap: () => getFileHeatMap,
-  findTasksByFile: () => findTasksByFile,
-  detectFileConflicts: () => detectFileConflicts,
-  bulkFindTasksByFiles: () => bulkFindTasksByFiles,
-  bulkAddTaskFiles: () => bulkAddTaskFiles,
-  addTaskFile: () => addTaskFile
+// src/db/comments.ts
+var exports_comments = {};
+__export(exports_comments, {
+  updateComment: () => updateComment,
+  logProgress: () => logProgress,
+  listComments: () => listComments,
+  getComment: () => getComment,
+  deleteComment: () => deleteComment,
+  addComment: () => addComment
 });
-function addTaskFile(input, db) {
+function addComment(input, db) {
   const d = db || getDatabase();
+  if (!getTask(input.task_id, d)) {
+    throw new TaskNotFoundError(input.task_id);
+  }
   const id = uuid();
   const timestamp = now();
-  const existing = d.query("SELECT id FROM task_files WHERE task_id = ? AND path = ?").get(input.task_id, input.path);
-  if (existing) {
-    d.run("UPDATE task_files SET status = ?, agent_id = ?, note = ?, updated_at = ? WHERE id = ?", [input.status || "active", input.agent_id || null, input.note || null, timestamp, existing.id]);
-    return getTaskFile(existing.id, d);
-  }
-  d.run(`INSERT INTO task_files (id, task_id, path, status, agent_id, note, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.task_id, input.path, input.status || "active", input.agent_id || null, input.note || null, timestamp, timestamp]);
-  return getTaskFile(id, d);
+  d.run(`INSERT INTO task_comments (id, task_id, agent_id, session_id, content, type, progress_pct, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.task_id,
+    input.agent_id || null,
+    input.session_id || null,
+    input.content,
+    input.type || "comment",
+    input.progress_pct ?? null,
+    timestamp
+  ]);
+  return getComment(id, d);
 }
-function getTaskFile(id, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM task_files WHERE id = ?").get(id);
+function logProgress(taskId, message, pct, agentId, db) {
+  return addComment({ task_id: taskId, content: message, type: "progress", progress_pct: pct, agent_id: agentId }, db);
 }
-function listTaskFiles(taskId, db) {
+function getComment(id, db) {
   const d = db || getDatabase();
-  return d.query("SELECT * FROM task_files WHERE task_id = ? ORDER BY path").all(taskId);
+  return d.query("SELECT * FROM task_comments WHERE id = ?").get(id);
 }
-function findTasksByFile(path, db) {
+function listComments(taskId, db) {
   const d = db || getDatabase();
-  return d.query("SELECT * FROM task_files WHERE path = ? AND status != 'removed' ORDER BY updated_at DESC").all(path);
+  return d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(taskId);
 }
-function updateTaskFileStatus(taskId, path, status, agentId, db) {
+function updateComment(id, input, db) {
   const d = db || getDatabase();
-  const timestamp = now();
-  d.run("UPDATE task_files SET status = ?, agent_id = COALESCE(?, agent_id), updated_at = ? WHERE task_id = ? AND path = ?", [status, agentId || null, timestamp, taskId, path]);
-  const row = d.query("SELECT * FROM task_files WHERE task_id = ? AND path = ?").get(taskId, path);
-  return row;
+  d.run("UPDATE task_comments SET content = ? WHERE id = ?", [input.content, id]);
+  const comment = getComment(id, d);
+  if (!comment) {
+    throw new Error(`Comment not found: ${id}`);
+  }
+  return comment;
 }
-function removeTaskFile(taskId, path, db) {
+function deleteComment(id, db) {
   const d = db || getDatabase();
-  const result = d.run("DELETE FROM task_files WHERE task_id = ? AND path = ?", [taskId, path]);
+  const result = d.run("DELETE FROM task_comments WHERE id = ?", [id]);
   return result.changes > 0;
 }
-function detectFileConflicts(taskId, paths, db) {
-  const d = db || getDatabase();
-  if (paths.length === 0)
-    return [];
-  const placeholders = paths.map(() => "?").join(", ");
-  const rows = d.query(`
-    SELECT tf.path, tf.agent_id AS conflicting_agent_id, t.id AS conflicting_task_id,
-           t.title AS conflicting_task_title, t.status AS conflicting_task_status
-    FROM task_files tf
-    JOIN tasks t ON tf.task_id = t.id
-    WHERE tf.path IN (${placeholders})
-      AND tf.task_id != ?
-      AND tf.status != 'removed'
-      AND t.status = 'in_progress'
-    ORDER BY tf.updated_at DESC
-  `).all(...paths, taskId);
-  return rows;
+var init_comments = __esm(() => {
+  init_types2();
+  init_database();
+  init_tasks();
+});
+
+// src/lib/search.ts
+var exports_search = {};
+__export(exports_search, {
+  searchTasks: () => searchTasks
+});
+function rowToTask2(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    status: row.status,
+    priority: row.priority,
+    requires_approval: Boolean(row.requires_approval)
+  };
 }
-function bulkFindTasksByFiles(paths, db) {
+function hasFts(db) {
+  try {
+    const result = db.query("SELECT 1 FROM sqlite_master WHERE type='table' AND name='tasks_fts'").get();
+    return result !== null;
+  } catch {
+    return false;
+  }
+}
+function escapeFtsQuery(q) {
+  return q.replace(/["*^()]/g, " ").trim().split(/\s+/).filter(Boolean).map((token) => `"${token}"*`).join(" ");
+}
+function searchTasks(options, projectId, taskListId, db) {
+  const opts = typeof options === "string" ? { query: options || undefined, project_id: projectId, task_list_id: taskListId } : options;
   const d = db || getDatabase();
-  if (paths.length === 0)
-    return [];
-  const placeholders = paths.map(() => "?").join(", ");
-  const rows = d.query(`SELECT tf.*, t.status AS task_status FROM task_files tf
-     JOIN tasks t ON tf.task_id = t.id
-     WHERE tf.path IN (${placeholders}) AND tf.status != 'removed'
-     ORDER BY tf.updated_at DESC`).all(...paths);
-  const byPath = new Map;
-  for (const path of paths)
-    byPath.set(path, []);
-  for (const row of rows) {
-    byPath.get(row.path)?.push(row);
+  clearExpiredLocks(d);
+  const params = [];
+  let sql;
+  const raw = opts.query?.trim() ?? "";
+  const q = raw === "*" ? "" : raw;
+  if (hasFts(d) && q) {
+    const ftsQuery = escapeFtsQuery(q);
+    sql = `SELECT t.* FROM tasks t
+      INNER JOIN tasks_fts fts ON fts.rowid = t.rowid
+      WHERE tasks_fts MATCH ?`;
+    params.push(ftsQuery);
+  } else if (q) {
+    const pattern = `%${q}%`;
+    sql = `SELECT * FROM tasks t WHERE (t.title LIKE ? OR t.description LIKE ? OR EXISTS (SELECT 1 FROM task_tags WHERE task_tags.task_id = t.id AND tag LIKE ?))`;
+    params.push(pattern, pattern, pattern);
+  } else {
+    sql = `SELECT * FROM tasks t WHERE 1=1`;
+  }
+  if (opts.project_id) {
+    sql += " AND t.project_id = ?";
+    params.push(opts.project_id);
+  }
+  if (opts.task_list_id) {
+    sql += " AND t.task_list_id = ?";
+    params.push(opts.task_list_id);
+  }
+  if (opts.status) {
+    if (Array.isArray(opts.status)) {
+      sql += ` AND t.status IN (${opts.status.map(() => "?").join(",")})`;
+      params.push(...opts.status);
+    } else {
+      sql += " AND t.status = ?";
+      params.push(opts.status);
+    }
+  }
+  if (opts.priority) {
+    if (Array.isArray(opts.priority)) {
+      sql += ` AND t.priority IN (${opts.priority.map(() => "?").join(",")})`;
+      params.push(...opts.priority);
+    } else {
+      sql += " AND t.priority = ?";
+      params.push(opts.priority);
+    }
+  }
+  if (opts.assigned_to) {
+    sql += " AND t.assigned_to = ?";
+    params.push(opts.assigned_to);
+  }
+  if (opts.agent_id) {
+    sql += " AND t.agent_id = ?";
+    params.push(opts.agent_id);
+  }
+  if (opts.created_after) {
+    sql += " AND t.created_at > ?";
+    params.push(opts.created_after);
+  }
+  if (opts.updated_after) {
+    sql += " AND t.updated_at > ?";
+    params.push(opts.updated_after);
+  }
+  if (opts.has_dependencies === true) {
+    sql += " AND t.id IN (SELECT task_id FROM task_dependencies)";
+  } else if (opts.has_dependencies === false) {
+    sql += " AND t.id NOT IN (SELECT task_id FROM task_dependencies)";
+  }
+  if (opts.is_blocked === true) {
+    sql += " AND t.id IN (SELECT td.task_id FROM task_dependencies td JOIN tasks dep ON dep.id = td.depends_on WHERE dep.status != 'completed')";
+  } else if (opts.is_blocked === false) {
+    sql += " AND t.id NOT IN (SELECT td.task_id FROM task_dependencies td JOIN tasks dep ON dep.id = td.depends_on WHERE dep.status != 'completed')";
+  }
+  if (hasFts(d) && q) {
+    sql += ` ORDER BY bm25(tasks_fts),
+      CASE t.priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+      t.created_at DESC`;
+  } else {
+    sql += ` ORDER BY
+      CASE t.priority WHEN 'critical' THEN 0 WHEN 'high' THEN 1 WHEN 'medium' THEN 2 WHEN 'low' THEN 3 END,
+      t.created_at DESC`;
+  }
+  const rows = d.query(sql).all(...params);
+  return rows.map(rowToTask2);
+}
+var init_search = __esm(() => {
+  init_database();
+});
+
+// src/db/handoffs.ts
+var exports_handoffs = {};
+__export(exports_handoffs, {
+  listHandoffs: () => listHandoffs,
+  getLatestHandoff: () => getLatestHandoff,
+  createHandoff: () => createHandoff
+});
+function createHandoff(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT INTO handoffs (id, agent_id, project_id, summary, completed, in_progress, blockers, next_steps, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.agent_id || null,
+    input.project_id || null,
+    input.summary,
+    input.completed ? JSON.stringify(input.completed) : null,
+    input.in_progress ? JSON.stringify(input.in_progress) : null,
+    input.blockers ? JSON.stringify(input.blockers) : null,
+    input.next_steps ? JSON.stringify(input.next_steps) : null,
+    timestamp
+  ]);
+  return {
+    id,
+    agent_id: input.agent_id || null,
+    project_id: input.project_id || null,
+    summary: input.summary,
+    completed: input.completed || null,
+    in_progress: input.in_progress || null,
+    blockers: input.blockers || null,
+    next_steps: input.next_steps || null,
+    created_at: timestamp
+  };
+}
+function rowToHandoff(row) {
+  return {
+    ...row,
+    completed: row.completed ? JSON.parse(row.completed) : null,
+    in_progress: row.in_progress ? JSON.parse(row.in_progress) : null,
+    blockers: row.blockers ? JSON.parse(row.blockers) : null,
+    next_steps: row.next_steps ? JSON.parse(row.next_steps) : null
+  };
+}
+function listHandoffs(projectId, limit = 10, db) {
+  const d = db || getDatabase();
+  if (projectId) {
+    return d.query("SELECT * FROM handoffs WHERE project_id = ? ORDER BY rowid DESC LIMIT ?").all(projectId, limit).map(rowToHandoff);
+  }
+  return d.query("SELECT * FROM handoffs ORDER BY rowid DESC LIMIT ?").all(limit).map(rowToHandoff);
+}
+function getLatestHandoff(agentId, projectId, db) {
+  const d = db || getDatabase();
+  let query = "SELECT * FROM handoffs WHERE 1=1";
+  const params = [];
+  if (agentId) {
+    query += " AND agent_id = ?";
+    params.push(agentId);
+  }
+  if (projectId) {
+    query += " AND project_id = ?";
+    params.push(projectId);
+  }
+  query += " ORDER BY rowid DESC LIMIT 1";
+  const row = d.query(query).get(...params);
+  return row ? rowToHandoff(row) : null;
+}
+var init_handoffs = __esm(() => {
+  init_database();
+});
+
+// src/lib/auto-assign.ts
+var exports_auto_assign = {};
+__export(exports_auto_assign, {
+  findBestAgent: () => findBestAgent,
+  autoAssignTask: () => autoAssignTask
+});
+function findBestAgent(_task, db) {
+  const d = db || getDatabase();
+  const agents = listAgents(d).filter((a) => (a.role || "agent") === "agent");
+  if (agents.length === 0)
+    return null;
+  const inProgressTasks = listTasks({ status: "in_progress" }, d);
+  const idToName = new Map;
+  const load = new Map;
+  for (const a of agents) {
+    idToName.set(a.id, a.name);
+    load.set(a.id, 0);
+  }
+  for (const t of inProgressTasks) {
+    const agentId = t.assigned_to || t.agent_id;
+    if (agentId && load.has(agentId)) {
+      load.set(agentId, (load.get(agentId) || 0) + 1);
+    }
+  }
+  let bestAgent = agents[0].name;
+  let bestLoad = load.get(agents[0].id) ?? 0;
+  for (const a of agents) {
+    const l = load.get(a.id) ?? 0;
+    if (l < bestLoad) {
+      bestAgent = a.name;
+      bestLoad = l;
+    }
+  }
+  return bestAgent;
+}
+function getAgentWorkloads(d) {
+  const rows = d.query("SELECT assigned_to, COUNT(*) as count FROM tasks WHERE status = 'in_progress' AND assigned_to IS NOT NULL GROUP BY assigned_to").all();
+  return new Map(rows.map((r) => [r.assigned_to, r.count]));
+}
+function buildPrompt(task, agents) {
+  const agentList = agents.map((a) => `- ${a.name} (role: ${a.role}, caps: [${a.capabilities.join(", ")}], active_tasks: ${a.in_progress_tasks})`).join(`
+`);
+  return `You are a task routing assistant. Given a task and available agents, choose the SINGLE best agent.
+
+TASK:
+Title: ${task.title}
+Priority: ${task.priority}
+Tags: ${task.tags.join(", ") || "none"}
+Description: ${task.description?.slice(0, 300) || "none"}
+
+AVAILABLE AGENTS:
+${agentList}
+
+Rules:
+- Match task tags/content to agent capabilities
+- Prefer agents with fewer active tasks
+- Prefer agents whose role fits the task (lead for critical, developer for features, qa for testing)
+- If no clear match, pick the agent with fewest active tasks
+
+Respond with ONLY a JSON object: {"agent_name": "<name>", "reason": "<one sentence>"}`;
+}
+async function callCerebras(prompt, apiKey) {
+  try {
+    const resp = await fetch(CEREBRAS_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${apiKey}` },
+      body: JSON.stringify({
+        model: CEREBRAS_MODEL,
+        messages: [{ role: "user", content: prompt }],
+        max_tokens: 150,
+        temperature: 0
+      }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!resp.ok)
+      return null;
+    const data = await resp.json();
+    const content = data?.choices?.[0]?.message?.content?.trim();
+    if (!content)
+      return null;
+    const match = content.match(/\{[^}]+\}/s);
+    if (!match)
+      return null;
+    return JSON.parse(match[0]);
+  } catch {
+    return null;
+  }
+}
+async function autoAssignTask(taskId, db) {
+  const d = db || getDatabase();
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new Error(`Task ${taskId} not found`);
+  const agents = listAgents(d).filter((a) => a.status === "active");
+  if (agents.length === 0) {
+    return { task_id: taskId, assigned_to: null, agent_name: null, method: "no_agents" };
+  }
+  const workloads = getAgentWorkloads(d);
+  const apiKey = process.env["CEREBRAS_API_KEY"];
+  let selectedAgent = null;
+  let method = "capability_match";
+  let reason;
+  if (apiKey) {
+    const agentData = agents.map((a) => ({
+      id: a.id,
+      name: a.name,
+      role: a.role || "agent",
+      capabilities: a.capabilities || [],
+      in_progress_tasks: workloads.get(a.id) ?? 0
+    }));
+    const result = await callCerebras(buildPrompt({
+      title: task.title,
+      description: task.description,
+      priority: task.priority,
+      tags: task.tags || []
+    }, agentData), apiKey);
+    if (result?.agent_name) {
+      selectedAgent = agents.find((a) => a.name === result.agent_name) ?? null;
+      if (selectedAgent) {
+        method = "cerebras";
+        reason = result.reason;
+      }
+    }
+  }
+  if (!selectedAgent) {
+    const taskTags = task.tags || [];
+    const capable = getCapableAgents(taskTags, { min_score: 0, limit: 10 }, d);
+    if (capable.length > 0) {
+      const sorted = capable.sort((a, b) => {
+        if (b.score !== a.score)
+          return b.score - a.score;
+        return (workloads.get(a.agent.id) ?? 0) - (workloads.get(b.agent.id) ?? 0);
+      });
+      selectedAgent = sorted[0].agent;
+      reason = `Capability match (score: ${sorted[0].score.toFixed(2)})`;
+    } else {
+      selectedAgent = agents.slice().sort((a, b) => (workloads.get(a.id) ?? 0) - (workloads.get(b.id) ?? 0))[0];
+      reason = `Least busy agent (${workloads.get(selectedAgent.id) ?? 0} active tasks)`;
+    }
+  }
+  if (selectedAgent) {
+    updateTask(taskId, { assigned_to: selectedAgent.id, version: task.version }, d);
+  }
+  return {
+    task_id: taskId,
+    assigned_to: selectedAgent?.id ?? null,
+    agent_name: selectedAgent?.name ?? null,
+    method,
+    reason
+  };
+}
+var CEREBRAS_API_URL = "https://api.cerebras.ai/v1/chat/completions", CEREBRAS_MODEL = "llama-3.3-70b";
+var init_auto_assign = __esm(() => {
+  init_database();
+  init_tasks();
+  init_agents();
+});
+
+// src/db/task-files.ts
+var exports_task_files = {};
+__export(exports_task_files, {
+  updateTaskFileStatus: () => updateTaskFileStatus,
+  removeTaskFile: () => removeTaskFile,
+  listTaskFiles: () => listTaskFiles,
+  listActiveFiles: () => listActiveFiles,
+  getTaskFile: () => getTaskFile,
+  getFileHeatMap: () => getFileHeatMap,
+  findTasksByFile: () => findTasksByFile,
+  detectFileConflicts: () => detectFileConflicts,
+  bulkFindTasksByFiles: () => bulkFindTasksByFiles,
+  bulkAddTaskFiles: () => bulkAddTaskFiles,
+  addTaskFile: () => addTaskFile
+});
+function addTaskFile(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  const existing = d.query("SELECT id FROM task_files WHERE task_id = ? AND path = ?").get(input.task_id, input.path);
+  if (existing) {
+    d.run("UPDATE task_files SET status = ?, agent_id = ?, note = ?, updated_at = ? WHERE id = ?", [input.status || "active", input.agent_id || null, input.note || null, timestamp, existing.id]);
+    return getTaskFile(existing.id, d);
+  }
+  d.run(`INSERT INTO task_files (id, task_id, path, status, agent_id, note, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [id, input.task_id, input.path, input.status || "active", input.agent_id || null, input.note || null, timestamp, timestamp]);
+  return getTaskFile(id, d);
+}
+function getTaskFile(id, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_files WHERE id = ?").get(id);
+}
+function listTaskFiles(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_files WHERE task_id = ? ORDER BY path").all(taskId);
+}
+function findTasksByFile(path, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_files WHERE path = ? AND status != 'removed' ORDER BY updated_at DESC").all(path);
+}
+function updateTaskFileStatus(taskId, path, status, agentId, db) {
+  const d = db || getDatabase();
+  const timestamp = now();
+  d.run("UPDATE task_files SET status = ?, agent_id = COALESCE(?, agent_id), updated_at = ? WHERE task_id = ? AND path = ?", [status, agentId || null, timestamp, taskId, path]);
+  const row = d.query("SELECT * FROM task_files WHERE task_id = ? AND path = ?").get(taskId, path);
+  return row;
+}
+function removeTaskFile(taskId, path, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM task_files WHERE task_id = ? AND path = ?", [taskId, path]);
+  return result.changes > 0;
+}
+function detectFileConflicts(taskId, paths, db) {
+  const d = db || getDatabase();
+  if (paths.length === 0)
+    return [];
+  const placeholders = paths.map(() => "?").join(", ");
+  const rows = d.query(`
+    SELECT tf.path, tf.agent_id AS conflicting_agent_id, t.id AS conflicting_task_id,
+           t.title AS conflicting_task_title, t.status AS conflicting_task_status
+    FROM task_files tf
+    JOIN tasks t ON tf.task_id = t.id
+    WHERE tf.path IN (${placeholders})
+      AND tf.task_id != ?
+      AND tf.status != 'removed'
+      AND t.status = 'in_progress'
+    ORDER BY tf.updated_at DESC
+  `).all(...paths, taskId);
+  return rows;
+}
+function bulkFindTasksByFiles(paths, db) {
+  const d = db || getDatabase();
+  if (paths.length === 0)
+    return [];
+  const placeholders = paths.map(() => "?").join(", ");
+  const rows = d.query(`SELECT tf.*, t.status AS task_status FROM task_files tf
+     JOIN tasks t ON tf.task_id = t.id
+     WHERE tf.path IN (${placeholders}) AND tf.status != 'removed'
+     ORDER BY tf.updated_at DESC`).all(...paths);
+  const byPath = new Map;
+  for (const path of paths)
+    byPath.set(path, []);
+  for (const row of rows) {
+    byPath.get(row.path)?.push(row);
   }
   return paths.map((path) => {
     const tasks = byPath.get(path) ?? [];
@@ -15461,6 +16232,645 @@ var init_task_relationships = __esm(() => {
   ];
 });
 
+// src/db/task-commits.ts
+var exports_task_commits = {};
+__export(exports_task_commits, {
+  unlinkTaskCommit: () => unlinkTaskCommit,
+  linkTaskToCommit: () => linkTaskToCommit,
+  getTaskCommits: () => getTaskCommits,
+  findTaskByCommit: () => findTaskByCommit
+});
+function rowToCommit(row) {
+  return {
+    ...row,
+    files_changed: row.files_changed ? JSON.parse(row.files_changed) : null
+  };
+}
+function linkTaskToCommit(input, db) {
+  const d = db || getDatabase();
+  const existing = d.query("SELECT * FROM task_commits WHERE task_id = ? AND sha = ?").get(input.task_id, input.sha);
+  if (existing) {
+    d.run("UPDATE task_commits SET message = COALESCE(?, message), author = COALESCE(?, author), files_changed = COALESCE(?, files_changed), committed_at = COALESCE(?, committed_at) WHERE id = ?", [input.message ?? null, input.author ?? null, input.files_changed ? JSON.stringify(input.files_changed) : null, input.committed_at ?? null, existing.id]);
+    return rowToCommit(d.query("SELECT * FROM task_commits WHERE id = ?").get(existing.id));
+  }
+  const id = uuid();
+  d.run("INSERT INTO task_commits (id, task_id, sha, message, author, files_changed, committed_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [id, input.task_id, input.sha, input.message ?? null, input.author ?? null, input.files_changed ? JSON.stringify(input.files_changed) : null, input.committed_at ?? null, now()]);
+  return rowToCommit(d.query("SELECT * FROM task_commits WHERE id = ?").get(id));
+}
+function getTaskCommits(taskId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM task_commits WHERE task_id = ? ORDER BY committed_at DESC, created_at DESC").all(taskId).map(rowToCommit);
+}
+function findTaskByCommit(sha, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM task_commits WHERE sha = ? OR sha LIKE ? LIMIT 1").get(sha, `${sha}%`);
+  if (!row)
+    return null;
+  return { task_id: row.task_id, commit: rowToCommit(row) };
+}
+function unlinkTaskCommit(taskId, sha, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM task_commits WHERE task_id = ? AND (sha = ? OR sha LIKE ?)", [taskId, sha, `${sha}%`]).changes > 0;
+}
+var init_task_commits = __esm(() => {
+  init_database();
+});
+
+// src/db/file-locks.ts
+var exports_file_locks = {};
+__export(exports_file_locks, {
+  unlockFile: () => unlockFile,
+  lockFile: () => lockFile,
+  listFileLocks: () => listFileLocks,
+  forceUnlockFile: () => forceUnlockFile,
+  cleanExpiredFileLocks: () => cleanExpiredFileLocks,
+  checkFileLock: () => checkFileLock,
+  FILE_LOCK_DEFAULT_TTL_SECONDS: () => FILE_LOCK_DEFAULT_TTL_SECONDS
+});
+function expiresAt(ttlSeconds) {
+  return new Date(Date.now() + ttlSeconds * 1000).toISOString();
+}
+function cleanExpiredFileLocks(db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM file_locks WHERE expires_at <= ?", [now()]);
+  return result.changes;
+}
+function lockFile(input, db) {
+  const d = db || getDatabase();
+  const ttl = input.ttl_seconds ?? FILE_LOCK_DEFAULT_TTL_SECONDS;
+  const expiry = expiresAt(ttl);
+  const timestamp = now();
+  cleanExpiredFileLocks(d);
+  const existing = d.query("SELECT * FROM file_locks WHERE path = ?").get(input.path);
+  if (existing) {
+    if (existing.agent_id === input.agent_id) {
+      d.run("UPDATE file_locks SET expires_at = ?, task_id = COALESCE(?, task_id) WHERE id = ?", [expiry, input.task_id ?? null, existing.id]);
+      return d.query("SELECT * FROM file_locks WHERE id = ?").get(existing.id);
+    }
+    throw new LockError(input.path, existing.agent_id);
+  }
+  const id = uuid();
+  d.run("INSERT INTO file_locks (id, path, agent_id, task_id, expires_at, created_at) VALUES (?, ?, ?, ?, ?, ?)", [id, input.path, input.agent_id, input.task_id ?? null, expiry, timestamp]);
+  return d.query("SELECT * FROM file_locks WHERE id = ?").get(id);
+}
+function unlockFile(path, agentId, db) {
+  const d = db || getDatabase();
+  cleanExpiredFileLocks(d);
+  const result = d.run("DELETE FROM file_locks WHERE path = ? AND agent_id = ?", [path, agentId]);
+  return result.changes > 0;
+}
+function checkFileLock(path, db) {
+  const d = db || getDatabase();
+  cleanExpiredFileLocks(d);
+  return d.query("SELECT * FROM file_locks WHERE path = ?").get(path);
+}
+function listFileLocks(agentId, db) {
+  const d = db || getDatabase();
+  cleanExpiredFileLocks(d);
+  if (agentId) {
+    return d.query("SELECT * FROM file_locks WHERE agent_id = ? ORDER BY created_at DESC").all(agentId);
+  }
+  return d.query("SELECT * FROM file_locks ORDER BY created_at DESC").all();
+}
+function forceUnlockFile(path, db) {
+  const d = db || getDatabase();
+  const result = d.run("DELETE FROM file_locks WHERE path = ?", [path]);
+  return result.changes > 0;
+}
+var FILE_LOCK_DEFAULT_TTL_SECONDS;
+var init_file_locks = __esm(() => {
+  init_database();
+  init_types2();
+  FILE_LOCK_DEFAULT_TTL_SECONDS = 30 * 60;
+});
+
+// src/db/kg.ts
+var exports_kg = {};
+__export(exports_kg, {
+  syncKgEdges: () => syncKgEdges,
+  removeKgEdges: () => removeKgEdges,
+  getRelated: () => getRelated,
+  getImpactAnalysis: () => getImpactAnalysis,
+  getCriticalPath: () => getCriticalPath,
+  findPath: () => findPath,
+  addKgEdge: () => addKgEdge
+});
+function rowToEdge(row) {
+  return {
+    ...row,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function syncKgEdges(db) {
+  const d = db || getDatabase();
+  let synced = 0;
+  const tx = d.transaction(() => {
+    const deps = d.query("SELECT task_id, depends_on FROM task_dependencies").all();
+    for (const dep of deps) {
+      synced += upsertEdge(d, dep.task_id, "task", dep.depends_on, "task", "depends_on");
+    }
+    const assignments = d.query("SELECT id, assigned_to FROM tasks WHERE assigned_to IS NOT NULL").all();
+    for (const a of assignments) {
+      synced += upsertEdge(d, a.id, "task", a.assigned_to, "agent", "assigned_to");
+    }
+    const agents = d.query("SELECT id, reports_to FROM agents WHERE reports_to IS NOT NULL").all();
+    for (const a of agents) {
+      synced += upsertEdge(d, a.id, "agent", a.reports_to, "agent", "reports_to");
+    }
+    const files = d.query("SELECT task_id, path FROM task_files WHERE status != 'removed'").all();
+    for (const f of files) {
+      synced += upsertEdge(d, f.task_id, "task", f.path, "file", "references_file");
+    }
+    const taskProjects = d.query("SELECT id, project_id FROM tasks WHERE project_id IS NOT NULL").all();
+    for (const tp of taskProjects) {
+      synced += upsertEdge(d, tp.id, "task", tp.project_id, "project", "in_project");
+    }
+    const taskPlans = d.query("SELECT id, plan_id FROM tasks WHERE plan_id IS NOT NULL").all();
+    for (const tp of taskPlans) {
+      synced += upsertEdge(d, tp.id, "task", tp.plan_id, "plan", "in_plan");
+    }
+    try {
+      const rels = d.query("SELECT source_task_id, target_task_id, relationship_type FROM task_relationships").all();
+      for (const r of rels) {
+        synced += upsertEdge(d, r.source_task_id, "task", r.target_task_id, "task", r.relationship_type);
+      }
+    } catch {}
+  });
+  tx();
+  return { synced };
+}
+function upsertEdge(d, sourceId, sourceType, targetId, targetType, relationType, weight = 1) {
+  try {
+    d.run(`INSERT OR IGNORE INTO kg_edges (id, source_id, source_type, target_id, target_type, relation_type, weight, metadata, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, '{}', ?)`, [uuid(), sourceId, sourceType, targetId, targetType, relationType, weight, now()]);
+    return 1;
+  } catch {
+    return 0;
+  }
+}
+function getRelated(entityId, opts, db) {
+  const d = db || getDatabase();
+  const direction = opts?.direction || "both";
+  const conditions = [];
+  const params = [];
+  if (direction === "outgoing" || direction === "both") {
+    conditions.push("source_id = ?");
+    params.push(entityId);
+  }
+  if (direction === "incoming" || direction === "both") {
+    conditions.push("target_id = ?");
+    params.push(entityId);
+  }
+  let sql = `SELECT * FROM kg_edges WHERE (${conditions.join(" OR ")})`;
+  if (opts?.relation_type) {
+    sql += " AND relation_type = ?";
+    params.push(opts.relation_type);
+  }
+  if (opts?.entity_type) {
+    sql += " AND (source_type = ? OR target_type = ?)";
+    params.push(opts.entity_type, opts.entity_type);
+  }
+  sql += " ORDER BY weight DESC, created_at DESC";
+  if (opts?.limit) {
+    sql += " LIMIT ?";
+    params.push(opts.limit);
+  }
+  return d.query(sql).all(...params).map(rowToEdge);
+}
+function findPath(sourceId, targetId, opts, db) {
+  const d = db || getDatabase();
+  const maxDepth = opts?.max_depth || 5;
+  const visited = new Set;
+  const queue = [{ id: sourceId, path: [] }];
+  const results = [];
+  visited.add(sourceId);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current.path.length >= maxDepth)
+      continue;
+    let sql = "SELECT * FROM kg_edges WHERE source_id = ?";
+    const params = [current.id];
+    if (opts?.relation_types && opts.relation_types.length > 0) {
+      const placeholders = opts.relation_types.map(() => "?").join(",");
+      sql += ` AND relation_type IN (${placeholders})`;
+      params.push(...opts.relation_types);
+    }
+    const edges = d.query(sql).all(...params).map(rowToEdge);
+    for (const edge of edges) {
+      const nextId = edge.target_id;
+      const newPath = [...current.path, edge];
+      if (nextId === targetId) {
+        results.push(newPath);
+        if (results.length >= 3)
+          return results;
+        continue;
+      }
+      if (!visited.has(nextId)) {
+        visited.add(nextId);
+        queue.push({ id: nextId, path: newPath });
+      }
+    }
+  }
+  return results;
+}
+function getImpactAnalysis(entityId, opts, db) {
+  const d = db || getDatabase();
+  const maxDepth = opts?.max_depth || 3;
+  const results = [];
+  const visited = new Set;
+  visited.add(entityId);
+  const queue = [{ id: entityId, depth: 0 }];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current.depth >= maxDepth)
+      continue;
+    let sql = "SELECT * FROM kg_edges WHERE source_id = ?";
+    const params = [current.id];
+    if (opts?.relation_types && opts.relation_types.length > 0) {
+      const placeholders = opts.relation_types.map(() => "?").join(",");
+      sql += ` AND relation_type IN (${placeholders})`;
+      params.push(...opts.relation_types);
+    }
+    const edges = d.query(sql).all(...params).map(rowToEdge);
+    for (const edge of edges) {
+      if (!visited.has(edge.target_id)) {
+        visited.add(edge.target_id);
+        results.push({
+          entity_id: edge.target_id,
+          entity_type: edge.target_type,
+          depth: current.depth + 1,
+          relation: edge.relation_type
+        });
+        queue.push({ id: edge.target_id, depth: current.depth + 1 });
+      }
+    }
+  }
+  return results;
+}
+function getCriticalPath(opts, db) {
+  const d = db || getDatabase();
+  let sql = `SELECT source_id, target_id FROM kg_edges WHERE relation_type = 'depends_on'`;
+  const params = [];
+  if (opts?.project_id) {
+    sql += ` AND source_id IN (SELECT id FROM tasks WHERE project_id = ?)`;
+    params.push(opts.project_id);
+  }
+  const edges = d.query(sql).all(...params);
+  const blocks = new Map;
+  for (const e of edges) {
+    if (!blocks.has(e.target_id))
+      blocks.set(e.target_id, new Set);
+    blocks.get(e.target_id).add(e.source_id);
+  }
+  const results = [];
+  for (const [taskId] of blocks) {
+    const visited = new Set;
+    const q = [taskId];
+    let maxDepth = 0;
+    let depth = 0;
+    let levelSize = q.length;
+    while (q.length > 0) {
+      const node = q.shift();
+      levelSize--;
+      const downstream = blocks.get(node);
+      if (downstream) {
+        for (const d2 of downstream) {
+          if (!visited.has(d2)) {
+            visited.add(d2);
+            q.push(d2);
+          }
+        }
+      }
+      if (levelSize === 0) {
+        depth++;
+        maxDepth = Math.max(maxDepth, depth);
+        levelSize = q.length;
+      }
+    }
+    if (visited.size > 0) {
+      results.push({ task_id: taskId, blocking_count: visited.size, depth: maxDepth });
+    }
+  }
+  results.sort((a, b) => b.blocking_count - a.blocking_count);
+  return results.slice(0, opts?.limit || 20);
+}
+function addKgEdge(sourceId, sourceType, targetId, targetType, relationType, weight = 1, metadata, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  d.run(`INSERT OR IGNORE INTO kg_edges (id, source_id, source_type, target_id, target_type, relation_type, weight, metadata, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, [id, sourceId, sourceType, targetId, targetType, relationType, weight, JSON.stringify(metadata || {}), timestamp]);
+  return { id, source_id: sourceId, source_type: sourceType, target_id: targetId, target_type: targetType, relation_type: relationType, weight, metadata: metadata || {}, created_at: timestamp };
+}
+function removeKgEdges(sourceId, targetId, relationType, db) {
+  const d = db || getDatabase();
+  if (relationType) {
+    return d.run("DELETE FROM kg_edges WHERE source_id = ? AND target_id = ? AND relation_type = ?", [sourceId, targetId, relationType]).changes;
+  }
+  return d.run("DELETE FROM kg_edges WHERE source_id = ? AND target_id = ?", [sourceId, targetId]).changes;
+}
+var init_kg = __esm(() => {
+  init_database();
+});
+
+// src/db/project-agent-roles.ts
+var exports_project_agent_roles = {};
+__export(exports_project_agent_roles, {
+  setProjectAgentRole: () => setProjectAgentRole,
+  removeProjectAgentRole: () => removeProjectAgentRole,
+  listProjectAgentRoles: () => listProjectAgentRoles,
+  getProjectOrgChart: () => getProjectOrgChart,
+  getAgentProjectRoles: () => getAgentProjectRoles
+});
+function rowToRole(row) {
+  return { ...row, is_lead: row.is_lead === 1 };
+}
+function setProjectAgentRole(projectId, agentId, role, isLead = false, db) {
+  const d = db || getDatabase();
+  const existing = d.query("SELECT * FROM project_agent_roles WHERE project_id = ? AND agent_id = ? AND role = ?").get(projectId, agentId, role);
+  if (existing) {
+    d.run("UPDATE project_agent_roles SET is_lead = ? WHERE id = ?", [isLead ? 1 : 0, existing.id]);
+    return rowToRole(d.query("SELECT * FROM project_agent_roles WHERE id = ?").get(existing.id));
+  }
+  const id = uuid();
+  d.run("INSERT INTO project_agent_roles (id, project_id, agent_id, role, is_lead, created_at) VALUES (?, ?, ?, ?, ?, ?)", [id, projectId, agentId, role, isLead ? 1 : 0, now()]);
+  return rowToRole(d.query("SELECT * FROM project_agent_roles WHERE id = ?").get(id));
+}
+function removeProjectAgentRole(projectId, agentId, role, db) {
+  const d = db || getDatabase();
+  if (role) {
+    return d.run("DELETE FROM project_agent_roles WHERE project_id = ? AND agent_id = ? AND role = ?", [projectId, agentId, role]).changes;
+  }
+  return d.run("DELETE FROM project_agent_roles WHERE project_id = ? AND agent_id = ?", [projectId, agentId]).changes;
+}
+function listProjectAgentRoles(projectId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM project_agent_roles WHERE project_id = ? ORDER BY role, created_at").all(projectId).map(rowToRole);
+}
+function getAgentProjectRoles(agentId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM project_agent_roles WHERE agent_id = ? ORDER BY project_id, role").all(agentId).map(rowToRole);
+}
+function getProjectOrgChart(projectId, opts, db) {
+  const d = db || getDatabase();
+  const globalTree = getOrgChart(d);
+  const projectRoles = listProjectAgentRoles(projectId, d);
+  const rolesByAgent = new Map;
+  for (const pr of projectRoles) {
+    if (!rolesByAgent.has(pr.agent_id))
+      rolesByAgent.set(pr.agent_id, { roles: [], isLead: false });
+    const entry = rolesByAgent.get(pr.agent_id);
+    entry.roles.push(pr.role);
+    if (pr.is_lead)
+      entry.isLead = true;
+  }
+  function augmentTree(nodes) {
+    return nodes.map((n) => {
+      const override = rolesByAgent.get(n.agent.id);
+      return {
+        ...n,
+        reports: augmentTree(n.reports),
+        project_roles: override?.roles ?? [],
+        is_project_lead: override?.isLead ?? false
+      };
+    }).filter((n) => {
+      if (!opts?.filter_to_project)
+        return true;
+      const hasRole = n.project_roles.length > 0;
+      const hasDescendant = n.reports.length > 0;
+      return hasRole || hasDescendant;
+    });
+  }
+  return augmentTree(globalTree);
+}
+var init_project_agent_roles = __esm(() => {
+  init_database();
+  init_agents();
+});
+
+// src/db/patrol.ts
+var exports_patrol = {};
+__export(exports_patrol, {
+  patrolTasks: () => patrolTasks,
+  getReviewQueue: () => getReviewQueue
+});
+function rowToTask3(row) {
+  return {
+    ...row,
+    status: row.status,
+    priority: row.priority,
+    tags: JSON.parse(row.tags || "[]"),
+    metadata: JSON.parse(row.metadata || "{}"),
+    requires_approval: Boolean(row.requires_approval)
+  };
+}
+function patrolTasks(opts, db) {
+  const d = db || getDatabase();
+  const stuckMinutes = opts?.stuck_minutes || 60;
+  const confidenceThreshold = opts?.confidence_threshold || 0.5;
+  const issues = [];
+  let projectFilter = "";
+  const projectParams = [];
+  if (opts?.project_id) {
+    projectFilter = " AND project_id = ?";
+    projectParams.push(opts.project_id);
+  }
+  const stuckCutoff = new Date(Date.now() - stuckMinutes * 60 * 1000).toISOString();
+  const stuckRows = d.query(`SELECT * FROM tasks WHERE status = 'in_progress' AND updated_at < ?${projectFilter} ORDER BY updated_at ASC`).all(stuckCutoff, ...projectParams);
+  for (const row of stuckRows) {
+    const task = rowToTask3(row);
+    const minutesStuck = Math.round((Date.now() - new Date(task.updated_at).getTime()) / 60000);
+    issues.push({
+      type: "stuck",
+      task_id: task.id,
+      task_title: task.title,
+      severity: minutesStuck > 480 ? "critical" : minutesStuck > 120 ? "high" : "medium",
+      detail: `In progress for ${minutesStuck} minutes without update`
+    });
+  }
+  const lowConfRows = d.query(`SELECT * FROM tasks WHERE status = 'completed' AND confidence IS NOT NULL AND confidence < ?${projectFilter} ORDER BY confidence ASC`).all(confidenceThreshold, ...projectParams);
+  for (const row of lowConfRows) {
+    const task = rowToTask3(row);
+    issues.push({
+      type: "low_confidence",
+      task_id: task.id,
+      task_title: task.title,
+      severity: (task.confidence ?? 0) < 0.3 ? "high" : "medium",
+      detail: `Completed with confidence ${task.confidence} (threshold: ${confidenceThreshold})`
+    });
+  }
+  const orphanedRows = d.query(`SELECT * FROM tasks WHERE status = 'pending' AND project_id IS NULL AND agent_id IS NULL AND assigned_to IS NULL ORDER BY created_at ASC`).all();
+  for (const row of orphanedRows) {
+    const task = rowToTask3(row);
+    issues.push({
+      type: "orphaned",
+      task_id: task.id,
+      task_title: task.title,
+      severity: "low",
+      detail: "Pending task with no project, no agent, and no assignee"
+    });
+  }
+  const needsReviewRows = d.query(`SELECT * FROM tasks WHERE status = 'completed' AND requires_approval = 1 AND approved_by IS NULL${projectFilter} ORDER BY completed_at DESC`).all(...projectParams);
+  for (const row of needsReviewRows) {
+    const task = rowToTask3(row);
+    issues.push({
+      type: "needs_review",
+      task_id: task.id,
+      task_title: task.title,
+      severity: "medium",
+      detail: "Completed but requires approval \u2014 not yet reviewed"
+    });
+  }
+  const pendingWithDeps = d.query(`SELECT t.* FROM tasks t
+     WHERE t.status = 'pending'${projectFilter}
+       AND t.id IN (SELECT task_id FROM task_dependencies)`).all(...projectParams);
+  for (const row of pendingWithDeps) {
+    const deps = d.query(`SELECT d.depends_on, t.status FROM task_dependencies d
+       JOIN tasks t ON t.id = d.depends_on
+       WHERE d.task_id = ?`).all(row.id);
+    if (deps.length > 0 && deps.every((dep) => dep.status === "failed" || dep.status === "cancelled")) {
+      const task = rowToTask3(row);
+      issues.push({
+        type: "zombie_blocked",
+        task_id: task.id,
+        task_title: task.title,
+        severity: "high",
+        detail: `Blocked by ${deps.length} task(s) that are all failed/cancelled \u2014 will never unblock`
+      });
+    }
+  }
+  const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+  issues.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
+  return {
+    issues,
+    total_issues: issues.length,
+    scanned_at: new Date().toISOString()
+  };
+}
+function getReviewQueue(opts, db) {
+  const d = db || getDatabase();
+  let sql = `SELECT * FROM tasks WHERE status = 'completed' AND (
+    (requires_approval = 1 AND approved_by IS NULL)
+    OR (confidence IS NOT NULL AND confidence < 0.5)
+  )`;
+  const params = [];
+  if (opts?.project_id) {
+    sql += " AND project_id = ?";
+    params.push(opts.project_id);
+  }
+  sql += " ORDER BY CASE WHEN requires_approval = 1 AND approved_by IS NULL THEN 0 ELSE 1 END, confidence ASC";
+  if (opts?.limit) {
+    sql += " LIMIT ?";
+    params.push(opts.limit);
+  }
+  return d.query(sql).all(...params).map(rowToTask3);
+}
+var init_patrol = __esm(() => {
+  init_database();
+});
+
+// src/db/agent-metrics.ts
+var exports_agent_metrics = {};
+__export(exports_agent_metrics, {
+  scoreTask: () => scoreTask,
+  getLeaderboard: () => getLeaderboard,
+  getAgentMetrics: () => getAgentMetrics
+});
+function getAgentMetrics(agentId, opts, db) {
+  const d = db || getDatabase();
+  const agent = d.query("SELECT id, name FROM agents WHERE id = ? OR LOWER(name) = LOWER(?)").get(agentId, agentId);
+  if (!agent)
+    return null;
+  let projectFilter = "";
+  const params = [agent.id, agent.id];
+  if (opts?.project_id) {
+    projectFilter = " AND project_id = ?";
+    params.push(opts.project_id);
+  }
+  const completed = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed'${projectFilter}`).get(...params).count;
+  const failed = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'failed'${projectFilter}`).get(...params).count;
+  const inProgress = d.query(`SELECT COUNT(*) as count FROM tasks WHERE (agent_id = ? OR assigned_to = ?) AND status = 'in_progress'${projectFilter}`).get(...params).count;
+  const total = completed + failed;
+  const completionRate = total > 0 ? completed / total : 0;
+  const avgTime = d.query(`SELECT AVG(
+       (julianday(completed_at) - julianday(created_at)) * 24 * 60
+     ) as avg_minutes
+     FROM tasks
+     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed' AND completed_at IS NOT NULL${projectFilter}`).get(...params);
+  const avgConf = d.query(`SELECT AVG(confidence) as avg_confidence
+     FROM tasks
+     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed' AND confidence IS NOT NULL${projectFilter}`).get(...params);
+  const reviewTasks = d.query(`SELECT metadata FROM tasks
+     WHERE (agent_id = ? OR assigned_to = ?) AND status = 'completed'${projectFilter}
+       AND metadata LIKE '%_review_score%'`).all(...params);
+  let reviewScoreAvg = null;
+  if (reviewTasks.length > 0) {
+    let total2 = 0;
+    let count = 0;
+    for (const row of reviewTasks) {
+      try {
+        const meta = JSON.parse(row.metadata);
+        if (typeof meta._review_score === "number") {
+          total2 += meta._review_score;
+          count++;
+        }
+      } catch {}
+    }
+    if (count > 0)
+      reviewScoreAvg = total2 / count;
+  }
+  const speedScore = avgTime?.avg_minutes != null ? Math.max(0, 1 - avgTime.avg_minutes / (60 * 24)) : 0.5;
+  const confidenceScore = avgConf?.avg_confidence ?? 0.5;
+  const volumeScore = Math.min(1, completed / 50);
+  const compositeScore = completionRate * 0.3 + speedScore * 0.2 + confidenceScore * 0.3 + volumeScore * 0.2;
+  return {
+    agent_id: agent.id,
+    agent_name: agent.name,
+    tasks_completed: completed,
+    tasks_failed: failed,
+    tasks_in_progress: inProgress,
+    completion_rate: Math.round(completionRate * 1000) / 1000,
+    avg_completion_minutes: avgTime?.avg_minutes != null ? Math.round(avgTime.avg_minutes * 10) / 10 : null,
+    avg_confidence: avgConf?.avg_confidence != null ? Math.round(avgConf.avg_confidence * 1000) / 1000 : null,
+    review_score_avg: reviewScoreAvg != null ? Math.round(reviewScoreAvg * 1000) / 1000 : null,
+    composite_score: Math.round(compositeScore * 1000) / 1000
+  };
+}
+function getLeaderboard(opts, db) {
+  const d = db || getDatabase();
+  const agents = d.query("SELECT id FROM agents ORDER BY name").all();
+  const entries = [];
+  for (const agent of agents) {
+    const metrics = getAgentMetrics(agent.id, { project_id: opts?.project_id }, d);
+    if (metrics && (metrics.tasks_completed > 0 || metrics.tasks_failed > 0 || metrics.tasks_in_progress > 0)) {
+      entries.push(metrics);
+    }
+  }
+  entries.sort((a, b) => b.composite_score - a.composite_score);
+  const limit = opts?.limit || 20;
+  return entries.slice(0, limit).map((entry, idx) => ({
+    ...entry,
+    rank: idx + 1
+  }));
+}
+function scoreTask(taskId, score, reviewerId, db) {
+  const d = db || getDatabase();
+  if (score < 0 || score > 1)
+    throw new Error("Score must be between 0 and 1");
+  const task = d.query("SELECT metadata FROM tasks WHERE id = ?").get(taskId);
+  if (!task)
+    throw new Error(`Task not found: ${taskId}`);
+  const metadata = JSON.parse(task.metadata || "{}");
+  metadata._review_score = score;
+  if (reviewerId)
+    metadata._reviewed_by = reviewerId;
+  metadata._reviewed_at = now();
+  d.run("UPDATE tasks SET metadata = ?, updated_at = ? WHERE id = ?", [JSON.stringify(metadata), now(), taskId]);
+}
+var init_agent_metrics = __esm(() => {
+  init_database();
+});
+
 // src/lib/extract.ts
 var exports_extract = {};
 __export(exports_extract, {
@@ -20675,9 +22085,8 @@ init_agents();
 init_database();
 
 // src/lib/logger.ts
-import { LogsClient } from "@hasna/logs";
 var client = null;
-function getLogger() {
+async function getLogger() {
   if (client)
     return client;
   const url = process.env.LOGS_URL;
@@ -20685,14 +22094,15 @@ function getLogger() {
   const apiKey = process.env.LOGS_API_KEY;
   if (!projectId)
     return null;
+  const { LogsClient } = await import("@hasna/logs");
   client = new LogsClient({ url, projectId, apiKey });
   return client;
 }
 async function logError(message, opts) {
-  const logger = getLogger();
-  if (!logger)
-    return;
   try {
+    const logger = await getLogger();
+    if (!logger)
+      return;
     await logger.push({
       level: "error",
       message,
@@ -20707,7 +22117,7 @@ async function logError(message, opts) {
 
 // src/mcp/index.ts
 init_types2();
-import { readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
 import { join as join10, dirname as dirname3 } from "path";
 import { fileURLToPath } from "url";
 
@@ -20950,14 +22360,24 @@ ${lines.join(`
 
 // src/mcp/tools/task-crud.ts
 init_tasks();
+init_types2();
 function registerTaskCrudTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask } = ctx;
+  function versionFor(taskId, version) {
+    const current = getTask(taskId);
+    if (!current)
+      throw new TaskNotFoundError(taskId);
+    if (version !== undefined && current.version !== version) {
+      throw new VersionConflictError(taskId, version, current.version);
+    }
+    return current.version;
+  }
   if (shouldRegisterTool("create_task")) {
     server.tool("create_task", "Create a new task in a project. Pass short_id=null to auto-generate.", {
       title: exports_external.string().describe("Task title"),
       description: exports_external.string().optional().describe("Task description (markdown)"),
-      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("Initial status (default: pending)"),
-      priority: exports_external.enum(["low", "medium", "high", "urgent"]).optional().describe("Priority (default: medium)"),
+      status: exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional().describe("Initial status (default: pending)"),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).optional().describe("Priority (default: medium)"),
       project_id: exports_external.string().optional().describe("Project ID"),
       task_list_id: exports_external.string().optional().describe("Task list ID"),
       assigned_to: exports_external.string().optional().describe("Agent ID or name to assign to"),
@@ -20987,9 +22407,9 @@ function registerTaskCrudTools(server, ctx) {
         if (confidence !== undefined)
           resolved.confidence = confidence;
         if (retry_count !== undefined)
-          resolved.retry_count = retry_count;
+          resolved.max_retries = retry_count;
         if (deadline)
-          resolved.deadline = deadline;
+          resolved.due_at = deadline;
         const task = createTask(resolved);
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
@@ -20999,8 +22419,8 @@ function registerTaskCrudTools(server, ctx) {
   }
   if (shouldRegisterTool("list_tasks")) {
     server.tool("list_tasks", "List tasks with optional filters. Pass empty arrays for multi-value filters (e.g. status=[] shows all).", {
-      status: exports_external.union([exports_external.enum(["pending", "in_progress", "completed", "cancelled"]), exports_external.array(exports_external.enum(["pending", "in_progress", "completed", "cancelled"]))]).optional().describe("Filter by status"),
-      priority: exports_external.union([exports_external.enum(["low", "medium", "high", "urgent"]), exports_external.array(exports_external.enum(["low", "medium", "high", "urgent"]))]).optional().describe("Filter by priority"),
+      status: exports_external.union([exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]), exports_external.array(exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]))]).optional().describe("Filter by status"),
+      priority: exports_external.union([exports_external.enum(["low", "medium", "high", "critical"]), exports_external.array(exports_external.enum(["low", "medium", "high", "critical"]))]).optional().describe("Filter by priority"),
       project_id: exports_external.string().optional().describe("Filter by project"),
       task_list_id: exports_external.string().optional().describe("Filter by task list"),
       assigned_to: exports_external.string().optional().describe("Filter by assignee (agent ID or name, empty string = unassigned)"),
@@ -21035,9 +22455,9 @@ function registerTaskCrudTools(server, ctx) {
     }, async ({ task_id }) => {
       try {
         const resolvedId = resolveId(task_id);
-        const task = getTask2(resolvedId);
+        const task = getTask(resolvedId);
         if (!task)
-          throw new NotFoundError(`Task not found: ${task_id}`);
+          throw new TaskNotFoundError(task_id);
         const focus = ctx.getAgentFocus(task.assigned_to || "");
         const lines = [
           `ID:       ${task.id}`,
@@ -21051,7 +22471,7 @@ function registerTaskCrudTools(server, ctx) {
           task.estimated_minutes != null ? `Estimate: ${task.estimated_minutes} min` : null,
           task.actual_minutes != null ? `Actual:   ${task.actual_minutes} min` : null,
           task.confidence != null ? `Confidence: ${task.confidence}` : null,
-          task.deadline ? `Deadline: ${task.deadline}` : null,
+          task.due_at ? `Due: ${task.due_at}` : null,
           task.completed_at ? `Completed: ${task.completed_at}` : null,
           focus ? `Focus:    agent=${focus.agent_id} project=${focus.project_id || "(global)"}` : null,
           task.created_at ? `Created:  ${task.created_at}` : null,
@@ -21073,8 +22493,8 @@ ${task.description}` : null
       task_id: exports_external.string().describe("Task ID"),
       title: exports_external.string().optional(),
       description: exports_external.string().optional(),
-      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
-      priority: exports_external.enum(["low", "medium", "high", "urgent"]).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().nullable().optional().describe("Agent ID or name, null to unassign"),
       project_id: exports_external.string().nullable().optional(),
       task_list_id: exports_external.string().nullable().optional(),
@@ -21103,9 +22523,15 @@ ${task.description}` : null
           resolved.task_list_id = resolveId(resolved.task_list_id, "task_lists");
         if (resolved.depends_on && Array.isArray(resolved.depends_on))
           resolved.depends_on = resolved.depends_on.map(resolveId);
-        if (resolved.estimate !== undefined)
+        if (resolved.estimate !== undefined) {
           resolved.estimated_minutes = resolved.estimate;
-        const task = updateTask(resolvedId, resolved, version);
+          delete resolved.estimate;
+        }
+        if (resolved.deadline !== undefined) {
+          resolved.due_at = resolved.deadline;
+          delete resolved.deadline;
+        }
+        const task = updateTask(resolvedId, { ...resolved, version: versionFor(resolvedId, version) });
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21202,48 +22628,23 @@ function deletePlan(id, db) {
   return result.changes > 0;
 }
 
-// src/db/comments.ts
-init_types2();
-init_database();
-init_tasks();
-function addComment(input, db) {
-  const d = db || getDatabase();
-  if (!getTask2(input.task_id, d)) {
-    throw new TaskNotFoundError(input.task_id);
-  }
-  const id = uuid();
-  const timestamp = now();
-  d.run(`INSERT INTO task_comments (id, task_id, agent_id, session_id, content, type, progress_pct, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
-    id,
-    input.task_id,
-    input.agent_id || null,
-    input.session_id || null,
-    input.content,
-    input.type || "comment",
-    input.progress_pct ?? null,
-    timestamp
-  ]);
-  return getComment(id, d);
-}
-function getComment(id, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM task_comments WHERE id = ?").get(id);
-}
-function listComments(taskId, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at").all(taskId);
-}
-function deleteComment(id, db) {
-  const d = db || getDatabase();
-  const result = d.run("DELETE FROM task_comments WHERE id = ?", [id]);
-  return result.changes > 0;
-}
-
 // src/mcp/tools/task-project-tools.ts
+init_comments();
 init_types2();
 function registerTaskProjectTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask } = ctx;
+  function versionFor(taskId, version) {
+    const current = getTask(taskId);
+    if (!current)
+      throw new TaskNotFoundError(taskId);
+    if (version !== undefined && current.version !== version) {
+      throw new VersionConflictError(taskId, version, current.version);
+    }
+    return current.version;
+  }
+  function updateWithOptionalVersion(taskId, updates, version) {
+    return updateTask(taskId, { ...updates, version: versionFor(taskId, version) });
+  }
   if (shouldRegisterTool("start_task")) {
     server.tool("start_task", "Mark a task as in_progress. Uses optimistic locking via version if provided.", {
       task_id: exports_external.string().describe("Task ID"),
@@ -21251,7 +22652,12 @@ function registerTaskProjectTools(server, ctx) {
     }, async ({ task_id, version }) => {
       try {
         const resolvedId = resolveId(task_id);
-        const task = updateTask(resolvedId, { status: "in_progress" }, version);
+        if (version !== undefined)
+          versionFor(resolvedId, version);
+        const current = getTask(resolvedId);
+        if (!current)
+          throw new TaskNotFoundError(resolvedId);
+        const task = startTask(resolvedId, current.assigned_to || current.agent_id || "mcp");
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21267,7 +22673,12 @@ function registerTaskProjectTools(server, ctx) {
     }, async ({ task_id, confidence, completed_at, version }) => {
       try {
         const resolvedId = resolveId(task_id);
-        const task = updateTask(resolvedId, { status: "completed", confidence, completed_at }, version);
+        if (version !== undefined)
+          versionFor(resolvedId, version);
+        const current = getTask(resolvedId);
+        if (!current)
+          throw new TaskNotFoundError(resolvedId);
+        const task = completeTask(resolvedId, current.assigned_to || current.agent_id || undefined, undefined, { confidence, completed_at });
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21281,7 +22692,7 @@ function registerTaskProjectTools(server, ctx) {
     }, async ({ task_id, version }) => {
       try {
         const resolvedId = resolveId(task_id);
-        const task = updateTask(resolvedId, { status: "cancelled" }, version);
+        const task = version === undefined ? setTaskStatus(resolvedId, "cancelled") : updateWithOptionalVersion(resolvedId, { status: "cancelled" }, version);
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21297,7 +22708,7 @@ function registerTaskProjectTools(server, ctx) {
       try {
         const resolvedId = resolveId(task_id);
         const resolvedAssignee = resolveId(new_assignee, "agents");
-        const task = updateTask(resolvedId, { assigned_to: resolvedAssignee }, version);
+        const task = updateWithOptionalVersion(resolvedId, { assigned_to: resolvedAssignee }, version);
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21312,7 +22723,7 @@ function registerTaskProjectTools(server, ctx) {
     }, async ({ task_id, deadline, version }) => {
       try {
         const resolvedId = resolveId(task_id);
-        const task = updateTask(resolvedId, { deadline }, version);
+        const task = updateWithOptionalVersion(resolvedId, { due_at: deadline }, version);
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21322,12 +22733,12 @@ function registerTaskProjectTools(server, ctx) {
   if (shouldRegisterTool("prioritize_task")) {
     server.tool("prioritize_task", "Set a task's priority.", {
       task_id: exports_external.string().describe("Task ID"),
-      priority: exports_external.enum(["low", "medium", "high", "urgent"]).describe("New priority"),
+      priority: exports_external.enum(["low", "medium", "high", "critical"]).describe("New priority"),
       version: exports_external.number().optional().describe("Expected version for optimistic locking")
     }, async ({ task_id, priority, version }) => {
       try {
         const resolvedId = resolveId(task_id);
-        const task = updateTask(resolvedId, { priority }, version);
+        const task = version === undefined ? setTaskPriority(resolvedId, priority) : updateWithOptionalVersion(resolvedId, { priority }, version);
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21383,18 +22794,18 @@ function registerTaskProjectTools(server, ctx) {
   if (shouldRegisterTool("bulk_update_tasks")) {
     server.tool("bulk_update_tasks", "Update multiple tasks at once. All tasks must pass the dependency check.", {
       task_ids: exports_external.array(exports_external.string()).describe("Array of task IDs to update"),
-      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
-      priority: exports_external.enum(["low", "medium", "high", "urgent"]).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().nullable().optional().describe("Agent ID or name, null to unassign")
     }, async ({ task_ids, status, priority, assigned_to }) => {
       try {
-        const { bulkUpdateTasks: bulkUpdateTasks2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { bulkUpdateTasks: bulkUpdateTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolved = task_ids.map(resolveId);
         let resolvedAssignee = assigned_to;
         if (resolvedAssignee && typeof resolvedAssignee === "string")
           resolvedAssignee = resolveId(resolvedAssignee, "agents");
         const result = bulkUpdateTasks2(resolved, { status, priority, assigned_to: resolvedAssignee });
-        return { content: [{ type: "text", text: `${result.updated} task(s) updated, ${result.skipped} skipped (dependency check).` }] };
+        return { content: [{ type: "text", text: `${result.updated} task(s) updated, ${result.failed.length} failed.` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
@@ -21405,8 +22816,8 @@ function registerTaskProjectTools(server, ctx) {
       tasks: exports_external.array(exports_external.object({
         title: exports_external.string(),
         description: exports_external.string().optional(),
-        status: exports_external.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
-        priority: exports_external.enum(["low", "medium", "high", "urgent"]).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(),
         task_list_id: exports_external.string().optional(),
         assigned_to: exports_external.string().optional(),
@@ -21417,7 +22828,7 @@ function registerTaskProjectTools(server, ctx) {
       })).describe("Array of task objects")
     }, async ({ tasks }) => {
       try {
-        const { bulkCreateTasks: bulkCreateTasks2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { bulkCreateTasks: bulkCreateTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolved = tasks.map((t) => {
           const r = { ...t };
           if (r.project_id)
@@ -21431,7 +22842,7 @@ function registerTaskProjectTools(server, ctx) {
           return r;
         });
         const result = bulkCreateTasks2(resolved);
-        return { content: [{ type: "text", text: `${result.created} task(s) created, ${result.skipped} skipped (duplicate short_id).` }] };
+        return { content: [{ type: "text", text: `${result.created.length} task(s) created.` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
@@ -21443,9 +22854,9 @@ function registerTaskProjectTools(server, ctx) {
       force: exports_external.boolean().optional().describe("Skip child check for all tasks (dangerous)")
     }, async ({ task_ids, force }) => {
       try {
-        const { bulkDeleteTasks } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { bulkDeleteTasks: bulkDeleteTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolved = task_ids.map(resolveId);
-        const result = bulkDeleteTasks(resolved, force);
+        const result = bulkDeleteTasks2(resolved, force);
         return { content: [{ type: "text", text: `${result.deleted} task(s) deleted, ${result.skipped} skipped (has children).` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21494,7 +22905,7 @@ function registerTaskProjectTools(server, ctx) {
         const project = getProject(resolvedId);
         if (!project)
           throw new TaskNotFoundError(`Project not found: ${project_id}`);
-        const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const tasks = listTasks3({ project_id: resolvedId, limit: 100 }, undefined);
         const lines = [
           `ID:          ${project.id}`,
@@ -21595,7 +23006,7 @@ function registerTaskProjectTools(server, ctx) {
           throw new TaskNotFoundError(`Task list not found: ${task_list_id}`);
         let tasks = [];
         if (include_tasks) {
-          const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+          const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
           tasks = listTasks3({ task_list_id: resolvedId, limit: 200 }, undefined);
         }
         const lines = [
@@ -21695,7 +23106,7 @@ Tasks:` : null,
           throw new TaskNotFoundError(`Plan not found: ${plan_id}`);
         let tasks = [];
         if (include_tasks) {
-          const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+          const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
           tasks = listTasks3({ plan_id: resolvedId, limit: 200 }, undefined);
         }
         const lines = [
@@ -21784,7 +23195,7 @@ Tasks:` : null,
         const tag = getTag(tag_id);
         if (!tag)
           throw new TaskNotFoundError(`Tag not found: ${tag_id}`);
-        const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const tasks = listTasks3({ tags: [tag.name], limit: 100 }, undefined);
         const lines = [
           `Tag: ${tag.name}${tag.color ? ` (${tag.color})` : ""}`,
@@ -21863,7 +23274,7 @@ Tasks:` : null,
         const label = getLabel(label_id);
         if (!label)
           throw new TaskNotFoundError(`Label not found: ${label_id}`);
-        const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const tasks = listTasks3({ tags: [label.name], limit: 100 }, undefined);
         const lines = [
           `Label: ${label.name}${label.color ? ` (${label.color})` : ""}`,
@@ -21914,7 +23325,7 @@ Tasks:` : null,
       try {
         const resolvedId = resolveId(task_id);
         const resolvedAuthor = author ? resolveId(author, "agents") : undefined;
-        const comment = addComment({ task_id: resolvedId, body, author: resolvedAuthor });
+        const comment = addComment({ task_id: resolvedId, content: body, agent_id: resolvedAuthor });
         return { content: [{ type: "text", text: `Comment added to ${task_id.slice(0, 8)}: ${body.slice(0, 50)}${body.length > 50 ? "..." : ""}` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21930,8 +23341,8 @@ Tasks:` : null,
         const comments = listComments(resolvedId);
         if (comments.length === 0)
           return { content: [{ type: "text", text: "No comments." }] };
-        const lines = comments.map((c) => `[${c.author || "unknown"}] ${c.created_at?.slice(0, 16)}:
-  ${c.body}`);
+        const lines = comments.map((c) => `[${c.agent_id || "unknown"}] ${c.created_at?.slice(0, 16)}:
+  ${c.content}`);
         return { content: [{ type: "text", text: lines.join(`
 
 `) }] };
@@ -21946,7 +23357,7 @@ Tasks:` : null,
       body: exports_external.string().describe("New comment body")
     }, async ({ comment_id, body }) => {
       try {
-        const comment = updateComment(comment_id, { body });
+        const comment = updateComment(comment_id, { content: body });
         return { content: [{ type: "text", text: `Comment ${comment_id.slice(0, 8)} updated.` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -21969,17 +23380,17 @@ Tasks:` : null,
     server.tool("search_tasks", "Full-text search across task titles and descriptions.", {
       query: exports_external.string().describe("Search query"),
       project_id: exports_external.string().optional().describe("Filter by project"),
-      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
+      status: exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional(),
       limit: exports_external.number().optional().describe("Max results (default: 20)")
     }, async ({ query, project_id, status, limit }) => {
       try {
-        const { searchTasks } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { searchTasks: searchTasks2 } = (init_search(), __toCommonJS(exports_search));
         const resolved = { query, limit };
         if (project_id)
           resolved.project_id = resolveId(project_id, "projects");
         if (status)
           resolved.status = status;
-        const results = searchTasks(resolved);
+        const results = searchTasks2(resolved);
         if (results.length === 0)
           return { content: [{ type: "text", text: `No results for: ${query}` }] };
         const lines = results.map((t) => `${t.short_id || t.id.slice(0, 8)} [${t.status}] ${t.title}`);
@@ -21991,34 +23402,22 @@ ${lines.join(`
       }
     });
   }
-  if (shouldRegisterTool("sync")) {
-    server.tool("sync", "Sync tasks from a GitHub PR or external source into the project.", {
-      source: exports_external.enum(["github_pr", "linear", "asana"]).describe("Source type"),
-      source_id: exports_external.string().describe("PR number, Linear issue ID, or Asana task ID"),
-      project_id: exports_external.string().optional().describe("Project ID to import into"),
-      options: exports_external.record(exports_external.unknown()).optional().describe("Source-specific options")
-    }, async ({ source, source_id, project_id, options }) => {
-      try {
-        const { syncFromGithubPR, syncFromLinear, syncFromAsana } = (()=>{throw new Error("Cannot require module "+"../lib/sync.js");})();
-        let result;
-        if (source === "github_pr") {
-          result = await syncFromGithubPR({ prNumber: parseInt(source_id), project_id: project_id ? resolveId(project_id, "projects") : undefined, ...options });
-        } else if (source === "linear") {
-          result = await syncFromLinear({ issueId: source_id, project_id: project_id ? resolveId(project_id, "projects") : undefined, ...options });
-        } else {
-          result = await syncFromAsana({ taskId: source_id, project_id: project_id ? resolveId(project_id, "projects") : undefined, ...options });
-        }
-        return { content: [{ type: "text", text: `Synced from ${source}: ${result.task?.title || source_id}` }] };
-      } catch (e) {
-        return { content: [{ type: "text", text: formatError(e) }], isError: true };
-      }
-    });
-  }
 }
 
 // src/mcp/tools/task-workflow-tools.ts
+init_types2();
 function registerTaskWorkflowTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask } = ctx;
+  function versionFor(taskId, version) {
+    const { getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+    const current = getTask2(taskId);
+    if (!current)
+      throw new TaskNotFoundError(taskId);
+    if (version !== undefined && current.version !== version) {
+      throw new VersionConflictError(taskId, version, current.version);
+    }
+    return current.version;
+  }
   if (shouldRegisterTool("approve_task")) {
     server.tool("approve_task", "Approve a task that requires_approval. Records who approved it.", {
       task_id: exports_external.string().describe("Task ID"),
@@ -22027,13 +23426,14 @@ function registerTaskWorkflowTools(server, ctx) {
       version: exports_external.number().optional().describe("Expected version for optimistic locking")
     }, async ({ task_id, approved_by, notes, version }) => {
       try {
-        const { updateTask: updateTask2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedId = resolveId(task_id);
         const resolvedApprover = approved_by ? resolveId(approved_by, "agents") : undefined;
         const task = updateTask2(resolvedId, {
           approved_by: resolvedApprover,
-          metadata: notes ? { approval_notes: notes } : {}
-        }, version);
+          metadata: notes ? { approval_notes: notes } : {},
+          version: versionFor(resolvedId, version)
+        });
         return { content: [{ type: "text", text: `Task ${task_id.slice(0, 8)} approved by ${resolvedApprover || "unknown"}` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -22048,15 +23448,11 @@ function registerTaskWorkflowTools(server, ctx) {
       version: exports_external.number().optional().describe("Expected version for optimistic locking")
     }, async ({ task_id, reason, agent_id, version }) => {
       try {
-        const { updateTask: updateTask2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { failTask: failTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedId = resolveId(task_id);
-        const task = updateTask2(resolvedId, {
-          status: "pending",
-          retry_count: (getTask(resolvedId)?.retry_count ?? 0) + 1,
-          back_on_board: false,
-          metadata: reason ? { failure_reason: reason } : {}
-        }, version);
-        return { content: [{ type: "text", text: `Task ${task_id.slice(0, 8)} marked failed. Retry count: ${task.retry_count}` }] };
+        versionFor(resolvedId, version);
+        const result = failTask2(resolvedId, agent_id, reason);
+        return { content: [{ type: "text", text: `Task ${task_id.slice(0, 8)} marked failed. Retry count: ${result.task.retry_count}` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
@@ -22065,12 +23461,12 @@ function registerTaskWorkflowTools(server, ctx) {
   if (shouldRegisterTool("get_my_tasks")) {
     server.tool("get_my_tasks", "Get tasks assigned to the calling agent. Supports focus mode scoping.", {
       agent_id: exports_external.string().optional().describe("Agent ID (defaults to context agent)"),
-      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe("Filter by status"),
+      status: exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional().describe("Filter by status"),
       project_id: exports_external.string().optional().describe("Filter by project (respects focus mode)"),
       limit: exports_external.number().optional().describe("Max results (default: 50)")
     }, async ({ agent_id, status, project_id, limit }) => {
       try {
-        const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const focus = ctx.getAgentFocus(agent_id || "");
         const effectiveAgentId = focus ? focus.agent_id : agent_id || "";
         const effectiveProjectId = focus?.project_id || project_id;
@@ -22090,6 +23486,122 @@ function registerTaskWorkflowTools(server, ctx) {
       }
     });
   }
+  if (shouldRegisterTool("get_next_task")) {
+    server.tool("get_next_task", "Get the best available pending task without claiming it.", {
+      agent_id: exports_external.string().optional().describe("Agent ID or name for assignment affinity"),
+      project_id: exports_external.string().optional().describe("Filter by project"),
+      task_list_id: exports_external.string().optional().describe("Filter by task list"),
+      plan_id: exports_external.string().optional().describe("Filter by plan"),
+      tags: exports_external.array(exports_external.string()).optional().describe("Filter by tags")
+    }, async ({ agent_id, project_id, task_list_id, plan_id, tags }) => {
+      try {
+        const { getNextTask: getNextTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const filters = {};
+        if (project_id)
+          filters.project_id = resolveId(project_id, "projects");
+        if (task_list_id)
+          filters.task_list_id = resolveId(task_list_id, "task_lists");
+        if (plan_id)
+          filters.plan_id = resolveId(plan_id, "plans");
+        if (tags)
+          filters.tags = tags;
+        const task = getNextTask2(agent_id, filters);
+        return { content: [{ type: "text", text: task ? formatTask(task) : "No available task." }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("claim_next_task")) {
+    server.tool("claim_next_task", "Atomically claim and start the best available pending task for an agent.", {
+      agent_id: exports_external.string().describe("Agent ID or name claiming the task"),
+      project_id: exports_external.string().optional().describe("Filter by project"),
+      task_list_id: exports_external.string().optional().describe("Filter by task list"),
+      plan_id: exports_external.string().optional().describe("Filter by plan"),
+      tags: exports_external.array(exports_external.string()).optional().describe("Filter by tags")
+    }, async ({ agent_id, project_id, task_list_id, plan_id, tags }) => {
+      try {
+        const { claimNextTask: claimNextTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const filters = {};
+        if (project_id)
+          filters.project_id = resolveId(project_id, "projects");
+        if (task_list_id)
+          filters.task_list_id = resolveId(task_list_id, "task_lists");
+        if (plan_id)
+          filters.plan_id = resolveId(plan_id, "plans");
+        if (tags)
+          filters.tags = tags;
+        const task = claimNextTask2(agent_id, filters);
+        return { content: [{ type: "text", text: task ? formatTask(task) : "No available task to claim." }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("get_tasks_changed_since")) {
+    server.tool("get_tasks_changed_since", "List tasks changed since an ISO timestamp.", {
+      since: exports_external.string().describe("ISO timestamp"),
+      project_id: exports_external.string().optional().describe("Filter by project"),
+      task_list_id: exports_external.string().optional().describe("Filter by task list"),
+      limit: exports_external.number().optional().describe("Maximum tasks to return")
+    }, async ({ since, project_id, task_list_id, limit }) => {
+      try {
+        const { getTasksChangedSince: getTasksChangedSince2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const filters = {};
+        if (project_id)
+          filters.project_id = resolveId(project_id, "projects");
+        if (task_list_id)
+          filters.task_list_id = resolveId(task_list_id, "task_lists");
+        const tasks = getTasksChangedSince2(since, filters).slice(0, limit || 50);
+        if (tasks.length === 0)
+          return { content: [{ type: "text", text: "No changed tasks." }] };
+        return { content: [{ type: "text", text: tasks.map(formatTask).join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  function registerContextTool(name, description) {
+    if (!shouldRegisterTool(name))
+      return;
+    server.tool(name, description, {
+      agent_id: exports_external.string().optional().describe("Agent ID or name"),
+      project_id: exports_external.string().optional().describe("Filter by project"),
+      task_list_id: exports_external.string().optional().describe("Filter by task list"),
+      explain_blocked: exports_external.boolean().optional().describe("Include blocked task details")
+    }, async ({ agent_id, project_id, task_list_id, explain_blocked }) => {
+      try {
+        const { getStatus: getStatus2, getNextTask: getNextTask2, getOverdueTasks: getOverdueTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { getLatestHandoff: getLatestHandoff2 } = (init_handoffs(), __toCommonJS(exports_handoffs));
+        const filters = {};
+        if (project_id)
+          filters.project_id = resolveId(project_id, "projects");
+        if (task_list_id)
+          filters.task_list_id = resolveId(task_list_id, "task_lists");
+        const status = getStatus2(filters, agent_id, { explain_blocked });
+        const next_task = getNextTask2(agent_id, filters);
+        const overdue = getOverdueTasks2(filters.project_id);
+        const latest_handoff = getLatestHandoff2(agent_id, filters.project_id);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              status,
+              next_task,
+              overdue_count: overdue.length,
+              latest_handoff,
+              as_of: new Date().toISOString()
+            }, null, 2)
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  registerContextTool("get_context", "Get session start context: queue status, next task, overdue count, and latest handoff.");
+  registerContextTool("bootstrap", "Bootstrap an agent session with queue context and the next available task.");
   if (shouldRegisterTool("get_org_chart")) {
     server.tool("get_org_chart", "Get the global org chart (agent hierarchy + titles).", {
       format: exports_external.enum(["text", "json"]).optional().describe("Output format (default: text)")
@@ -22110,7 +23622,7 @@ function registerTaskWorkflowTools(server, ctx) {
           }).join(`
 `);
         };
-        const { getOrgChart: getOrgChart2 } = (()=>{throw new Error("Cannot require module "+"../db/agents.js");})();
+        const { getOrgChart: getOrgChart2 } = (init_agents(), __toCommonJS(exports_agents));
         const tree = getOrgChart2();
         if (format === "json") {
           return { content: [{ type: "text", text: JSON.stringify(tree, null, 2) }] };
@@ -22130,10 +23642,10 @@ function registerTaskWorkflowTools(server, ctx) {
       reports_to: exports_external.string().describe("Manager agent ID or name")
     }, async ({ agent_id, reports_to }) => {
       try {
-        const { setReportsTo } = (()=>{throw new Error("Cannot require module "+"../db/agents.js");})();
+        const { updateAgent: updateAgent2 } = (init_agents(), __toCommonJS(exports_agents));
         const resolvedAgent = resolveId(agent_id, "agents");
         const resolvedManager = resolveId(reports_to, "agents");
-        setReportsTo(resolvedAgent, resolvedManager);
+        updateAgent2(resolvedAgent, { reports_to: resolvedManager });
         return { content: [{ type: "text", text: `${agent_id} now reports to ${reports_to}` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -22151,9 +23663,9 @@ function registerTaskAutoTools(server, ctx) {
       project_id: exports_external.string().optional().describe("Scope to a project")
     }, async ({ days = 7, project_id }) => {
       try {
-        const { archiveCompletedTasks } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { archiveCompletedTasks: archiveCompletedTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
-        const count = archiveCompletedTasks(days, resolvedProjectId);
+        const count = archiveCompletedTasks2(days, resolvedProjectId);
         return { content: [{ type: "text", text: `Archived ${count} completed task(s) older than ${days} days.` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -22179,9 +23691,9 @@ function registerTaskAutoTools(server, ctx) {
       limit: exports_external.number().optional().describe("Max results (default: 50)")
     }, async ({ project_id, limit }) => {
       try {
-        const { getArchivedTasks } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { getArchivedTasks: getArchivedTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
-        const tasks = getArchivedTasks({ project_id: resolvedProjectId, limit: limit || 50 });
+        const tasks = getArchivedTasks2({ project_id: resolvedProjectId, limit: limit || 50 });
         if (tasks.length === 0)
           return { content: [{ type: "text", text: "No archived tasks." }] };
         const lines = tasks.map((t) => `${t.short_id || t.id.slice(0, 8)} ${t.title} archived ${t.archived_at}`);
@@ -22197,14 +23709,13 @@ function registerTaskAutoTools(server, ctx) {
       task_id: exports_external.string().describe("Task ID")
     }, async ({ task_id }) => {
       try {
-        const { autoAssign } = (init_agents(), __toCommonJS(exports_agents));
         const resolvedId = resolveId(task_id);
-        const assignment = autoAssign(resolvedId);
-        if (!assignment)
+        const { autoAssignTask: autoAssignTask2 } = (init_auto_assign(), __toCommonJS(exports_auto_assign));
+        const assignment = await autoAssignTask2(resolvedId);
+        if (!assignment.assigned_to)
           return { content: [{ type: "text", text: "No suitable agent found for this task." }] };
-        const { updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
-        updateTask2(resolvedId, { assigned_to: assignment.agent_id });
-        return { content: [{ type: "text", text: `Task ${task_id.slice(0, 8)} assigned to ${assignment.agent_name} (score: ${assignment.score.toFixed(2)})` }] };
+        const reason = assignment.reason ? ` \u2014 ${assignment.reason}` : "";
+        return { content: [{ type: "text", text: `Task ${task_id.slice(0, 8)} assigned to ${assignment.agent_name || assignment.assigned_to} via ${assignment.method}${reason}` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
@@ -22215,10 +23726,23 @@ function registerTaskAutoTools(server, ctx) {
       agent_id: exports_external.string().optional().describe("Agent ID (defaults to context agent)")
     }, async ({ agent_id }) => {
       try {
-        const { getAgentWorkload } = (init_agents(), __toCommonJS(exports_agents));
+        const { listTasks: listTasks3, getBlockedTasks: getBlockedTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const focus = ctx.getAgentFocus(agent_id || "");
         const effectiveAgentId = focus ? focus.agent_id : agent_id || "";
-        const workload = getAgentWorkload(effectiveAgentId);
+        if (!effectiveAgentId) {
+          return { content: [{ type: "text", text: "No agent_id provided and no agent focus is active." }], isError: true };
+        }
+        const assigned = listTasks3({ assigned_to: effectiveAgentId, limit: 500 }, undefined);
+        const now2 = Date.now();
+        const dueSoonCutoff = now2 + 24 * 60 * 60 * 1000;
+        const blocked = getBlockedTasks2().filter((t) => t.assigned_to === effectiveAgentId);
+        const workload = {
+          in_progress: assigned.filter((t) => t.status === "in_progress").length,
+          pending: assigned.filter((t) => t.status === "pending").length,
+          completed_recent: assigned.filter((t) => t.status === "completed" && t.completed_at && now2 - new Date(t.completed_at).getTime() <= 7 * 24 * 60 * 60 * 1000).length,
+          due_soon: assigned.filter((t) => t.due_at && new Date(t.due_at).getTime() <= dueSoonCutoff && new Date(t.due_at).getTime() >= now2 && !["completed", "cancelled", "failed"].includes(t.status)).length,
+          blocked: blocked.length
+        };
         const lines = [
           `Agent: ${effectiveAgentId}`,
           `In Progress: ${workload.in_progress}`,
@@ -22240,10 +23764,29 @@ function registerTaskAutoTools(server, ctx) {
       max_per_agent: exports_external.number().optional().describe("Max tasks per agent (default: 5)")
     }, async ({ project_id, max_per_agent }) => {
       try {
-        const { rebalanceWorkload } = (init_agents(), __toCommonJS(exports_agents));
+        const { listAgents: listAgents2 } = (init_agents(), __toCommonJS(exports_agents));
+        const { listTasks: listTasks3, updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
-        const result = rebalanceWorkload({ project_id: resolvedProjectId, max_per_agent: max_per_agent || 5 });
-        return { content: [{ type: "text", text: `Rebalanced: moved ${result.moved} task(s), ${result.skipped} skipped.` }] };
+        const limit = max_per_agent || 5;
+        const agents = listAgents2().filter((agent) => agent.status === "active");
+        if (agents.length === 0)
+          return { content: [{ type: "text", text: "No active agents available for rebalancing." }] };
+        const activeTasks = listTasks3({ project_id: resolvedProjectId, status: ["pending", "in_progress"], limit: 1000 }, undefined);
+        const load = new Map(agents.map((agent) => [agent.id, activeTasks.filter((t) => t.assigned_to === agent.id).length]));
+        let moved = 0;
+        let skipped = 0;
+        for (const task of activeTasks.filter((t) => t.status === "pending" && t.assigned_to && (load.get(t.assigned_to) ?? 0) > limit)) {
+          const target = agents.filter((agent) => agent.id !== task.assigned_to).sort((a, b) => (load.get(a.id) ?? 0) - (load.get(b.id) ?? 0))[0];
+          if (!target || (load.get(target.id) ?? 0) >= limit) {
+            skipped++;
+            continue;
+          }
+          updateTask2(task.id, { assigned_to: target.id, version: task.version });
+          load.set(task.assigned_to, (load.get(task.assigned_to) ?? 1) - 1);
+          load.set(target.id, (load.get(target.id) ?? 0) + 1);
+          moved++;
+        }
+        return { content: [{ type: "text", text: `Rebalanced: moved ${moved} task(s), ${skipped} skipped.` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
@@ -22256,13 +23799,13 @@ function registerTaskAutoTools(server, ctx) {
       agent_id: exports_external.string().optional().describe("Filter by assignee")
     }, async ({ hours = 24, project_id, agent_id }) => {
       try {
-        const { notifyUpcomingDeadlines } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { notifyUpcomingDeadlines: notifyUpcomingDeadlines2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
         const resolvedAgentId = agent_id ? resolveId(agent_id, "agents") : undefined;
-        const tasks = notifyUpcomingDeadlines({ hours, project_id: resolvedProjectId, agent_id: resolvedAgentId });
+        const tasks = notifyUpcomingDeadlines2({ hours, project_id: resolvedProjectId, agent_id: resolvedAgentId });
         if (tasks.length === 0)
           return { content: [{ type: "text", text: "No deadlines approaching." }] };
-        const lines = tasks.map((t) => `${t.short_id || t.id.slice(0, 8)} ${t.title} due ${t.deadline}`);
+        const lines = tasks.map((t) => `${t.short_id || t.id.slice(0, 8)} ${t.title} due ${t.due_at}`);
         return { content: [{ type: "text", text: `${tasks.length} task(s) due within ${hours}h:
 ${lines.join(`
 `)}` }] };
@@ -22296,9 +23839,9 @@ ${lines.join(`
       project_id: exports_external.string().optional().describe("Filter by project")
     }, async ({ project_id }) => {
       try {
-        const { getBlockedTasks } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { getBlockedTasks: getBlockedTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
-        const tasks = getBlockedTasks(resolvedProjectId);
+        const tasks = getBlockedTasks2(resolvedProjectId);
         if (tasks.length === 0)
           return { content: [{ type: "text", text: "No blocked tasks." }] };
         const lines = tasks.map((t) => `${t.short_id || t.id.slice(0, 8)} [${t.status}] ${t.title} \u2014 blocked by ${(t.blocked_by || []).map((b) => b.slice(0, 8)).join(", ")}`);
@@ -22315,9 +23858,9 @@ ${lines.join(`
       project_id: exports_external.string().optional().describe("Filter by project")
     }, async ({ project_id }) => {
       try {
-        const { getBlockingTasks } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { getBlockingTasks: getBlockingTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
-        const tasks = getBlockingTasks(resolvedProjectId);
+        const tasks = getBlockingTasks2(resolvedProjectId);
         if (tasks.length === 0)
           return { content: [{ type: "text", text: "No tasks blocking others." }] };
         const lines = tasks.map((t) => `${t.short_id || t.id.slice(0, 8)} [${t.status}] ${t.title} \u2014 blocking ${t.blocking_count} task(s)`);
@@ -22332,20 +23875,18 @@ ${lines.join(`
   if (shouldRegisterTool("get_health")) {
     server.tool("get_health", "Get system health: task counts by status, active agents, project summary.", async () => {
       try {
-        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const { listProjects: listProjects2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { countTasks: countTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { listProjects: listProjects2 } = (init_projects(), __toCommonJS(exports_projects));
         const { listAgents: listAgents2 } = (init_agents(), __toCommonJS(exports_agents));
-        const [pending, inProgress, completed, cancelled] = await Promise.all([
-          Promise.resolve(listTasks3({ status: "pending", limit: 1 }, undefined)),
-          Promise.resolve(listTasks3({ status: "in_progress", limit: 1 }, undefined)),
-          Promise.resolve(listTasks3({ status: "completed", limit: 1 }, undefined)),
-          Promise.resolve(listTasks3({ status: "cancelled", limit: 1 }, undefined))
-        ]);
-        const projects = listProjects2({ limit: 100 });
-        const agents = listAgents2({ limit: 100 });
+        const pending = countTasks2({ status: "pending" });
+        const inProgress = countTasks2({ status: "in_progress" });
+        const completed = countTasks2({ status: "completed" });
+        const cancelled = countTasks2({ status: "cancelled" });
+        const projects = listProjects2();
+        const agents = listAgents2();
         const lines = [
           `=== System Health ===`,
-          `Tasks: ${pending.total} pending | ${inProgress.total} in progress | ${completed.total} completed | ${cancelled.total} cancelled`,
+          `Tasks: ${pending} pending | ${inProgress} in progress | ${completed} completed | ${cancelled} cancelled`,
           `Projects: ${projects.length} total`,
           `Agents: ${agents.length} registered`
         ];
@@ -22362,17 +23903,31 @@ ${lines.join(`
 function registerTaskAdvTools(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError, formatTask, formatTaskDetail } = ctx;
   if (shouldRegisterTool("get_status")) {
-    server.tool("get_status", "Get a task's current status including blockers, dependencies, comments, and assignee.", {
-      task_id: exports_external.string().describe("Task ID")
-    }, async ({ task_id }) => {
+    server.tool("get_status", "Get queue status summary, or pass task_id for a task's detailed status.", {
+      task_id: exports_external.string().optional().describe("Task ID for task-specific status"),
+      project_id: exports_external.string().optional().describe("Filter summary by project"),
+      task_list_id: exports_external.string().optional().describe("Filter summary by task list"),
+      agent_id: exports_external.string().optional().describe("Agent for next-task affinity"),
+      explain_blocked: exports_external.boolean().optional().describe("Include blocked task explanations in summary")
+    }, async ({ task_id, project_id, task_list_id, agent_id, explain_blocked }) => {
       try {
+        if (!task_id) {
+          const { getStatus: getStatus2 } = (init_tasks(), __toCommonJS(exports_tasks));
+          const filters = {};
+          if (project_id)
+            filters.project_id = resolveId(project_id, "projects");
+          if (task_list_id)
+            filters.task_list_id = resolveId(task_list_id, "task_lists");
+          const status = getStatus2(filters, agent_id, { explain_blocked });
+          return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
+        }
         const resolvedId = resolveId(task_id);
-        const { getTask: getTask4 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const task = getTask4(resolvedId);
+        const { getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const task = getTask2(resolvedId);
         if (!task)
           throw new Error(`Task not found: ${task_id}`);
         const { getTaskDependencies: getTaskDependencies3 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const { listComments: listComments2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { listComments: listComments2 } = (init_comments(), __toCommonJS(exports_comments));
         const { listTaskFiles: listTaskFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const [deps, comments, files] = await Promise.all([
           Promise.resolve(getTaskDependencies3(resolvedId, "both")),
@@ -22382,14 +23937,14 @@ function registerTaskAdvTools(server, ctx) {
         const lines = [
           `Status: ${task.status} | Priority: ${task.priority}`,
           task.assigned_to ? `Assigned: ${task.assigned_to}` : "Unassigned",
-          task.deadline ? `Deadline: ${task.deadline}` : null,
+          task.due_at ? `Due: ${task.due_at}` : null,
           task.confidence != null ? `Confidence: ${task.confidence}` : null,
           deps.length > 0 ? `
 Dependencies (${deps.length}):` : null,
           ...deps.map((d) => `  [${d.direction}] ${d.task_id.slice(0, 8)} (${d.status})`),
           comments.length > 0 ? `
 Comments (${comments.length}):` : null,
-          ...comments.map((c) => `  [${c.author || "?"}] ${c.created_at?.slice(0, 16)}: ${c.body.slice(0, 80)}`),
+          ...comments.map((c) => `  [${c.agent_id || "?"}] ${c.created_at?.slice(0, 16)}: ${c.content.slice(0, 80)}`),
           files.length > 0 ? `
 Files (${files.length}):` : null,
           ...files.map((f) => `  ${f.status} ${f.path}`)
@@ -22407,22 +23962,22 @@ Files (${files.length}):` : null,
     }, async ({ task_id }) => {
       try {
         const resolvedId = resolveId(task_id);
-        const { getTask: getTask4 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const task = getTask4(resolvedId);
+        const { getTask: getTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const task = getTask2(resolvedId);
         if (!task)
           throw new Error(`Task not found: ${task_id}`);
         const { getTaskDependencies: getTaskDependencies3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const { getTaskRelationships: getTaskRelationships2 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
-        const { listComments: listComments2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { listComments: listComments2 } = (init_comments(), __toCommonJS(exports_comments));
         const { listTaskFiles: listTaskFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
-        const { getTaskCommits } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { getTaskCommits: getTaskCommits2 } = (init_task_commits(), __toCommonJS(exports_task_commits));
         const { getTaskWatchers: getTaskWatchers2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const [deps, rels, comments, files, commits, watchers] = await Promise.all([
           Promise.resolve(getTaskDependencies3(resolvedId, "both")),
           Promise.resolve(getTaskRelationships2(resolvedId)),
           Promise.resolve(listComments2(resolvedId)),
           Promise.resolve(listTaskFiles2(resolvedId)),
-          Promise.resolve(getTaskCommits(resolvedId)),
+          Promise.resolve(getTaskCommits2(resolvedId)),
           Promise.resolve(getTaskWatchers2(resolvedId))
         ]);
         const lines = [
@@ -22436,7 +23991,7 @@ Files (${files.length}):` : null,
           task.tags?.length ? `Tags:     ${task.tags.join(", ")}` : null,
           task.created_at ? `Created:  ${task.created_at}` : null,
           task.updated_at ? `Updated:  ${task.updated_at}` : null,
-          task.deadline ? `Deadline: ${task.deadline}` : null,
+          task.due_at ? `Due: ${task.due_at}` : null,
           task.completed_at ? `Completed: ${task.completed_at}` : null,
           deps.length > 0 ? `
 --- Dependencies (${deps.length}) ---` : null,
@@ -22446,7 +24001,7 @@ Files (${files.length}):` : null,
           ...rels.map((r) => `  ${r.source_task_id.slice(0, 8)} --[${r.relationship_type}]--> ${r.target_task_id.slice(0, 8)}`),
           comments.length > 0 ? `
 --- Comments (${comments.length}) ---` : null,
-          ...comments.map((c) => `  [${c.author || "?"}] ${c.created_at?.slice(0, 16)}: ${c.body.slice(0, 120)}`),
+          ...comments.map((c) => `  [${c.agent_id || "?"}] ${c.created_at?.slice(0, 16)}: ${c.content.slice(0, 120)}`),
           files.length > 0 ? `
 --- Files (${files.length}) ---` : null,
           ...files.map((f) => `  [${f.status}] ${f.path}`),
@@ -22495,8 +24050,8 @@ ${JSON.stringify(task.metadata, null, 2)}` : null
           limit: 20
         }, undefined);
         const completedYesterday = completed.filter((t) => t.completed_at && t.completed_at.startsWith(yesterdayStr));
-        const { getBlockedTasks } = (init_tasks(), __toCommonJS(exports_tasks));
-        const blocked = getBlockedTasks(effectiveProjectId ? resolveId(effectiveProjectId, "projects") : undefined).filter((t) => t.assigned_to === effectiveAgentId);
+        const { getBlockedTasks: getBlockedTasks2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const blocked = getBlockedTasks2(effectiveProjectId ? resolveId(effectiveProjectId, "projects") : undefined).filter((t) => t.assigned_to === effectiveAgentId);
         const lines = [
           `Standup for ${effectiveAgentId} (${effectiveProjectId ? `project: ${effectiveProjectId.slice(0, 8)}` : "all projects"})`,
           inProgress.length > 0 ? `
@@ -22525,11 +24080,11 @@ No blocked tasks.`,
       agent_id: exports_external.string().optional().describe("Agent claiming (defaults to context)")
     }, async ({ task_id, agent_id }) => {
       try {
-        const { updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { startTask: startTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedId = resolveId(task_id);
         const focus = ctx.getAgentFocus(agent_id || "");
-        const effectiveAgent = focus ? focus.agent_id : agent_id || "";
-        const task = updateTask2(resolvedId, { status: "in_progress", assigned_to: effectiveAgent });
+        const effectiveAgent = focus ? focus.agent_id : agent_id || "mcp";
+        const task = startTask2(resolvedId, effectiveAgent);
         return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -22541,211 +24096,95 @@ No blocked tasks.`,
       task_id: exports_external.string().describe("Task ID")
     }, async ({ task_id }) => {
       try {
-        const { updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const task = updateTask2(resolveId(task_id), { status: "pending", assigned_to: null });
-        return { content: [{ type: "text", text: formatTask(task) }] };
-      } catch (e) {
-        return { content: [{ type: "text", text: formatError(e) }], isError: true };
-      }
-    });
-  }
-  if (shouldRegisterTool("extend_task")) {
-    server.tool("extend_task", "Add more time to a task's estimate.", {
-      task_id: exports_external.string().describe("Task ID"),
-      minutes: exports_external.number().describe("Additional minutes to add to estimate")
-    }, async ({ task_id, minutes }) => {
-      try {
-        const { getTask: getTask4, updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { getTask: getTask2, updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const resolvedId = resolveId(task_id);
-        const task = getTask4(resolvedId);
-        if (!task)
+        const current = getTask2(resolvedId);
+        if (!current)
           throw new Error(`Task not found: ${task_id}`);
-        const currentEstimate = task.estimated_minutes || 0;
-        const updated = updateTask2(resolvedId, { estimated_minutes: currentEstimate + minutes });
-        return { content: [{ type: "text", text: `Estimate updated: ${currentEstimate} \u2192 ${updated.estimated_minutes} min (+${minutes})` }] };
-      } catch (e) {
-        return { content: [{ type: "text", text: formatError(e) }], isError: true };
-      }
-    });
-  }
-  if (shouldRegisterTool("add_comment")) {
-    server.tool("add_comment", "Alias for create_comment.", {
-      task_id: exports_external.string().describe("Task ID"),
-      body: exports_external.string().describe("Comment body"),
-      author: exports_external.string().optional().describe("Author agent ID or name")
-    }, async ({ task_id, body, author }) => {
-      try {
-        const { createComment } = (init_tasks(), __toCommonJS(exports_tasks));
-        const resolvedId = resolveId(task_id);
-        const resolvedAuthor = author ? resolveId(author, "agents") : undefined;
-        createComment({ task_id: resolvedId, body, author: resolvedAuthor });
-        return { content: [{ type: "text", text: `Comment added to ${task_id.slice(0, 8)}` }] };
-      } catch (e) {
-        return { content: [{ type: "text", text: formatError(e) }], isError: true };
-      }
-    });
-  }
-  if (shouldRegisterTool("get_comments")) {
-    server.tool("get_comments", "Alias for list_comments.", {
-      task_id: exports_external.string().describe("Task ID")
-    }, async ({ task_id }) => {
-      try {
-        const { listComments: listComments2 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const comments = listComments2(resolveId(task_id));
-        if (comments.length === 0)
-          return { content: [{ type: "text", text: "No comments." }] };
-        const lines = comments.map((c) => `[${c.author || "?"}] ${c.created_at?.slice(0, 16)}: ${c.body}`);
-        return { content: [{ type: "text", text: lines.join(`
-
-`) }] };
-      } catch (e) {
-        return { content: [{ type: "text", text: formatError(e) }], isError: true };
-      }
-    });
-  }
-  if (shouldRegisterTool("list_my_tasks")) {
-    server.tool("list_my_tasks", "Alias for get_my_tasks.", {
-      agent_id: exports_external.string().optional().describe("Agent ID (defaults to context agent)"),
-      status: exports_external.enum(["pending", "in_progress", "completed", "cancelled"]).optional(),
-      project_id: exports_external.string().optional().describe("Filter by project"),
-      limit: exports_external.number().optional()
-    }, async ({ agent_id, status, project_id, limit }) => {
-      try {
-        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
-        const focus = ctx.getAgentFocus(agent_id || "");
-        const effectiveAgentId = focus ? focus.agent_id : agent_id || "";
-        const effectiveProjectId = focus?.project_id || project_id;
-        const tasks = listTasks3({
-          assigned_to: effectiveAgentId,
-          status,
-          project_id: effectiveProjectId ? resolveId(effectiveProjectId, "projects") : undefined,
-          limit: limit || 50
-        }, undefined);
-        if (tasks.length === 0)
-          return { content: [{ type: "text", text: "No tasks found." }] };
-        const lines = tasks.map(formatTask);
-        return { content: [{ type: "text", text: lines.join(`
-`) }] };
-      } catch (e) {
-        return { content: [{ type: "text", text: formatError(e) }], isError: true };
-      }
-    });
-  }
-  if (shouldRegisterTool("list_agents")) {
-    server.tool("list_agents", "List all registered agents.", {
-      project_id: exports_external.string().optional().describe("Filter by project"),
-      role: exports_external.string().optional().describe("Filter by global role"),
-      capabilities: exports_external.array(exports_external.string()).optional().describe("Filter by capabilities")
-    }, async ({ project_id, role, capabilities }) => {
-      try {
-        const { listAgents: listAgents2 } = (init_agents(), __toCommonJS(exports_agents));
-        const resolved = {};
-        if (project_id)
-          resolved.project_id = resolveId(project_id, "projects");
-        if (role)
-          resolved.role = role;
-        if (capabilities)
-          resolved.capabilities = capabilities;
-        const agents = listAgents2(resolved);
-        if (agents.length === 0)
-          return { content: [{ type: "text", text: "No agents found." }] };
-        const lines = agents.map((a) => `\u25CF ${a.name} [${a.role || "no role"}]${a.capabilities?.length ? ` caps:[${a.capabilities.join(",")}]` : ""}`);
-        return { content: [{ type: "text", text: lines.join(`
-`) }] };
-      } catch (e) {
-        return { content: [{ type: "text", text: formatError(e) }], isError: true };
-      }
-    });
-  }
-  if (shouldRegisterTool("get_agent")) {
-    server.tool("get_agent", "Get full details for an agent.", {
-      agent_id: exports_external.string().describe("Agent ID or name")
-    }, async ({ agent_id }) => {
-      try {
-        const { getAgentByName: getAgentByName2, getAgent: getAgent2 } = (init_agents(), __toCommonJS(exports_agents));
-        const resolvedId = resolveId(agent_id, "agents");
-        const agent = agent_id.includes("@") || !resolvedId.startsWith("agent_") ? getAgentByName2(agent_id) : getAgent2(resolvedId);
-        if (!agent)
-          return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
-        const lines = [
-          `ID:          ${agent.id}`,
-          `Name:        ${agent.name}`,
-          agent.email ? `Email:       ${agent.email}` : null,
-          agent.title ? `Title:       ${agent.title}` : null,
-          agent.role ? `Role:        ${agent.role}` : null,
-          agent.capabilities?.length ? `Capabilities: ${agent.capabilities.join(", ")}` : null,
-          agent.last_seen_at ? `Last Seen:   ${agent.last_seen_at}` : null
-        ].filter(Boolean);
-        return { content: [{ type: "text", text: lines.join(`
-`) }] };
+        const task = updateTask2(resolvedId, { status: "pending", assigned_to: null, version: current.version });
+        return { content: [{ type: "text", text: formatTask(task) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
-    });
-  }
-  if (shouldRegisterTool("update_agent")) {
-    server.tool("update_agent", "Update an agent's fields.", {
-      agent_id: exports_external.string().describe("Agent ID or name"),
-      name: exports_external.string().optional(),
-      email: exports_external.string().optional(),
-      title: exports_external.string().optional(),
-      role: exports_external.string().optional(),
-      capabilities: exports_external.array(exports_external.string()).optional()
-    }, async ({ agent_id, ...updates }) => {
+    });
+  }
+  if (shouldRegisterTool("extend_task")) {
+    server.tool("extend_task", "Add more time to a task's estimate.", {
+      task_id: exports_external.string().describe("Task ID"),
+      minutes: exports_external.number().describe("Additional minutes to add to estimate")
+    }, async ({ task_id, minutes }) => {
       try {
-        const { getAgentByName: getAgentByName2, updateAgent: updateAgent2 } = (init_agents(), __toCommonJS(exports_agents));
-        const resolvedId = resolveId(agent_id, "agents");
-        const agent = agent_id.includes("@") || !resolvedId.startsWith("agent_") ? getAgentByName2(agent_id) : { id: resolvedId };
-        updateAgent2(agent.id, updates);
-        return { content: [{ type: "text", text: `Agent ${agent.id.slice(0, 8)} updated.` }] };
+        const { getTask: getTask2, updateTask: updateTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const resolvedId = resolveId(task_id);
+        const task = getTask2(resolvedId);
+        if (!task)
+          throw new Error(`Task not found: ${task_id}`);
+        const currentEstimate = task.estimated_minutes || 0;
+        const updated = updateTask2(resolvedId, { estimated_minutes: currentEstimate + minutes, version: task.version });
+        return { content: [{ type: "text", text: `Estimate updated: ${currentEstimate} \u2192 ${updated.estimated_minutes} min (+${minutes})` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
     });
   }
-  if (shouldRegisterTool("delete_agent")) {
-    server.tool("delete_agent", "Deregister an agent.", {
-      agent_id: exports_external.string().describe("Agent ID or name")
-    }, async ({ agent_id }) => {
+  if (shouldRegisterTool("add_comment")) {
+    server.tool("add_comment", "Alias for create_comment.", {
+      task_id: exports_external.string().describe("Task ID"),
+      body: exports_external.string().describe("Comment body"),
+      author: exports_external.string().optional().describe("Author agent ID or name")
+    }, async ({ task_id, body, author }) => {
       try {
-        const { getAgentByName: getAgentByName2, deleteAgent: deleteAgent2 } = (init_agents(), __toCommonJS(exports_agents));
-        const resolvedId = resolveId(agent_id, "agents");
-        const agent = agent_id.includes("@") || !resolvedId.startsWith("agent_") ? getAgentByName2(agent_id) : { id: resolvedId };
-        if (!agent)
-          return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
-        deleteAgent2(agent.id);
-        return { content: [{ type: "text", text: `Agent ${agent_id} deleted.` }] };
+        const { addComment: addComment2 } = (init_comments(), __toCommonJS(exports_comments));
+        const resolvedId = resolveId(task_id);
+        const resolvedAuthor = author ? resolveId(author, "agents") : undefined;
+        addComment2({ task_id: resolvedId, content: body, agent_id: resolvedAuthor });
+        return { content: [{ type: "text", text: `Comment added to ${task_id.slice(0, 8)}` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
     });
   }
-  if (shouldRegisterTool("register_agent")) {
-    server.tool("register_agent", "Register a new agent.", {
-      name: exports_external.string().describe("Agent name"),
-      email: exports_external.string().optional(),
-      title: exports_external.string().optional(),
-      role: exports_external.string().optional(),
-      capabilities: exports_external.array(exports_external.string()).optional()
-    }, async ({ name, email, title, role, capabilities }) => {
+  if (shouldRegisterTool("get_comments")) {
+    server.tool("get_comments", "Alias for list_comments.", {
+      task_id: exports_external.string().describe("Task ID")
+    }, async ({ task_id }) => {
       try {
-        const { registerAgent: registerAgent2 } = (init_agents(), __toCommonJS(exports_agents));
-        const agent = registerAgent2({ name, email, title, role, capabilities });
-        return { content: [{ type: "text", text: `Agent registered: ${agent.name} (${agent.id})` }] };
+        const { listComments: listComments2 } = (init_comments(), __toCommonJS(exports_comments));
+        const comments = listComments2(resolveId(task_id));
+        if (comments.length === 0)
+          return { content: [{ type: "text", text: "No comments." }] };
+        const lines = comments.map((c) => `[${c.agent_id || "?"}] ${c.created_at?.slice(0, 16)}: ${c.content}`);
+        return { content: [{ type: "text", text: lines.join(`
+
+`) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
     });
   }
-  if (shouldRegisterTool("heartbeat")) {
-    server.tool("heartbeat", "Agent heartbeat \u2014 updates last_seen_at timestamp.", {
-      agent_id: exports_external.string().describe("Agent ID"),
-      status: exports_external.string().optional().describe("Current status message")
-    }, async ({ agent_id, status }) => {
+  if (shouldRegisterTool("list_my_tasks")) {
+    server.tool("list_my_tasks", "Alias for get_my_tasks.", {
+      agent_id: exports_external.string().optional().describe("Agent ID (defaults to context agent)"),
+      status: exports_external.enum(["pending", "in_progress", "completed", "failed", "cancelled"]).optional(),
+      project_id: exports_external.string().optional().describe("Filter by project"),
+      limit: exports_external.number().optional()
+    }, async ({ agent_id, status, project_id, limit }) => {
       try {
-        const { heartbeat } = (init_agents(), __toCommonJS(exports_agents));
-        heartbeat(resolveId(agent_id, "agents"), status);
-        return { content: [{ type: "text", text: "Heartbeat received." }] };
+        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const focus = ctx.getAgentFocus(agent_id || "");
+        const effectiveAgentId = focus ? focus.agent_id : agent_id || "";
+        const effectiveProjectId = focus?.project_id || project_id;
+        const tasks = listTasks3({
+          assigned_to: effectiveAgentId,
+          status,
+          project_id: effectiveProjectId ? resolveId(effectiveProjectId, "projects") : undefined,
+          limit: limit || 50
+        }, undefined);
+        if (tasks.length === 0)
+          return { content: [{ type: "text", text: "No tasks found." }] };
+        const lines = tasks.map(formatTask);
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
       }
@@ -22792,6 +24231,11 @@ function registerTaskMetaTools(server, ctx) {
           prioritize_task: "prioritize_task \u2014 Set priority. Params: task_id, priority, version",
           search_tasks: "search_tasks \u2014 Full-text search. Params: query, project_id, status, limit",
           get_my_tasks: "get_my_tasks \u2014 Get tasks for calling agent. Params: agent_id, status, project_id, limit",
+          get_next_task: "get_next_task \u2014 Get the next available task without claiming it. Params: agent_id, project_id, task_list_id, plan_id, tags",
+          claim_next_task: "claim_next_task \u2014 Atomically claim and start the next available task. Params: agent_id, project_id, task_list_id, plan_id, tags",
+          get_tasks_changed_since: "get_tasks_changed_since \u2014 List tasks changed since an ISO timestamp. Params: since, project_id, task_list_id, limit",
+          get_context: "get_context \u2014 Get session start context. Params: agent_id, project_id, task_list_id, explain_blocked",
+          bootstrap: "bootstrap \u2014 Bootstrap an agent session with queue context. Params: agent_id, project_id, task_list_id, explain_blocked",
           standup: "standup \u2014 Get standup report. Params: agent_id, project_id",
           patrol_tasks: "patrol_tasks \u2014 Scan for task issues. Params: stuck_minutes, confidence_threshold, project_id",
           get_review_queue: "get_review_queue \u2014 Get tasks needing review. Params: project_id, limit",
@@ -22849,9 +24293,20 @@ function registerTaskMetaTools(server, ctx) {
           get_health: "get_health \u2014 Get system health stats",
           approve_task: "approve_task \u2014 Approve a task. Params: task_id, approved_by, notes, version",
           fail_task: "fail_task \u2014 Mark task failed. Params: task_id, reason, agent_id, version",
+          register_agent: "register_agent \u2014 Register an agent. Params: name, description, role, title, capabilities, session_id, working_dir, force",
+          list_agents: "list_agents \u2014 List registered agents. Params: include_archived",
+          get_agent: "get_agent \u2014 Get agent details. Params: agent_id, id, name",
+          update_agent: "update_agent \u2014 Update an agent. Params: agent_id, id, name, description, role, title, level, capabilities, permissions, metadata",
+          delete_agent: "delete_agent \u2014 Archive an agent. Params: agent_id, id, name",
+          unarchive_agent: "unarchive_agent \u2014 Restore an archived agent. Params: agent_id, id, name",
+          heartbeat: "heartbeat \u2014 Update an agent heartbeat. Params: agent_id",
+          release_agent: "release_agent \u2014 Release an agent session/name. Params: agent_id, session_id",
+          set_focus: "set_focus \u2014 Focus an agent on a project. Params: agent_id, project_id, task_list_id",
+          get_focus: "get_focus \u2014 Get current agent focus. Params: agent_id",
+          unfocus: "unfocus \u2014 Clear agent focus. Params: agent_id",
+          suggest_agent_name: "suggest_agent_name \u2014 Suggest available agent names. Params: working_dir",
           get_org_chart: "get_org_chart \u2014 Get global org chart. Params: format",
           set_reports_to: "set_reports_to \u2014 Set org hierarchy. Params: agent_id, reports_to",
-          sync: "sync \u2014 Sync from external source. Params: source, source_id, project_id, options",
           extract_todos: "extract_todos \u2014 Scan code for TODO comments. Params: path, project_id, task_list_id, patterns, tags, assigned_to, agent_id, dry_run, extensions",
           migrate_pg: "migrate_pg \u2014 Apply PostgreSQL migrations. Params: connection_string"
         };
@@ -22870,39 +24325,7 @@ function registerTaskMetaTools(server, ctx) {
 init_tasks();
 init_projects();
 init_agents();
-
-// src/db/task-commits.ts
-init_database();
-function rowToCommit(row) {
-  return {
-    ...row,
-    files_changed: row.files_changed ? JSON.parse(row.files_changed) : null
-  };
-}
-function linkTaskToCommit(input, db) {
-  const d = db || getDatabase();
-  const existing = d.query("SELECT * FROM task_commits WHERE task_id = ? AND sha = ?").get(input.task_id, input.sha);
-  if (existing) {
-    d.run("UPDATE task_commits SET message = COALESCE(?, message), author = COALESCE(?, author), files_changed = COALESCE(?, files_changed), committed_at = COALESCE(?, committed_at) WHERE id = ?", [input.message ?? null, input.author ?? null, input.files_changed ? JSON.stringify(input.files_changed) : null, input.committed_at ?? null, existing.id]);
-    return rowToCommit(d.query("SELECT * FROM task_commits WHERE id = ?").get(existing.id));
-  }
-  const id = uuid();
-  d.run("INSERT INTO task_commits (id, task_id, sha, message, author, files_changed, committed_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [id, input.task_id, input.sha, input.message ?? null, input.author ?? null, input.files_changed ? JSON.stringify(input.files_changed) : null, input.committed_at ?? null, now()]);
-  return rowToCommit(d.query("SELECT * FROM task_commits WHERE id = ?").get(id));
-}
-function getTaskCommits(taskId, db) {
-  const d = db || getDatabase();
-  return d.query("SELECT * FROM task_commits WHERE task_id = ? ORDER BY committed_at DESC, created_at DESC").all(taskId).map(rowToCommit);
-}
-function findTaskByCommit(sha, db) {
-  const d = db || getDatabase();
-  const row = d.query("SELECT * FROM task_commits WHERE sha = ? OR sha LIKE ? LIMIT 1").get(sha, `${sha}%`);
-  if (!row)
-    return null;
-  return { task_id: row.task_id, commit: rowToCommit(row) };
-}
-
-// src/mcp/tools/task-resources.ts
+init_task_commits();
 function registerTaskResources(server, ctx) {
   const { shouldRegisterTool, resolveId, formatError } = ctx;
   server.resource("tasks", "todos://tasks", { description: "All active tasks", mimeType: "application/json" }, async () => {
@@ -22927,7 +24350,7 @@ function registerTaskResources(server, ctx) {
       note: exports_external.string().optional().describe("Note about why this file is linked")
     }, async ({ task_id, path, paths: multiplePaths, status, agent_id, note }) => {
       try {
-        const { addTaskFile: addTaskFile2, bulkAddTaskFiles: bulkAddTaskFiles2, detectFileConflicts: detectFileConflicts2 } = (()=>{throw new Error("Cannot require module "+"../db/task-files.js");})();
+        const { addTaskFile: addTaskFile2, bulkAddTaskFiles: bulkAddTaskFiles2, detectFileConflicts: detectFileConflicts2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const resolvedId = resolveId(task_id);
         let addedFiles;
         if (multiplePaths && multiplePaths.length > 0) {
@@ -22971,7 +24394,7 @@ function registerTaskResources(server, ctx) {
   if (shouldRegisterTool("list_task_files")) {
     server.tool("list_task_files", "List all files linked to a task.", { task_id: exports_external.string().describe("Task ID") }, async ({ task_id }) => {
       try {
-        const { listTaskFiles: listTaskFiles2 } = (()=>{throw new Error("Cannot require module "+"../db/task-files.js");})();
+        const { listTaskFiles: listTaskFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const resolvedId = resolveId(task_id);
         const files = listTaskFiles2(resolvedId);
         if (files.length === 0)
@@ -22988,7 +24411,7 @@ ${lines.join(`
   if (shouldRegisterTool("find_tasks_by_file")) {
     server.tool("find_tasks_by_file", "Find which tasks are linked to a specific file path. Shows who's working on what files.", { path: exports_external.string().describe("File path to search for") }, async ({ path }) => {
       try {
-        const { findTasksByFile: findTasksByFile2 } = (()=>{throw new Error("Cannot require module "+"../db/task-files.js");})();
+        const { findTasksByFile: findTasksByFile2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const files = findTasksByFile2(path);
         if (files.length === 0)
           return { content: [{ type: "text", text: `No tasks linked to ${path}` }] };
@@ -23008,7 +24431,7 @@ ${lines.join(`
       min_edits: exports_external.number().optional().describe("Minimum edit count to include (default: 1)")
     }, async ({ limit, project_id, min_edits }) => {
       try {
-        const { getFileHeatMap: getFileHeatMap2 } = (()=>{throw new Error("Cannot require module "+"../db/task-files.js");})();
+        const { getFileHeatMap: getFileHeatMap2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const resolvedProjectId = project_id ? resolveId(project_id, "projects") : undefined;
         const results = getFileHeatMap2({ limit, project_id: resolvedProjectId, min_edits });
         return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
@@ -23022,7 +24445,7 @@ ${lines.join(`
       paths: exports_external.array(exports_external.string()).describe("Array of file paths to check")
     }, async ({ paths }) => {
       try {
-        const { bulkFindTasksByFiles: bulkFindTasksByFiles2 } = (()=>{throw new Error("Cannot require module "+"../db/task-files.js");})();
+        const { bulkFindTasksByFiles: bulkFindTasksByFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
         const results = bulkFindTasksByFiles2(paths);
         return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
       } catch (e) {
@@ -23035,11 +24458,11 @@ ${lines.join(`
       project_id: exports_external.string().optional().describe("Filter by project")
     }, async ({ project_id }) => {
       try {
-        const { listActiveFiles: listActiveFiles2 } = (()=>{throw new Error("Cannot require module "+"../db/task-files.js");})();
+        const { listActiveFiles: listActiveFiles2 } = (init_task_files(), __toCommonJS(exports_task_files));
         let files = listActiveFiles2();
         if (project_id) {
           const pid = resolveId(project_id, "projects");
-          const db = (()=>{throw new Error("Cannot require module "+"../db/database.js");})().getDatabase();
+          const db = (init_database(), __toCommonJS(exports_database)).getDatabase();
           files = db.query(`
               SELECT
                 tf.path,
@@ -23121,8 +24544,8 @@ ${lines.join(`
       ttl_seconds: exports_external.number().optional().describe("Lock TTL in seconds (default: 1800 = 30 min)")
     }, async ({ path, agent_id, task_id, ttl_seconds }) => {
       try {
-        const { lockFile } = (()=>{throw new Error("Cannot require module "+"../db/file-locks.js");})();
-        const lock = lockFile({ path, agent_id, task_id, ttl_seconds });
+        const { lockFile: lockFile2 } = (init_file_locks(), __toCommonJS(exports_file_locks));
+        const lock = lockFile2({ path, agent_id, task_id, ttl_seconds });
         return { content: [{ type: "text", text: JSON.stringify(lock, null, 2) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -23135,8 +24558,8 @@ ${lines.join(`
       agent_id: exports_external.string().describe("Agent releasing the lock (must be the lock holder)")
     }, async ({ path, agent_id }) => {
       try {
-        const { unlockFile } = (()=>{throw new Error("Cannot require module "+"../db/file-locks.js");})();
-        const released = unlockFile(path, agent_id);
+        const { unlockFile: unlockFile2 } = (init_file_locks(), __toCommonJS(exports_file_locks));
+        const released = unlockFile2(path, agent_id);
         return { content: [{ type: "text", text: JSON.stringify({ released, path }) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -23148,8 +24571,8 @@ ${lines.join(`
       path: exports_external.string().describe("File path to check")
     }, async ({ path }) => {
       try {
-        const { checkFileLock } = (()=>{throw new Error("Cannot require module "+"../db/file-locks.js");})();
-        const lock = checkFileLock(path);
+        const { checkFileLock: checkFileLock2 } = (init_file_locks(), __toCommonJS(exports_file_locks));
+        const lock = checkFileLock2(path);
         if (!lock)
           return { content: [{ type: "text", text: JSON.stringify({ path, locked: false }) }] };
         return { content: [{ type: "text", text: JSON.stringify({ path, locked: true, ...lock }) }] };
@@ -23163,8 +24586,8 @@ ${lines.join(`
       agent_id: exports_external.string().optional().describe("Filter locks by agent")
     }, async ({ agent_id }) => {
       try {
-        const { listFileLocks } = (()=>{throw new Error("Cannot require module "+"../db/file-locks.js");})();
-        const locks = listFileLocks(agent_id);
+        const { listFileLocks: listFileLocks2 } = (init_file_locks(), __toCommonJS(exports_file_locks));
+        const locks = listFileLocks2(agent_id);
         return { content: [{ type: "text", text: JSON.stringify(locks, null, 2) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -23187,8 +24610,8 @@ function registerTaskRelTools(server, ctx) {
       next_steps: exports_external.array(exports_external.string()).optional().describe("Recommended next actions")
     }, async ({ agent_id, project_id, summary, completed, in_progress, blockers, next_steps }) => {
       try {
-        const { createHandoff } = (()=>{throw new Error("Cannot require module "+"../db/handoffs.js");})();
-        const handoff = createHandoff({
+        const { createHandoff: createHandoff2 } = (init_handoffs(), __toCommonJS(exports_handoffs));
+        const handoff = createHandoff2({
           agent_id,
           project_id: project_id ? resolveId(project_id, "projects") : undefined,
           summary,
@@ -23209,8 +24632,8 @@ function registerTaskRelTools(server, ctx) {
       project_id: exports_external.string().optional().describe("Filter by project")
     }, async ({ agent_id, project_id }) => {
       try {
-        const { getLatestHandoff } = (()=>{throw new Error("Cannot require module "+"../db/handoffs.js");})();
-        const handoff = getLatestHandoff(agent_id, project_id ? resolveId(project_id, "projects") : undefined);
+        const { getLatestHandoff: getLatestHandoff2 } = (init_handoffs(), __toCommonJS(exports_handoffs));
+        const handoff = getLatestHandoff2(agent_id, project_id ? resolveId(project_id, "projects") : undefined);
         if (!handoff)
           return { content: [{ type: "text", text: "No handoffs found." }] };
         const lines = [
@@ -23240,7 +24663,7 @@ function registerTaskRelTools(server, ctx) {
       created_by: exports_external.string().optional().describe("Agent ID who created this relationship")
     }, async ({ source_task_id, target_task_id, relationship_type, created_by }) => {
       try {
-        const { addTaskRelationship: addTaskRelationship2 } = (()=>{throw new Error("Cannot require module "+"../db/task-relationships.js");})();
+        const { addTaskRelationship: addTaskRelationship2 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
         const rel = addTaskRelationship2({
           source_task_id: resolveId(source_task_id),
           target_task_id: resolveId(target_task_id),
@@ -23261,7 +24684,7 @@ function registerTaskRelTools(server, ctx) {
       relationship_type: exports_external.enum(["related_to", "conflicts_with", "similar_to", "duplicates", "supersedes", "modifies_same_file"]).optional()
     }, async ({ id, source_task_id, target_task_id, relationship_type }) => {
       try {
-        const { removeTaskRelationship: removeTaskRelationship2, removeTaskRelationshipByPair: removeTaskRelationshipByPair2 } = (()=>{throw new Error("Cannot require module "+"../db/task-relationships.js");})();
+        const { removeTaskRelationship: removeTaskRelationship2, removeTaskRelationshipByPair: removeTaskRelationshipByPair2 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
         let removed = false;
         if (id) {
           removed = removeTaskRelationship2(id);
@@ -23282,7 +24705,7 @@ function registerTaskRelTools(server, ctx) {
       relationship_type: exports_external.enum(["related_to", "conflicts_with", "similar_to", "duplicates", "supersedes", "modifies_same_file"]).optional()
     }, async ({ task_id, relationship_type }) => {
       try {
-        const { getTaskRelationships: getTaskRelationships2 } = (()=>{throw new Error("Cannot require module "+"../db/task-relationships.js");})();
+        const { getTaskRelationships: getTaskRelationships2 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
         const rels = getTaskRelationships2(resolveId(task_id), relationship_type);
         if (rels.length === 0)
           return { content: [{ type: "text", text: "No relationships found." }] };
@@ -23299,7 +24722,7 @@ function registerTaskRelTools(server, ctx) {
       task_id: exports_external.string().describe("Task ID to detect file relationships for")
     }, async ({ task_id }) => {
       try {
-        const { autoDetectFileRelationships: autoDetectFileRelationships2 } = (()=>{throw new Error("Cannot require module "+"../db/task-relationships.js");})();
+        const { autoDetectFileRelationships: autoDetectFileRelationships2 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
         const created = autoDetectFileRelationships2(resolveId(task_id));
         return { content: [{ type: "text", text: created.length > 0 ? `Created ${created.length} file relationship(s).` : "No file overlaps detected." }] };
       } catch (e) {
@@ -23310,8 +24733,8 @@ function registerTaskRelTools(server, ctx) {
   if (shouldRegisterTool("sync_kg")) {
     server.tool("sync_kg", "Sync all existing relationships into the knowledge graph edges table. Idempotent.", {}, async () => {
       try {
-        const { syncKgEdges } = (()=>{throw new Error("Cannot require module "+"../db/kg.js");})();
-        const result = syncKgEdges();
+        const { syncKgEdges: syncKgEdges2 } = (init_kg(), __toCommonJS(exports_kg));
+        const result = syncKgEdges2();
         return { content: [{ type: "text", text: `Knowledge graph synced: ${result.synced} edge(s) processed.` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -23327,8 +24750,8 @@ function registerTaskRelTools(server, ctx) {
       limit: exports_external.number().optional().describe("Max results")
     }, async ({ entity_id, relation_type, entity_type, direction, limit }) => {
       try {
-        const { getRelated } = (()=>{throw new Error("Cannot require module "+"../db/kg.js");})();
-        const edges = getRelated(entity_id, { relation_type, entity_type, direction, limit });
+        const { getRelated: getRelated2 } = (init_kg(), __toCommonJS(exports_kg));
+        const edges = getRelated2(entity_id, { relation_type, entity_type, direction, limit });
         if (edges.length === 0)
           return { content: [{ type: "text", text: "No related entities found." }] };
         const lines = edges.map((e) => `${e.source_id.slice(0, 12)}(${e.source_type}) --[${e.relation_type}]--> ${e.target_id.slice(0, 12)}(${e.target_type})`);
@@ -23347,8 +24770,8 @@ function registerTaskRelTools(server, ctx) {
       relation_types: exports_external.array(exports_external.string()).optional().describe("Filter by relation types")
     }, async ({ source_id, target_id, max_depth, relation_types }) => {
       try {
-        const { findPath } = (()=>{throw new Error("Cannot require module "+"../db/kg.js");})();
-        const paths = findPath(source_id, target_id, { max_depth, relation_types });
+        const { findPath: findPath2 } = (init_kg(), __toCommonJS(exports_kg));
+        const paths = findPath2(source_id, target_id, { max_depth, relation_types });
         if (paths.length === 0)
           return { content: [{ type: "text", text: "No path found." }] };
         const lines = paths.map((path, i) => {
@@ -23372,8 +24795,8 @@ function registerTaskRelTools(server, ctx) {
       relation_types: exports_external.array(exports_external.string()).optional().describe("Filter by relation types")
     }, async ({ entity_id, max_depth, relation_types }) => {
       try {
-        const { getImpactAnalysis } = (()=>{throw new Error("Cannot require module "+"../db/kg.js");})();
-        const impact = getImpactAnalysis(entity_id, { max_depth, relation_types });
+        const { getImpactAnalysis: getImpactAnalysis2 } = (init_kg(), __toCommonJS(exports_kg));
+        const impact = getImpactAnalysis2(entity_id, { max_depth, relation_types });
         if (impact.length === 0)
           return { content: [{ type: "text", text: "No downstream impact detected." }] };
         const byDepth = new Map;
@@ -23403,8 +24826,8 @@ Depth ${depth}:`);
       limit: exports_external.number().optional().describe("Max results (default: 20)")
     }, async ({ project_id, limit }) => {
       try {
-        const { getCriticalPath } = (()=>{throw new Error("Cannot require module "+"../db/kg.js");})();
-        const result = getCriticalPath({ project_id: project_id ? resolveId(project_id, "projects") : undefined, limit });
+        const { getCriticalPath: getCriticalPath2 } = (init_kg(), __toCommonJS(exports_kg));
+        const result = getCriticalPath2({ project_id: project_id ? resolveId(project_id, "projects") : undefined, limit });
         if (result.length === 0)
           return { content: [{ type: "text", text: "No critical path data. Run sync_kg first to populate the knowledge graph." }] };
         const lines = result.map((r, i) => `${i + 1}. ${r.task_id.slice(0, 8)} blocks ${r.blocking_count} task(s), max depth ${r.depth}`);
@@ -23424,13 +24847,13 @@ ${lines.join(`
       is_lead: exports_external.coerce.boolean().optional().describe("Whether this agent is the project lead for this role")
     }, async ({ project_id, agent_name, role, is_lead }) => {
       try {
-        const { setProjectAgentRole } = (()=>{throw new Error("Cannot require module "+"../db/project-agent-roles.js");})();
-        const { getAgentByName: getAgentByName2 } = (()=>{throw new Error("Cannot require module "+"../db/agents.js");})();
+        const { setProjectAgentRole: setProjectAgentRole2 } = (init_project_agent_roles(), __toCommonJS(exports_project_agent_roles));
+        const { getAgentByName: getAgentByName2 } = (init_agents(), __toCommonJS(exports_agents));
         const agent = getAgentByName2(agent_name);
         if (!agent)
           return { content: [{ type: "text", text: `Agent not found: ${agent_name}` }], isError: true };
         const pid = resolveId(project_id, "projects");
-        const result = setProjectAgentRole(pid, agent.id, role, is_lead ?? false);
+        const result = setProjectAgentRole2(pid, agent.id, role, is_lead ?? false);
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -23460,9 +24883,9 @@ ${lines.join(`
           }).join(`
 `);
         };
-        const { getProjectOrgChart } = (()=>{throw new Error("Cannot require module "+"../db/project-agent-roles.js");})();
+        const { getProjectOrgChart: getProjectOrgChart2 } = (init_project_agent_roles(), __toCommonJS(exports_project_agent_roles));
         const pid = resolveId(project_id, "projects");
-        const tree = getProjectOrgChart(pid, { filter_to_project });
+        const tree = getProjectOrgChart2(pid, { filter_to_project });
         if (format === "json") {
           return { content: [{ type: "text", text: JSON.stringify(tree, null, 2) }] };
         }
@@ -23480,9 +24903,9 @@ ${lines.join(`
       project_id: exports_external.string().describe("Project ID")
     }, async ({ project_id }) => {
       try {
-        const { listProjectAgentRoles } = (()=>{throw new Error("Cannot require module "+"../db/project-agent-roles.js");})();
+        const { listProjectAgentRoles: listProjectAgentRoles2 } = (init_project_agent_roles(), __toCommonJS(exports_project_agent_roles));
         const pid = resolveId(project_id, "projects");
-        const roles = listProjectAgentRoles(pid);
+        const roles = listProjectAgentRoles2(pid);
         return { content: [{ type: "text", text: JSON.stringify(roles, null, 2) }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -23496,7 +24919,7 @@ ${lines.join(`
       limit: exports_external.number().optional().describe("Max results")
     }, async ({ capabilities, min_score, limit }) => {
       try {
-        const { getCapableAgents: getCapableAgents2 } = (()=>{throw new Error("Cannot require module "+"../db/agents.js");})();
+        const { getCapableAgents: getCapableAgents2 } = (init_agents(), __toCommonJS(exports_agents));
         const results = getCapableAgents2(capabilities, { min_score, limit });
         if (results.length === 0)
           return { content: [{ type: "text", text: "No agents match the given capabilities." }] };
@@ -23515,8 +24938,8 @@ ${lines.join(`
       project_id: exports_external.string().optional().describe("Filter by project")
     }, async ({ stuck_minutes, confidence_threshold, project_id }) => {
       try {
-        const { patrolTasks } = (()=>{throw new Error("Cannot require module "+"../db/patrol.js");})();
-        const result = patrolTasks({
+        const { patrolTasks: patrolTasks2 } = (init_patrol(), __toCommonJS(exports_patrol));
+        const result = patrolTasks2({
           stuck_minutes,
           confidence_threshold,
           project_id: project_id ? resolveId(project_id, "projects") : undefined
@@ -23542,8 +24965,8 @@ ${lines.join(`
       limit: exports_external.number().optional().describe("Max results (default: all)")
     }, async ({ project_id, limit }) => {
       try {
-        const { getReviewQueue } = (()=>{throw new Error("Cannot require module "+"../db/patrol.js");})();
-        const tasks = getReviewQueue({
+        const { getReviewQueue: getReviewQueue2 } = (init_patrol(), __toCommonJS(exports_patrol));
+        const tasks = getReviewQueue2({
           project_id: project_id ? resolveId(project_id, "projects") : undefined,
           limit
         });
@@ -23569,8 +24992,8 @@ ${lines.join(`
       reviewer_id: exports_external.string().optional().describe("Agent ID of reviewer")
     }, async ({ task_id, score, reviewer_id }) => {
       try {
-        const { scoreTask } = (()=>{throw new Error("Cannot require module "+"../db/agent-metrics.js");})();
-        scoreTask(resolveId(task_id), score, reviewer_id);
+        const { scoreTask: scoreTask2 } = (init_agent_metrics(), __toCommonJS(exports_agent_metrics));
+        scoreTask2(resolveId(task_id), score, reviewer_id);
         return { content: [{ type: "text", text: `Task ${task_id.slice(0, 8)} scored: ${score}` }] };
       } catch (e) {
         return { content: [{ type: "text", text: formatError(e) }], isError: true };
@@ -23587,7 +25010,7 @@ ${lines.join(`
       notes: exports_external.string().optional().describe("Notes about what was done")
     }, async ({ task_id, minutes, agent_id, started_at, ended_at, notes }) => {
       try {
-        const { logTime: logTime2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { logTime: logTime2 } = (init_tasks(), __toCommonJS(exports_tasks));
         logTime2({ task_id: resolveId(task_id), minutes, agent_id, started_at, ended_at, notes });
         return { content: [{ type: "text", text: `Logged ${minutes} min on task ${task_id.slice(0, 8)}` }] };
       } catch (e) {
@@ -23602,7 +25025,7 @@ ${lines.join(`
       since: exports_external.string().optional().describe("ISO date \u2014 only tasks completed after this date")
     }, async ({ project_id, agent_id, since }) => {
       try {
-        const { getTimeReport: getTimeReport2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { getTimeReport: getTimeReport2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const report = getTimeReport2({ project_id: project_id ? resolveId(project_id, "projects") : undefined, agent_id, since });
         if (report.length === 0)
           return { content: [{ type: "text", text: "No completed tasks found." }] };
@@ -23626,7 +25049,7 @@ ${lines.join(`
       agent_id: exports_external.string().optional().describe("Agent subscribing (defaults to context agent)")
     }, async ({ task_id, agent_id }) => {
       try {
-        const { watchTask: watchTask2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { watchTask: watchTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         watchTask2(resolveId(task_id), agent_id || "");
         return { content: [{ type: "text", text: `Now watching task ${task_id.slice(0, 8)}` }] };
       } catch (e) {
@@ -23640,7 +25063,7 @@ ${lines.join(`
       agent_id: exports_external.string().optional().describe("Agent unsubscribing (defaults to context agent)")
     }, async ({ task_id, agent_id }) => {
       try {
-        const { unwatchTask: unwatchTask2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { unwatchTask: unwatchTask2 } = (init_tasks(), __toCommonJS(exports_tasks));
         unwatchTask2(resolveId(task_id), agent_id || "");
         return { content: [{ type: "text", text: `Stopped watching task ${task_id.slice(0, 8)}` }] };
       } catch (e) {
@@ -23653,7 +25076,7 @@ ${lines.join(`
       task_id: exports_external.string().describe("Task ID")
     }, async ({ task_id }) => {
       try {
-        const { getTaskWatchers: getTaskWatchers2 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { getTaskWatchers: getTaskWatchers2 } = (init_tasks(), __toCommonJS(exports_tasks));
         const watchers = getTaskWatchers2(resolveId(task_id));
         if (watchers.length === 0)
           return { content: [{ type: "text", text: "No watchers." }] };
@@ -23672,15 +25095,15 @@ ${lines.join(`
       agent_id: exports_external.string().optional().describe("Filter by assignee")
     }, async ({ project_id, plan_id, task_list_id, since, agent_id }) => {
       try {
-        const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
-        const { patrolTasks } = (()=>{throw new Error("Cannot require module "+"../db/patrol.js");})();
+        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
+        const { patrolTasks: patrolTasks2 } = (init_patrol(), __toCommonJS(exports_patrol));
         const completed = listTasks3({ status: "completed", project_id, plan_id, task_list_id, assigned_to: agent_id, limit: 500 }, undefined);
         const filtered = since ? completed.filter((t) => t.completed_at && t.completed_at >= since) : completed;
         const total = filtered.length;
         const lowConf = filtered.filter((t) => t.confidence != null && t.confidence < 0.7).length;
         const withEstimate = filtered.filter((t) => t.estimated_minutes != null && t.actual_minutes != null);
         const avgDiff = withEstimate.length > 0 ? withEstimate.reduce((acc, t) => acc + (t.actual_minutes - t.estimated_minutes), 0) / withEstimate.length : 0;
-        const patrolResult = patrolTasks({ project_id: project_id ? resolveId(project_id, "projects") : undefined });
+        const patrolResult = patrolTasks2({ project_id: project_id ? resolveId(project_id, "projects") : undefined });
         const stuck = patrolResult.issues.filter((i) => i.type === "stuck").length;
         const lines = [
           `Retro (${total} completed tasks${since ? ` since ${since}` : ""})`,
@@ -23701,7 +25124,7 @@ ${lines.join(`
       limit: exports_external.number().optional().describe("Max results (default: 20)")
     }, async ({ project_id, limit }) => {
       try {
-        const { listTasks: listTasks3 } = (()=>{throw new Error("Cannot require module "+"../db/tasks.js");})();
+        const { listTasks: listTasks3 } = (init_tasks(), __toCommonJS(exports_tasks));
         const tasks = listTasks3({ status: "pending", project_id, assigned_to: "", limit: limit || 20 }, undefined);
         if (tasks.length === 0)
           return { content: [{ type: "text", text: "Inbox is empty." }] };
@@ -23720,8 +25143,8 @@ ${lines.join(`
       project_id: exports_external.string().optional().describe("Filter by project")
     }, async ({ agent_id, project_id }) => {
       try {
-        const { getAgentMetrics } = (()=>{throw new Error("Cannot require module "+"../db/agent-metrics.js");})();
-        const metrics = getAgentMetrics(agent_id, {
+        const { getAgentMetrics: getAgentMetrics2 } = (init_agent_metrics(), __toCommonJS(exports_agent_metrics));
+        const metrics = getAgentMetrics2(agent_id, {
           project_id: project_id ? resolveId(project_id, "projects") : undefined
         });
         if (!metrics)
@@ -23748,8 +25171,8 @@ ${lines.join(`
       limit: exports_external.number().optional().describe("Max entries (default: 20)")
     }, async ({ project_id, limit }) => {
       try {
-        const { getLeaderboard } = (()=>{throw new Error("Cannot require module "+"../db/agent-metrics.js");})();
-        const entries = getLeaderboard({
+        const { getLeaderboard: getLeaderboard2 } = (init_agent_metrics(), __toCommonJS(exports_agent_metrics));
+        const entries = getLeaderboard2({
           project_id: project_id ? resolveId(project_id, "projects") : undefined,
           limit
         });
@@ -23999,15 +25422,373 @@ ${lines.join(`
   }
 }
 
+// src/mcp/tools/agents.ts
+init_agents();
+init_config2();
+init_database();
+function registerAgentTools(server, { shouldRegisterTool, resolveId, formatError, agentFocusMap, getAgentFocus }) {
+  if (shouldRegisterTool("set_focus")) {
+    server.tool("set_focus", "Focus this agent on a project. All list/search/status tools will default to this project.", {
+      agent_id: exports_external.string().describe("Agent ID or name"),
+      project_id: exports_external.string().optional().describe("Project to focus on. Omit to clear."),
+      task_list_id: exports_external.string().optional().describe("Task list to focus on")
+    }, async ({ agent_id, project_id, task_list_id }) => {
+      try {
+        const resolvedProject = project_id ? resolveId(project_id, "projects") : undefined;
+        const focus = { agent_id, project_id: resolvedProject, task_list_id };
+        agentFocusMap.set(agent_id, focus);
+        try {
+          const agent = getAgentByName(agent_id) || getAgent(agent_id);
+          if (agent) {
+            const db = getDatabase();
+            db.run("UPDATE agents SET active_project_id = ? WHERE id = ?", [resolvedProject || null, agent.id]);
+          }
+        } catch {}
+        const projectName = resolvedProject ? ` (${resolvedProject.slice(0, 8)})` : "";
+        return { content: [{ type: "text", text: `Focused on project${projectName}. Read tools will default to this scope. Pass explicit project_id to override.` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("get_focus")) {
+    server.tool("get_focus", "Get the current focus for an agent.", { agent_id: exports_external.string().describe("Agent ID or name") }, async ({ agent_id }) => {
+      const focus = getAgentFocus(agent_id);
+      if (!focus?.project_id) {
+        return { content: [{ type: "text", text: "No focus set. Showing all projects." }] };
+      }
+      return { content: [{ type: "text", text: `Focused on project: ${focus.project_id}${focus.task_list_id ? `, task list: ${focus.task_list_id}` : ""}` }] };
+    });
+  }
+  if (shouldRegisterTool("unfocus")) {
+    server.tool("unfocus", "Clear focus \u2014 show all projects and tasks.", { agent_id: exports_external.string().describe("Agent ID or name") }, async ({ agent_id }) => {
+      agentFocusMap.delete(agent_id);
+      try {
+        const agent = getAgentByName(agent_id) || getAgent(agent_id);
+        if (agent) {
+          const db = getDatabase();
+          db.run("UPDATE agents SET active_project_id = NULL WHERE id = ?", [agent.id]);
+        }
+      } catch {}
+      return { content: [{ type: "text", text: "Focus cleared. Showing all projects." }] };
+    });
+  }
+  if (shouldRegisterTool("register_agent")) {
+    server.tool("register_agent", "Register an agent. Any name is allowed \u2014 the configured pool is advisory, not enforced. Returns a conflict error if the name is held by a recently-active agent.", {
+      name: exports_external.string().describe("Agent name \u2014 any name is allowed. Use suggest_agent_name to see pool suggestions and avoid conflicts."),
+      description: exports_external.string().optional(),
+      role: exports_external.string().optional(),
+      title: exports_external.string().optional(),
+      level: exports_external.string().optional(),
+      permissions: exports_external.array(exports_external.string()).optional(),
+      capabilities: exports_external.array(exports_external.string()).optional().describe("Agent capabilities/skills for task routing (e.g. ['typescript', 'testing', 'devops'])"),
+      session_id: exports_external.string().optional().describe("Unique ID for this coding session (e.g. process PID + timestamp, or env var). Used to detect name collisions across sessions. Store it and pass on every register_agent call."),
+      working_dir: exports_external.string().optional().describe("Working directory of this session \u2014 used to look up the project's agent pool and identify who holds the name in a conflict"),
+      force: exports_external.boolean().optional().describe("Force takeover of an active agent's name. Use with caution \u2014 only when you know the previous session is dead.")
+    }, async ({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force }) => {
+      try {
+        const pool = getAgentPoolForProject(working_dir);
+        const result = registerAgent({ name, description, role, title, level, permissions, capabilities, session_id, working_dir, force, pool: pool || undefined });
+        if (isAgentConflict(result)) {
+          const suggestLine = result.suggestions && result.suggestions.length > 0 ? `
+Available names: ${result.suggestions.join(", ")}` : "";
+          const hint = `CONFLICT: ${result.message}${suggestLine}`;
+          return {
+            content: [{ type: "text", text: hint }],
+            isError: true
+          };
+        }
+        const agent = result;
+        const poolLine = pool ? `
+Pool: [${pool.join(", ")}]` : "";
+        return {
+          content: [{
+            type: "text",
+            text: `Agent registered:
+ID: ${agent.id}
+Name: ${agent.name}${agent.description ? `
+Description: ${agent.description}` : ""}
+Session: ${agent.session_id ?? "unbound"}${poolLine}
+Created: ${agent.created_at}
+Last seen: ${agent.last_seen_at}`
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("suggest_agent_name")) {
+    server.tool("suggest_agent_name", "Get available agent names for a project. Shows configured pool, active agents, and suggestions. If no pool is configured, any name is allowed.", {
+      working_dir: exports_external.string().optional().describe("Your working directory \u2014 used to look up the project's allowed name pool from config")
+    }, async ({ working_dir }) => {
+      try {
+        const pool = getAgentPoolForProject(working_dir);
+        const cutoff = new Date(Date.now() - 30 * 60 * 1000).toISOString();
+        const allActive = listAgents().filter((a) => a.last_seen_at > cutoff);
+        if (!pool) {
+          const lines2 = [
+            "No agent pool configured \u2014 any name is allowed.",
+            allActive.length > 0 ? `Active agents (avoid these names): ${allActive.map((a) => `${a.name} (seen ${Math.round((Date.now() - new Date(a.last_seen_at).getTime()) / 60000)}m ago)`).join(", ")}` : "No active agents.",
+            `
+To restrict names, configure agent_pool or project_pools in ~/.hasna/todos/config.json`
+          ];
+          return { content: [{ type: "text", text: lines2.join(`
+`) }] };
+        }
+        const available = getAvailableNamesFromPool(pool, getDatabase());
+        const activeInPool = allActive.filter((a) => pool.map((n) => n.toLowerCase()).includes(a.name));
+        const lines = [
+          `Project pool: ${pool.join(", ")}`,
+          `Available now (${available.length}): ${available.length > 0 ? available.join(", ") : "none \u2014 all names in use"}`,
+          activeInPool.length > 0 ? `Active agents: ${activeInPool.map((a) => `${a.name} (seen ${Math.round((Date.now() - new Date(a.last_seen_at).getTime()) / 60000)}m ago)`).join(", ")}` : "Active agents: none",
+          available.length > 0 ? `
+Suggested: ${available[0]}` : `
+No names available. Wait for an active agent to go stale (30min timeout).`
+        ];
+        return { content: [{ type: "text", text: lines.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("list_agents")) {
+    server.tool("list_agents", "List all registered agents. By default shows only active agents \u2014 set include_archived to see archived ones too.", {
+      include_archived: exports_external.boolean().optional().describe("Include archived agents in the list (default: false)")
+    }, async ({ include_archived }) => {
+      try {
+        const agents = listAgents({ include_archived: include_archived ?? false });
+        if (agents.length === 0) {
+          return { content: [{ type: "text", text: "No agents registered." }] };
+        }
+        const text = agents.map((a) => {
+          const statusTag = a.status === "archived" ? " [archived]" : "";
+          return `${a.id} | ${a.name}${statusTag}${a.description ? ` - ${a.description}` : ""} (last seen: ${a.last_seen_at})`;
+        }).join(`
+`);
+        return { content: [{ type: "text", text: `${agents.length} agent(s):
+${text}` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("get_agent")) {
+    server.tool("get_agent", "Get agent details by ID or name. Provide one of id or name.", {
+      agent_id: exports_external.string().optional(),
+      id: exports_external.string().optional(),
+      name: exports_external.string().optional()
+    }, async ({ agent_id, id, name }) => {
+      try {
+        const identifier = agent_id || id || name;
+        if (!identifier) {
+          return { content: [{ type: "text", text: "Provide agent_id, id, or name." }], isError: true };
+        }
+        const agent = getAgent(identifier) || getAgentByName(identifier);
+        if (!agent) {
+          return { content: [{ type: "text", text: `Agent not found: ${identifier}` }], isError: true };
+        }
+        const parts = [
+          `ID: ${agent.id}`,
+          `Name: ${agent.name}`
+        ];
+        if (agent.description)
+          parts.push(`Description: ${agent.description}`);
+        if (Object.keys(agent.metadata).length > 0)
+          parts.push(`Metadata: ${JSON.stringify(agent.metadata)}`);
+        parts.push(`Created: ${agent.created_at}`);
+        parts.push(`Last seen: ${agent.last_seen_at}`);
+        return { content: [{ type: "text", text: parts.join(`
+`) }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("rename_agent")) {
+    server.tool("rename_agent", "Rename an agent. Resolve by id or current name.", {
+      id: exports_external.string().optional(),
+      name: exports_external.string().optional(),
+      new_name: exports_external.string()
+    }, async ({ id, name, new_name }) => {
+      try {
+        if (!id && !name) {
+          return { content: [{ type: "text", text: "Provide either id or name." }], isError: true };
+        }
+        const agent = id ? getAgent(id) : getAgentByName(name);
+        if (!agent) {
+          return { content: [{ type: "text", text: `Agent not found: ${id || name}` }], isError: true };
+        }
+        const oldName = agent.name;
+        const updated = updateAgent(agent.id, { name: new_name });
+        const db = getDatabase();
+        const tasksResult = db.run("UPDATE tasks SET assigned_to = ? WHERE assigned_to = ?", [new_name, oldName]);
+        const taskNote = tasksResult.changes > 0 ? `
+Updated assigned_to on ${tasksResult.changes} task(s).` : "";
+        return {
+          content: [{
+            type: "text",
+            text: `Agent renamed: ${oldName} -> ${updated.name}
+ID: ${updated.id}${taskNote}`
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("update_agent")) {
+    server.tool("update_agent", "Update an agent's description, role, title, or other metadata. Resolve by id or name.", {
+      agent_id: exports_external.string().optional(),
+      id: exports_external.string().optional(),
+      name: exports_external.string().optional(),
+      description: exports_external.string().optional(),
+      role: exports_external.string().optional(),
+      title: exports_external.string().optional(),
+      level: exports_external.string().optional(),
+      capabilities: exports_external.array(exports_external.string()).optional(),
+      permissions: exports_external.array(exports_external.string()).optional(),
+      metadata: exports_external.record(exports_external.unknown()).optional()
+    }, async ({ agent_id, id, name, ...updates }) => {
+      try {
+        const identifier = agent_id || id || name;
+        if (!identifier) {
+          return { content: [{ type: "text", text: "Provide agent_id, id, or name." }], isError: true };
+        }
+        const agent = getAgent(identifier) || getAgentByName(identifier);
+        if (!agent) {
+          return { content: [{ type: "text", text: `Agent not found: ${identifier}` }], isError: true };
+        }
+        const updated = updateAgent(agent.id, updates);
+        return { content: [{ type: "text", text: `Agent updated: ${updated.name} (${updated.id.slice(0, 8)})` }] };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("delete_agent")) {
+    server.tool("delete_agent", "Archive an agent (soft delete). The agent is hidden from list_agents but preserved for task history. Use unarchive_agent to restore. Resolve by id or name.", {
+      agent_id: exports_external.string().optional(),
+      id: exports_external.string().optional(),
+      name: exports_external.string().optional()
+    }, async ({ agent_id, id, name }) => {
+      try {
+        const identifier = agent_id || id || name;
+        if (!identifier) {
+          return { content: [{ type: "text", text: "Provide agent_id, id, or name." }], isError: true };
+        }
+        const agent = getAgent(identifier) || getAgentByName(identifier);
+        if (!agent) {
+          return { content: [{ type: "text", text: `Agent not found: ${identifier}` }], isError: true };
+        }
+        const archived = archiveAgent(agent.id);
+        return {
+          content: [{
+            type: "text",
+            text: archived ? `Agent archived: ${agent.name} (${agent.id}). Use unarchive_agent to restore.` : `Failed to archive agent: ${agent.name}`
+          }],
+          isError: !archived
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("unarchive_agent")) {
+    server.tool("unarchive_agent", "Restore an archived agent back to active status. Resolve by id or name.", {
+      agent_id: exports_external.string().optional(),
+      id: exports_external.string().optional(),
+      name: exports_external.string().optional()
+    }, async ({ agent_id, id, name }) => {
+      try {
+        const identifier = agent_id || id || name;
+        if (!identifier) {
+          return { content: [{ type: "text", text: "Provide agent_id, id, or name." }], isError: true };
+        }
+        const agent = getAgent(identifier) || getAgentByName(identifier);
+        if (!agent) {
+          return { content: [{ type: "text", text: `Agent not found: ${identifier}` }], isError: true };
+        }
+        if (agent.status === "active") {
+          return { content: [{ type: "text", text: `Agent ${agent.name} is already active.` }] };
+        }
+        const restored = unarchiveAgent(agent.id);
+        return {
+          content: [{
+            type: "text",
+            text: restored ? `Agent restored: ${agent.name} (${agent.id}) is now active.` : `Failed to restore agent: ${agent.name}`
+          }],
+          isError: !restored
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("heartbeat")) {
+    server.tool("heartbeat", "Update your last_seen_at timestamp to signal you're still active. Call periodically during long tasks to prevent being marked stale.", {
+      agent_id: exports_external.string().describe("Your agent ID or name.")
+    }, async ({ agent_id }) => {
+      try {
+        const agent = getAgent(agent_id) || getAgentByName(agent_id);
+        if (!agent) {
+          return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
+        }
+        updateAgentActivity(agent.id);
+        return {
+          content: [{
+            type: "text",
+            text: `Heartbeat: ${agent.name} (${agent.id}) \u2014 last_seen_at updated to ${new Date().toISOString()}`
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+  if (shouldRegisterTool("release_agent")) {
+    server.tool("release_agent", "Explicitly release/logout an agent \u2014 clears session binding and makes the name immediately available. Call this when your session ends instead of waiting for the 30-minute stale timeout.", {
+      agent_id: exports_external.string().describe("Your agent ID or name."),
+      session_id: exports_external.string().optional().describe("Your session ID \u2014 if provided, release only succeeds if it matches (prevents other sessions from releasing your agent).")
+    }, async ({ agent_id, session_id }) => {
+      try {
+        const agent = getAgent(agent_id) || getAgentByName(agent_id);
+        if (!agent) {
+          return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
+        }
+        const released = releaseAgent(agent.id, session_id);
+        if (!released) {
+          return { content: [{ type: "text", text: `Release denied: session_id does not match agent's current session.` }], isError: true };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Agent released: ${agent.name} (${agent.id}) \u2014 session cleared, name is now available.`
+          }]
+        };
+      } catch (e) {
+        return { content: [{ type: "text", text: formatError(e) }], isError: true };
+      }
+    });
+  }
+}
+
 // src/mcp/index.ts
 function getMcpVersion() {
   try {
-    const __dir = dirname3(fileURLToPath(import.meta.url));
-    const pkgPath = join10(__dir, "..", "package.json");
-    return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
+    let dir = dirname3(fileURLToPath(import.meta.url));
+    for (let i = 0;i < 4; i++) {
+      const pkgPath = join10(dir, "package.json");
+      if (existsSync10(pkgPath)) {
+        return JSON.parse(readFileSync6(pkgPath, "utf-8")).version || "0.0.0";
+      }
+      dir = dirname3(dir);
+    }
   } catch {
     return "0.0.0";
   }
+  return "0.0.0";
 }
 var server = new McpServer({
   name: "todos",
@@ -24026,6 +25807,7 @@ var MINIMAL_TOOLS = new Set([
   "get_next_task",
   "bootstrap",
   "get_tasks_changed_since",
+  "get_health",
   "heartbeat",
   "release_agent"
 ]);
@@ -24204,6 +25986,7 @@ registerTaskMetaTools(server, toolContext);
 registerTaskResources(server, toolContext);
 registerTaskRelTools(server, toolContext);
 registerCodeTools(server, toolContext);
+registerAgentTools(server, { ...toolContext, agentFocusMap });
 registerMachineTools(server, { shouldRegisterTool, formatError });
 registerDispatchTools(server, { shouldRegisterTool, resolveId, formatError });
 registerCloudSyncTools(server, { shouldRegisterTool, formatError });