server-memory-enhanced 2.2.1 → 2.3.0

package/dist/index.js

@@ -6,8 +6,9 @@ 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 } from './lib/schemas.js';
+import { EntitySchema, RelationSchema, SaveMemoryInputSchema, SaveMemoryOutputSchema, GetAnalyticsInputSchema, GetAnalyticsOutputSchema, GetObservationHistoryInputSchema, GetObservationHistoryOutputSchema, ListEntitiesInputSchema, ListEntitiesOutputSchema, ValidateMemoryInputSchema, ValidateMemoryOutputSchema } 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';
 import { Neo4jStorageAdapter } from './lib/neo4j-storage-adapter.js';
 import { NEO4J_ENV_VARS, STORAGE_LOG_MESSAGES, NEO4J_ERROR_MESSAGES } from './lib/storage-config.js';
@@ -110,27 +111,57 @@ const server = new McpServer({
 // Register NEW save_memory tool (Section 1 of spec - Unified Tool)
 server.registerTool("save_memory", {
     title: "Save Memory",
-    description: "Save entities and their relations to memory graph atomically. RULES: 1) Each observation max 150 chars (atomic facts only). 2) Each entity MUST have at least 1 relation. This is the recommended way to create entities and relations.",
+    description: "Save entities and their relations to memory graph atomically. RULES: 1) Each observation max 300 chars (atomic facts, technical content supported). 2) Each entity MUST have at least 1 relation. This is the recommended way to create entities and relations.",
     inputSchema: SaveMemoryInputSchema,
     outputSchema: SaveMemoryOutputSchema
 }, async (input) => {
-    const result = await handleSaveMemory(input, (entities) => knowledgeGraphManager.createEntities(entities), (relations) => knowledgeGraphManager.createRelations(relations));
+    const result = await handleSaveMemory(input, (entities) => knowledgeGraphManager.createEntities(entities), (relations) => knowledgeGraphManager.createRelations(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` +
+            `Quality score: ${(result.quality_score * 100).toFixed(1)}%\n`;
+        if (result.created.entity_names && result.created.entity_names.length > 0) {
+            successText += `\nCreated entities: ${result.created.entity_names.join(', ')}\n`;
+        }
+        if (result.warnings.length > 0) {
+            successText += `\nWarnings:\n${result.warnings.join('\n')}`;
+        }
         return {
             content: [{
                     type: "text",
-                    text: `✓ Successfully saved ${result.created.entities} entities and ${result.created.relations} relations.\n` +
-                        `Quality score: ${(result.quality_score * 100).toFixed(1)}%\n` +
-                        (result.warnings.length > 0 ? `\nWarnings:\n${result.warnings.join('\n')}` : '')
+                    text: successText
                 }],
             structuredContent: result
         };
     }
     else {
+        // Format validation errors for display
+        let errorText = '✗ Validation failed:\n\n';
+        if (result.validation_errors) {
+            if (Array.isArray(result.validation_errors) && result.validation_errors.length > 0) {
+                // Check if structured errors
+                if (typeof result.validation_errors[0] === 'object') {
+                    const structuredErrors = result.validation_errors;
+                    errorText += structuredErrors.map(err => {
+                        let msg = `Entity #${err.entity_index} "${err.entity_name}" (${err.entity_type}):\n`;
+                        err.errors.forEach((e) => msg += `  - ${e}\n`);
+                        if (err.observations && err.observations.length > 0) {
+                            msg += `  Observations: ${err.observations.join(', ')}\n`;
+                        }
+                        return msg;
+                    }).join('\n');
+                }
+                else {
+                    // Fallback to string errors
+                    errorText += result.validation_errors.join('\n');
+                }
+            }
+        }
+        errorText += '\nFix all validation errors and retry. All entities must be valid to maintain memory integrity.';
         return {
             content: [{
                     type: "text",
-                    text: `✗ Validation failed:\n${result.validation_errors?.join('\n')}`
+                    text: errorText
                 }],
             structuredContent: result,
             isError: true
@@ -329,6 +360,139 @@ server.registerTool("query_nodes", {
         structuredContent: { ...graph }
     };
 });
+// 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.",
+    inputSchema: ListEntitiesInputSchema,
+    outputSchema: ListEntitiesOutputSchema
+}, async (input) => {
+    const { threadId, entityType, namePattern } = input;
+    const entities = await knowledgeGraphManager.listEntities(threadId, entityType, namePattern);
+    return {
+        content: [{
+                type: "text",
+                text: `Found ${entities.length} entities:\n` +
+                    entities.map(e => `  - ${e.name} (${e.entityType})`).join('\n')
+            }],
+        structuredContent: { entities }
+    };
+});
+// Register validate_memory tool for pre-validation (dry-run)
+server.registerTool("validate_memory", {
+    title: "Validate Memory",
+    description: "Validate entities without saving (dry-run). Check for errors before attempting save_memory. Returns detailed validation results per entity.",
+    inputSchema: ValidateMemoryInputSchema,
+    outputSchema: ValidateMemoryOutputSchema
+}, async (input) => {
+    const { entities, threadId } = input;
+    // Get existing entity names for cross-thread reference validation
+    let existingEntityNames;
+    try {
+        existingEntityNames = await knowledgeGraphManager.getEntityNamesInThread(threadId);
+    }
+    catch (error) {
+        // If we can't get existing entities, proceed without cross-thread validation
+    }
+    // Preserve original entityType values before validation normalizes them
+    // This is needed to match warnings to the correct entities
+    const originalEntityTypes = entities.map((e) => e.entityType);
+    // Run validation (same logic as save_memory but without saving)
+    const validationResult = validateSaveMemoryRequest(entities, existingEntityNames);
+    // Transform validation result into per-entity format
+    const results = new Map();
+    // Initialize all entities as valid
+    entities.forEach((entity, index) => {
+        results.set(index, {
+            index: index,
+            name: entity.name,
+            type: originalEntityTypes[index], // Use original type, not normalized
+            valid: true,
+            errors: [],
+            warnings: []
+        });
+    });
+    // Add errors to corresponding entities
+    validationResult.errors.forEach((err) => {
+        const result = results.get(err.entityIndex);
+        if (result) {
+            result.valid = false;
+            const errorMsg = err.suggestion
+                ? `${err.error} Suggestion: ${err.suggestion}`
+                : err.error;
+            result.errors.push(errorMsg);
+        }
+    });
+    // Add warnings to corresponding entities
+    validationResult.warnings.forEach((warning) => {
+        // Parse entity type from warning if possible, otherwise add to first entity
+        const entityMatch = warning.match(/EntityType '([^']+)'/);
+        if (entityMatch) {
+            const warningEntityType = entityMatch[1];
+            let attached = false;
+            // Find entity whose ORIGINAL entityType matches the type in the warning
+            // (warnings contain the original type before normalization)
+            originalEntityTypes.forEach((origType, index) => {
+                if (origType === warningEntityType) {
+                    const result = results.get(index);
+                    if (result) {
+                        result.warnings.push(warning);
+                        attached = true;
+                    }
+                }
+            });
+            // If no matching entity type found, attach to first entity as fallback
+            if (!attached) {
+                const firstResult = results.get(0);
+                if (firstResult) {
+                    firstResult.warnings.push(warning);
+                }
+            }
+        }
+        else {
+            // No entity type information in warning; attach to first entity
+            const firstResult = results.get(0);
+            if (firstResult) {
+                firstResult.warnings.push(warning);
+            }
+        }
+    });
+    const resultArray = Array.from(results.values());
+    const allValid = resultArray.every(r => r.valid);
+    // Format response text
+    let responseText = allValid
+        ? `✓ All ${entities.length} entities are valid and ready to save.\n`
+        : `✗ Validation failed for ${resultArray.filter(r => !r.valid).length} of ${entities.length} entities:\n\n`;
+    if (!allValid) {
+        resultArray.filter(r => !r.valid).forEach(r => {
+            responseText += `Entity #${r.index} "${r.name}" (${r.type}):\n`;
+            r.errors.forEach(e => responseText += `  - ${e}\n`);
+            if (r.warnings.length > 0) {
+                r.warnings.forEach(w => responseText += `  ⚠ ${w}\n`);
+            }
+            responseText += '\n';
+        });
+    }
+    // Add warnings for valid entities if any
+    const validWithWarnings = resultArray.filter(r => r.valid && r.warnings.length > 0);
+    if (validWithWarnings.length > 0) {
+        responseText += 'Warnings:\n';
+        validWithWarnings.forEach(r => {
+            responseText += `Entity #${r.index} "${r.name}" (${r.type}):\n`;
+            r.warnings.forEach(w => responseText += `  ⚠ ${w}\n`);
+        });
+    }
+    return {
+        content: [{
+                type: "text",
+                text: responseText
+            }],
+        structuredContent: {
+            all_valid: allValid,
+            results: resultArray
+        }
+    };
+});
 // Register get_memory_stats tool
 server.registerTool("get_memory_stats", {
     title: "Get Memory Statistics",

package/dist/lib/constants.js

@@ -5,8 +5,9 @@
 /**
  * Maximum length for observations in characters
  * Per spec Section 2: Hard Limits on Observation Length
+ * Increased to 300 to accommodate technical content (URLs, connection strings, etc.)
  */
-export const MAX_OBSERVATION_LENGTH = 150;
+export const MAX_OBSERVATION_LENGTH = 300;
 /**
  * Maximum number of sentences allowed per observation
  * Per spec Section 2: Hard Limits on Observation Length

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

@@ -203,6 +203,69 @@ export class KnowledgeGraphManager {
             relations: filteredRelations,
         };
     }
+    /**
+     * Get names of all entities that can be referenced in relations.
+     * @returns Set of entity names that exist in the graph.
+     *
+     * Note: Returns ALL entities globally because entity names are globally unique across
+     * all threads in the collaborative knowledge graph (by design - see createEntities).
+     * This enables any thread to reference any existing entity, supporting incremental
+     * building and cross-thread collaboration. Thread-specific filtering is not needed
+     * since entity names cannot conflict across threads.
+     */
+    async getAllEntityNames() {
+        const graph = await this.storage.loadGraph();
+        const entityNames = new Set();
+        // Return all entities in the graph that can be referenced
+        // This allows incremental building: entities from previous save_memory calls
+        // can be referenced in new calls, enabling cross-save entity relations
+        for (const entity of graph.entities) {
+            entityNames.add(entity.name);
+        }
+        return entityNames;
+    }
+    /**
+     * @deprecated Use {@link getAllEntityNames} instead.
+     *
+     * This method is kept for backward compatibility. It accepts a threadId parameter
+     * for API consistency but does not use it for filtering; it returns the same
+     * global set of entity names as {@link getAllEntityNames}.
+     *
+     * @param threadId The thread ID (accepted but not used)
+     * @returns Set of entity names that exist in the graph
+     */
+    async getEntityNamesInThread(threadId) {
+        return this.getAllEntityNames();
+    }
+    /**
+     * List entities with optional filtering by type and name pattern
+     * @param threadId Optional thread ID to filter by. If not provided, returns entities from all threads.
+     * @param entityType Optional entity type filter (exact match)
+     * @param namePattern Optional name pattern filter (case-insensitive substring match)
+     * @returns Array of entities with name and entityType
+     */
+    async listEntities(threadId, entityType, namePattern) {
+        const graph = await this.storage.loadGraph();
+        let filteredEntities = graph.entities;
+        // Filter by thread ID if specified (otherwise returns all threads)
+        if (threadId) {
+            filteredEntities = filteredEntities.filter(e => e.agentThreadId === threadId);
+        }
+        // Filter by entity type if specified
+        if (entityType) {
+            filteredEntities = filteredEntities.filter(e => e.entityType === entityType);
+        }
+        // Filter by name pattern if specified (case-insensitive)
+        if (namePattern) {
+            const pattern = namePattern.toLowerCase();
+            filteredEntities = filteredEntities.filter(e => e.name.toLowerCase().includes(pattern));
+        }
+        // Return simplified list with just name and entityType
+        return filteredEntities.map(e => ({
+            name: e.name,
+            entityType: e.entityType
+        }));
+    }
     // Enhancement 1: Memory Statistics & Insights
     async getMemoryStats() {
         const graph = await this.storage.loadGraph();

package/dist/lib/save-memory-handler.js

@@ -9,18 +9,57 @@ import { randomUUID } from 'crypto';
  * Saves entities and their relations to the knowledge graph atomically
  * Either all entities + relations succeed, or none are saved (rollback)
  */
-export async function handleSaveMemory(input, createEntitiesFn, createRelationsFn) {
+export async function handleSaveMemory(input, createEntitiesFn, createRelationsFn, getExistingEntityNamesFn) {
     const timestamp = new Date().toISOString();
-    // Validate the entire request
-    const validationResult = validateSaveMemoryRequest(input.entities);
+    // Get existing entity names for cross-thread reference validation
+    let existingEntityNames;
+    if (getExistingEntityNamesFn) {
+        try {
+            existingEntityNames = await getExistingEntityNamesFn(input.threadId);
+        }
+        catch (error) {
+            // If we can't get existing entities, proceed without cross-thread validation
+            console.warn(`Failed to get existing entities for thread ${input.threadId}:`, error);
+        }
+    }
+    // Validate the entire request (with cross-thread entity reference support)
+    const validationResult = validateSaveMemoryRequest(input.entities, existingEntityNames);
     if (!validationResult.valid) {
-        // Return validation errors
+        // Group errors by entity for better structure
+        const errorsByEntity = new Map();
+        for (const err of validationResult.errors) {
+            if (!errorsByEntity.has(err.entityIndex)) {
+                errorsByEntity.set(err.entityIndex, {
+                    entity_name: err.entity,
+                    entity_type: err.entityType,
+                    errors: [],
+                    observations: []
+                });
+            }
+            const entityErrors = errorsByEntity.get(err.entityIndex);
+            const errorMsg = err.suggestion
+                ? `${err.error} Suggestion: ${err.suggestion}`
+                : err.error;
+            entityErrors.errors.push(errorMsg);
+            if (err.observationPreview) {
+                entityErrors.observations.push(err.observationPreview);
+            }
+        }
+        // Convert to structured format
+        const structuredErrors = Array.from(errorsByEntity.entries()).map(([index, data]) => ({
+            entity_index: index,
+            entity_name: data.entity_name,
+            entity_type: data.entity_type,
+            errors: data.errors,
+            observations: data.observations.length > 0 ? data.observations : undefined
+        }));
+        // Return validation errors with detailed structure
         return {
             success: false,
             created: { entities: 0, relations: 0 },
             warnings: [],
             quality_score: 0,
-            validation_errors: validationResult.errors.map(err => `${err.entity}: ${err.error}${err.suggestion ? ` Suggestion: ${err.suggestion}` : ''}`)
+            validation_errors: structuredErrors
         };
     }
     try {
@@ -77,11 +116,14 @@ export async function handleSaveMemory(input, createEntitiesFn, createRelationsF
         const createdRelations = await createRelationsFn(relations);
         // Calculate quality score
         const qualityScore = calculateQualityScore(input.entities);
+        // Extract entity names for reference in subsequent calls
+        const entityNames = createdEntities.map(e => e.name);
         return {
             success: true,
             created: {
                 entities: createdEntities.length,
-                relations: createdRelations.length
+                relations: createdRelations.length,
+                entity_names: entityNames
             },
             warnings: validationResult.warnings,
             quality_score: qualityScore

package/dist/lib/schemas.js

@@ -42,7 +42,7 @@ export const SaveMemoryRelationSchema = z.object({
 export const SaveMemoryEntitySchema = z.object({
     name: z.string().min(1).max(100).describe("Unique identifier for the entity"),
     entityType: z.string().min(1).max(50).describe("Type of entity (e.g., Person, Document, File, or custom types like Patient, API). Convention: start with capital letter."),
-    observations: z.array(z.string().min(5).max(150).describe("Atomic fact, max 150 chars")).min(1).describe("Array of atomic facts. Each must be ONE fact, max 150 chars."),
+    observations: z.array(z.string().min(5).max(300).describe("Atomic fact, max 300 chars (increased to accommodate technical content)")).min(1).describe("Array of atomic facts. Each must be ONE fact, max 300 chars."),
     relations: z.array(SaveMemoryRelationSchema)
         .min(1)
         .describe("REQUIRED: Every entity must have at least 1 relation"),
@@ -57,7 +57,8 @@ export const SaveMemoryOutputSchema = z.object({
     success: z.boolean(),
     created: z.object({
         entities: z.number(),
-        relations: z.number()
+        relations: z.number(),
+        entity_names: z.array(z.string()).optional().describe("Names of created entities (for reference in subsequent calls)")
     }),
     warnings: z.array(z.string()),
     quality_score: z.number().min(0).max(1),
@@ -100,3 +101,31 @@ export const GetObservationHistoryInputSchema = z.object({
 export const GetObservationHistoryOutputSchema = z.object({
     history: z.array(ObservationSchema).describe("Full version chain of the observation, chronologically ordered")
 });
+// Schema for list_entities tool (Simple Entity Lookup)
+export const ListEntitiesInputSchema = z.object({
+    threadId: z.string().optional().describe("Filter by thread ID (optional - returns entities from all threads if not specified)"),
+    entityType: z.string().optional().describe("Filter by entity type (e.g., 'Person', 'Service', 'Document')"),
+    namePattern: z.string().optional().describe("Filter by name pattern (case-insensitive substring match)")
+});
+export const ListEntitiesOutputSchema = z.object({
+    entities: z.array(z.object({
+        name: z.string(),
+        entityType: z.string()
+    })).describe("List of entities matching the filters")
+});
+// Schema for validate_memory tool (Pre-Validation)
+export const ValidateMemoryInputSchema = z.object({
+    entities: z.array(SaveMemoryEntitySchema).min(1).describe("Array of entities to validate"),
+    threadId: z.string().min(1).describe("Thread ID for this conversation/project")
+});
+export const ValidateMemoryOutputSchema = z.object({
+    all_valid: z.boolean().describe("True if all entities pass validation"),
+    results: z.array(z.object({
+        index: z.number().describe("Entity index in the input array"),
+        name: z.string().describe("Entity name"),
+        type: z.string().describe("Entity type"),
+        valid: z.boolean().describe("True if this entity passes validation"),
+        errors: z.array(z.string()).describe("List of validation errors"),
+        warnings: z.array(z.string()).describe("List of validation warnings")
+    })).describe("Validation results for each entity")
+});

package/dist/lib/validation.js

@@ -3,24 +3,39 @@
  */
 import { MAX_OBSERVATION_LENGTH, MIN_OBSERVATION_LENGTH, MAX_SENTENCES, SENTENCE_TERMINATORS, TARGET_AVG_RELATIONS, RELATION_SCORE_WEIGHT, OBSERVATION_SCORE_WEIGHT } from './constants.js';
 /**
- * Counts actual sentences in text, ignoring periods in version numbers and decimals
+ * Counts actual sentences in text, ignoring periods in technical content
  * @param text The text to analyze
  * @returns Number of actual sentences
  */
 function countSentences(text) {
-    // Remove version numbers (e.g., 1.2.0, v5.4.3, V2.1.0) and decimal numbers before counting
-    // This prevents false positives where technical data is incorrectly counted as sentences
-    // Using explicit case handling [vV] for version prefix
-    const cleaned = text
-        .replace(/\b[vV]?\d+\.\d+(\.\d+)*\b/g, 'VERSION'); // handles version numbers and decimals
-    // Split on actual sentence terminators
+    // Patterns to ignore - technical content that contains periods but aren't sentence boundaries
+    // NOTE: Order matters! More specific patterns (multi-letter abbreviations) must come before more general patterns
+    const patternsToIgnore = [
+        /https?:\/\/[^\s]+/g, // URLs (http:// or https://) - allows periods in paths
+        /\b\d+\.\d+\.\d+\.\d+\b/g, // IP addresses (e.g., 192.168.1.1)
+        /\b[A-Za-z]:[\\\/](?:[^\s<>:"|?*]+(?:\s+[^\s<>:"|?*]+)*)/g, // Windows/Unix paths (handles spaces, e.g., C:\Program Files\...)
+        /\b[vV]?\d+\.\d+(\.\d+)*\b/g, // Version numbers (e.g., v1.2.0, 5.4.3)
+        /\b(?:[A-Z]\.){2,}/g, // Multi-letter abbreviations (e.g., U.S., U.K., U.S.A., P.D.F., I.B.M., etc.) - must come before single-letter pattern
+        /\b[A-Z][a-z]{0,3}\./g, // Common single-letter abbreviations (e.g., Dr., Mr., Mrs., Ms., Jr., Sr., etc.)
+        /\b[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]*[a-zA-Z0-9])?){2,}\b/g, // Hostnames/domains with at least 2 dots (e.g., sub.domain.com) - must come after all abbreviation patterns
+    ];
+    // Replace technical patterns with placeholders to prevent false sentence detection
+    let cleaned = text;
+    for (const pattern of patternsToIgnore) {
+        cleaned = cleaned.replace(pattern, 'PLACEHOLDER');
+    }
+    // Split on actual sentence terminators and count non-empty sentences
     const sentences = cleaned.split(SENTENCE_TERMINATORS).filter(s => s.trim().length > 0);
     return sentences.length;
 }
+/**
+ * Maximum length for observation preview in error messages
+ */
+const OBSERVATION_PREVIEW_LENGTH = 50;
 /**
  * Validates a single observation according to spec requirements:
  * - Min 5 characters
- * - Max 150 characters
+ * - Max 300 characters (increased to accommodate technical content)
  * - Max 3 sentences (ignoring periods in version numbers and decimals)
  */
 export function validateObservation(obs) {
@@ -35,7 +50,7 @@ export function validateObservation(obs) {
         return {
             valid: false,
             error: `Observation too long (${obs.length} chars). Max ${MAX_OBSERVATION_LENGTH}.`,
-            suggestion: `Split into multiple observations.`
+            suggestion: `Split into atomic facts.`
         };
     }
     const sentenceCount = countSentences(obs);
@@ -62,15 +77,20 @@ export function validateEntityRelations(entity) {
     return { valid: true };
 }
 /**
- * Validates that relation targets exist in the same request
+ * Validates that relation targets exist in the same request or in existing entities
+ * @param entity The entity whose relations to validate
+ * @param allEntityNames Set of entity names in the current request
+ * @param existingEntityNames Optional set of entity names that already exist in storage (for cross-thread references)
  */
-export function validateRelationTargets(entity, allEntityNames) {
+export function validateRelationTargets(entity, allEntityNames, existingEntityNames) {
     for (const relation of entity.relations) {
-        if (!allEntityNames.has(relation.targetEntity)) {
+        const targetInCurrentBatch = allEntityNames.has(relation.targetEntity);
+        const targetInExisting = existingEntityNames?.has(relation.targetEntity) ?? false;
+        if (!targetInCurrentBatch && !targetInExisting) {
             return {
                 valid: false,
-                error: `Target entity '${relation.targetEntity}' not found in request`,
-                suggestion: `targetEntity must reference another entity in the same save_memory call`
+                error: `Target entity '${relation.targetEntity}' not found in request or existing entities`,
+                suggestion: `targetEntity must reference another entity in the same save_memory call or an existing entity`
             };
         }
     }
@@ -99,15 +119,23 @@ export function normalizeEntityType(entityType) {
     }
     return { normalized, warnings };
 }
-export function validateSaveMemoryRequest(entities) {
+/**
+ * Validates all aspects of a save_memory request
+ * @param entities The entities to validate
+ * @param existingEntityNames Optional set of entity names that already exist in storage (for cross-thread references)
+ */
+export function validateSaveMemoryRequest(entities, existingEntityNames) {
     const errors = [];
     const warnings = [];
     // Collect all entity names for relation validation
     const entityNames = new Set(entities.map(e => e.name));
-    for (const entity of entities) {
+    for (let entityIndex = 0; entityIndex < entities.length; entityIndex++) {
+        const entity = entities[entityIndex];
         // Validate entity type and collect warnings
+        // Note: entityType is normalized in-place for consistency with existing behavior
+        // The normalized value is used throughout the rest of validation and saving
         const { normalized, warnings: typeWarnings } = normalizeEntityType(entity.entityType);
-        entity.entityType = normalized; // Apply normalization
+        entity.entityType = normalized; // Apply normalization (intentional mutation for consistency)
         warnings.push(...typeWarnings);
         // Validate observations (note: observations are still strings in SaveMemoryEntity input)
         for (let i = 0; i < entity.observations.length; i++) {
@@ -115,8 +143,12 @@ export function validateSaveMemoryRequest(entities) {
             if (!obsResult.valid) {
                 errors.push({
                     entity: entity.name,
+                    entityIndex: entityIndex,
+                    entityType: entity.entityType,
                     error: `Observation ${i + 1}: ${obsResult.error}`,
-                    suggestion: obsResult.suggestion
+                    suggestion: obsResult.suggestion,
+                    observationPreview: entity.observations[i].substring(0, OBSERVATION_PREVIEW_LENGTH) +
+                        (entity.observations[i].length > OBSERVATION_PREVIEW_LENGTH ? '...' : '')
                 });
             }
         }
@@ -125,15 +157,19 @@ export function validateSaveMemoryRequest(entities) {
         if (!relResult.valid) {
             errors.push({
                 entity: entity.name,
+                entityIndex: entityIndex,
+                entityType: entity.entityType,
                 error: relResult.error || 'Invalid relations',
                 suggestion: relResult.suggestion
             });
         }
-        // Validate relation targets
-        const targetResult = validateRelationTargets(entity, entityNames);
+        // Validate relation targets (now supports cross-thread references)
+        const targetResult = validateRelationTargets(entity, entityNames, existingEntityNames);
         if (!targetResult.valid) {
             errors.push({
                 entity: entity.name,
+                entityIndex: entityIndex,
+                entityType: entity.entityType,
                 error: targetResult.error || 'Invalid relation target',
                 suggestion: targetResult.suggestion
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "server-memory-enhanced",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Enhanced MCP server for memory with agent threading, timestamps, and confidence scoring",
   "license": "MIT",
   "mcpName": "io.github.modelcontextprotocol/server-memory-enhanced",