@hasna/todos 0.9.82 → 0.10.1

package/dist/mcp/index.js

@@ -220,6 +220,30 @@ function ensureSchema(db) {
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
       updated_at TEXT NOT NULL DEFAULT (datetime('now'))
     )`);
+  ensureTable("task_relationships", `
+    CREATE TABLE task_relationships (
+      id TEXT PRIMARY KEY,
+      source_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      target_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      relationship_type TEXT NOT NULL,
+      metadata TEXT DEFAULT '{}',
+      created_by TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      CHECK (source_task_id != target_task_id)
+    )`);
+  ensureTable("kg_edges", `
+    CREATE TABLE kg_edges (
+      id TEXT PRIMARY KEY,
+      source_id TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      target_id TEXT NOT NULL,
+      target_type TEXT NOT NULL,
+      relation_type TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 1.0,
+      metadata TEXT DEFAULT '{}',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(source_id, source_type, target_id, target_type, relation_type)
+    )`);
   ensureColumn("projects", "task_list_id", "TEXT");
   ensureColumn("projects", "task_prefix", "TEXT");
   ensureColumn("projects", "task_counter", "INTEGER NOT NULL DEFAULT 0");
@@ -244,6 +268,7 @@ function ensureSchema(db) {
   ensureColumn("agents", "title", "TEXT");
   ensureColumn("agents", "level", "TEXT");
   ensureColumn("agents", "org_id", "TEXT");
+  ensureColumn("agents", "capabilities", "TEXT DEFAULT '[]'");
   ensureColumn("projects", "org_id", "TEXT");
   ensureColumn("plans", "task_list_id", "TEXT");
   ensureColumn("plans", "agent_id", "TEXT");
@@ -270,6 +295,12 @@ function ensureSchema(db) {
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_sources_project ON project_sources(project_id)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_project_sources_type ON project_sources(type)");
   ensureIndex("CREATE INDEX IF NOT EXISTS idx_tasks_assigned_by ON tasks(assigned_by)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_rel_source ON task_relationships(source_task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_rel_target ON task_relationships(target_task_id)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_task_rel_type ON task_relationships(relationship_type)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_source ON kg_edges(source_id, source_type)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_target ON kg_edges(target_id, target_type)");
+  ensureIndex("CREATE INDEX IF NOT EXISTS idx_kg_relation ON kg_edges(relation_type)");
 }
 function backfillTaskTags(db) {
   try {
@@ -730,6 +761,44 @@ var init_database = __esm(() => {
   ALTER TABLE tasks ADD COLUMN assigned_from_project TEXT;
   CREATE INDEX IF NOT EXISTS idx_tasks_assigned_by ON tasks(assigned_by);
   INSERT OR IGNORE INTO _migrations (id) VALUES (26);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS task_relationships (
+    id TEXT PRIMARY KEY,
+    source_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    target_task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    relationship_type TEXT NOT NULL CHECK(relationship_type IN ('related_to', 'conflicts_with', 'similar_to', 'duplicates', 'supersedes', 'modifies_same_file')),
+    metadata TEXT DEFAULT '{}',
+    created_by TEXT,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    CHECK (source_task_id != target_task_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_task_rel_source ON task_relationships(source_task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_rel_target ON task_relationships(target_task_id);
+  CREATE INDEX IF NOT EXISTS idx_task_rel_type ON task_relationships(relationship_type);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (27);
+  `,
+    `
+  CREATE TABLE IF NOT EXISTS kg_edges (
+    id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL,
+    source_type TEXT NOT NULL,
+    target_id TEXT NOT NULL,
+    target_type TEXT NOT NULL,
+    relation_type TEXT NOT NULL,
+    weight REAL NOT NULL DEFAULT 1.0,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE(source_id, source_type, target_id, target_type, relation_type)
+  );
+  CREATE INDEX IF NOT EXISTS idx_kg_source ON kg_edges(source_id, source_type);
+  CREATE INDEX IF NOT EXISTS idx_kg_target ON kg_edges(target_id, target_type);
+  CREATE INDEX IF NOT EXISTS idx_kg_relation ON kg_edges(relation_type);
+  INSERT OR IGNORE INTO _migrations (id) VALUES (28);
+  `,
+    `
+  ALTER TABLE agents ADD COLUMN capabilities TEXT DEFAULT '[]';
+  INSERT OR IGNORE INTO _migrations (id) VALUES (29);
   `
   ];
 });
