@hasna/conversations 0.1.32 → 0.2.0

package/bin/mcp.js

@@ -28939,15 +28939,26 @@ function getUnreadBlockers(agent) {
   `).all(agent, agent);
   return rows.map(parseMessage);
 }
+function getThreadReplies(messageId) {
+  const db2 = getDb();
+  const rows = db2.prepare("SELECT * FROM messages WHERE reply_to = ? ORDER BY created_at ASC, id ASC").all(messageId);
+  return rows.map(parseMessage);
+}
 function searchMessages(opts) {
   const db2 = getDb();
   const limit = Number.isFinite(opts.limit) && opts.limit > 0 ? Math.floor(opts.limit) : 20;
+  const sortByRelevance = opts.sort !== "recent";
+  const priorityWeights = { urgent: 10, high: 5, normal: 1, low: 0.5 };
   try {
-    const ftsConditions = [];
     const ftsParams = [];
-    const words = opts.query.trim().split(/\s+/).filter(Boolean);
-    const ftsQuery = words.map((w) => `"${w.replace(/"/g, '""')}"`).join(" ");
-    ftsConditions.push("messages_fts MATCH ?");
+    const query = opts.query.trim();
+    let ftsQuery;
+    if (query.startsWith('"') && query.endsWith('"')) {
+      ftsQuery = query;
+    } else {
+      const words = query.split(/\s+/).filter(Boolean);
+      ftsQuery = words.map((w) => `"${w.replace(/"/g, '""')}"`).join(" ");
+    }
     ftsParams.push(ftsQuery);
     let extraWhere = "";
     if (opts.space) {
@@ -28962,11 +28973,23 @@ function searchMessages(opts) {
       extraWhere += " AND m.to_agent = ?";
       ftsParams.push(opts.to);
     }
-    const rows2 = db2.prepare(`SELECT m.* FROM messages m
+    const orderClause = sortByRelevance ? "ORDER BY rank" : "ORDER BY m.created_at DESC, m.id DESC";
+    const rows2 = db2.prepare(`SELECT m.*, rank,
+        snippet(messages_fts, 0, '**', '**', '...', 20) as snippet
+       FROM messages m
        JOIN messages_fts ON messages_fts.rowid = m.id
-       WHERE ${ftsConditions.join(" AND ")}${extraWhere}
-       ORDER BY m.created_at DESC, m.id DESC LIMIT ${limit}`).all(...ftsParams);
-    return rows2.map(parseMessage);
+       WHERE messages_fts MATCH ?${extraWhere}
+       ${orderClause} LIMIT ${limit}`).all(...ftsParams);
+    const maxRank = rows2.reduce((max, r) => Math.max(max, Math.abs(r.rank || 0)), 0) || 1;
+    return rows2.map((row) => {
+      const msg = parseMessage(row);
+      const ftsScore = maxRank > 0 ? Math.abs(row.rank || 0) / maxRank * 100 : 50;
+      const priorityBoost = priorityWeights[msg.priority] || 1;
+      const pinnedBoost = msg.pinned_at ? 20 : 0;
+      const blockingBoost = msg.blocking ? 15 : 0;
+      const relevance_score = Math.round((ftsScore * priorityBoost + pinnedBoost + blockingBoost) * 100) / 100;
+      return { ...msg, snippet: row.snippet || null, relevance_score };
+    });
   } catch {}
   const conditions = ["content LIKE ?"];
   const params = [`%${opts.query}%`];
@@ -28984,7 +29007,10 @@ function searchMessages(opts) {
   }
   const where = `WHERE ${conditions.join(" AND ")}`;
   const rows = db2.prepare(`SELECT * FROM messages ${where} ORDER BY created_at DESC, id DESC LIMIT ${limit}`).all(...params);
-  return rows.map(parseMessage);
+  return rows.map((row) => {
+    const msg = parseMessage(row);
+    return { ...msg, snippet: null, relevance_score: 0 };
+  });
 }
 
 // src/lib/sessions.ts
@@ -29017,6 +29043,32 @@ function listSessions(agent) {
     };
   });
 }
+function getSessionActivity(sessionId) {
+  const db2 = getDb();
+  const exists = db2.prepare("SELECT 1 FROM messages WHERE session_id = ? LIMIT 1").get(sessionId);
+  if (!exists)
+    return null;
+  const msgsLast1h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-1 hour')").get(sessionId).c;
+  const msgsLast24h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-24 hours')").get(sessionId).c;
+  const uniqueAgents = db2.prepare("SELECT COUNT(DISTINCT from_agent) as c FROM messages WHERE session_id = ?").get(sessionId).c;
+  const totalMsgs = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ?").get(sessionId).c;
+  const replyCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND reply_to IS NOT NULL").get(sessionId).c;
+  const replyRatio = totalMsgs > 0 ? Math.round(replyCount / totalMsgs * 100) / 100 : 0;
+  const priorityRow = db2.prepare("SELECT priority, COUNT(*) as c FROM messages WHERE session_id = ? GROUP BY priority ORDER BY c DESC LIMIT 1").get(sessionId);
+  const reactionCount = db2.prepare("SELECT COUNT(*) as c FROM reactions r JOIN messages m ON r.message_id = m.id WHERE m.session_id = ?").get(sessionId).c;
+  const agentsLast1h = db2.prepare("SELECT COUNT(DISTINCT from_agent) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-1 hour')").get(sessionId).c;
+  const isTrending = msgsLast1h >= 5 || agentsLast1h >= 3;
+  return {
+    session_id: sessionId,
+    msgs_last_1h: msgsLast1h,
+    msgs_last_24h: msgsLast24h,
+    unique_agents: uniqueAgents,
+    reply_ratio: replyRatio,
+    avg_priority: priorityRow?.priority ?? "normal",
+    reaction_count: reactionCount,
+    is_trending: isTrending
+  };
+}
 
 // src/lib/spaces.ts
 init_db();
