server-memory-enhanced 3.0.0 → 3.2.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, ReadGraphInputSchema, SearchNodesInputSchema, OpenNodesInputSchema, QueryNodesInputSchema, GetMemoryStatsInputSchema, GetRecentChangesInputSchema, FindRelationPathInputSchema, DetectConflictsInputSchema, GetFlaggedEntitiesInputSchema, GetContextInputSchema } 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,15 @@ server.registerTool("delete_relations", {
 // Register read_graph tool
 server.registerTool("read_graph", {
     title: "Read Graph",
-    description: "Read the knowledge graph for a specific thread (thread isolation enforced)",
+    description: "Read the knowledge graph for a specific thread (thread isolation enforced). Supports filtering by minimum importance threshold.",
     inputSchema: ReadGraphInputSchema,
     outputSchema: {
         entities: z.array(EntitySchemaCompat),
         relations: z.array(RelationSchemaCompat)
     }
 }, async (input) => {
-    const graph = await knowledgeGraphManager.readGraph(input.threadId);
+    const { threadId, minImportance } = input;
+    const graph = await knowledgeGraphManager.readGraph(threadId, minImportance);
     return {
         content: [{ type: "text", text: JSON.stringify(graph, null, 2) }],
         structuredContent: { ...graph }
@@ -592,17 +578,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
@@ -612,20 +595,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
@@ -635,17 +612,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` }

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}` : ''}]`;

package/dist/lib/knowledge-graph-manager.js

@@ -43,39 +43,43 @@ export class KnowledgeGraphManager {
         await this.initializePromise;
     }
     // Entity Operations
-    async createEntities(entities) {
+    async createEntities(threadId, entities) {
         await this.ensureInitialized();
-        return EntityOps.createEntities(this.storage, entities);
+        return EntityOps.createEntities(this.storage, threadId, entities);
     }
-    async deleteEntities(entityNames) {
+    async deleteEntities(threadId, entityNames) {
         await this.ensureInitialized();
-        return EntityOps.deleteEntities(this.storage, entityNames);
+        return EntityOps.deleteEntities(this.storage, threadId, entityNames);
     }
     // Relation Operations
-    async createRelations(relations) {
+    async createRelations(threadId, relations) {
         await this.ensureInitialized();
-        return RelationOps.createRelations(this.storage, relations);
+        return RelationOps.createRelations(this.storage, threadId, relations);
     }
-    async deleteRelations(relations) {
+    async deleteRelations(threadId, relations) {
         await this.ensureInitialized();
-        return RelationOps.deleteRelations(this.storage, relations);
+        return RelationOps.deleteRelations(this.storage, threadId, relations);
     }
     // Observation Operations
-    async addObservations(observations) {
+    async addObservations(threadId, observations) {
         await this.ensureInitialized();
-        return ObservationOps.addObservations(this.storage, observations);
+        return ObservationOps.addObservations(this.storage, threadId, observations);
     }
-    async deleteObservations(deletions) {
+    async deleteObservations(threadId, deletions) {
         await this.ensureInitialized();
-        return ObservationOps.deleteObservations(this.storage, deletions);
+        return ObservationOps.deleteObservations(this.storage, threadId, deletions);
     }
     async updateObservation(params) {
         await this.ensureInitialized();
         return ObservationOps.updateObservation(this.storage, params);
     }
     // Graph Reading Operations
-    async readGraph(threadId) {
+    async readGraph(threadId, minImportance) {
         await this.ensureInitialized();
+        // Pass minImportance if provided, otherwise let readGraph use its default
+        if (minImportance !== undefined) {
+            return GraphReader.readGraph(this.storage, threadId, minImportance);
+        }
         return GraphReader.readGraph(this.storage, threadId);
     }
     // Search Operations
@@ -131,18 +135,18 @@ export class KnowledgeGraphManager {
         return AnalyticsService.getAnalytics(this.storage, threadId);
     }
     // Memory Maintenance
-    async pruneMemory(options) {
+    async pruneMemory(threadId, options) {
         await this.ensureInitialized();
-        return MemoryPruner.pruneMemory(this.storage, options);
+        return MemoryPruner.pruneMemory(this.storage, threadId, options);
     }
-    async bulkUpdate(updates) {
+    async bulkUpdate(threadId, updates) {
         await this.ensureInitialized();
-        return BulkUpdater.bulkUpdate(this.storage, updates);
+        return BulkUpdater.bulkUpdate(this.storage, threadId, updates);
     }
     // Collaboration Features
-    async flagForReview(entityName, reason, reviewer) {
+    async flagForReview(threadId, entityName, reason, reviewer) {
         await this.ensureInitialized();
-        return FlagManager.flagForReview(this.storage, entityName, reason, reviewer);
+        return FlagManager.flagForReview(this.storage, threadId, entityName, reason, reviewer);
     }
     async getFlaggedEntities(threadId) {
         await this.ensureInitialized();

package/dist/lib/maintenance/bulk-updater.js

@@ -4,13 +4,14 @@
 import { randomUUID } from 'crypto';
 /**
  * Perform bulk updates on multiple entities
+ * Thread isolation: Only updates entities in the specified thread
  */
-export async function bulkUpdate(storage, updates) {
+export async function bulkUpdate(storage, threadId, updates) {
     const graph = await storage.loadGraph();
     let updated = 0;
     const notFound = [];
     for (const update of updates) {
-        const entity = graph.entities.find(e => e.name === update.entityName);
+        const entity = graph.entities.find(e => e.name === update.entityName && e.agentThreadId === threadId);
         if (!entity) {
             notFound.push(update.entityName);
             continue;

package/dist/lib/maintenance/memory-pruner.js

@@ -3,13 +3,18 @@
  */
 /**
  * Prune memory based on age and importance criteria
+ * Thread isolation: Only prunes entities and relations in the specified thread
  */
-export async function pruneMemory(storage, options) {
+export async function pruneMemory(storage, threadId, options) {
     const graph = await storage.loadGraph();
-    const initialEntityCount = graph.entities.length;
-    const initialRelationCount = graph.relations.length;
-    // Filter entities to remove
-    let entitiesToKeep = graph.entities;
+    // Filter to only entities in the specified thread
+    const threadEntities = graph.entities.filter(e => e.agentThreadId === threadId);
+    const initialEntityCount = threadEntities.length;
+    // Count initial relations in the thread
+    const threadEntityNames = new Set(threadEntities.map(e => e.name));
+    const initialRelationCount = graph.relations.filter(r => r.agentThreadId === threadId && threadEntityNames.has(r.from) && threadEntityNames.has(r.to)).length;
+    // Filter entities to remove within the thread
+    let entitiesToKeep = threadEntities;
     if (options.olderThan) {
         const cutoffDate = new Date(options.olderThan);
         entitiesToKeep = entitiesToKeep.filter(e => new Date(e.timestamp) >= cutoffDate);
@@ -18,13 +23,13 @@ export async function pruneMemory(storage, options) {
         entitiesToKeep = entitiesToKeep.filter(e => e.importance >= options.importanceLessThan);
     }
     // Ensure we keep minimum entities
-    // If keepMinEntities is set and we need more entities, backfill from the original graph
+    // If keepMinEntities is set and we need more entities, backfill from the original thread entities
     // sorted by importance and recency
     if (options.keepMinEntities && entitiesToKeep.length < options.keepMinEntities) {
         const minToKeep = options.keepMinEntities;
         const alreadyKeptNames = new Set(entitiesToKeep.map(e => e.name));
-        // Candidates are entities from the original graph that are not already kept
-        const candidates = graph.entities
+        // Candidates are entities from the thread that are not already kept
+        const candidates = threadEntities
             .filter(e => !alreadyKeptNames.has(e.name))
             .sort((a, b) => {
             if (a.importance !== b.importance)
@@ -36,13 +41,17 @@ export async function pruneMemory(storage, options) {
         entitiesToKeep = [...entitiesToKeep, ...backfill];
     }
     const keptEntityNames = new Set(entitiesToKeep.map(e => e.name));
-    // Remove relations that reference removed entities
-    const relationsToKeep = graph.relations.filter(r => keptEntityNames.has(r.from) && keptEntityNames.has(r.to));
-    graph.entities = entitiesToKeep;
-    graph.relations = relationsToKeep;
+    const removedEntityNames = new Set(threadEntityNames);
+    keptEntityNames.forEach(name => removedEntityNames.delete(name));
+    // Update the main graph: remove entities from this thread that should be pruned
+    graph.entities = graph.entities.filter(e => e.agentThreadId !== threadId || keptEntityNames.has(e.name));
+    // Remove relations from this thread that reference removed entities
+    graph.relations = graph.relations.filter(r => !(r.agentThreadId === threadId && (removedEntityNames.has(r.from) || removedEntityNames.has(r.to))));
     await storage.saveGraph(graph);
+    // Count remaining relations in the thread after pruning
+    const finalRelationCount = graph.relations.filter(r => r.agentThreadId === threadId && keptEntityNames.has(r.from) && keptEntityNames.has(r.to)).length;
     return {
         removedEntities: initialEntityCount - entitiesToKeep.length,
-        removedRelations: initialRelationCount - relationsToKeep.length
+        removedRelations: initialRelationCount - finalRelationCount
     };
 }

package/dist/lib/operations/entity-operations.js

@@ -5,10 +5,12 @@
  * Create new entities in the knowledge graph
  * Entity names are globally unique across all threads in the collaborative knowledge graph
  * This prevents duplicate entities while allowing multiple threads to contribute to the same entity
+ * @param threadId - Thread ID passed for context (entities already have agentThreadId set)
  */
-export async function createEntities(storage, entities) {
+export async function createEntities(storage, threadId, entities) {
     const graph = await storage.loadGraph();
     const existingNames = new Set(graph.entities.map(e => e.name));
+    // Filter out entities that already exist, entities are expected to have agentThreadId already set
     const newEntities = entities.filter(e => !existingNames.has(e.name));
     graph.entities.push(...newEntities);
     await storage.saveGraph(graph);
@@ -17,11 +19,18 @@ export async function createEntities(storage, entities) {
 /**
  * Delete entities from the knowledge graph
  * Also removes all relations referencing the deleted entities
+ * Thread isolation: Only deletes entities that belong to the specified thread
  */
-export async function deleteEntities(storage, entityNames) {
+export async function deleteEntities(storage, threadId, entityNames) {
     const graph = await storage.loadGraph();
     const namesToDelete = new Set(entityNames);
-    graph.entities = graph.entities.filter(e => !namesToDelete.has(e.name));
-    graph.relations = graph.relations.filter(r => !namesToDelete.has(r.from) && !namesToDelete.has(r.to));
+    // Determine which entities will actually be deleted for this thread
+    const deletedEntityNames = new Set(graph.entities
+        .filter(e => namesToDelete.has(e.name) && e.agentThreadId === threadId)
+        .map(e => e.name));
+    // Delete entities that were identified for deletion
+    graph.entities = graph.entities.filter(e => !deletedEntityNames.has(e.name));
+    // Only delete relations that belong to the specified thread and reference actually deleted entities
+    graph.relations = graph.relations.filter(r => !(r.agentThreadId === threadId && (deletedEntityNames.has(r.from) || deletedEntityNames.has(r.to))));
     await storage.saveGraph(graph);
 }

package/dist/lib/operations/observation-operations.js

@@ -7,13 +7,15 @@ import { validateObservationNotSuperseded, createObservationVersion } from '../u
 /**
  * Add observations to entities
  * Checks for duplicate content and creates version chains when content is updated
+ * Thread parameter is used for validation to ensure only entities in the thread are modified
  */
-export async function addObservations(storage, observations) {
+export async function addObservations(storage, threadId, observations) {
     const graph = await storage.loadGraph();
     const results = observations.map(o => {
-        const entity = graph.entities.find(e => e.name === o.entityName);
+        // Find entity - thread validation happens here to ensure we only modify entities from this thread
+        const entity = graph.entities.find(e => e.name === o.entityName && e.agentThreadId === threadId);
         if (!entity) {
-            throw new Error(`Entity with name ${o.entityName} not found`);
+            throw new Error(`Entity with name ${o.entityName} not found in thread ${threadId}`);
         }
         // Check for existing observations with same content to create version chain
         const newObservations = [];
@@ -56,11 +58,13 @@ export async function addObservations(storage, observations) {
 /**
  * Delete observations from entities
  * Supports deletion by content (backward compatibility) or by ID
+ * Thread parameter is used for validation to ensure only entities in the thread are modified
  */
-export async function deleteObservations(storage, deletions) {
+export async function deleteObservations(storage, threadId, deletions) {
     const graph = await storage.loadGraph();
     deletions.forEach(d => {
-        const entity = graph.entities.find(e => e.name === d.entityName);
+        // Find entity - thread validation happens here to ensure we only modify entities from this thread
+        const entity = graph.entities.find(e => e.name === d.entityName && e.agentThreadId === threadId);
         if (entity) {
             // Delete observations by content (for backward compatibility) or by ID
             entity.observations = entity.observations.filter(o => !d.observations.includes(o.content) && !d.observations.includes(o.id));

package/dist/lib/operations/relation-operations.js

@@ -6,8 +6,9 @@ import { createRelationKey } from '../utils/relation-key.js';
  * Create new relations in the knowledge graph
  * Relations are globally unique by (from, to, relationType) across all threads
  * This enables multiple threads to collaboratively build the knowledge graph
+ * @param threadId - Thread ID passed for context (relations already have agentThreadId set)
  */
-export async function createRelations(storage, relations) {
+export async function createRelations(storage, threadId, relations) {
     const graph = await storage.loadGraph();
     // Validate that referenced entities exist
     const entityNames = new Set(graph.entities.map(e => e.name));
@@ -33,13 +34,14 @@ export async function createRelations(storage, relations) {
 }
 /**
  * Delete relations from the knowledge graph
- * Deletions affect all threads in the collaborative knowledge graph
+ * Thread isolation: Only deletes relations that belong to the specified thread
  */
-export async function deleteRelations(storage, relations) {
+export async function deleteRelations(storage, threadId, relations) {
     const graph = await storage.loadGraph();
-    // Delete relations globally across all threads by matching (from, to, relationType)
+    // Delete relations only from the specified thread by matching (from, to, relationType, threadId)
     graph.relations = graph.relations.filter(r => !relations.some(delRelation => r.from === delRelation.from &&
         r.to === delRelation.to &&
-        r.relationType === delRelation.relationType));
+        r.relationType === delRelation.relationType &&
+        r.agentThreadId === threadId));
     await storage.saveGraph(graph);
 }