@hasna/todos 0.9.83 → 0.10.2

package/dist/cli/index.js

@@ -2282,6 +2282,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");
@@ -2306,6 +2330,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");
@@ -2332,6 +2357,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 {
@@ -2801,6 +2832,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);
   `
   ];
 });
@@ -3137,8 +3206,7 @@ __export(exports_config, {
   getCompletionGuardConfig: () => getCompletionGuardConfig,
   getAgentTasksDir: () => getAgentTasksDir,
   getAgentTaskListId: () => getAgentTaskListId,
-  getAgentPoolForProject: () => getAgentPoolForProject,
-  DEFAULT_AGENT_POOL: () => DEFAULT_AGENT_POOL
+  getAgentPoolForProject: () => getAgentPoolForProject
 });
 import { existsSync as existsSync3 } from "fs";
 import { join as join3 } from "path";
@@ -3198,7 +3266,7 @@ function getAgentPoolForProject(workingDir) {
       return config.project_pools[bestKey];
     }
   }
-  return config.agent_pool || DEFAULT_AGENT_POOL;
+  return config.agent_pool || null;
 }
 function getCompletionGuardConfig(projectPath) {
   const config = loadConfig();
@@ -3208,26 +3276,9 @@ function getCompletionGuardConfig(projectPath) {
   }
   return global;
 }
-var DEFAULT_AGENT_POOL, cached = null, GUARD_DEFAULTS;
+var cached = null, GUARD_DEFAULTS;
 var init_config = __esm(() => {
   init_sync_utils();
-  DEFAULT_AGENT_POOL = [
-    "maximus",
-    "cassius",
-    "aurelius",
-    "brutus",
-    "titus",
-    "nero",
-    "cicero",
-    "seneca",
-    "cato",
-    "julius",
-    "marcus",
-    "lucius",
-    "quintus",
-    "gaius",
-    "publius"
-  ];
   GUARD_DEFAULTS = {
     enabled: false,
     min_work_seconds: 30,
@@ -4679,10 +4730,12 @@ __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,
@@ -4700,30 +4753,13 @@ 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();
@@ -4764,8 +4800,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,
@@ -4773,6 +4809,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 || {}),
@@ -4828,6 +4865,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);
@@ -4875,6 +4916,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();
@@ -9810,6 +9873,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
 var exports_mcp = {};
 __export(exports_mcp, {
@@ -10839,25 +11480,28 @@ ${text}` }] };
     });
   }
   if (shouldRegisterTool("register_agent")) {
-    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."),
+    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(),
+      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")
-    }, async ({ name, description, session_id, working_dir }) => {
+    }, async ({ name, description, capabilities, session_id, working_dir }) => {
       try {
         const pool = getAgentPoolForProject(working_dir);
-        const result = registerAgent({ name, description, session_id, working_dir, pool });
+        const result = registerAgent({ name, description, capabilities, session_id, working_dir, pool: pool || undefined });
         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}`;
+          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",
@@ -10865,8 +11509,7 @@ Available names: ${result.suggestions.join(", ")}` : "";
 ID: ${agent.id}
 Name: ${agent.name}${agent.description ? `
 Description: ${agent.description}` : ""}
-Session: ${agent.session_id ?? "unbound"}
-Pool: [${pool.join(", ")}]
+Session: ${agent.session_id ?? "unbound"}${poolLine}
 Created: ${agent.created_at}
 Last seen: ${agent.last_seen_at}`
           }]
@@ -10877,21 +11520,32 @@ 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")
+    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 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 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 ~/.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"}`,
-          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",
+          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 yet. Wait for an active agent to go stale (30min timeout).`
+No names available. Wait for an active agent to go stale (30min timeout).`
         ];
         return { content: [{ type: "text", text: lines.join(`
 `) }] };
@@ -12234,12 +12888,12 @@ Claimed: ${formatTask(result.claimed)}`);
         delete_plan: `Delete a plan. Tasks in the plan are orphaned, not deleted.
   Params: id(string, req)
   Example: {id: 'a1b2c3d4'}`,
-        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)
+        suggest_agent_name: `Check available agent names before registering. Shows active agents and, if a pool is configured, which pool names are free.
+  Params: working_dir(string \u2014 your working directory, used to look up project pool from config)
   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'}`,
+        register_agent: `Register an agent. Any name is allowed \u2014 pool is advisory. Returns CONFLICT if name is held by a recently-active agent.
+  Params: name(string, req), description(string), capabilities(string[]), session_id(string \u2014 unique per session), working_dir(string \u2014 used to determine project pool)
+  Example: {name: 'my-agent', 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)
@@ -12497,6 +13151,328 @@ ${lines.join(`
       }
     });
   }
+  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" }] };