@j0hanz/memory-mcp 1.5.0 → 1.7.0

package/dist/schemas/inputs.js

@@ -14,7 +14,6 @@ const TAG_SCHEMA = z
     .describe('Tag (no whitespace, max 50 chars)');
 const TAGS_ARRAY_SCHEMA = z
     .array(TAG_SCHEMA)
-    .min(1, { error: 'At least one tag is required' })
     .max(100, { error: 'Maximum 100 tags allowed' })
     .describe('Memory tags');
 const MEMORY_TYPE_SCHEMA = z
@@ -67,6 +66,18 @@ const SEARCH_MEMORY_TYPE_DESCRIPTION = 'Memory type filter';
 const RECALL_MIN_IMPORTANCE_DESCRIPTION = 'Min importance filter';
 const RECALL_MAX_IMPORTANCE_DESCRIPTION = 'Max importance filter';
 const RECALL_MEMORY_TYPE_DESCRIPTION = 'Memory type filter';
+function describeHash(label) {
+    return HASH_SCHEMA.describe(label);
+}
+function createPrefaultIntField(config) {
+    return z
+        .int()
+        .min(config.min)
+        .max(config.max)
+        .optional()
+        .prefault(config.prefault)
+        .describe(config.description);
+}
 function describeImportanceFilter(description) {
     return IMPORTANCE_FILTER_SCHEMA.clone().describe(description);
 }
@@ -114,19 +125,22 @@ export const StoreMemoriesInputSchema = z
     .describe('Store multiple memories');
 export const GetMemoryInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
 })
     .describe('Get memory by hash');
 export const UpdateMemoryInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
-    content: CONTENT_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
+    content: CONTENT_SCHEMA.optional(),
     tags: TAGS_ARRAY_SCHEMA.optional(),
+})
+    .refine((data) => data.content !== undefined || data.tags !== undefined, {
+    error: 'At least one of content or tags must be provided',
 })
     .describe('Update memory');
 export const DeleteMemoryInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
 })
     .describe('Delete memory by hash');
 export const DeleteMemoriesInputSchema = z
@@ -138,16 +152,20 @@ export const DeleteMemoriesInputSchema = z
         .describe('Hashes to delete (1-50)'),
 })
     .describe('Delete multiple memories');
+const RELATIONSHIP_ENDPOINT_FIELDS = {
+    from_hash: describeHash('Source hash'),
+    to_hash: describeHash('Target hash'),
+    relation_type: RELATION_TYPE_SCHEMA.describe('Relationship type'),
+};
 export const SearchMemoriesInputSchema = z
     .strictObject({
     query: SEARCH_QUERY_SCHEMA.describe('Search query'),
-    limit: z
-        .int()
-        .min(1)
-        .max(100)
-        .optional()
-        .prefault(20)
-        .describe('Max results (default 20)'),
+    limit: createPrefaultIntField({
+        min: 1,
+        max: 100,
+        prefault: 20,
+        description: 'Max results (default 20)',
+    }),
     cursor: CURSOR_SCHEMA.optional().describe(CURSOR_DESCRIPTION),
     ...SEARCH_FILTER_FIELDS,
 })
@@ -155,44 +173,47 @@ export const SearchMemoriesInputSchema = z
 export const RecallInputSchema = z
     .strictObject({
     query: SEARCH_QUERY_SCHEMA.describe('Search query'),
-    depth: z
-        .int()
-        .min(0)
-        .max(3)
-        .optional()
-        .prefault(1)
-        .describe('Relationship hops (0-3)'),
-    limit: z
-        .int()
-        .min(1)
-        .max(50)
-        .optional()
-        .prefault(10)
-        .describe('Max seed memories (default 10)'),
+    depth: createPrefaultIntField({
+        min: 0,
+        max: 3,
+        prefault: 1,
+        description: 'Relationship hops (0-3)',
+    }),
+    limit: createPrefaultIntField({
+        min: 1,
+        max: 50,
+        prefault: 10,
+        description: 'Max seed memories (default 10)',
+    }),
     cursor: CURSOR_SCHEMA.optional().describe(CURSOR_DESCRIPTION),
     ...RECALL_FILTER_FIELDS,
 })
     .describe('Recall memories via graph traversal');