@@ -29898,10 +29950,606 @@ function renameAgent(oldName, newName) {
   db2.prepare("UPDATE agent_presence SET agent = ? WHERE LOWER(agent) = ?").run(normalizedNew, normalizedOld);
   return true;
 }
+
+// src/lib/reactions.ts
+init_db();
+function addReaction(messageId, agent, emoji3) {
+  const db2 = getDb();
+  const stmt = db2.prepare(`
+    INSERT INTO reactions (message_id, agent, emoji)
+    VALUES (?, ?, ?)
+    ON CONFLICT (message_id, agent, emoji) DO UPDATE SET agent = agent
+    RETURNING *
+  `);
+  const row = stmt.get(messageId, agent, emoji3);
+  return row;
+}
+function removeReaction(messageId, agent, emoji3) {
+  const db2 = getDb();
+  const stmt = db2.prepare("DELETE FROM reactions WHERE message_id = ? AND agent = ? AND emoji = ?");
+  const result = stmt.run(messageId, agent, emoji3);
+  return result.changes > 0;
+}
+function getReactions(messageId) {
+  const db2 = getDb();
+  const rows = db2.prepare("SELECT * FROM reactions WHERE message_id = ? ORDER BY created_at ASC, id ASC").all(messageId);
+  return rows;
+}
+function getReactionSummary(messageId) {
+  const db2 = getDb();
+  const rows = db2.prepare(`
+    SELECT emoji, GROUP_CONCAT(agent) as agents, COUNT(*) as count
+    FROM reactions
+    WHERE message_id = ?
+    GROUP BY emoji
+    ORDER BY count DESC, MIN(created_at) ASC
+  `).all(messageId);
+  return rows.map((row) => ({
+    emoji: row.emoji,
+    count: row.count,
+    agents: row.agents.split(",")
+  }));
+}
+
+// src/lib/locks.ts
+init_db();
+var DEFAULT_LOCK_EXPIRY_MS = 5 * 60 * 1000;
+function acquireLock(resourceType, resourceId, agentId, lockType = "advisory", expiryMs = DEFAULT_LOCK_EXPIRY_MS) {
+  const db2 = getDb();
+  return db2.transaction(() => {
+    cleanExpiredLocks();
+    const existing = db2.prepare(`
+      SELECT * FROM resource_locks
+      WHERE resource_type = ? AND resource_id = ? AND lock_type = ?
+    `).get(resourceType, resourceId, lockType);
+    if (existing) {
+      if (existing.agent_id !== agentId) {
+        return { acquired: false, lock: null, held_by: existing.agent_id };
+      }
+      const expiresAt = new Date(Date.now() + expiryMs).toISOString().replace("T", "T").replace("Z", "");
+      db2.prepare(`
+        UPDATE resource_locks SET expires_at = ?, locked_at = strftime('%Y-%m-%dT%H:%M:%f', 'now')
+        WHERE resource_type = ? AND resource_id = ? AND lock_type = ?
+      `).run(expiresAt, resourceType, resourceId, lockType);
+    } else {
+      const expiresAt = new Date(Date.now() + expiryMs).toISOString().slice(0, -1);
+      db2.prepare(`
+        INSERT INTO resource_locks (resource_type, resource_id, agent_id, lock_type, locked_at, expires_at)
+        VALUES (?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%f', 'now'), ?)
+      `).run(resourceType, resourceId, agentId, lockType, expiresAt);
+    }
+    const lock = db2.prepare(`
+      SELECT * FROM resource_locks WHERE resource_type = ? AND resource_id = ? AND lock_type = ?
+    `).get(resourceType, resourceId, lockType);
+    return { acquired: true, lock };
+  }).immediate();
+}
+function releaseLock(resourceType, resourceId, agentId) {
+  const db2 = getDb();
+  const result = db2.prepare(`
+    DELETE FROM resource_locks
+    WHERE resource_type = ? AND resource_id = ? AND agent_id = ?
+  `).run(resourceType, resourceId, agentId);
+  return result.changes > 0;
+}
+function checkLock(resourceType, resourceId) {
+  const db2 = getDb();
+  cleanExpiredLocks();
+  return db2.prepare(`
+    SELECT * FROM resource_locks
+    WHERE resource_type = ? AND resource_id = ?
+    ORDER BY locked_at ASC
+    LIMIT 1
+  `).get(resourceType, resourceId);
+}
+function cleanExpiredLocks() {
+  const db2 = getDb();
+  const result = db2.prepare(`
+    DELETE FROM resource_locks WHERE expires_at < strftime('%Y-%m-%dT%H:%M:%f', 'now')
+  `).run();
+  return result.changes;
+}
+function listLocks(opts) {
+  const db2 = getDb();
+  cleanExpiredLocks();
+  let query = "SELECT * FROM resource_locks WHERE 1=1";
+  const params = [];
+  if (opts?.resource_type) {
+    query += " AND resource_type = ?";
+    params.push(opts.resource_type);
+  }
+  if (opts?.agent_id) {
+    query += " AND agent_id = ?";
+    params.push(opts.agent_id);
+  }
+  query += " ORDER BY locked_at ASC";
+  return db2.prepare(query).all(...params);
+}
+
+// src/lib/hot.ts
+init_db();
+function computeHotness(sessionId) {
+  const db2 = getDb();
+  const base = db2.prepare(`
+    SELECT session_id,
+      GROUP_CONCAT(DISTINCT from_agent) as agents,
+      MAX(space) as space,
+      MAX(created_at) as last_message_at,
+      COUNT(*) as message_count
+    FROM messages WHERE session_id = ?
+    GROUP BY session_id
+  `).get(sessionId);
+  if (!base)
+    return null;
+  const msgsLast1h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-1 hour')").get(sessionId).c;
+  const msgsLast24h = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-24 hours')").get(sessionId).c;
+  const uniqueAgents = db2.prepare("SELECT COUNT(DISTINCT from_agent) as c FROM messages WHERE session_id = ?").get(sessionId).c;
+  const reactionCount = db2.prepare("SELECT COUNT(*) as c FROM reactions r JOIN messages m ON r.message_id = m.id WHERE m.session_id = ?").get(sessionId).c;
+  const replyCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND reply_to IS NOT NULL").get(sessionId).c;
+  const highPriorityCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND priority IN ('high', 'urgent')").get(sessionId).c;
+  const blockerCount = db2.prepare("SELECT COUNT(*) as c FROM messages WHERE session_id = ? AND blocking = 1").get(sessionId).c;
+  const lastMsgMs = new Date(base.last_message_at + "Z").getTime();
+  const hoursSinceLast = Math.max(0, (Date.now() - lastMsgMs) / 3600000);
+  const hotness_score = Math.round(msgsLast1h * 3 + uniqueAgents * 5 + reactionCount * 2 + replyCount * 4 + highPriorityCount * 10 + blockerCount * 20 - hoursSinceLast * 2);
+  return {
+    session_id: base.session_id,
+    participants: base.agents.split(","),
+    space: base.space,
+    last_message_at: base.last_message_at,
+    message_count: base.message_count,
+    hotness_score,
+    metrics: {
+      msgs_last_1h: msgsLast1h,
+      msgs_last_24h: msgsLast24h,
+      unique_agents: uniqueAgents,
+      reaction_count: reactionCount,
+      reply_count: replyCount,
+      high_priority_count: highPriorityCount,
+      blocker_count: blockerCount,
+      hours_since_last: Math.round(hoursSinceLast * 10) / 10
+    }
+  };
+}
+function listHotSessions(opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 20;
+  const minScore = opts?.min_score ?? 0;
+  let where = "";
+  const params = [];
+  if (opts?.space) {
+    where = " WHERE space = ?";
+    params.push(opts.space);
+  } else if (opts?.project_id) {
+    where = " WHERE project_id = ?";
+    params.push(opts.project_id);
+  }
+  const sessions = db2.prepare(`SELECT session_id, MAX(created_at) as last_at FROM messages${where} GROUP BY session_id ORDER BY last_at DESC LIMIT 100`).all(...params);
+  const hotSessions = [];
+  for (const { session_id } of sessions) {
+    const hot = computeHotness(session_id);
+    if (hot && hot.hotness_score >= minScore) {
+      hotSessions.push(hot);
+    }
+  }
+  hotSessions.sort((a, b) => b.hotness_score - a.hotness_score);
+  return hotSessions.slice(0, limit);
+}
+
+// src/lib/topics.ts
+init_db();
+var STOPWORDS = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "of",
+  "with",
+  "by",
+  "from",
+  "is",
+  "it",
+  "this",
+  "that",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "shall",
+  "can",
+  "need",
+  "not",
+  "no",
+  "so",
+  "if",
+  "then",
+  "than",
+  "too",
+  "very",
+  "just",
+  "about",
+  "up",
+  "out",
+  "all",
+  "also",
+  "as",
+  "into",
+  "only",
+  "other",
+  "each",
+  "every",
+  "both",
+  "few",
+  "more",
+  "most",
+  "some",
+  "such",
+  "any",
+  "over",
+  "after",
+  "before",
+  "between",
+  "under",
+  "above",
+  "here",
+  "there",
+  "when",
+  "where",
+  "how",
+  "what",
+  "which",
+  "who",
+  "whom",
+  "why",
+  "its",
+  "my",
+  "your",
+  "his",
+  "her",
+  "our",
+  "their",
+  "we",
+  "you",
+  "he",
+  "she",
+  "they",
+  "i",
+  "me",
+  "him",
+  "us",
+  "them",
+  "now",
+  "new",
+  "get",
+  "got",
+  "go",
+  "going",
+  "done",
+  "make",
+  "made",
+  "see",
+  "know",
+  "think",
+  "want",
+  "one",
+  "two",
+  "like",
+  "still",
+  "back",
+  "even"
+]);
+function extractTopics(text, topN = 10) {
+  const cleaned = text.replace(/```[\s\S]*?```/g, " ").replace(/`[^`]+`/g, " ").replace(/https?:\/\/\S+/g, " ").replace(/[#*_~|>\[\](){}]/g, " ").replace(/\d+/g, " ").toLowerCase();
+  const words = cleaned.split(/\s+/).filter((w) => w.length >= 3 && !STOPWORDS.has(w) && /^[a-z]/.test(w));
+  const freq = new Map;
+  for (const w of words) {
+    freq.set(w, (freq.get(w) || 0) + 1);
+  }
+  const totalWords = words.length || 1;
+  return [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, topN).map(([topic, count]) => ({
+    topic,
+    weight: Math.round(count / totalWords * 1000) / 1000,
+    count
+  }));
+}
+function getSpaceTopics(spaceName, opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 100;
+  const sinceClause = opts?.since ? "AND created_at > ?" : "";
+  const params = [spaceName];
+  if (opts?.since)
+    params.push(opts.since);
+  const rows = db2.prepare(`SELECT content FROM messages WHERE space = ? ${sinceClause} ORDER BY created_at DESC LIMIT ${limit}`).all(...params);
+  const combined = rows.map((r) => r.content).join(`
+`);
+  return extractTopics(combined, 15);
+}
+function getSessionTopics(sessionId, opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 100;
+  const rows = db2.prepare(`SELECT content FROM messages WHERE session_id = ? ORDER BY created_at DESC LIMIT ${limit}`).all(sessionId);
+  const combined = rows.map((r) => r.content).join(`
+`);
+  return extractTopics(combined, 15);
+}
+function getTrendingTopics(opts) {
+  const db2 = getDb();
+  const hours = opts?.hours ?? 24;
+  const topN = opts?.top_n ?? 20;
+  let where = `WHERE created_at > strftime('%Y-%m-%dT%H:%M:%f', 'now', '-${hours} hours')`;
+  const params = [];
+  if (opts?.project_id) {
+    where += " AND project_id = ?";
+    params.push(opts.project_id);
+  }
+  const rows = db2.prepare(`SELECT content FROM messages ${where} ORDER BY created_at DESC LIMIT 500`).all(...params);
+  const combined = rows.map((r) => r.content).join(`
+`);
+  return extractTopics(combined, topN);
+}
+
+// src/lib/summary.ts
+init_db();
+function getConversationSummary(sessionOrSpace, opts) {
+  const db2 = getDb();
+  const limit = opts?.limit ?? 50;
+  const isSpace = sessionOrSpace.startsWith("space:") || db2.prepare("SELECT 1 FROM spaces WHERE name = ?").get(sessionOrSpace);
+  const filterCol = isSpace ? "space" : "session_id";
+  const filterVal = isSpace && !sessionOrSpace.startsWith("space:") ? sessionOrSpace : sessionOrSpace;
+  const messages = db2.prepare(`SELECT * FROM messages WHERE ${filterCol} = ? ORDER BY created_at DESC LIMIT ${limit}`).all(filterVal);
+  if (messages.length === 0)
+    return null;
+  const agents = new Set;
+  for (const m of messages) {
+    agents.add(m.from_agent);
+    if (m.to_agent)
+      agents.add(m.to_agent);
+  }
+  const dates = messages.map((m) => m.created_at).sort();
+  const dateRange = { first: dates[0], last: dates[dates.length - 1] };
+  const allContent = messages.map((m) => m.content).join(`
+`);
+  const topics = extractTopics(allContent, 10);
+  const keyMessages = [];
+  for (const m of messages) {
+    const priority = m.priority;
+    if (priority === "high" || priority === "urgent") {
+      keyMessages.push({
+        id: m.id,
+        from: m.from_agent,
+        content: m.content.slice(0, 200),
+        reason: `${priority} priority`
+      });
+    }
+    if (m.blocking) {
+      keyMessages.push({
+        id: m.id,
+        from: m.from_agent,
+        content: m.content.slice(0, 200),
+        reason: "blocking message"
+      });
+    }
+  }
+  for (const m of messages) {
+    if (m.pinned_at) {
+      keyMessages.push({
+        id: m.id,
+        from: m.from_agent,
+        content: m.content.slice(0, 200),
+        reason: "pinned"
+      });
+    }
+  }
+  const msgIds = messages.map((m) => m.id);
+  if (msgIds.length > 0) {
+    const placeholders = msgIds.map(() => "?").join(",");
+    const reacted = db2.prepare(`SELECT message_id, COUNT(*) as c FROM reactions WHERE message_id IN (${placeholders}) GROUP BY message_id ORDER BY c DESC LIMIT 3`).all(...msgIds);
+    for (const r of reacted) {
+      const m = messages.find((msg) => msg.id === r.message_id);
+      if (m) {
+        keyMessages.push({
+          id: r.message_id,
+          from: m.from_agent,
+          content: m.content.slice(0, 200),
+          reason: `${r.c} reaction(s)`
+        });
+      }
+    }
+  }
+  const seen = new Set;
+  const uniqueKey = keyMessages.filter((k) => {
+    if (seen.has(k.id))
+      return false;
+    seen.add(k.id);
+    return true;
+  }).slice(0, 10);
+  const blockers = messages.filter((m) => m.blocking && !m.read_at).map((m) => ({
+    id: m.id,
+    from: m.from_agent,
+    content: m.content.slice(0, 200),
+    created_at: m.created_at
+  }));
+  const replyCount = messages.filter((m) => m.reply_to).length;
+  const reactionCount = msgIds.length > 0 ? db2.prepare(`SELECT COUNT(*) as c FROM reactions WHERE message_id IN (${msgIds.map(() => "?").join(",")})`).get(...msgIds).c : 0;
+  const priorityCounts = {};
+  for (const m of messages) {
+    const p = m.priority;
+    priorityCounts[p] = (priorityCounts[p] || 0) + 1;
+  }
+  const avgPriority = Object.entries(priorityCounts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? "normal";
+  return {
+    session_id: sessionOrSpace,
+    participants: [...agents].filter((a) => a !== sessionOrSpace),
+    message_count: messages.length,
+    date_range: dateRange,
+    topics,
+    key_messages: uniqueKey,
+    unresolved_blockers: blockers,
+    activity: {
+      reply_count: replyCount,
+      reaction_count: reactionCount,
+      avg_priority: avgPriority
+    }
+  };
+}
+
+// src/lib/graph.ts
+init_db();
+function ensureGraphTable() {
+  const db2 = getDb();
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS graph_edges (
+      from_type TEXT NOT NULL,
+      from_id TEXT NOT NULL,
+      to_type TEXT NOT NULL,
+      to_id TEXT NOT NULL,
+      relation TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 1,
+      metadata TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%f', 'now')),
+      UNIQUE(from_type, from_id, to_type, to_id, relation)
+    )
+  `);
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_graph_from ON graph_edges(from_type, from_id)");
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_graph_to ON graph_edges(to_type, to_id)");
+  db2.exec("CREATE INDEX IF NOT EXISTS idx_graph_relation ON graph_edges(relation)");
+}
+function buildGraph() {
+  const db2 = getDb();
+  ensureGraphTable();
+  let created = 0;
+  let updated = 0;
+  const upsert = db2.prepare(`
+    INSERT INTO graph_edges (from_type, from_id, to_type, to_id, relation, weight, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%f', 'now'))
+    ON CONFLICT(from_type, from_id, to_type, to_id, relation) DO UPDATE SET
+      weight = excluded.weight,
+      updated_at = excluded.updated_at
+  `);
+  const insertOrUpdate = db2.transaction(() => {
+    const dmPairs = db2.prepare(`
+      SELECT from_agent, to_agent, COUNT(*) as cnt, MAX(created_at) as last_at
+      FROM messages WHERE space IS NULL AND from_agent != to_agent
+      GROUP BY from_agent, to_agent
+    `).all();
+    for (const pair of dmPairs) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='agent' AND from_id=? AND to_type='agent' AND to_id=? AND relation='communicates_with'").get(pair.from_agent, pair.to_agent);
+      upsert.run("agent", pair.from_agent, "agent", pair.to_agent, "communicates_with", pair.cnt);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+    const spacePosts = db2.prepare(`
+      SELECT from_agent, space, COUNT(*) as cnt
+      FROM messages WHERE space IS NOT NULL
+      GROUP BY from_agent, space
+    `).all();
+    for (const sp of spacePosts) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='agent' AND from_id=? AND to_type='space' AND to_id=? AND relation='posts_in'").get(sp.from_agent, sp.space);
+      upsert.run("agent", sp.from_agent, "space", sp.space, "posts_in", sp.cnt);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+    const members = db2.prepare("SELECT agent, space FROM space_members").all();
+    for (const m of members) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='agent' AND from_id=? AND to_type='space' AND to_id=? AND relation='member_of'").get(m.agent, m.space);
+      upsert.run("agent", m.agent, "space", m.space, "member_of", 1);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+    const spaceProjects = db2.prepare("SELECT name, project_id FROM spaces WHERE project_id IS NOT NULL").all();
+    for (const sp of spaceProjects) {
+      const existing = db2.prepare("SELECT 1 FROM graph_edges WHERE from_type='space' AND from_id=? AND to_type='project' AND to_id=? AND relation='belongs_to'").get(sp.name, sp.project_id);
+      upsert.run("space", sp.name, "project", sp.project_id, "belongs_to", 1);
+      if (existing)
+        updated++;
+      else
+        created++;
+    }
+  });
+  insertOrUpdate();
+  return { edges_created: created, edges_updated: updated };
+}
+function getRelated(entityType, entityId) {
+  const db2 = getDb();
+  ensureGraphTable();
+  const outgoing = db2.prepare(`
+    SELECT to_type as type, to_id as id, relation, weight FROM graph_edges
+    WHERE from_type = ? AND from_id = ? ORDER BY weight DESC
+  `).all(entityType, entityId);
+  const incoming = db2.prepare(`
+    SELECT from_type as type, from_id as id, relation, weight FROM graph_edges
+    WHERE to_type = ? AND to_id = ? ORDER BY weight DESC
+  `).all(entityType, entityId);
+  return [...outgoing, ...incoming];
+}
+function getAgentNetwork(agent) {
+  const db2 = getDb();
+  ensureGraphTable();
+  const comms = db2.prepare(`
+    SELECT to_id as agent, weight as message_count,
+      (SELECT MAX(created_at) FROM messages WHERE from_agent = ? AND to_agent = ge.to_id AND space IS NULL) as last_at
+    FROM graph_edges ge
+    WHERE from_type = 'agent' AND from_id = ? AND relation = 'communicates_with'
+    ORDER BY weight DESC LIMIT 20
+  `).all(agent, agent);
+  const spaces = db2.prepare(`
+    SELECT to_id as space, weight as message_count FROM graph_edges
+    WHERE from_type = 'agent' AND from_id = ? AND relation = 'posts_in'
+    ORDER BY weight DESC LIMIT 20
+  `).all(agent);
+  const projects = db2.prepare(`
+    SELECT DISTINCT g2.to_id FROM graph_edges g1
+    JOIN graph_edges g2 ON g1.to_type = 'space' AND g1.to_id = g2.from_id AND g2.relation = 'belongs_to'
+    WHERE g1.from_type = 'agent' AND g1.from_id = ? AND g1.relation IN ('member_of', 'posts_in')
+  `).all(agent);
+  return {
+    agent,
+    communicates_with: comms,
+    spaces,
+    projects: projects.map((p) => p.to_id)
+  };
+}
+function getGraphStats() {
+  const db2 = getDb();
+  ensureGraphTable();
+  const total = db2.prepare("SELECT COUNT(*) as c FROM graph_edges").get().c;
+  const byRelation = db2.prepare("SELECT relation, COUNT(*) as c FROM graph_edges GROUP BY relation ORDER BY c DESC").all();
+  const map3 = {};
+  for (const r of byRelation)
+    map3[r.relation] = r.c;
+  return { total_edges: total, by_relation: map3 };
+}
 // package.json
 var package_default = {
   name: "@hasna/conversations",
-  version: "0.1.32",
+  version: "0.2.0",
   description: "Real-time CLI messaging for AI agents",
   type: "module",
   bin: {
@@ -30630,6 +31278,207 @@ server.registerTool("get_pinned_messages", {
     content: [{ type: "text", text: JSON.stringify(messages) }]
   };
 });
+server.registerTool("build_graph", {
+  description: "Build/rebuild the knowledge graph from messages, spaces, and projects. Creates relationship edges between agents, spaces, and projects.",
+  inputSchema: {}
+}, async () => {
+  const result = buildGraph();
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+});
+server.registerTool("get_related", {
+  description: "Find all entities related to a given entity in the knowledge graph.",
+  inputSchema: {
+    entity_type: exports_external.string(),
+    entity_id: exports_external.string()
+  }
+}, async (args) => {
+  const related = getRelated(args.entity_type, args.entity_id);
+  return { content: [{ type: "text", text: JSON.stringify(related) }] };
+});
+server.registerTool("get_agent_network", {
+  description: "Get an agent's communication network: who they talk to, spaces, projects.",
+  inputSchema: {
+    agent: exports_external.string()
+  }
+}, async (args) => {
+  const network = getAgentNetwork(args.agent);
+  return { content: [{ type: "text", text: JSON.stringify(network) }] };
+});
+server.registerTool("graph_stats", {
+  description: "Get knowledge graph statistics: total edges and counts by relation type.",
+  inputSchema: {}
+}, async () => {
+  const stats = getGraphStats();
+  return { content: [{ type: "text", text: JSON.stringify(stats) }] };
+});
+server.registerTool("get_summary", {
+  description: "Get a structured summary of a conversation (session or space): participants, topics, key messages, blockers, activity.",
+  inputSchema: {
+    session_id: exports_external.string().optional(),
+    space: exports_external.string().optional(),
+    limit: exports_external.coerce.number().optional()
+  }
+}, async (args) => {
+  const target = args.space || args.session_id;
+  if (!target)
+    return { content: [{ type: "text", text: "session_id or space required" }], isError: true };
+  const summary = getConversationSummary(target, { limit: args.limit });
+  if (!summary)
+    return { content: [{ type: "text", text: `No messages found for "${target}"` }], isError: true };
+  return { content: [{ type: "text", text: JSON.stringify(summary) }] };
+});
+server.registerTool("get_topics", {
+  description: "Extract topics from a space or session. Returns weighted keyword list.",
+  inputSchema: {
+    space: exports_external.string().optional(),
+    session_id: exports_external.string().optional(),
+    limit: exports_external.coerce.number().optional()
+  }
+}, async (args) => {
+  const topics = args.space ? getSpaceTopics(args.space, { limit: args.limit }) : args.session_id ? getSessionTopics(args.session_id, { limit: args.limit }) : getTrendingTopics({ top_n: args.limit });
+  return { content: [{ type: "text", text: JSON.stringify(topics) }] };
+});
+server.registerTool("trending_topics", {
+  description: "Get trending topics across all messages in the last N hours.",
+  inputSchema: {
+    hours: exports_external.coerce.number().optional(),
+    project_id: exports_external.string().optional(),
+    top_n: exports_external.coerce.number().optional()
+  }
+}, async (args) => {
+  const topics = getTrendingTopics({ hours: args.hours, project_id: args.project_id, top_n: args.top_n });
+  return { content: [{ type: "text", text: JSON.stringify(topics) }] };
+});
+server.registerTool("get_session_activity", {
+  description: "Get activity metrics for a session: message velocity, unique agents, reply ratio, reaction count, trending status.",
+  inputSchema: {
+    session_id: exports_external.string()
+  }
+}, async (args) => {
+  const activity = getSessionActivity(args.session_id);
+  if (!activity) {
+    return { content: [{ type: "text", text: `session "${args.session_id}" not found` }], isError: true };
+  }
+  return { content: [{ type: "text", text: JSON.stringify(activity) }] };
+});
+server.registerTool("hot_sessions", {
+  description: "List conversations ranked by activity hotness (message velocity, reactions, replies, priority, blockers).",
+  inputSchema: {
+    limit: exports_external.coerce.number().optional(),
+    min_score: exports_external.coerce.number().optional(),
+    space: exports_external.string().optional(),
+    project_id: exports_external.string().optional()
+  }
+}, async (args) => {
+  const sessions = listHotSessions({
+    limit: args.limit,
+    min_score: args.min_score,
+    space: args.space,
+    project_id: args.project_id
+  });
+  return { content: [{ type: "text", text: JSON.stringify(sessions) }] };
+});
+server.registerTool("add_reaction", {
+  description: "Add an emoji reaction to a message.",
+  inputSchema: {
+    message_id: exports_external.coerce.number(),
+    emoji: exports_external.string(),
+    from: exports_external.string().optional()
+  }
+}, async (args) => {
+  const { message_id, emoji: emoji3, from: fromParam } = args;
+  const agent = resolveIdentity(fromParam);
+  const reaction = addReaction(message_id, agent, emoji3);
+  return { content: [{ type: "text", text: JSON.stringify(reaction) }] };
+});
+server.registerTool("remove_reaction", {
+  description: "Remove an emoji reaction from a message.",
+  inputSchema: {
+    message_id: exports_external.coerce.number(),
+    emoji: exports_external.string(),
+    from: exports_external.string().optional()
+  }
+}, async (args) => {
+  const { message_id, emoji: emoji3, from: fromParam } = args;
+  const agent = resolveIdentity(fromParam);
+  const removed = removeReaction(message_id, agent, emoji3);
+  return { content: [{ type: "text", text: JSON.stringify({ removed }) }] };
+});
+server.registerTool("get_reactions", {
+  description: "Get all reactions for a message.",
+  inputSchema: {
+    message_id: exports_external.coerce.number()
+  }
+}, async (args) => {
+  const reactions = getReactions(args.message_id);
+  return { content: [{ type: "text", text: JSON.stringify(reactions) }] };
+});
+server.registerTool("get_reaction_summary", {
+  description: "Get emoji reaction counts and agent lists for a message.",
+  inputSchema: {
+    message_id: exports_external.coerce.number()
+  }
+}, async (args) => {
+  const summary = getReactionSummary(args.message_id);
+  return { content: [{ type: "text", text: JSON.stringify(summary) }] };
+});
+server.registerTool("acquire_lock", {
+  description: "Acquire an advisory or exclusive lock on a resource. Returns conflict info if another agent holds the lock.",
+  inputSchema: {
+    resource_type: exports_external.string(),
+    resource_id: exports_external.string(),
+    lock_type: exports_external.enum(["advisory", "exclusive"]).optional(),
+    expiry_ms: exports_external.coerce.number().optional(),
+    from: exports_external.string().optional()
+  }
+}, async (args) => {
+  const { resource_type, resource_id, lock_type, expiry_ms, from: fromParam } = args;
+  const agent = resolveIdentity(fromParam);
+  const result = acquireLock(resource_type, resource_id, agent, lock_type ?? "advisory", expiry_ms);
+  return { content: [{ type: "text", text: JSON.stringify(result) }] };
+});
+server.registerTool("release_lock", {
+  description: "Release a lock held by the agent on a resource.",
+  inputSchema: {
+    resource_type: exports_external.string(),
+    resource_id: exports_external.string(),
+    from: exports_external.string().optional()
+  }
+}, async (args) => {
+  const { resource_type, resource_id, from: fromParam } = args;
+  const agent = resolveIdentity(fromParam);
+  const released = releaseLock(resource_type, resource_id, agent);
+  return { content: [{ type: "text", text: JSON.stringify({ released }) }] };
+});
+server.registerTool("check_lock", {
+  description: "Check if a resource is currently locked and who holds it.",
+  inputSchema: {
+    resource_type: exports_external.string(),
+    resource_id: exports_external.string()
+  }
+}, async (args) => {
+  const lock = checkLock(args.resource_type, args.resource_id);
+  return { content: [{ type: "text", text: JSON.stringify(lock ?? { locked: false }) }] };
+});
+server.registerTool("list_locks", {
+  description: "List all active (non-expired) locks. Filter by resource_type or agent.",
+  inputSchema: {
+    resource_type: exports_external.string().optional(),
+    agent_id: exports_external.string().optional()
+  }
+}, async (args) => {
+  const locks = listLocks({ resource_type: args.resource_type, agent_id: args.agent_id });
+  return { content: [{ type: "text", text: JSON.stringify(locks) }] };
+});
+server.registerTool("get_thread_replies", {
+  description: "Get all replies in a thread for a given parent message ID.",
+  inputSchema: {
+    message_id: exports_external.coerce.number()
+  }
+}, async (args) => {
+  const replies = getThreadReplies(args.message_id);
+  return { content: [{ type: "text", text: JSON.stringify(replies) }] };
+});
 server.registerTool("set_focus", {
   description: "Set agent focus to a project. All read-heavy tools will default to this project scope. Stores in MCP session memory AND updates agent_presence.project_id in DB.",
   inputSchema: {
@@ -30828,6 +31677,24 @@ server.registerTool("search_tools", {
     "pin_message",
     "unpin_message",
     "get_pinned_messages",
+    "build_graph",
+    "get_related",
+    "get_agent_network",
+    "graph_stats",
+    "get_summary",
+    "get_topics",
+    "trending_topics",
+    "get_session_activity",
+    "hot_sessions",
+    "add_reaction",
+    "remove_reaction",
+    "get_reactions",
+    "get_reaction_summary",
+    "acquire_lock",
+    "release_lock",
+    "check_lock",
+    "list_locks",
+    "get_thread_replies",
     "set_focus",
     "get_focus",
     "unfocus",
@@ -30877,6 +31744,24 @@ server.registerTool("describe_tools", {
     pin_message: "Pin a message. Required: id",
     unpin_message: "Unpin a message. Required: id",
     get_pinned_messages: "Get pinned messages. Optional: space?, session_id?, limit?",
+    build_graph: "Build/rebuild knowledge graph from messages, spaces, projects. Returns edge counts.",
+    get_related: "Find entities related to a given entity. Required: entity_type, entity_id",
+    get_agent_network: "Agent's communication network: contacts, spaces, projects. Required: agent",
+    graph_stats: "Knowledge graph stats: total edges, by relation type",
+    get_summary: "Structured conversation summary: participants, topics, key messages, blockers. Required: session_id? or space?. Optional: limit?",
+    get_topics: "Extract topics from space or session. Optional: space?, session_id?, limit?",
+    trending_topics: "Trending topics across all messages. Optional: hours?, project_id?, top_n?",
+    get_session_activity: "Get activity metrics for a session: velocity, agents, reply ratio, reactions, trending. Required: session_id",
+    hot_sessions: "List conversations by hotness score (velocity, reactions, replies, priority, blockers). Optional: limit?, min_score?, space?, project_id?",
+    add_reaction: "Add emoji reaction to a message. Required: message_id, emoji. Optional: from?",
+    remove_reaction: "Remove emoji reaction from a message. Required: message_id, emoji. Optional: from?",
+    get_reactions: "Get all reactions for a message. Required: message_id",
+    get_reaction_summary: "Get emoji counts + agent lists for a message. Required: message_id",
+    acquire_lock: "Acquire advisory/exclusive lock on a resource. Required: resource_type, resource_id. Optional: lock_type?(advisory|exclusive), expiry_ms?, from?",
+    release_lock: "Release lock held by agent. Required: resource_type, resource_id. Optional: from?",
+    check_lock: "Check if resource is locked and who holds it. Required: resource_type, resource_id",
+    list_locks: "List active locks. Optional: resource_type?, agent_id?",
+    get_thread_replies: "Get all replies in a thread. Required: message_id. Optional: limit?",
     set_focus: "Set agent focus to a project. All read tools default to this scope. Required: project_id. Optional: from?",
     get_focus: "Get current focus: session focus, DB project_id, effective project_id. Optional: from?",
     unfocus: "Clear agent focus (session + DB). Optional: from?",