@@ -885,14 +954,22 @@ __export(exports_agents, {
   updateAgentActivity: () => updateAgentActivity,
   updateAgent: () => updateAgent,
   registerAgent: () => registerAgent,
+  matchCapabilities: () => matchCapabilities,
   listAgents: () => listAgents,
   isAgentConflict: () => isAgentConflict,
   getOrgChart: () => getOrgChart,
   getDirectReports: () => getDirectReports,
+  getCapableAgents: () => getCapableAgents,
+  getAvailableNamesFromPool: () => getAvailableNamesFromPool,
   getAgentByName: () => getAgentByName,
   getAgent: () => getAgent,
   deleteAgent: () => deleteAgent
 });
+function getAvailableNamesFromPool(pool, db) {
+  const cutoff = new Date(Date.now() - AGENT_ACTIVE_WINDOW_MS).toISOString();
+  const activeNames = new Set(db.query("SELECT name FROM agents WHERE last_seen_at > ?").all(cutoff).map((r) => r.name.toLowerCase()));
+  return pool.filter((name) => !activeNames.has(name.toLowerCase()));
+}
 function shortUuid() {
   return crypto.randomUUID().slice(0, 8);
 }
@@ -900,12 +977,31 @@ function rowToAgent(row) {
   return {
     ...row,
     permissions: JSON.parse(row.permissions || '["*"]'),
+    capabilities: JSON.parse(row.capabilities || "[]"),
     metadata: JSON.parse(row.metadata || "{}")
   };
 }
 function registerAgent(input, db) {
   const d = db || getDatabase();
   const normalizedName = input.name.trim().toLowerCase();
+  if (input.pool && input.pool.length > 0) {
+    const poolLower = input.pool.map((n) => n.toLowerCase());
+    if (!poolLower.includes(normalizedName)) {
+      const available = getAvailableNamesFromPool(input.pool, d);
+      const suggestion = available.length > 0 ? available[0] : null;
+      return {
+        conflict: true,
+        pool_violation: true,
+        existing_id: "",
+        existing_name: normalizedName,
+        last_seen_at: "",
+        session_hint: null,
+        working_dir: input.working_dir || null,
+        suggestions: available.slice(0, 5),
+        message: `"${normalizedName}" is not in this project's agent pool [${input.pool.join(", ")}]. ${available.length > 0 ? `Try: ${available.slice(0, 3).join(", ")}` : "No names are currently available \u2014 wait for an active agent to go stale."}${suggestion ? ` Suggested: ${suggestion}` : ""}`
+      };
+    }
+  }
   const existing = getAgentByName(normalizedName, d);
   if (existing) {
     const lastSeenMs = new Date(existing.last_seen_at).getTime();
@@ -914,6 +1010,7 @@ function registerAgent(input, db) {
     const differentSession = input.session_id && existing.session_id && input.session_id !== existing.session_id;
     if (isActive && differentSession) {
       const minutesAgo = Math.round((Date.now() - lastSeenMs) / 60000);
+      const suggestions = input.pool ? getAvailableNamesFromPool(input.pool, d) : [];
       return {
         conflict: true,
         existing_id: existing.id,
@@ -921,7 +1018,8 @@ function registerAgent(input, db) {
         last_seen_at: existing.last_seen_at,
         session_hint: existing.session_id ? existing.session_id.slice(0, 8) : null,
         working_dir: existing.working_dir,
-        message: `Agent "${normalizedName}" is already active (last seen ${minutesAgo}m ago, session ${existing.session_id?.slice(0, 8)}\u2026, dir: ${existing.working_dir ?? "unknown"}). Are you that agent? If so, pass session_id="${existing.session_id}" to reclaim it. Otherwise choose a different name.`
+        suggestions: suggestions.slice(0, 5),
+        message: `Agent "${normalizedName}" is already active (last seen ${minutesAgo}m ago, session ${existing.session_id?.slice(0, 8)}\u2026, dir: ${existing.working_dir ?? "unknown"}). Are you that agent? If so, pass session_id="${existing.session_id}" to reclaim it. Otherwise choose a different name.${suggestions.length > 0 ? ` Available: ${suggestions.slice(0, 3).join(", ")}` : ""}`
       };
     }
     const updates = ["last_seen_at = ?"];
@@ -944,8 +1042,8 @@ function registerAgent(input, db) {
   }
   const id = shortUuid();
   const timestamp = now();
-  d.run(`INSERT INTO agents (id, name, description, role, title, level, permissions, reports_to, org_id, metadata, created_at, last_seen_at, session_id, working_dir)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+  d.run(`INSERT INTO agents (id, name, description, role, title, level, permissions, capabilities, reports_to, org_id, metadata, created_at, last_seen_at, session_id, working_dir)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
     id,
     normalizedName,
     input.description || null,
@@ -953,6 +1051,7 @@ function registerAgent(input, db) {
     input.title || null,
     input.level || null,
     JSON.stringify(input.permissions || ["*"]),
+    JSON.stringify(input.capabilities || []),
     input.reports_to || null,
     input.org_id || null,
     JSON.stringify(input.metadata || {}),
@@ -1008,6 +1107,10 @@ function updateAgent(id, input, db) {
     sets.push("permissions = ?");
     params.push(JSON.stringify(input.permissions));
   }
+  if (input.capabilities !== undefined) {
+    sets.push("capabilities = ?");
+    params.push(JSON.stringify(input.capabilities));
+  }
   if (input.title !== undefined) {
     sets.push("title = ?");
     params.push(input.title);
@@ -1055,6 +1158,28 @@ function getOrgChart(db) {
   }
   return buildTree(null);
 }
+function matchCapabilities(agentCapabilities, requiredCapabilities) {
+  if (requiredCapabilities.length === 0)
+    return 1;
+  if (agentCapabilities.length === 0)
+    return 0;
+  const agentSet = new Set(agentCapabilities.map((c) => c.toLowerCase()));
+  let matches = 0;
+  for (const req of requiredCapabilities) {
+    if (agentSet.has(req.toLowerCase()))
+      matches++;
+  }
+  return matches / requiredCapabilities.length;
+}
+function getCapableAgents(capabilities, opts, db) {
+  const agents = listAgents(db);
+  const minScore = opts?.min_score ?? 0.1;
+  const scored = agents.map((agent) => ({
+    agent,
+    score: matchCapabilities(agent.capabilities, capabilities)
+  })).filter((entry) => entry.score >= minScore).sort((a, b) => b.score - a.score);
+  return opts?.limit ? scored.slice(0, opts.limit) : scored;
+}
 var AGENT_ACTIVE_WINDOW_MS;
 var init_agents = __esm(() => {
   init_database();
@@ -1195,6 +1320,584 @@ var init_handoffs = __esm(() => {
   init_database();
 });
 
+// src/db/task-relationships.ts
+var exports_task_relationships = {};
+__export(exports_task_relationships, {
+  removeTaskRelationshipByPair: () => removeTaskRelationshipByPair,
+  removeTaskRelationship: () => removeTaskRelationship,
+  getTaskRelationships: () => getTaskRelationships,
+  getTaskRelationship: () => getTaskRelationship,
+  findRelatedTaskIds: () => findRelatedTaskIds,
+  autoDetectFileRelationships: () => autoDetectFileRelationships,
+  addTaskRelationship: () => addTaskRelationship,
+  RELATIONSHIP_TYPES: () => RELATIONSHIP_TYPES
+});
+function rowToRelationship(row) {
+  return {
+    ...row,
+    relationship_type: row.relationship_type,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function addTaskRelationship(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const timestamp = now();
+  if (input.source_task_id === input.target_task_id) {
+    throw new Error("Cannot create a relationship between a task and itself");
+  }
+  const symmetric = ["related_to", "conflicts_with", "similar_to", "modifies_same_file"];
+  if (symmetric.includes(input.relationship_type)) {
+    const existing = d.query(`SELECT id FROM task_relationships
+       WHERE relationship_type = ?
+         AND ((source_task_id = ? AND target_task_id = ?) OR (source_task_id = ? AND target_task_id = ?))`).get(input.relationship_type, input.source_task_id, input.target_task_id, input.target_task_id, input.source_task_id);
+    if (existing) {
+      return getTaskRelationship(existing.id, d);
+    }
+  } else {
+    const existing = d.query("SELECT id FROM task_relationships WHERE source_task_id = ? AND target_task_id = ? AND relationship_type = ?").get(input.source_task_id, input.target_task_id, input.relationship_type);
+    if (existing) {
+      return getTaskRelationship(existing.id, d);
+    }
+  }
+  d.run(`INSERT INTO task_relationships (id, source_task_id, target_task_id, relationship_type, metadata, created_by, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.source_task_id,
+    input.target_task_id,
+    input.relationship_type,
+    JSON.stringify(input.metadata || {}),
+    input.created_by || null,
+    timestamp
+  ]);
+  return getTaskRelationship(id, d);
+}
+function getTaskRelationship(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM task_relationships WHERE id = ?").get(id);
+  return row ? rowToRelationship(row) : null;
+}
+function removeTaskRelationship(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM task_relationships WHERE id = ?", [id]).changes > 0;
+}
+function removeTaskRelationshipByPair(sourceTaskId, targetTaskId, relationshipType, db) {
+  const d = db || getDatabase();
+  const symmetric = ["related_to", "conflicts_with", "similar_to", "modifies_same_file"];
+  if (symmetric.includes(relationshipType)) {
+    return d.run(`DELETE FROM task_relationships
+       WHERE relationship_type = ?
+         AND ((source_task_id = ? AND target_task_id = ?) OR (source_task_id = ? AND target_task_id = ?))`, [relationshipType, sourceTaskId, targetTaskId, targetTaskId, sourceTaskId]).changes > 0;
+  }
+  return d.run("DELETE FROM task_relationships WHERE source_task_id = ? AND target_task_id = ? AND relationship_type = ?", [sourceTaskId, targetTaskId, relationshipType]).changes > 0;
+}
+function getTaskRelationships(taskId, relationshipType, db) {
+  const d = db || getDatabase();
+  let sql = "SELECT * FROM task_relationships WHERE (source_task_id = ? OR target_task_id = ?)";
+  const params = [taskId, taskId];
+  if (relationshipType) {
+    sql += " AND relationship_type = ?";
+    params.push(relationshipType);
+  }
+  sql += " ORDER BY created_at DESC";
+  return d.query(sql).all(...params).map(rowToRelationship);
+}
+function findRelatedTaskIds(taskId, relationshipType, db) {
+  const rels = getTaskRelationships(taskId, relationshipType, db);
+  const ids = new Set;
+  for (const rel of rels) {
+    if (rel.source_task_id === taskId)
+      ids.add(rel.target_task_id);
+    else
+      ids.add(rel.source_task_id);
+  }
+  return [...ids];
+}
+function autoDetectFileRelationships(taskId, db) {
+  const d = db || getDatabase();
+  const files = d.query("SELECT path FROM task_files WHERE task_id = ? AND status != 'removed'").all(taskId);
+  const created = [];
+  for (const file of files) {
+    const others = d.query("SELECT DISTINCT task_id FROM task_files WHERE path = ? AND task_id != ? AND status != 'removed'").all(file.path, taskId);
+    for (const other of others) {
+      try {
+        const rel = addTaskRelationship({
+          source_task_id: taskId,
+          target_task_id: other.task_id,
+          relationship_type: "modifies_same_file",
+          metadata: { shared_file: file.path }
+        }, d);
+        created.push(rel);
+      } catch {}
+    }
+  }
+  return created;
+}
+var RELATIONSHIP_TYPES;
+var init_task_relationships = __esm(() => {
+  init_database();
+  RELATIONSHIP_TYPES = [
+    "related_to",
+    "conflicts_with",
+    "similar_to",
+    "duplicates",
+    "supersedes",
+    "modifies_same_file"
+  ];
+});
+
+// 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/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/mcp/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -5432,6 +6135,23 @@ function appendSyncConflict(metadata, conflict, limit = 5) {
 }
 
 // src/lib/config.ts
+var DEFAULT_AGENT_POOL = [
+  "maximus",
+  "cassius",
+  "aurelius",
+  "brutus",
+  "titus",
+  "nero",
+  "cicero",
+  "seneca",
+  "cato",
+  "julius",
+  "marcus",
+  "lucius",
+  "quintus",
+  "gaius",
+  "publius"
+];
 function getConfigPath() {
   return join3(process.env["HOME"] || HOME, ".todos", "config.json");
 }
@@ -5481,6 +6201,23 @@ var GUARD_DEFAULTS = {
   window_minutes: 10,
   cooldown_seconds: 60
 };
+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 || DEFAULT_AGENT_POOL;
+}
 function getCompletionGuardConfig(projectPath) {
   const config = loadConfig();
   const global = { ...GUARD_DEFAULTS, ...config.completion_guard };
@@ -8491,17 +9228,22 @@ if (shouldRegisterTool("unfocus")) {
   });
 }
 if (shouldRegisterTool("register_agent")) {
-  server.tool("register_agent", "Register an agent. Pass session_id (unique per coding session) to prevent name conflicts. Returns conflict error if name is taken by an active agent in a different session.", {
-    name: exports_external.string(),
+  server.tool("register_agent", "Register an agent. Name must be from the project's configured pool. Returns a conflict error with available name suggestions if the name is taken or not allowed.", {
+    name: exports_external.string().describe("Agent name \u2014 must be from the project's allowed pool (Roman names by default). Use suggest_agent_name first if unsure."),
     description: 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 helps identify who holds the name in a conflict")
-  }, async ({ name, description, session_id, working_dir }) => {
+    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")
+  }, async ({ name, description, capabilities, session_id, working_dir }) => {
     try {
-      const result = registerAgent({ name, description, session_id, working_dir });
+      const pool = getAgentPoolForProject(working_dir);
+      const result = registerAgent({ name, description, capabilities, session_id, working_dir, pool });
       if (isAgentConflict(result)) {
+        const suggestLine = result.suggestions && result.suggestions.length > 0 ? `
+Available names: ${result.suggestions.join(", ")}` : "";
+        const hint = result.pool_violation ? `POOL_VIOLATION: ${result.message}${suggestLine}` : `CONFLICT: ${result.message}${suggestLine}`;
         return {
-          content: [{ type: "text", text: `CONFLICT: ${result.message}` }],
+          content: [{ type: "text", text: hint }],
           isError: true
         };
       }
@@ -8514,6 +9256,7 @@ ID: ${agent.id}
 Name: ${agent.name}${agent.description ? `
 Description: ${agent.description}` : ""}
 Session: ${agent.session_id ?? "unbound"}
+Pool: [${pool.join(", ")}]
 Created: ${agent.created_at}
 Last seen: ${agent.last_seen_at}`
         }]
@@ -8523,6 +9266,30 @@ Last seen: ${agent.last_seen_at}`
     }
   });
 }
+if (shouldRegisterTool("suggest_agent_name")) {
+  server.tool("suggest_agent_name", "Get available agent names for a project. Call this before register_agent to avoid conflicts.", {
+    working_dir: exports_external.string().optional().describe("Your working directory \u2014 used to look up the project's allowed name pool")
+  }, async ({ working_dir }) => {
+    try {
+      const pool = getAgentPoolForProject(working_dir);
+      const available = getAvailableNamesFromPool(pool, getDatabase());
+      const cutoff = new Date(Date.now() - 30 * 60 * 1000).toISOString();
+      const active = listAgents().filter((a) => a.last_seen_at > cutoff && 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"}`,
+        active.length > 0 ? `Active agents: ${active.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 yet. 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", {}, async () => {
     try {
@@ -9715,6 +10482,7 @@ if (shouldRegisterTool("search_tools")) {
       "update_plan",
       "delete_plan",
       "register_agent",
+      "suggest_agent_name",
       "list_agents",
       "get_agent",
       "rename_agent",
@@ -9856,9 +10624,12 @@ if (shouldRegisterTool("describe_tools")) {
       delete_plan: `Delete a plan. Tasks in the plan are orphaned, not deleted.
   Params: id(string, req)
   Example: {id: 'a1b2c3d4'}`,
-      register_agent: `Register an agent. ALWAYS pass session_id (unique per session) to prevent name conflicts. Returns CONFLICT error if name is active in another session \u2014 pick a different name or reclaim with matching session_id.
-  Params: name(string, req), description(string), session_id(string \u2014 unique per session, e.g. PID+timestamp), working_dir(string)
-  Example: {name: 'maximus', session_id: 'abc123-1741952000', working_dir: '/workspace/platform'}`,
+      suggest_agent_name: `Get available agent names for your project before registering. Shows the pool, which names are active, and the best suggestion.
+  Params: working_dir(string \u2014 your working directory, used to look up project pool)
+  Example: {working_dir: '/workspace/platform'}`,
+      register_agent: `Register an agent. Name must be from the project's pool (call suggest_agent_name first). Returns CONFLICT or POOL_VIOLATION with suggestions if name is taken or not allowed.
+  Params: name(string, req), description(string), session_id(string \u2014 unique per session, e.g. PID+timestamp), working_dir(string, req \u2014 used to determine project pool)
+  Example: {name: 'cassius', session_id: 'abc123-1741952000', working_dir: '/workspace/platform'}`,
       list_agents: "List all registered agents with IDs, names, and last seen timestamps. No params.",
       get_agent: `Get agent details by ID or name. Provide one of id or name.
   Params: id(string), name(string)
@@ -10116,6 +10887,328 @@ if (shouldRegisterTool("get_latest_handoff")) {
     }
   });
 }
+if (shouldRegisterTool("add_task_relationship")) {
+  server.tool("add_task_relationship", "Create a semantic relationship between two tasks (related_to, conflicts_with, similar_to, duplicates, supersedes, modifies_same_file).", {
+    source_task_id: exports_external.string().describe("Source task ID"),
+    target_task_id: exports_external.string().describe("Target task ID"),
+    relationship_type: exports_external.enum(["related_to", "conflicts_with", "similar_to", "duplicates", "supersedes", "modifies_same_file"]).describe("Type of relationship"),
+    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 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
+      const rel = addTaskRelationship2({
+        source_task_id: resolveId(source_task_id),
+        target_task_id: resolveId(target_task_id),
+        relationship_type,
+        created_by
+      });
+      return { content: [{ type: "text", text: `Relationship created: ${rel.source_task_id.slice(0, 8)} --[${rel.relationship_type}]--> ${rel.target_task_id.slice(0, 8)}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("remove_task_relationship")) {
+  server.tool("remove_task_relationship", "Remove a semantic relationship between tasks by ID or by source+target+type.", {
+    id: exports_external.string().optional().describe("Relationship ID to remove"),
+    source_task_id: exports_external.string().optional().describe("Source task ID (use with target_task_id + type)"),
+    target_task_id: exports_external.string().optional().describe("Target task ID"),
+    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 } = (init_task_relationships(), __toCommonJS(exports_task_relationships));
+      let removed = false;
+      if (id) {
+        removed = removeTaskRelationship2(id);
+      } else if (source_task_id && target_task_id && relationship_type) {
+        removed = removeTaskRelationshipByPair2(resolveId(source_task_id), resolveId(target_task_id), relationship_type);
+      } else {
+        return { content: [{ type: "text", text: "Provide either 'id' or 'source_task_id + target_task_id + relationship_type'" }], isError: true };
+      }
+      return { content: [{ type: "text", text: removed ? "Relationship removed." : "Relationship not found." }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("get_task_relationships")) {
+  server.tool("get_task_relationships", "Get all semantic relationships for a task.", {
+    task_id: exports_external.string().describe("Task ID"),
+    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 } = (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." }] };
+      const lines = rels.map((r) => `${r.source_task_id.slice(0, 8)} --[${r.relationship_type}]--> ${r.target_task_id.slice(0, 8)}${r.metadata && Object.keys(r.metadata).length > 0 ? ` (${JSON.stringify(r.metadata)})` : ""}`);
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("detect_file_relationships")) {
+  server.tool("detect_file_relationships", "Auto-detect tasks that modify the same files and create modifies_same_file relationships.", {
+    task_id: exports_external.string().describe("Task ID to detect file relationships for")
+  }, async ({ task_id }) => {
+    try {
+      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) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("sync_kg")) {
+  server.tool("sync_kg", "Sync all existing relationships into the knowledge graph edges table. Idempotent.", {}, async () => {
+    try {
+      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 };
+    }
+  });
+}
+if (shouldRegisterTool("get_related_entities")) {
+  server.tool("get_related_entities", "Get entities related to a given entity in the knowledge graph.", {
+    entity_id: exports_external.string().describe("Entity ID (task, agent, project, file path)"),
+    relation_type: exports_external.string().optional().describe("Filter by relation type (depends_on, assigned_to, reports_to, references_file, in_project, in_plan, etc.)"),
+    entity_type: exports_external.string().optional().describe("Filter by entity type (task, agent, project, file, plan)"),
+    direction: exports_external.enum(["outgoing", "incoming", "both"]).optional().describe("Edge direction"),
+    limit: exports_external.number().optional().describe("Max results")
+  }, async ({ entity_id, relation_type, entity_type, direction, limit }) => {
+    try {
+      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})`);
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("find_path")) {
+  server.tool("find_path", "Find paths between two entities in the knowledge graph.", {
+    source_id: exports_external.string().describe("Starting entity ID"),
+    target_id: exports_external.string().describe("Target entity ID"),
+    max_depth: exports_external.number().optional().describe("Maximum path depth (default: 5)"),
+    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: 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) => {
+        const steps = path.map((e) => `${e.source_id.slice(0, 8)} --[${e.relation_type}]--> ${e.target_id.slice(0, 8)}`);
+        return `Path ${i + 1} (${path.length} hops):
+  ${steps.join(`
+  `)}`;
+      });
+      return { content: [{ type: "text", text: lines.join(`
+
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("get_impact_analysis")) {
+  server.tool("get_impact_analysis", "Analyze what entities are affected if a given entity changes. Traverses the knowledge graph.", {
+    entity_id: exports_external.string().describe("Entity ID to analyze impact for"),
+    max_depth: exports_external.number().optional().describe("Maximum traversal depth (default: 3)"),
+    relation_types: exports_external.array(exports_external.string()).optional().describe("Filter by relation types")
+  }, async ({ entity_id, max_depth, relation_types }) => {
+    try {
+      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;
+      for (const i of impact) {
+        if (!byDepth.has(i.depth))
+          byDepth.set(i.depth, []);
+        byDepth.get(i.depth).push(i);
+      }
+      const lines = [`Impact analysis: ${impact.length} affected entities`];
+      for (const [depth, entities] of [...byDepth.entries()].sort((a, b) => a[0] - b[0])) {
+        lines.push(`
+Depth ${depth}:`);
+        for (const e of entities) {
+          lines.push(`  ${e.entity_id.slice(0, 12)} (${e.entity_type}) via ${e.relation}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("get_critical_path")) {
+  server.tool("get_critical_path", "Find tasks that block the most downstream work (critical path analysis).", {
+    project_id: exports_external.string().optional().describe("Filter by project"),
+    limit: exports_external.number().optional().describe("Max results (default: 20)")
+  }, async ({ project_id, limit }) => {
+    try {
+      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}`);
+      return { content: [{ type: "text", text: `Critical path:
+${lines.join(`
+`)}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("get_capable_agents")) {
+  server.tool("get_capable_agents", "Find agents that match given capabilities, sorted by match score.", {
+    capabilities: exports_external.array(exports_external.string()).describe("Required capabilities to match against"),
+    min_score: exports_external.number().optional().describe("Minimum match score 0.0-1.0 (default: 0.1)"),
+    limit: exports_external.number().optional().describe("Max results")
+  }, async ({ capabilities, min_score, limit }) => {
+    try {
+      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." }] };
+      const lines = results.map((r) => `${r.agent.name} (${r.agent.id}) score:${(r.score * 100).toFixed(0)}% caps:[${r.agent.capabilities.join(",")}]`);
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("patrol_tasks")) {
+  server.tool("patrol_tasks", "Scan for task issues: stuck tasks, low-confidence completions, orphaned tasks, zombie-blocked tasks, and pending reviews.", {
+    stuck_minutes: exports_external.number().optional().describe("Minutes threshold for stuck detection (default: 60)"),
+    confidence_threshold: exports_external.number().optional().describe("Confidence threshold for low-confidence detection (default: 0.5)"),
+    project_id: exports_external.string().optional().describe("Filter by project")
+  }, async ({ stuck_minutes, confidence_threshold, project_id }) => {
+    try {
+      const { patrolTasks: patrolTasks2 } = (init_patrol(), __toCommonJS(exports_patrol));
+      const result = patrolTasks2({
+        stuck_minutes,
+        confidence_threshold,
+        project_id: project_id ? resolveId(project_id, "projects") : undefined
+      });
+      if (result.total_issues === 0)
+        return { content: [{ type: "text", text: "All clear \u2014 no issues detected." }] };
+      const lines = [`Found ${result.total_issues} issue(s):
+`];
+      for (const issue of result.issues) {
+        lines.push(`[${issue.severity.toUpperCase()}] ${issue.type}: ${issue.task_title.slice(0, 60)} (${issue.task_id.slice(0, 8)})`);
+        lines.push(`  ${issue.detail}`);
+      }
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("get_review_queue")) {
+  server.tool("get_review_queue", "Get tasks that need review: requires_approval but unapproved, or low confidence completions.", {
+    project_id: exports_external.string().optional().describe("Filter by project"),
+    limit: exports_external.number().optional().describe("Max results (default: all)")
+  }, async ({ project_id, limit }) => {
+    try {
+      const { getReviewQueue: getReviewQueue2 } = (init_patrol(), __toCommonJS(exports_patrol));
+      const tasks = getReviewQueue2({
+        project_id: project_id ? resolveId(project_id, "projects") : undefined,
+        limit
+      });
+      if (tasks.length === 0)
+        return { content: [{ type: "text", text: "Review queue is empty." }] };
+      const lines = tasks.map((t) => {
+        const conf = t.confidence != null ? ` confidence:${t.confidence}` : "";
+        const approval = t.requires_approval && !t.approved_by ? " [needs approval]" : "";
+        return `${t.short_id || t.id.slice(0, 8)} ${t.title.slice(0, 60)}${conf}${approval}`;
+      });
+      return { content: [{ type: "text", text: `Review queue (${tasks.length}):
+${lines.join(`
+`)}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("score_task")) {
+  server.tool("score_task", "Score a completed task's quality (0.0-1.0). Stores in task metadata for agent performance tracking.", {
+    task_id: exports_external.string().describe("Task ID to score"),
+    score: exports_external.number().min(0).max(1).describe("Quality score 0.0-1.0"),
+    reviewer_id: exports_external.string().optional().describe("Agent ID of reviewer")
+  }, async ({ task_id, score, reviewer_id }) => {
+    try {
+      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 };
+    }
+  });
+}
+if (shouldRegisterTool("get_agent_metrics")) {
+  server.tool("get_agent_metrics", "Get performance metrics for an agent: completion rate, speed, confidence, review scores.", {
+    agent_id: exports_external.string().describe("Agent ID or name"),
+    project_id: exports_external.string().optional().describe("Filter by project")
+  }, async ({ agent_id, project_id }) => {
+    try {
+      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)
+        return { content: [{ type: "text", text: `Agent not found: ${agent_id}` }], isError: true };
+      const lines = [
+        `Agent: ${metrics.agent_name} (${metrics.agent_id})`,
+        `Completed: ${metrics.tasks_completed} | Failed: ${metrics.tasks_failed} | In Progress: ${metrics.tasks_in_progress}`,
+        `Completion Rate: ${(metrics.completion_rate * 100).toFixed(1)}%`,
+        metrics.avg_completion_minutes != null ? `Avg Completion Time: ${metrics.avg_completion_minutes} min` : null,
+        metrics.avg_confidence != null ? `Avg Confidence: ${(metrics.avg_confidence * 100).toFixed(1)}%` : null,
+        metrics.review_score_avg != null ? `Avg Review Score: ${(metrics.review_score_avg * 100).toFixed(1)}%` : null,
+        `Composite Score: ${(metrics.composite_score * 100).toFixed(1)}%`
+      ].filter(Boolean);
+      return { content: [{ type: "text", text: lines.join(`
+`) }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
+if (shouldRegisterTool("get_leaderboard")) {
+  server.tool("get_leaderboard", "Get agent leaderboard ranked by composite performance score.", {
+    project_id: exports_external.string().optional().describe("Filter by project"),
+    limit: exports_external.number().optional().describe("Max entries (default: 20)")
+  }, async ({ project_id, limit }) => {
+    try {
+      const { getLeaderboard: getLeaderboard2 } = (init_agent_metrics(), __toCommonJS(exports_agent_metrics));
+      const entries = getLeaderboard2({
+        project_id: project_id ? resolveId(project_id, "projects") : undefined,
+        limit
+      });
+      if (entries.length === 0)
+        return { content: [{ type: "text", text: "No agents with task activity found." }] };
+      const lines = entries.map((e) => `#${e.rank} ${e.agent_name.padEnd(15)} score:${(e.composite_score * 100).toFixed(0).padStart(3)}% done:${String(e.tasks_completed).padStart(3)} rate:${(e.completion_rate * 100).toFixed(0)}%`);
+      return { content: [{ type: "text", text: `Leaderboard:
+${lines.join(`
+`)}` }] };
+    } catch (e) {
+      return { content: [{ type: "text", text: formatError(e) }], isError: true };
+    }
+  });
+}
 server.resource("task-lists", "todos://task-lists", { description: "All task lists", mimeType: "application/json" }, async () => {
   const lists = listTaskLists();
   return { contents: [{ uri: "todos://task-lists", text: JSON.stringify(lists, null, 2), mimeType: "application/json" }] };