@hasna/todos 0.9.83 → 0.10.2

package/dist/index.js

@@ -659,6 +659,44 @@ var MIGRATIONS = [
   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);
   `
 ];
 var _db = null;
@@ -796,6 +834,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");
@@ -820,6 +882,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");
@@ -846,6 +909,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 {
@@ -2771,30 +2840,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();
@@ -2835,8 +2887,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,
@@ -2844,6 +2896,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 || {}),
@@ -2899,6 +2952,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);
@@ -2946,6 +3003,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;
+}
 // src/db/task-lists.ts
 function rowToTaskList(row) {
   return {
@@ -3266,8 +3345,537 @@ function deleteOrg(id, db) {
   const d = db || getDatabase();
   return d.run("DELETE FROM orgs WHERE id = ?", [id]).changes > 0;
 }
-// src/lib/search.ts
+// src/db/task-relationships.ts
+var RELATIONSHIP_TYPES = [
+  "related_to",
+  "conflicts_with",
+  "similar_to",
+  "duplicates",
+  "supersedes",
+  "modifies_same_file"
+];
+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;
+}
+// src/db/kg.ts
+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;
+}
+// src/db/patrol.ts
 function rowToTask2(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 = rowToTask2(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 = rowToTask2(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 = rowToTask2(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 = rowToTask2(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 = rowToTask2(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(rowToTask2);
+}
+// src/db/agent-metrics.ts
+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]);
+}
+// src/lib/search.ts
+function rowToTask3(row) {
   return {
     ...row,
     tags: JSON.parse(row.tags || "[]"),
@@ -3367,7 +3975,7 @@ function searchTasks(options, projectId, taskListId, db) {
       t.created_at DESC`;
   }
   const rows = d.query(sql).all(...params);
-  return rows.map(rowToTask2);
+  return rows.map(rowToTask3);
 }
 // src/lib/claude-tasks.ts
 import { existsSync as existsSync4, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -3901,25 +4509,32 @@ export {
   taskFromTemplate,
   syncWithAgents,
   syncWithAgent,
+  syncKgEdges,
   startTask,
   slugify,
   setTaskStatus,
   setTaskPriority,
   searchTasks,
+  scoreTask,
   resolvePartialId,
   resetDatabase,
+  removeTaskRelationshipByPair,
+  removeTaskRelationship,
   removeTaskFile,
   removeProjectSource,
+  removeKgEdges,
   removeDependency,
   removeChecklistItem,
   releaseLock,
   registerAgent,
   redistributeStaleTasks,
+  patrolTasks,
   parseRecurrenceRule,
   now,
   nextTaskShortId,
   nextOccurrence,
   moveTask,
+  matchCapabilities,
   logTaskChange,
   logProgress,
   lockTask,
@@ -3944,6 +4559,8 @@ export {
   getTasksChangedSince,
   getTaskWithRelations,
   getTaskStats,
+  getTaskRelationships,
+  getTaskRelationship,
   getTaskListBySlug,
   getTaskList,
   getTaskHistory,
@@ -3955,6 +4572,8 @@ export {
   getStatus,
   getStaleTasks,
   getSession,
+  getReviewQueue,
+  getRelated,
   getRecentActivity,
   getProjectWithSources,
   getProjectByPath,
@@ -3965,18 +4584,25 @@ export {
   getOrgByName,
   getOrg,
   getNextTask,
+  getLeaderboard,
   getLatestHandoff,
+  getImpactAnalysis,
   getDirectReports,
   getDatabase,
+  getCriticalPath,
   getCompletionGuardConfig,
   getComment,
   getChecklistStats,
   getChecklist,
+  getCapableAgents,
   getBlockingDeps,
+  getAgentMetrics,
   getAgentByName,
   getAgent,
   getActiveWork,
   findTasksByFile,
+  findRelatedTaskIds,
+  findPath,
   failTask,
   ensureTaskList,
   ensureProject,
@@ -4016,8 +4642,11 @@ export {
   bulkUpdateTasks,
   bulkCreateTasks,
   bulkAddTaskFiles,
+  autoDetectFileRelationships,
+  addTaskRelationship,
   addTaskFile,
   addProjectSource,
+  addKgEdge,
   addDependency,
   addComment,
   addChecklistItem,
@@ -4028,6 +4657,7 @@ export {
   TaskListNotFoundError,
   TASK_STATUSES,
   TASK_PRIORITIES,
+  RELATIONSHIP_TYPES,
   ProjectNotFoundError,
   PlanNotFoundError,
   PLAN_STATUSES,