server-memory-enhanced 2.3.1 → 3.0.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import { KnowledgeGraphManager } from './lib/knowledge-graph-manager.js';
-import { EntitySchema, RelationSchema, SaveMemoryInputSchema, SaveMemoryOutputSchema, GetAnalyticsInputSchema, GetAnalyticsOutputSchema, GetObservationHistoryInputSchema, GetObservationHistoryOutputSchema, ListEntitiesInputSchema, ListEntitiesOutputSchema, ValidateMemoryInputSchema, ValidateMemoryOutputSchema, UpdateObservationInputSchema, UpdateObservationOutputSchema } from './lib/schemas.js';
+import { EntitySchema, RelationSchema, SaveMemoryInputSchema, SaveMemoryOutputSchema, GetAnalyticsInputSchema, GetAnalyticsOutputSchema, GetObservationHistoryInputSchema, GetObservationHistoryOutputSchema, ListEntitiesInputSchema, ListEntitiesOutputSchema, ValidateMemoryInputSchema, ValidateMemoryOutputSchema, UpdateObservationInputSchema, UpdateObservationOutputSchema, ReadGraphInputSchema, SearchNodesInputSchema, OpenNodesInputSchema, QueryNodesInputSchema, GetMemoryStatsInputSchema, GetRecentChangesInputSchema, FindRelationPathInputSchema, DetectConflictsInputSchema, GetFlaggedEntitiesInputSchema, GetContextInputSchema } from './lib/schemas.js';
 import { handleSaveMemory } from './lib/save-memory-handler.js';
 import { validateSaveMemoryRequest } from './lib/validation.js';
 import { JsonlStorageAdapter } from './lib/jsonl-storage-adapter.js';