+const RETRIEVE_CONTEXT_FILTER_FIELDS = createSearchFilterFields({
+    min: 'Min importance filter',
+    max: 'Max importance filter',
+    type: 'Memory type filter',
+});
 export const RetrieveContextInputSchema = z
     .strictObject({
     query: SEARCH_QUERY_SCHEMA.describe('Search query'),
-    token_budget: z
-        .int()
-        .min(100)
-        .max(200000)
-        .optional()
-        .prefault(4000)
-        .describe('Max tokens (default 4000)'),
+    token_budget: createPrefaultIntField({
+        min: 100,
+        max: 200000,
+        prefault: 4000,
+        description: 'Max tokens (default 4000)',
+    }),
     strategy: z
         .enum(['importance', 'recency', 'relevance'])
         .optional()
         .prefault('relevance')
         .describe('Sort strategy'),
+    ...RETRIEVE_CONTEXT_FILTER_FIELDS,
 })
     .describe('Retrieve context within token budget');
 export const GetRelationshipsInputSchema = z
     .strictObject({
-    hash: HASH_SCHEMA,
+    hash: describeHash('SHA-256 hash'),
     direction: z
         .enum(['outgoing', 'incoming', 'both'])
         .optional()
@@ -202,16 +223,12 @@ export const GetRelationshipsInputSchema = z
     .describe('Get relationships');
 export const CreateRelationshipInputSchema = z
     .strictObject({
-    from_hash: HASH_SCHEMA.describe('Source hash'),
-    to_hash: HASH_SCHEMA.describe('Target hash'),
-    relation_type: RELATION_TYPE_SCHEMA.describe('Relationship type'),
+    ...RELATIONSHIP_ENDPOINT_FIELDS,
 })
     .describe('Create relationship');
 export const DeleteRelationshipInputSchema = z
     .strictObject({
-    from_hash: HASH_SCHEMA.describe('Source hash'),
-    to_hash: HASH_SCHEMA.describe('Target hash'),
-    relation_type: RELATION_TYPE_SCHEMA.describe('Relationship type'),
+    ...RELATIONSHIP_ENDPOINT_FIELDS,
 })
     .describe('Delete relationship');
 export const MemoryStatsInputSchema = z

package/dist/schemas/outputs.d.ts

@@ -73,23 +73,23 @@ export declare const RelationshipEdgeSchema: z.ZodObject<{
     relation_type: z.ZodString;
 }, z.core.$strict>;
 export declare const RelationshipWithMemorySchema: z.ZodObject<{
-    from_hash: z.ZodString;
-    to_hash: z.ZodString;
-    relation_type: z.ZodString;
     created_at: z.ZodString;
     linked_hash: z.ZodString;
     linked_content: z.ZodString;
     linked_tags: z.ZodArray<z.ZodString>;
+    from_hash: z.ZodString;
+    to_hash: z.ZodString;
+    relation_type: z.ZodString;
 }, z.core.$strict>;
 export declare const RelationshipResultSchema: z.ZodObject<{
     relationships: z.ZodArray<z.ZodObject<{
-        from_hash: z.ZodString;
-        to_hash: z.ZodString;
-        relation_type: z.ZodString;
         created_at: z.ZodString;
         linked_hash: z.ZodString;
         linked_content: z.ZodString;
         linked_tags: z.ZodArray<z.ZodString>;
+        from_hash: z.ZodString;
+        to_hash: z.ZodString;
+        relation_type: z.ZodString;
     }, z.core.$strict>>;
     count: z.ZodNumber;
 }, z.core.$strict>;

package/dist/schemas/outputs.js

@@ -3,6 +3,11 @@ const STRING_SCHEMA = z.string();
 const NUMBER_SCHEMA = z.number();
 const BOOLEAN_SCHEMA = z.boolean();
 const STRING_ARRAY_SCHEMA = z.array(STRING_SCHEMA);
+const RELATIONSHIP_FIELDS = {
+    from_hash: STRING_SCHEMA.describe('Source hash'),
+    to_hash: STRING_SCHEMA.describe('Target hash'),
+    relation_type: STRING_SCHEMA.describe('Relationship type'),
+};
 export const ErrorResultSchema = z
     .strictObject({
     code: STRING_SCHEMA.describe('Error code'),
@@ -65,16 +70,12 @@ export const SearchResultSchema = z
     .describe('Search result');
 export const RelationshipEdgeSchema = z
     .strictObject({
-    from_hash: z.string().describe('Source hash'),
-    to_hash: z.string().describe('Target hash'),
-    relation_type: z.string().describe('Relationship type'),
+    ...RELATIONSHIP_FIELDS,
 })
     .describe('Relationship edge');
 export const RelationshipWithMemorySchema = z
     .strictObject({
-    from_hash: z.string().describe('Source hash'),
-    to_hash: z.string().describe('Target hash'),
-    relation_type: z.string().describe('Relationship type'),
+    ...RELATIONSHIP_FIELDS,
     created_at: z.string().describe('Created at'),
     linked_hash: z.string().describe('Linked memory hash'),
     linked_content: z.string().describe('Linked memory content'),

package/dist/server.js

@@ -63,15 +63,22 @@ function createIconDescriptors() {
         return undefined;
     return [{ src, mimeType: ICON_MIME, sizes: ICON_SIZES }];
 }
-export function createServer(db) {
+function buildServerIdentity() {
     const { version } = loadPackageManifest();
     const icons = createIconDescriptors();
-    const instructions = loadInstructions();
-    const server = new McpServer({
+    return {
         name: SERVER_NAME,
         version,
         ...(icons ? { icons } : {}),
-    }, {
+    };
+}
+function buildServerInstructions() {
+    return loadInstructions();
+}
+export function createServer(db) {
+    const identity = buildServerIdentity();
+    const instructions = buildServerInstructions();
+    const server = new McpServer(identity, {
         capabilities: SERVER_CAPABILITIES,
         instructions,
     });

package/dist/tools/create-relationship.js

@@ -1,10 +1,11 @@
-import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
+import { E_NOT_FOUND } from '../lib/errors.js';
 import { logToolEvent } from '../lib/mcp-utils.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { CreateRelationshipInputSchema } from '../schemas/inputs.js';
-import { CreateRelationshipResultSchema } from '../schemas/outputs.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
+import { formatRelationshipPreview } from './result.js';
 const INSERT_RELATIONSHIP_SQL = `INSERT OR IGNORE INTO relationships (from_hash, to_hash, relation_type, created_at)
   VALUES (?, ?, ?, ?)`;
 const SELECT_HASHES_SQL = 'SELECT hash FROM memories WHERE hash IN (?, ?) LIMIT 2';
@@ -42,25 +43,19 @@ function createRelationshipTx(db, params) {
     });
 }
 export function registerCreateRelationship(server, db) {
-    registerToolWithContract(server, 'create_relationship', CreateRelationshipInputSchema, CreateRelationshipResultSchema, wrapToolHandler(async (params) => {
-        try {
-            const txResult = createRelationshipTx(db, params);
-            if (!txResult.ok) {
-                return createErrorResponse(txResult.code, txResult.message);
-            }
-            await logToolEvent(server, 'create_relationship', {
-                fromHash: params.from_hash,
-                toHash: params.to_hash,
-                relationType: params.relation_type,
-                created: txResult.created,
-            });
-            return createToolResponse({ created: txResult.created });
+    registerToolWithContract(server, 'create_relationship', wrapToolHandler(async (params) => executeToolSafely(async () => {
+        const txResult = createRelationshipTx(db, params);
+        if (!txResult.ok) {
+            return createErrorResponse(txResult.code, txResult.message);
         }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
-        progressMessage: (params) => `⊕ create_relationship: ${params.from_hash.slice(0, 8)}... -> ${params.to_hash.slice(0, 8)}... [${params.relation_type}]`,
+        await logToolEvent(server, 'create_relationship', {
+            fromHash: params.from_hash,
+            toHash: params.to_hash,
+            relationType: params.relation_type,
+            created: txResult.created,
+        });
+        return createToolResponse({ created: txResult.created });
+    }), {
+        progressMessage: (params) => `⊕ create_relationship: ${formatRelationshipPreview(params.from_hash, params.to_hash)} [${params.relation_type}]`,
     }));
 }

package/dist/tools/delete-memories.js

@@ -1,54 +1,45 @@
-import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { DELETE_MEMORY_SQL } from '../lib/sql.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { DeleteMemoriesInputSchema } from '../schemas/inputs.js';
-import { BatchResultSchema } from '../schemas/outputs.js';
+import { executeToolSafely, summarizeBatch } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 async function notifyDeletedResources(server, items) {
+    // MCP spec (v2025-11-25) has no 'deleted' resource notification;
+    // 'updated' is the closest available signal to inform clients.
     const notifications = items
         .filter((item) => item.deleted)
         .map((item) => notifyMemoryResourceUpdated(server, item.hash));
     await Promise.allSettled(notifications);
 }
 export function registerDeleteMemories(server, db) {
-    registerToolWithContract(server, 'delete_memories', DeleteMemoriesInputSchema, BatchResultSchema, wrapToolHandler(async (params) => {
-        try {
-            const results = db.transaction(() => {
-                const items = [];
-                const stmt = db.prepareOnce(DELETE_MEMORY_SQL);
-                for (const hash of params.hashes) {
-                    const result = stmt.run(hash);
-                    items.push({
-                        hash,
-                        ok: true,
-                        deleted: result.changes > 0,
-                    });
-                }
-                return items;
-            });
-            let deleted = 0;
-            let succeeded = 0;
-            for (const item of results) {
-                if (item.ok)
-                    succeeded += 1;
-                if (item.deleted)
-                    deleted += 1;
+    registerToolWithContract(server, 'delete_memories', wrapToolHandler(async (params) => executeToolSafely(async () => {
+        const results = db.transaction(() => {
+            const items = [];
+            const stmt = db.prepareOnce(DELETE_MEMORY_SQL);
+            for (const hash of params.hashes) {
+                const result = stmt.run(hash);
+                items.push({
+                    hash,
+                    ok: true,
+                    deleted: result.changes > 0,
+                });
             }
-            const failed = results.length - succeeded;
-            await logToolEvent(server, 'delete_memories', {
-                total: params.hashes.length,
-                deleted,
-            });
-            await notifyDeletedResources(server, results);
-            return createToolResponse({ items: results, succeeded, failed });
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
+            return items;
+        });
+        const summary = summarizeBatch(results, (item) => item.deleted === true);
+        await logToolEvent(server, 'delete_memories', {
+            total: params.hashes.length,
+            deleted: summary.matched,
+        });
+        await notifyDeletedResources(server, results);
+        return createToolResponse({
+            items: results,
+            succeeded: summary.succeeded,
+            failed: summary.failed,
+        });
+    }), {
         progressMessage: (params) => `⊖ delete_memories: ${params.hashes.length} hashes [batch]`,
     }));
 }

package/dist/tools/delete-memory.js

@@ -1,29 +1,25 @@
-import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { DELETE_MEMORY_SQL } from '../lib/sql.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { DeleteMemoryInputSchema } from '../schemas/inputs.js';
-import { DeleteResultSchema } from '../schemas/outputs.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
+import { formatHashPreview } from './result.js';
 function deleteByHash(db, hash) {
     return db.prepareOnce(DELETE_MEMORY_SQL).run(hash).changes > 0;
 }
 export function registerDeleteMemory(server, db) {
-    registerToolWithContract(server, 'delete_memory', DeleteMemoryInputSchema, DeleteResultSchema, wrapToolHandler(async (params) => {
-        try {
-            const deleted = deleteByHash(db, params.hash);
-            if (deleted) {
-                await logToolEvent(server, 'delete', { hash: params.hash });
-                await notifyMemoryResourceUpdated(server, params.hash);
-            }
-            return createToolResponse({ deleted, hash: params.hash });
+    registerToolWithContract(server, 'delete_memory', wrapToolHandler(async (params) => executeToolSafely(async () => {
+        const deleted = deleteByHash(db, params.hash);
+        if (deleted) {
+            await logToolEvent(server, 'delete', { hash: params.hash });
+            // MCP spec (v2025-11-25) has no 'deleted' resource notification;
+            // 'updated' is the closest available signal to inform clients.
+            await notifyMemoryResourceUpdated(server, params.hash);
         }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
-        progressMessage: (params) => `⊖ delete_memory: ${params.hash.slice(0, 12)}... [single]`,
+        return createToolResponse({ deleted, hash: params.hash });
+    }), {
+        progressMessage: (params) => `⊖ delete_memory: ${formatHashPreview(params.hash)} [single]`,
     }));
 }

package/dist/tools/delete-relationship.js

@@ -1,35 +1,20 @@
-import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { DeleteRelationshipInputSchema } from '../schemas/inputs.js';
-import { DeleteRelationshipResultSchema } from '../schemas/outputs.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
+import { formatRelationshipPreview } from './result.js';
 const DELETE_RELATIONSHIP_SQL = 'DELETE FROM relationships WHERE from_hash = ? AND to_hash = ? AND relation_type = ?';
-const DELETE_RELATIONSHIP_RESULT = { deleted: true };
-function formatRelationship(params) {
-    return `${params.from_hash} -[${params.relation_type}]-> ${params.to_hash}`;
-}
-function createNotFoundRelationshipMessage(params) {
-    return `Relationship not found: ${formatRelationship(params)}`;
-}
 function deleteRelationship(db, params) {
     return (db
         .prepareOnce(DELETE_RELATIONSHIP_SQL)
         .run(params.from_hash, params.to_hash, params.relation_type).changes > 0);
 }
 export function registerDeleteRelationship(server, db) {
-    registerToolWithContract(server, 'delete_relationship', DeleteRelationshipInputSchema, DeleteRelationshipResultSchema, wrapToolHandler((params) => {
-        try {
-            if (!deleteRelationship(db, params)) {
-                return createErrorResponse(E_NOT_FOUND, createNotFoundRelationshipMessage(params));
-            }
-            return createToolResponse(DELETE_RELATIONSHIP_RESULT);
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
-        progressMessage: (params) => `⊖ delete_relationship: ${params.from_hash.slice(0, 8)}... -> ${params.to_hash.slice(0, 8)}... [${params.relation_type}]`,
+    registerToolWithContract(server, 'delete_relationship', wrapToolHandler((params) => executeToolSafely(() => {
+        const deleted = deleteRelationship(db, params);
+        return createToolResponse({ deleted });
+    }), {
+        progressMessage: (params) => `⊖ delete_relationship: ${formatRelationshipPreview(params.from_hash, params.to_hash)} [${params.relation_type}]`,
     }));
 }

package/dist/tools/get-memory.js

@@ -1,11 +1,12 @@
-import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
+import { E_NOT_FOUND } from '../lib/errors.js';
 import { SELECT_MEMORY_BY_HASH_SQL } from '../lib/sql.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
 import { parseMemoryRow } from '../lib/types.js';
-import { GetMemoryInputSchema } from '../schemas/inputs.js';
-import { MemoryResultSchema } from '../schemas/outputs.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
+import { formatHashPreview } from './result.js';
 function getMemoryRow(db, hash) {
     return db.prepareOnce(SELECT_MEMORY_BY_HASH_SQL).get(hash);
 }
@@ -13,20 +14,14 @@ function notFound(hash) {
     return createErrorResponse(E_NOT_FOUND, `Memory not found: ${hash}`);
 }
 export function registerGetMemory(server, db) {
-    registerToolWithContract(server, 'get_memory', GetMemoryInputSchema, MemoryResultSchema, wrapToolHandler((params) => {
-        try {
-            const row = getMemoryRow(db, params.hash);
-            if (!row) {
-                return notFound(params.hash);
-            }
-            const memory = parseMemoryRow(row);
-            return createToolResponse({ ...memory });
+    registerToolWithContract(server, 'get_memory', wrapToolHandler((params) => executeToolSafely(() => {
+        const row = getMemoryRow(db, params.hash);
+        if (!row) {
+            return notFound(params.hash);
         }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
-        progressMessage: (params) => `⊙ get_memory: ${params.hash.slice(0, 12)}... [single]`,
+        const memory = parseMemoryRow(row);
+        return createToolResponse({ ...memory });
+    }), {
+        progressMessage: (params) => `⊙ get_memory: ${formatHashPreview(params.hash)} [single]`,
     }));
 }

package/dist/tools/get-relationships.js

@@ -1,11 +1,12 @@
-import { E_NOT_FOUND, E_UNKNOWN, getErrorMessage, rethrowMcpError, } from '../lib/errors.js';
+import { E_NOT_FOUND } from '../lib/errors.js';
 import { SELECT_MEMORY_HASH_SQL } from '../lib/sql.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
 import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
 import { parseTags } from '../lib/types.js';
-import { GetRelationshipsInputSchema } from '../schemas/inputs.js';
-import { RelationshipResultSchema } from '../schemas/outputs.js';
+import {} from '../schemas/inputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
+import { formatHashPreview } from './result.js';
 // Pre-defined SQL for each direction mode to maximise prepareOnce cache hits.
 const OUTGOING_SQL = `
   SELECT r.from_hash, r.to_hash, r.relation_type, r.created_at,
@@ -60,8 +61,10 @@ function toRelationshipWithMemory(row) {
     };
 }
 export function registerGetRelationships(server, db) {
-    registerToolWithContract(server, 'get_relationships', GetRelationshipsInputSchema, RelationshipResultSchema, wrapToolHandler((params) => {
-        try {
+    registerToolWithContract(server, 'get_relationships', wrapToolHandler((params) => executeToolSafely(() => {
+        // Transaction eliminates TOCTOU: memory cannot be deleted
+        // between the existence check and the relationship query.
+        return db.transaction(() => {
             if (!memoryExists(db, params.hash)) {
                 return createErrorResponse(E_NOT_FOUND, `Memory not found: ${params.hash}`);
             }
@@ -71,12 +74,8 @@ export function registerGetRelationships(server, db) {
                 relationships,
                 count: relationships.length,
             });
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, {
-        progressMessage: (params) => `⊙ get_relationships: ${params.hash.slice(0, 12)}... [${params.direction}]`,
+        });
+    }), {
+        progressMessage: (params) => `⊙ get_relationships: ${formatHashPreview(params.hash)} [${params.direction}]`,
     }));
 }

package/dist/tools/memory-stats.js

@@ -1,8 +1,6 @@
-import { E_UNKNOWN, getErrorMessage, rethrowMcpError } from '../lib/errors.js';
 import { MEMORY_AGGREGATE_SQL, RELATIONSHIP_COUNT_SQL, TYPE_COUNTS_SQL, } from '../lib/sql.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { MemoryStatsInputSchema } from '../schemas/inputs.js';
-import { StatsResultSchema } from '../schemas/outputs.js';
+import { executeToolSafely } from '../lib/tool-execution.js';
+import { createToolResponse } from '../lib/tool-response.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 function toTypeCounts(rows) {
@@ -13,30 +11,24 @@ function toTypeCounts(rows) {
     return byType;
 }
 export function registerMemoryStats(server, db) {
-    registerToolWithContract(server, 'memory_stats', MemoryStatsInputSchema, StatsResultSchema, wrapToolHandler(() => {
-        try {
-            const aggregate = db
-                .prepareOnce(MEMORY_AGGREGATE_SQL)
-                .get();
-            const totalRelationships = db.prepareOnce(RELATIONSHIP_COUNT_SQL).get()?.total ?? 0;
-            const typeRows = db.prepareOnce(TYPE_COUNTS_SQL).all();
-            const byType = toTypeCounts(typeRows);
-            return createToolResponse({
-                memories: {
-                    total: aggregate?.total ?? 0,
-                    oldest: aggregate?.oldest ?? null,
-                    newest: aggregate?.newest ?? null,
-                    avg_importance: aggregate?.avg_importance ?? null,
-                },
-                relationships: {
-                    total: totalRelationships,
-                },
-                by_type: byType,
-            });
-        }
-        catch (err) {
-            rethrowMcpError(err);
-            return createErrorResponse(E_UNKNOWN, getErrorMessage(err));
-        }
-    }, { progressMessage: () => '⊙ memory_stats: [aggregate]' }));
+    registerToolWithContract(server, 'memory_stats', wrapToolHandler(() => executeToolSafely(() => {
+        const aggregate = db
+            .prepareOnce(MEMORY_AGGREGATE_SQL)
+            .get();
+        const totalRelationships = db.prepareOnce(RELATIONSHIP_COUNT_SQL).get()?.total ?? 0;
+        const typeRows = db.prepareOnce(TYPE_COUNTS_SQL).all();
+        const byType = toTypeCounts(typeRows);
+        return createToolResponse({
+            memories: {
+                total: aggregate?.total ?? 0,
+                oldest: aggregate?.oldest ?? null,
+                newest: aggregate?.newest ?? null,
+                avg_importance: aggregate?.avg_importance ?? null,
+            },
+            relationships: {
+                total: totalRelationships,
+            },
+            by_type: byType,
+        });
+    }), { progressMessage: () => '⊙ memory_stats: [aggregate]' }));
 }