server-memory-enhanced 2.3.2 → 3.1.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, CreateEntitiesInputSchema, CreateRelationsInputSchema, AddObservationsInputSchema, DeleteEntitiesInputSchema, DeleteObservationsInputSchema, DeleteRelationsInputSchema, PruneMemoryInputSchema, BulkUpdateInputSchema, FlagForReviewInputSchema } 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';
@@ -115,7 +115,7 @@ server.registerTool("save_memory", {
     inputSchema: SaveMemoryInputSchema,
     outputSchema: SaveMemoryOutputSchema
 }, async (input) => {
-    const result = await handleSaveMemory(input, (entities) => knowledgeGraphManager.createEntities(entities), (relations) => knowledgeGraphManager.createRelations(relations), (threadId) => knowledgeGraphManager.getEntityNamesInThread(threadId));
+    const result = await handleSaveMemory(input, (threadId, entities) => knowledgeGraphManager.createEntities(threadId, entities), (threadId, relations) => knowledgeGraphManager.createRelations(threadId, relations), (threadId) => knowledgeGraphManager.getEntityNamesInThread(threadId));
     if (result.success) {
         // Build success message with entity names
         let successText = `✓ Successfully saved ${result.created.entities} entities and ${result.created.relations} relations.\n` +
@@ -171,14 +171,13 @@ server.registerTool("save_memory", {
 server.registerTool("create_entities", {
     title: "Create Entities",
     description: "Create multiple new entities in the knowledge graph with metadata (agent thread ID, timestamp, confidence, importance)",
-    inputSchema: {
-        entities: z.array(EntitySchemaCompat)
-    },
+    inputSchema: CreateEntitiesInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat)
     }
-}, async ({ entities }) => {
-    const result = await knowledgeGraphManager.createEntities(entities);
+}, async (input) => {
+    const { threadId, entities } = input;
+    const result = await knowledgeGraphManager.createEntities(threadId, entities);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         structuredContent: { entities: result }
@@ -188,14 +187,13 @@ server.registerTool("create_entities", {
 server.registerTool("create_relations", {
     title: "Create Relations",
     description: "Create multiple new relations between entities in the knowledge graph with metadata (agent thread ID, timestamp, confidence, importance). Relations should be in active voice",
-    inputSchema: {
-        relations: z.array(RelationSchemaCompat)
-    },
+    inputSchema: CreateRelationsInputSchema,
     outputSchema: {
         relations: z.array(RelationSchemaCompat)
     }
-}, async ({ relations }) => {
-    const result = await knowledgeGraphManager.createRelations(relations);
+}, async (input) => {
+    const { threadId, relations } = input;
+    const result = await knowledgeGraphManager.createRelations(threadId, relations);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         structuredContent: { relations: result }
@@ -205,24 +203,16 @@ server.registerTool("create_relations", {
 server.registerTool("add_observations", {
     title: "Add Observations",
     description: "Add new observations to existing entities in the knowledge graph with metadata (agent thread ID, timestamp, confidence, importance)",
-    inputSchema: {
-        observations: z.array(z.object({
-            entityName: z.string().describe("The name of the entity to add the observations to"),
-            contents: z.array(z.string()).describe("An array of observation contents to add"),
-            agentThreadId: z.string().describe("The agent thread ID adding these observations"),
-            timestamp: z.string().describe("ISO 8601 timestamp of when the observations are added"),
-            confidence: z.number().min(0).max(1).describe("Confidence coefficient from 0 to 1"),
-            importance: z.number().min(0).max(1).describe("Importance for memory integrity if lost: 0 (not important) to 1 (critical)")
-        }))
-    },
+    inputSchema: AddObservationsInputSchema,
     outputSchema: {
         results: z.array(z.object({
             entityName: z.string(),
             addedObservations: z.array(z.string())
         }))
     }
-}, async ({ observations }) => {
-    const result = await knowledgeGraphManager.addObservations(observations);
+}, async (input) => {
+    const { threadId, observations } = input;
+    const result = await knowledgeGraphManager.addObservations(threadId, observations);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         structuredContent: { results: result }
@@ -232,15 +222,14 @@ server.registerTool("add_observations", {
 server.registerTool("delete_entities", {
     title: "Delete Entities",
     description: "Delete multiple entities and their associated relations from the knowledge graph",
-    inputSchema: {
-        entityNames: z.array(z.string()).describe("An array of entity names to delete")
-    },
+    inputSchema: DeleteEntitiesInputSchema,
     outputSchema: {
         success: z.boolean(),
         message: z.string()
     }
-}, async ({ entityNames }) => {
-    await knowledgeGraphManager.deleteEntities(entityNames);
+}, async (input) => {
+    const { threadId, entityNames } = input;
+    await knowledgeGraphManager.deleteEntities(threadId, entityNames);
     return {
         content: [{ type: "text", text: "Entities deleted successfully" }],
         structuredContent: { success: true, message: "Entities deleted successfully" }
@@ -250,18 +239,14 @@ server.registerTool("delete_entities", {
 server.registerTool("delete_observations", {
     title: "Delete Observations",
     description: "Delete specific observations from entities in the knowledge graph",
-    inputSchema: {
-        deletions: z.array(z.object({
-            entityName: z.string().describe("The name of the entity containing the observations"),
-            observations: z.array(z.string()).describe("An array of observations to delete")
-        }))
-    },
+    inputSchema: DeleteObservationsInputSchema,
     outputSchema: {
         success: z.boolean(),
         message: z.string()
     }
-}, async ({ deletions }) => {
-    await knowledgeGraphManager.deleteObservations(deletions);
+}, async (input) => {
+    const { threadId, deletions } = input;
+    await knowledgeGraphManager.deleteObservations(threadId, deletions);
     return {
         content: [{ type: "text", text: "Observations deleted successfully" }],
         structuredContent: { success: true, message: "Observations deleted successfully" }
@@ -273,7 +258,8 @@ server.registerTool("update_observation", {
     description: "Update an existing observation by creating a new version with updated content. This maintains version history through the supersedes/superseded_by chain.",
     inputSchema: UpdateObservationInputSchema.shape,
     outputSchema: UpdateObservationOutputSchema.shape
-}, async ({ entityName, observationId, newContent, agentThreadId, timestamp, confidence, importance }) => {
+}, async (input) => {
+    const { entityName, observationId, newContent, agentThreadId, timestamp, confidence, importance } = input;
     const updatedObservation = await knowledgeGraphManager.updateObservation({
         entityName,
         observationId,
@@ -297,15 +283,14 @@ server.registerTool("update_observation", {
 server.registerTool("delete_relations", {
     title: "Delete Relations",
     description: "Delete multiple relations from the knowledge graph",
-    inputSchema: {
-        relations: z.array(RelationSchemaCompat).describe("An array of relations to delete")
-    },
+    inputSchema: DeleteRelationsInputSchema,
     outputSchema: {
         success: z.boolean(),
         message: z.string()
     }
-}, async ({ relations }) => {
-    await knowledgeGraphManager.deleteRelations(relations);
+}, async (input) => {
+    const { threadId, relations } = input;
+    await knowledgeGraphManager.deleteRelations(threadId, relations);
     return {
         content: [{ type: "text", text: "Relations deleted successfully" }],
         structuredContent: { success: true, message: "Relations deleted successfully" }
@@ -314,14 +299,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 +315,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 +331,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 +347,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 +364,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 +497,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 +511,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 +521,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 +537,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 +554,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 +566,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 }
@@ -608,17 +577,14 @@ server.registerTool("detect_conflicts", {
 server.registerTool("prune_memory", {
     title: "Prune Memory",
     description: "Remove old or low-importance entities to manage memory size, with option to keep minimum number of entities",
-    inputSchema: {
-        olderThan: z.string().optional().describe("ISO 8601 timestamp - remove entities older than this"),
-        importanceLessThan: z.number().min(0).max(1).optional().describe("Remove entities with importance less than this value"),
-        keepMinEntities: z.number().optional().describe("Minimum number of entities to keep regardless of filters")
-    },
+    inputSchema: PruneMemoryInputSchema,
     outputSchema: {
         removedEntities: z.number(),
         removedRelations: z.number()
     }
-}, async (options) => {
-    const result = await knowledgeGraphManager.pruneMemory(options);
+}, async (input) => {
+    const { threadId, ...options } = input;
+    const result = await knowledgeGraphManager.pruneMemory(threadId, options);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         structuredContent: result
@@ -628,20 +594,14 @@ server.registerTool("prune_memory", {
 server.registerTool("bulk_update", {
     title: "Bulk Update",
     description: "Efficiently update multiple entities at once with new confidence, importance, or observations",
-    inputSchema: {
-        updates: z.array(z.object({
-            entityName: z.string(),
-            confidence: z.number().min(0).max(1).optional(),
-            importance: z.number().min(0).max(1).optional(),
-            addObservations: z.array(z.string()).optional()
-        }))
-    },
+    inputSchema: BulkUpdateInputSchema,
     outputSchema: {
         updated: z.number(),
         notFound: z.array(z.string())
     }
-}, async ({ updates }) => {
-    const result = await knowledgeGraphManager.bulkUpdate(updates);
+}, async (input) => {
+    const { threadId, updates } = input;
+    const result = await knowledgeGraphManager.bulkUpdate(threadId, updates);
     return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         structuredContent: result
@@ -651,17 +611,14 @@ server.registerTool("bulk_update", {
 server.registerTool("flag_for_review", {
     title: "Flag Entity for Review",
     description: "Mark an entity for human review with a specific reason (Human-in-the-Loop)",
-    inputSchema: {
-        entityName: z.string().describe("Name of entity to flag"),
-        reason: z.string().describe("Reason for flagging"),
-        reviewer: z.string().optional().describe("Optional reviewer name")
-    },
+    inputSchema: FlagForReviewInputSchema,
     outputSchema: {
         success: z.boolean(),
         message: z.string()
     }
-}, async ({ entityName, reason, reviewer }) => {
-    await knowledgeGraphManager.flagForReview(entityName, reason, reviewer);
+}, async (input) => {
+    const { threadId, entityName, reason, reviewer } = input;
+    await knowledgeGraphManager.flagForReview(threadId, entityName, reason, reviewer);
     return {
         content: [{ type: "text", text: `Entity "${entityName}" flagged for review` }],
         structuredContent: { success: true, message: `Entity "${entityName}" flagged for review` }
@@ -670,13 +627,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 +642,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 +692,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/conflict-detector.js

@@ -5,11 +5,13 @@ 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) {
+export async function detectConflicts(storage, threadId) {
     const graph = await storage.loadGraph();
     const conflicts = [];
-    for (const entity of graph.entities) {
+    // 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++) {

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

@@ -4,16 +4,18 @@
 /**
  * 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, entityNames, depth = 1) {
+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
+    // 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
-            const relatedRelations = graph.relations.filter(r => r.from === entityName || r.to === entityName);
+            // 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);
@@ -21,9 +23,10 @@ export async function getContext(storage, entityNames, depth = 1) {
             });
         }
     }
-    // Get all entities and relations in context
-    const contextEntities = graph.entities.filter(e => contextEntityNames.has(e.name));
-    const contextRelations = graph.relations.filter(r => contextEntityNames.has(r.from) && contextEntityNames.has(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

@@ -2,31 +2,34 @@
  * Memory statistics service
  */
 /**
- * Get comprehensive memory statistics
+ * Get comprehensive memory statistics for a specific thread
+ * Filtered by threadId for thread isolation
  */
-export async function getMemoryStats(storage) {
+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 = {};
-    graph.entities.forEach(e => {
+    threadEntities.forEach(e => {
         entityTypes[e.entityType] = (entityTypes[e.entityType] || 0) + 1;
     });
     // Calculate averages
-    const avgConfidence = graph.entities.length > 0
-        ? graph.entities.reduce((sum, e) => sum + e.confidence, 0) / graph.entities.length
+    const avgConfidence = threadEntities.length > 0
+        ? threadEntities.reduce((sum, e) => sum + e.confidence, 0) / threadEntities.length
         : 0;
-    const avgImportance = graph.entities.length > 0
-        ? graph.entities.reduce((sum, e) => sum + e.importance, 0) / graph.entities.length
+    const avgImportance = threadEntities.length > 0
+        ? threadEntities.reduce((sum, e) => sum + e.importance, 0) / threadEntities.length
         : 0;
-    // Count unique threads
-    const threads = new Set([
-        ...graph.entities.map(e => e.agentThreadId),
-        ...graph.relations.map(r => r.agentThreadId)
-    ]);
-    // Recent activity (last 7 days, grouped by day)
+    // 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 = graph.entities.filter(e => new Date(e.timestamp) >= sevenDaysAgo);
+    const recentEntities = threadEntities.filter(e => new Date(e.timestamp) >= sevenDaysAgo);
     // Group by day
     const activityByDay = {};
     recentEntities.forEach(e => {
@@ -37,8 +40,8 @@ export async function getMemoryStats(storage) {
         .map(([timestamp, entityCount]) => ({ timestamp, entityCount }))
         .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
     return {
-        entityCount: graph.entities.length,
-        relationCount: graph.relations.length,
+        entityCount: threadEntities.length,
+        relationCount: threadRelations.length,
         threadCount: threads.size,
         entityTypes,
         avgConfidence,
@@ -47,15 +50,16 @@ export async function getMemoryStats(storage) {
     };
 }
 /**
- * Get recent changes since a specific timestamp
+ * Get recent changes since a specific timestamp for a specific thread
+ * Filtered by threadId for thread isolation
  */
-export async function getRecentChanges(storage, since) {
+export async function getRecentChanges(storage, threadId, since) {
     const graph = await storage.loadGraph();
     const sinceDate = new Date(since);
-    // Only return entities and relations that were actually modified since the specified time
-    const recentEntities = graph.entities.filter(e => new Date(e.timestamp) >= sinceDate);
-    // Only include relations that are recent themselves
-    const recentRelations = graph.relations.filter(r => new Date(r.timestamp) >= sinceDate);
+    // 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

@@ -4,16 +4,17 @@
 /**
  * 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, from, to, maxDepth = 5) {
+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
+    // 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) {
+    for (const rel of graph.relations.filter(r => r.agentThreadId === threadId)) {
         if (!relationsFrom.has(rel.from)) {
             relationsFrom.set(rel.from, []);
         }

package/dist/lib/collaboration/flag-manager.js

@@ -4,12 +4,13 @@
 import { randomUUID } from 'crypto';
 /**
  * Flag an entity for review
+ * Thread isolation: Only flags entities in the specified thread
  */
-export async function flagForReview(storage, entityName, reason, reviewer) {
+export async function flagForReview(storage, threadId, entityName, reason, reviewer) {
     const graph = await storage.loadGraph();
-    const entity = graph.entities.find(e => e.name === entityName);
+    const entity = graph.entities.find(e => e.name === entityName && e.agentThreadId === threadId);
     if (!entity) {
-        throw new Error(`Entity with name ${entityName} not found`);
+        throw new Error(`Entity with name ${entityName} not found in thread ${threadId}`);
     }
     // Add a special observation to mark for review
     const flagContent = `[FLAGGED FOR REVIEW: ${reason}${reviewer ? ` - Reviewer: ${reviewer}` : ''}]`;
@@ -30,9 +31,11 @@ export async function flagForReview(storage, entityName, reason, reviewer) {
     }
 }
 /**
- * Get all entities flagged for review
+ * Get all entities flagged for review in a specific thread
+ * Filtered by threadId for thread isolation
  */
-export async function getFlaggedEntities(storage) {
+export async function getFlaggedEntities(storage, threadId) {
     const graph = await storage.loadGraph();
-    return graph.entities.filter(e => e.observations.some(obs => obs.content.includes('[FLAGGED FOR REVIEW:')));
+    return graph.entities.filter(e => e.agentThreadId === threadId &&
+        e.observations.some(obs => obs.content.includes('[FLAGGED FOR REVIEW:')));
 }