@@ -314,14 +314,14 @@ server.registerTool("delete_relations", {
 // Register read_graph tool
 server.registerTool("read_graph", {
     title: "Read Graph",
-    description: "Read the entire knowledge graph",
-    inputSchema: {},
+    description: "Read the knowledge graph for a specific thread (thread isolation enforced)",
+    inputSchema: ReadGraphInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async () => {
-    const graph = await knowledgeGraphManager.readGraph();
+}, async (input) => {
+    const graph = await knowledgeGraphManager.readGraph(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -330,16 +330,14 @@ server.registerTool("read_graph", {
 // Register search_nodes tool
 server.registerTool("search_nodes", {
     title: "Search Nodes",
-    description: "Search for nodes in the knowledge graph based on a query",
-    inputSchema: {
-        query: z.string().describe("The search query to match against entity names, types, and observation content")
-    },
+    description: "Search for nodes in the knowledge graph based on a query (thread isolation enforced)",
+    inputSchema: SearchNodesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ query }) => {
-    const graph = await knowledgeGraphManager.searchNodes(query);
+}, async (input) => {
+    const graph = await knowledgeGraphManager.searchNodes(input.threadId, input.query);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -348,16 +346,14 @@ server.registerTool("search_nodes", {
 // Register open_nodes tool
 server.registerTool("open_nodes", {
     title: "Open Nodes",
-    description: "Open specific nodes in the knowledge graph by their names",
-    inputSchema: {
-        names: z.array(z.string()).describe("An array of entity names to retrieve")
-    },
+    description: "Open specific nodes in the knowledge graph by their names (thread isolation enforced)",
+    inputSchema: OpenNodesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ names }) => {
-    const graph = await knowledgeGraphManager.openNodes(names);
+}, async (input) => {
+    const graph = await knowledgeGraphManager.openNodes(input.threadId, input.names);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -366,21 +362,15 @@ server.registerTool("open_nodes", {
 // Register query_nodes tool for advanced filtering
 server.registerTool("query_nodes", {
     title: "Query Nodes",
-    description: "Query nodes and relations in the knowledge graph with advanced filtering by timestamp, confidence, and importance ranges",
-    inputSchema: {
-        timestampStart: z.string().optional().describe("ISO 8601 timestamp - filter for items created on or after this time"),
-        timestampEnd: z.string().optional().describe("ISO 8601 timestamp - filter for items created on or before this time"),
-        confidenceMin: z.number().min(0).max(1).optional().describe("Minimum confidence value (0-1)"),
-        confidenceMax: z.number().min(0).max(1).optional().describe("Maximum confidence value (0-1)"),
-        importanceMin: z.number().min(0).max(1).optional().describe("Minimum importance value (0-1)"),
-        importanceMax: z.number().min(0).max(1).optional().describe("Maximum importance value (0-1)")
-    },
+    description: "Query nodes and relations in the knowledge graph with advanced filtering by timestamp, confidence, and importance ranges (thread isolation enforced)",
+    inputSchema: QueryNodesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async (filters) => {
-    const graph = await knowledgeGraphManager.queryNodes(filters);
+}, async (input) => {
+    const { threadId, ...filters } = input;
+    const graph = await knowledgeGraphManager.queryNodes(threadId, Object.keys(filters).length > 0 ? filters : undefined);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -389,7 +379,7 @@ server.registerTool("query_nodes", {
 // Register list_entities tool for simple entity lookup
 server.registerTool("list_entities", {
     title: "List Entities",
-    description: "List entities with optional filtering by entity type and name pattern. Returns a simple list of entity names and types for quick discovery.",
+    description: "List entities with optional filtering by entity type and name pattern. Returns a simple list of entity names and types for quick discovery. Thread isolation enforced - only shows entities from the specified thread.",
     inputSchema: ListEntitiesInputSchema,
     outputSchema: ListEntitiesOutputSchema
 }, async (input) => {
@@ -522,8 +512,8 @@ server.registerTool("validate_memory", {
 // Register get_memory_stats tool
 server.registerTool("get_memory_stats", {
     title: "Get Memory Statistics",
-    description: "Get comprehensive statistics about the knowledge graph including entity counts, thread activity, and confidence/importance metrics",
-    inputSchema: {},
+    description: "Get comprehensive statistics about the knowledge graph for a specific thread including entity counts, activity, and confidence/importance metrics (thread isolation enforced)",
+    inputSchema: GetMemoryStatsInputSchema,
     outputSchema: {
         entityCount: z.number(),
         relationCount: z.number(),
@@ -536,8 +526,8 @@ server.registerTool("get_memory_stats", {
             entityCount: z.number()
         }))
     }
-}, async () => {
-    const stats = await knowledgeGraphManager.getMemoryStats();
+}, async (input) => {
+    const stats = await knowledgeGraphManager.getMemoryStats(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify(stats, null, 2) }],
         structuredContent: stats
@@ -546,16 +536,14 @@ server.registerTool("get_memory_stats", {
 // Register get_recent_changes tool
 server.registerTool("get_recent_changes", {
     title: "Get Recent Changes",
-    description: "Retrieve entities and relations that were created or modified since a specific timestamp",
-    inputSchema: {
-        since: z.string().describe("ISO 8601 timestamp - return changes since this time")
-    },
+    description: "Retrieve entities and relations that were created or modified since a specific timestamp (thread isolation enforced)",
+    inputSchema: GetRecentChangesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ since }) => {
-    const changes = await knowledgeGraphManager.getRecentChanges(since);
+}, async (input) => {
+    const changes = await knowledgeGraphManager.getRecentChanges(input.threadId, input.since);
     return {
         content: [{ type: "text", text: JSON.stringify(changes, null, 2) }],
         structuredContent: { ...changes }
@@ -564,19 +552,15 @@ server.registerTool("get_recent_changes", {
 // Register find_relation_path tool
 server.registerTool("find_relation_path", {
     title: "Find Relationship Path",
-    description: "Find a path of relationships connecting two entities in the knowledge graph",
-    inputSchema: {
-        from: z.string().describe("Starting entity name"),
-        to: z.string().describe("Target entity name"),
-        maxDepth: z.number().optional().default(5).describe("Maximum path depth to search (default: 5)")
-    },
+    description: "Find a path of relationships connecting two entities in the knowledge graph (thread isolation enforced)",
+    inputSchema: FindRelationPathInputSchema,
     outputSchema: {
         found: z.boolean(),
         path: z.array(z.string()),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ from, to, maxDepth }) => {
-    const result = await knowledgeGraphManager.findRelationPath(from, to, maxDepth || 5);
+}, async (input) => {
+    const result = await knowledgeGraphManager.findRelationPath(input.threadId, input.from, input.to, input.maxDepth || 5);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         structuredContent: result
@@ -585,8 +569,8 @@ server.registerTool("find_relation_path", {
 // Register detect_conflicts tool
 server.registerTool("detect_conflicts", {
     title: "Detect Conflicts",
-    description: "Detect potentially conflicting observations within entities using pattern matching and negation detection",
-    inputSchema: {},
+    description: "Detect potentially conflicting observations within entities using pattern matching and negation detection (thread isolation enforced)",
+    inputSchema: DetectConflictsInputSchema,
     outputSchema: {
         conflicts: z.array(z.object({
             entityName: z.string(),
@@ -597,8 +581,8 @@ server.registerTool("detect_conflicts", {
             }))
         }))
     }
-}, async () => {
-    const conflicts = await knowledgeGraphManager.detectConflicts();
+}, async (input) => {
+    const conflicts = await knowledgeGraphManager.detectConflicts(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify({ conflicts }, null, 2) }],
         structuredContent: { conflicts }
@@ -670,13 +654,13 @@ server.registerTool("flag_for_review", {
 // Register get_flagged_entities tool
 server.registerTool("get_flagged_entities", {
     title: "Get Flagged Entities",
-    description: "Retrieve all entities that have been flagged for human review",
-    inputSchema: {},
+    description: "Retrieve all entities that have been flagged for human review (thread isolation enforced)",
+    inputSchema: GetFlaggedEntitiesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat)
     }
-}, async () => {
-    const entities = await knowledgeGraphManager.getFlaggedEntities();
+}, async (input) => {
+    const entities = await knowledgeGraphManager.getFlaggedEntities(input.threadId);
     return {
         content: [{ type: "text", text: JSON.stringify({ entities }, null, 2) }],
         structuredContent: { entities }
@@ -685,17 +669,14 @@ server.registerTool("get_flagged_entities", {
 // Register get_context tool
 server.registerTool("get_context", {
     title: "Get Context",
-    description: "Retrieve entities and relations related to specified entities up to a certain depth, useful for understanding context around specific topics",
-    inputSchema: {
-        entityNames: z.array(z.string()).describe("Names of entities to get context for"),
-        depth: z.number().optional().default(1).describe("How many relationship hops to include (default: 1)")
-    },
+    description: "Retrieve entities and relations related to specified entities up to a certain depth, useful for understanding context around specific topics (thread isolation enforced)",
+    inputSchema: GetContextInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ entityNames, depth }) => {
-    const context = await knowledgeGraphManager.getContext(entityNames, depth || 1);
+}, async (input) => {
+    const context = await knowledgeGraphManager.getContext(input.threadId, input.entityNames, input.depth || 1);
     return {
         content: [{ type: "text", text: JSON.stringify(context, null, 2) }],
         structuredContent: { ...context }
@@ -738,11 +719,11 @@ server.registerTool("get_analytics", {
 // Register get_observation_history tool
 server.registerTool("get_observation_history", {
     title: "Get Observation History",
-    description: "Retrieve the full version chain for a specific observation, showing how it evolved over time",
+    description: "Retrieve the full version chain for a specific observation, showing how it evolved over time (thread isolation enforced)",
     inputSchema: GetObservationHistoryInputSchema,
     outputSchema: GetObservationHistoryOutputSchema
 }, async (input) => {
-    const result = await knowledgeGraphManager.getObservationHistory(input.entityName, input.observationId);
+    const result = await knowledgeGraphManager.getObservationHistory(input.threadId, input.entityName, input.observationId);
     return {
         content: [{ type: "text", text: JSON.stringify({ history: result }, null, 2) }],
         structuredContent: { history: result }

package/dist/lib/analysis/analytics-service.js

@@ -0,0 +1,111 @@
+/**
+ * Analytics service for thread-specific metrics
+ */
+/**
+ * Calculate recent changes for a thread
+ */
+function calculateRecentChanges(threadEntities) {
+    return threadEntities
+        .map(e => ({
+        entityName: e.name,
+        entityType: e.entityType,
+        lastModified: e.timestamp,
+        changeType: 'created' // Simplified: all are 'created' for now
+    }))
+        .sort((a, b) => b.lastModified.localeCompare(a.lastModified))
+        .slice(0, 10);
+}
+/**
+ * Calculate top important entities for a thread
+ */
+function calculateTopImportant(threadEntities) {
+    return threadEntities
+        .map(e => ({
+        entityName: e.name,
+        entityType: e.entityType,
+        importance: e.importance,
+        observationCount: e.observations.length
+    }))
+        .sort((a, b) => b.importance - a.importance)
+        .slice(0, 10);
+}
+/**
+ * Calculate most connected entities for a thread
+ */
+function calculateMostConnected(threadEntities, entityRelationCounts) {
+    return Array.from(entityRelationCounts.entries())
+        .map(([entityName, connectedSet]) => {
+        const entity = threadEntities.find(e => e.name === entityName);
+        return {
+            entityName,
+            entityType: entity.entityType,
+            relationCount: connectedSet.size,
+            connectedTo: Array.from(connectedSet)
+        };
+    })
+        .sort((a, b) => b.relationCount - a.relationCount)
+        .slice(0, 10);
+}
+/**
+ * Calculate orphaned entities for a thread
+ */
+function calculateOrphanedEntities(threadEntities, threadRelations, entityRelationCounts) {
+    const orphaned_entities = [];
+    const allEntityNames = new Set(threadEntities.map(e => e.name));
+    for (const entity of threadEntities) {
+        const relationCount = entityRelationCounts.get(entity.name)?.size || 0;
+        if (relationCount === 0) {
+            orphaned_entities.push({
+                entityName: entity.name,
+                entityType: entity.entityType,
+                reason: 'no_relations'
+            });
+        }
+        else {
+            // Check for broken relations (pointing to non-existent entities)
+            const entityRelations = threadRelations.filter(r => r.from === entity.name || r.to === entity.name);
+            const hasBrokenRelation = entityRelations.some(r => !allEntityNames.has(r.from) || !allEntityNames.has(r.to));
+            if (hasBrokenRelation) {
+                orphaned_entities.push({
+                    entityName: entity.name,
+                    entityType: entity.entityType,
+                    reason: 'broken_relation'
+                });
+            }
+        }
+    }
+    return orphaned_entities;
+}
+/**
+ * Get analytics for a specific thread (limited to 4 core metrics)
+ */
+export async function getAnalytics(storage, threadId) {
+    const graph = await storage.loadGraph();
+    // Filter to thread-specific data
+    const threadEntities = graph.entities.filter(e => e.agentThreadId === threadId);
+    const threadRelations = graph.relations.filter(r => r.agentThreadId === threadId);
+    // Calculate all metrics
+    const recent_changes = calculateRecentChanges(threadEntities);
+    const top_important = calculateTopImportant(threadEntities);
+    // Build the relation counts map once for both most_connected and orphaned_entities
+    const entityRelationCounts = new Map();
+    for (const entity of threadEntities) {
+        entityRelationCounts.set(entity.name, new Set());
+    }
+    for (const relation of threadRelations) {
+        if (entityRelationCounts.has(relation.from)) {
+            entityRelationCounts.get(relation.from).add(relation.to);
+        }
+        if (entityRelationCounts.has(relation.to)) {
+            entityRelationCounts.get(relation.to).add(relation.from);
+        }
+    }
+    const most_connected = calculateMostConnected(threadEntities, entityRelationCounts);
+    const orphaned_entities = calculateOrphanedEntities(threadEntities, threadRelations, entityRelationCounts);
+    return {
+        recent_changes,
+        top_important,
+        most_connected,
+        orphaned_entities
+    };
+}

package/dist/lib/analysis/conflict-detector.js

@@ -0,0 +1,50 @@
+/**
+ * Conflict detection service
+ */
+import { hasNegation, NEGATION_WORDS } from '../utils/negation-detector.js';
+/**
+ * Detect conflicting observations within entities
+ * Identifies potential contradictions by checking for negation patterns
+ * Filtered by threadId for thread isolation
+ */
+export async function detectConflicts(storage, threadId) {
+    const graph = await storage.loadGraph();
+    const conflicts = [];
+    // Only analyze entities in the specified thread
+    for (const entity of graph.entities.filter(e => e.agentThreadId === threadId)) {
+        const entityConflicts = [];
+        for (let i = 0; i < entity.observations.length; i++) {
+            for (let j = i + 1; j < entity.observations.length; j++) {
+                const obs1Content = entity.observations[i].content.toLowerCase();
+                const obs2Content = entity.observations[j].content.toLowerCase();
+                // Skip if observations are in the same version chain
+                if (entity.observations[i].supersedes === entity.observations[j].id ||
+                    entity.observations[j].supersedes === entity.observations[i].id ||
+                    entity.observations[i].superseded_by === entity.observations[j].id ||
+                    entity.observations[j].superseded_by === entity.observations[i].id) {
+                    continue;
+                }
+                // Check for negation patterns
+                const obs1HasNegation = hasNegation(obs1Content);
+                const obs2HasNegation = hasNegation(obs2Content);
+                // If one has negation and they share key words, might be a conflict
+                if (obs1HasNegation !== obs2HasNegation) {
+                    const words1 = obs1Content.split(/\s+/).filter(w => w.length > 3);
+                    const words2Set = new Set(obs2Content.split(/\s+/).filter(w => w.length > 3));
+                    const commonWords = words1.filter(w => words2Set.has(w) && !NEGATION_WORDS.has(w));
+                    if (commonWords.length >= 2) {
+                        entityConflicts.push({
+                            obs1: entity.observations[i].content,
+                            obs2: entity.observations[j].content,
+                            reason: 'Potential contradiction with negation'
+                        });
+                    }
+                }
+            }
+        }
+        if (entityConflicts.length > 0) {
+            conflicts.push({ entityName: entity.name, conflicts: entityConflicts });
+        }
+    }
+    return conflicts;
+}

package/dist/lib/analysis/context-builder.js

@@ -0,0 +1,34 @@
+/**
+ * Context builder service
+ */
+/**
+ * Get context (entities related to specified entities up to a certain depth)
+ * Expands to include related entities up to specified depth
+ * Filtered by threadId for thread isolation
+ */
+export async function getContext(storage, threadId, entityNames, depth = 1) {
+    const graph = await storage.loadGraph();
+    const contextEntityNames = new Set(entityNames);
+    // Expand to include related entities up to specified depth - only within this thread
+    for (let d = 0; d < depth; d++) {
+        const currentEntities = Array.from(contextEntityNames);
+        for (const entityName of currentEntities) {
+            // Find all relations involving this entity - only from this thread
+            const relatedRelations = graph.relations.filter(r => r.agentThreadId === threadId &&
+                (r.from === entityName || r.to === entityName));
+            // Add related entities
+            relatedRelations.forEach(r => {
+                contextEntityNames.add(r.from);
+                contextEntityNames.add(r.to);
+            });
+        }
+    }
+    // Get all entities and relations in context - only from this thread
+    const contextEntities = graph.entities.filter(e => e.agentThreadId === threadId && contextEntityNames.has(e.name));
+    const contextRelations = graph.relations.filter(r => r.agentThreadId === threadId &&
+        contextEntityNames.has(r.from) && contextEntityNames.has(r.to));
+    return {
+        entities: contextEntities,
+        relations: contextRelations
+    };
+}

package/dist/lib/analysis/memory-stats.js

@@ -0,0 +1,67 @@
+/**
+ * Memory statistics service
+ */
+/**
+ * Get comprehensive memory statistics for a specific thread
+ * Filtered by threadId for thread isolation
+ */
+export async function getMemoryStats(storage, threadId) {
+    const graph = await storage.loadGraph();
+    // Filter entities and relations by threadId
+    const threadEntities = graph.entities.filter(e => e.agentThreadId === threadId);
+    const threadRelations = graph.relations.filter(r => r.agentThreadId === threadId);
+    // Count entity types
+    const entityTypes = {};
+    threadEntities.forEach(e => {
+        entityTypes[e.entityType] = (entityTypes[e.entityType] || 0) + 1;
+    });
+    // Calculate averages
+    const avgConfidence = threadEntities.length > 0
+        ? threadEntities.reduce((sum, e) => sum + e.confidence, 0) / threadEntities.length
+        : 0;
+    const avgImportance = threadEntities.length > 0
+        ? threadEntities.reduce((sum, e) => sum + e.importance, 0) / threadEntities.length
+        : 0;
+    // Count unique threads in the system (across all entities in the graph)
+    const threads = new Set(graph.entities
+        .map(e => e.agentThreadId)
+        .filter((id) => !!id));
+    // Recent activity (last 7 days, grouped by day) - only for this thread
+    const now = new Date();
+    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const recentEntities = threadEntities.filter(e => new Date(e.timestamp) >= sevenDaysAgo);
+    // Group by day
+    const activityByDay = {};
+    recentEntities.forEach(e => {
+        const day = e.timestamp.substring(0, 10); // YYYY-MM-DD
+        activityByDay[day] = (activityByDay[day] || 0) + 1;
+    });
+    const recentActivity = Object.entries(activityByDay)
+        .map(([timestamp, entityCount]) => ({ timestamp, entityCount }))
+        .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    return {
+        entityCount: threadEntities.length,
+        relationCount: threadRelations.length,
+        threadCount: threads.size,
+        entityTypes,
+        avgConfidence,
+        avgImportance,
+        recentActivity
+    };
+}
+/**
+ * Get recent changes since a specific timestamp for a specific thread
+ * Filtered by threadId for thread isolation
+ */
+export async function getRecentChanges(storage, threadId, since) {
+    const graph = await storage.loadGraph();
+    const sinceDate = new Date(since);
+    // Only return entities and relations from this thread that were modified since the specified time
+    const recentEntities = graph.entities.filter(e => e.agentThreadId === threadId && new Date(e.timestamp) >= sinceDate);
+    // Only include relations from this thread that are recent themselves
+    const recentRelations = graph.relations.filter(r => r.agentThreadId === threadId && new Date(r.timestamp) >= sinceDate);
+    return {
+        entities: recentEntities,
+        relations: recentRelations
+    };
+}

package/dist/lib/analysis/path-finder.js

@@ -0,0 +1,78 @@
+/**
+ * Path finding service for the knowledge graph
+ */
+/**
+ * Find the shortest path between two entities in the knowledge graph
+ * Uses BFS algorithm with bidirectional search
+ * Filtered by threadId for thread isolation
+ */
+export async function findRelationPath(storage, threadId, from, to, maxDepth = 5) {
+    const graph = await storage.loadGraph();
+    if (from === to) {
+        return { found: true, path: [from], relations: [] };
+    }
+    // Build indexes for efficient relation lookup - only for relations in this thread
+    const relationsFrom = new Map();
+    const relationsTo = new Map();
+    for (const rel of graph.relations.filter(r => r.agentThreadId === threadId)) {
+        if (!relationsFrom.has(rel.from)) {
+            relationsFrom.set(rel.from, []);
+        }
+        relationsFrom.get(rel.from).push(rel);
+        if (!relationsTo.has(rel.to)) {
+            relationsTo.set(rel.to, []);
+        }
+        relationsTo.get(rel.to).push(rel);
+    }
+    // BFS to find shortest path
+    const queue = [
+        { entity: from, path: [from], relations: [] }
+    ];
+    const visited = new Set([from]);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current.path.length > maxDepth) {
+            continue;
+        }
+        // Find all relations connected to current entity (both outgoing and incoming for bidirectional search)
+        const outgoing = relationsFrom.get(current.entity) || [];
+        const incoming = relationsTo.get(current.entity) || [];
+        // Check outgoing relations
+        for (const rel of outgoing) {
+            if (rel.to === to) {
+                return {
+                    found: true,
+                    path: [...current.path, rel.to],
+                    relations: [...current.relations, rel]
+                };
+            }
+            if (!visited.has(rel.to)) {
+                visited.add(rel.to);
+                queue.push({
+                    entity: rel.to,
+                    path: [...current.path, rel.to],
+                    relations: [...current.relations, rel]
+                });
+            }
+        }
+        // Check incoming relations (traverse backwards)
+        for (const rel of incoming) {
+            if (rel.from === to) {
+                return {
+                    found: true,
+                    path: [...current.path, rel.from],
+                    relations: [...current.relations, rel]
+                };
+            }
+            if (!visited.has(rel.from)) {
+                visited.add(rel.from);
+                queue.push({
+                    entity: rel.from,
+                    path: [...current.path, rel.from],
+                    relations: [...current.relations, rel]
+                });
+            }
+        }
+    }
+    return { found: false, path: [], relations: [] };
+}

package/dist/lib/collaboration/conversation-service.js

@@ -0,0 +1,43 @@
+/**
+ * Conversation service (agent threads)
+ */
+/**
+ * List all conversations (agent threads) with summary information
+ */
+export async function listConversations(storage) {
+    const graph = await storage.loadGraph();
+    // Group data by agent thread
+    const threadMap = new Map();
+    // Collect entities by thread
+    for (const entity of graph.entities) {
+        if (!threadMap.has(entity.agentThreadId)) {
+            threadMap.set(entity.agentThreadId, { entities: [], relations: [], timestamps: [] });
+        }
+        const threadData = threadMap.get(entity.agentThreadId);
+        threadData.entities.push(entity);
+        threadData.timestamps.push(entity.timestamp);
+    }
+    // Collect relations by thread
+    for (const relation of graph.relations) {
+        if (!threadMap.has(relation.agentThreadId)) {
+            threadMap.set(relation.agentThreadId, { entities: [], relations: [], timestamps: [] });
+        }
+        const threadData = threadMap.get(relation.agentThreadId);
+        threadData.relations.push(relation);
+        threadData.timestamps.push(relation.timestamp);
+    }
+    // Build conversation summaries
+    const conversations = Array.from(threadMap.entries()).map(([agentThreadId, data]) => {
+        const timestamps = data.timestamps.sort((a, b) => a.localeCompare(b));
+        return {
+            agentThreadId,
+            entityCount: data.entities.length,
+            relationCount: data.relations.length,
+            firstCreated: timestamps[0] || '',
+            lastUpdated: timestamps[timestamps.length - 1] || ''
+        };
+    });
+    // Sort by last updated (most recent first)
+    conversations.sort((a, b) => b.lastUpdated.localeCompare(a.lastUpdated));
+    return { conversations };
+}