@j0hanz/memory-mcp 1.6.0 → 1.7.0

package/dist/resources/index.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerAllResources(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.js

@@ -104,6 +104,12 @@ const INSTRUCTIONS_CONTENT = loadInstructions();
 const TOOL_CATALOG_CONTENT = buildToolCatalog();
 const WORKFLOW_GUIDE_CONTENT = buildWorkflowGuide();
 const SERVER_CONFIG_CONTENT = buildServerConfig();
+const STATIC_CONTENT_BY_KEY = {
+    instructions: INSTRUCTIONS_CONTENT,
+    toolCatalog: TOOL_CATALOG_CONTENT,
+    workflows: WORKFLOW_GUIDE_CONTENT,
+    serverConfig: SERVER_CONFIG_CONTENT,
+};
 const STATIC_RESOURCE_SEEDS = [
     {
         name: 'instructions',
@@ -142,35 +148,19 @@ const STATIC_RESOURCE_SEEDS = [
         contentKey: 'serverConfig',
     },
 ];
-function resolveStaticResourceContent(contentKey) {
-    switch (contentKey) {
-        case 'instructions':
-            return INSTRUCTIONS_CONTENT;
-        case 'toolCatalog':
-            return TOOL_CATALOG_CONTENT;
-        case 'workflows':
-            return WORKFLOW_GUIDE_CONTENT;
-        case 'serverConfig':
-            return SERVER_CONFIG_CONTENT;
-    }
-}
 function getStaticMarkdownResources() {
     return STATIC_RESOURCE_SEEDS.map((seed) => ({
         ...seed,
-        content: resolveStaticResourceContent(seed.contentKey),
+        content: STATIC_CONTENT_BY_KEY[seed.contentKey],
     }));
 }
-// --- Registration ---
-export function registerAllResources(server, db) {
-    for (const config of getStaticMarkdownResources()) {
-        registerStaticMarkdownResource(server, config);
-    }
-    // internal://tool-info/{toolName}
+function completeToolName(value) {
+    return TOOL_NAMES.filter((toolName) => toolName.startsWith(value));
+}
+function registerToolInfoResource(server) {
     server.registerResource('tool-info', new ResourceTemplate(TOOL_INFO_URI_TEMPLATE, {
-        list: () => listToolInfoResources(),
-        complete: {
-            toolName: (value) => TOOL_NAMES.filter((n) => n.startsWith(value)),
-        },
+        list: listToolInfoResources,
+        complete: { toolName: completeToolName },
     }), {
         title: 'Tool Info',
         description: 'Per-tool detail: parameters, behavior, and output shape. Supports toolName auto-completion.',
@@ -179,11 +169,10 @@ export function registerAllResources(server, db) {
     }, (uri, variables) => {
         const toolName = requireSingleVariable(variables, 'toolName', 'Missing toolName parameter');
         const info = requireKnownToolInfo(toolName);
-        return {
-            contents: [createMarkdownContent(uri.href, info)],
-        };
+        return { contents: [createMarkdownContent(uri.href, info)] };
     });
-    // memory://memories/{hash}
+}
+function registerMemoryResource(server, db) {
     const hashCompletion = createHashCompletionCallback(db);
     server.registerResource('memory', new ResourceTemplate(MEMORY_RESOURCE_URI_TEMPLATE, {
         list: () => listMemoryResources(db),
@@ -204,3 +193,11 @@ export function registerAllResources(server, db) {
         };
     });
 }
+// --- Registration ---
+export function registerAllResources(server, db) {
+    for (const config of getStaticMarkdownResources()) {
+        registerStaticMarkdownResource(server, config);
+    }
+    registerToolInfoResource(server);
+    registerMemoryResource(server, db);
+}

package/dist/resources/instructions.d.ts

@@ -1,2 +1 @@
 export declare function buildServerInstructions(): string;
-//# sourceMappingURL=instructions.d.ts.map

package/dist/resources/server-config.d.ts

@@ -1,2 +1 @@
 export declare function buildServerConfig(): string;
-//# sourceMappingURL=server-config.d.ts.map

package/dist/resources/tool-catalog.d.ts

@@ -1,2 +1 @@
 export declare function buildToolCatalog(): string;
-//# sourceMappingURL=tool-catalog.d.ts.map

package/dist/resources/tool-catalog.js

@@ -1,15 +1,6 @@
-import { extractJsonSchema, } from '../lib/json-schema.js';
+import { getSchemaMeta } from '../lib/json-schema.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 import { buildCoreContextPack } from './tool-info.js';
-function getSchemaMeta(schema) {
-    const jsonSchema = extractJsonSchema(schema);
-    return {
-        properties: (jsonSchema['properties'] ?? {}),
-        requiredFields: new Set(Array.isArray(jsonSchema['required'])
-            ? jsonSchema['required']
-            : []),
-    };
-}
 function extractOptionalParams(toolName, schema) {
     const { properties, requiredFields } = getSchemaMeta(schema);
     const rows = [];

package/dist/resources/tool-info.d.ts

@@ -2,4 +2,3 @@ export declare function getSharedConstraints(): readonly string[];
 export declare function buildCoreContextPack(): string;
 export declare function getToolInfo(name: string): string | undefined;
 export declare function getToolNames(): string[];
-//# sourceMappingURL=tool-info.d.ts.map

package/dist/resources/tool-info.js

@@ -1,4 +1,4 @@
-import { extractJsonSchema, } from '../lib/json-schema.js';
+import { extractJsonSchema, getSchemaMeta, } from '../lib/json-schema.js';
 import { getToolContracts } from '../lib/tool-contracts.js';
 // --- Shared Constraints (Single Source of Truth) ---
 const SHARED_CONSTRAINTS = [
@@ -61,15 +61,6 @@ function formatParamConstraints(prop) {
         parts.push(`enum: ${prop['enum'].join(' | ')}`);
     return parts.length > 0 ? `; ${parts.join(', ')}` : '';
 }
-function getSchemaMeta(schema) {
-    const jsonSchema = extractJsonSchema(schema);
-    return {
-        properties: (jsonSchema['properties'] ?? {}),
-        requiredFields: new Set(Array.isArray(jsonSchema['required'])
-            ? jsonSchema['required']
-            : []),
-    };
-}
 function getSortedSchemaProperties(properties) {
     return Object.entries(properties).sort(([a], [b]) => a.localeCompare(b));
 }

package/dist/resources/workflows.d.ts

@@ -1,2 +1 @@
 export declare function buildWorkflowGuide(): string;
-//# sourceMappingURL=workflows.d.ts.map

package/dist/schemas/index.d.ts

@@ -1,3 +1,2 @@
 export * from './inputs.js';
 export * from './outputs.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/schemas/inputs.d.ts

@@ -63,7 +63,7 @@ export declare const GetMemoryInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const UpdateMemoryInputSchema: z.ZodObject<{
     hash: z.ZodString;
-    content: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export declare const DeleteMemoryInputSchema: z.ZodObject<{
@@ -77,7 +77,7 @@ export declare const SearchMemoriesInputSchema: z.ZodObject<{
     max_importance: z.ZodOptional<z.ZodNumber>;
     memory_type: z.ZodOptional<typeof MEMORY_TYPE_SCHEMA>;
     query: z.ZodString;
-    limit: z.ZodPrefault<z.ZodOptional<z.ZodInt>>;
+    limit: z.ZodPrefault<z.ZodOptional<z.ZodNumber>>;
     cursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const RecallInputSchema: z.ZodObject<{
@@ -85,13 +85,16 @@ export declare const RecallInputSchema: z.ZodObject<{
     max_importance: z.ZodOptional<z.ZodNumber>;
     memory_type: z.ZodOptional<typeof MEMORY_TYPE_SCHEMA>;
     query: z.ZodString;
-    depth: z.ZodPrefault<z.ZodOptional<z.ZodInt>>;
-    limit: z.ZodPrefault<z.ZodOptional<z.ZodInt>>;
+    depth: z.ZodPrefault<z.ZodOptional<z.ZodNumber>>;
+    limit: z.ZodPrefault<z.ZodOptional<z.ZodNumber>>;
     cursor: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const RetrieveContextInputSchema: z.ZodObject<{
+    min_importance: z.ZodOptional<z.ZodNumber>;
+    max_importance: z.ZodOptional<z.ZodNumber>;
+    memory_type: z.ZodOptional<typeof MEMORY_TYPE_SCHEMA>;
     query: z.ZodString;
-    token_budget: z.ZodPrefault<z.ZodOptional<z.ZodInt>>;
+    token_budget: z.ZodPrefault<z.ZodOptional<z.ZodNumber>>;
     strategy: z.ZodPrefault<z.ZodOptional<z.ZodEnum<{
         importance: "importance";
         recency: "recency";
@@ -118,4 +121,3 @@ export declare const DeleteRelationshipInputSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const MemoryStatsInputSchema: z.ZodObject<{}, z.core.$strict>;
 export {};
-//# sourceMappingURL=inputs.d.ts.map

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
@@ -70,6 +69,15 @@ 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);
 }
@@ -123,8 +131,11 @@ export const GetMemoryInputSchema = z
 export const UpdateMemoryInputSchema = z
     .strictObject({
     hash: describeHash('SHA-256 hash'),
-    content: CONTENT_SCHEMA,
+    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
@@ -149,13 +160,12 @@ const RELATIONSHIP_ENDPOINT_FIELDS = {
 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,
 })
@@ -163,39 +173,42 @@ 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

package/dist/schemas/outputs.d.ts

@@ -145,4 +145,3 @@ export declare const RetrieveContextResultSchema: z.ZodObject<{
     estimated_tokens: z.ZodNumber;
     truncated: z.ZodBoolean;
 }, z.core.$strict>;
-//# sourceMappingURL=outputs.d.ts.map

package/dist/server.d.ts

@@ -1,4 +1,3 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from './db/typed.js';
 export declare function createServer(db: TypedDb): McpServer;
-//# sourceMappingURL=server.d.ts.map

package/dist/tools/create-relationship.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerCreateRelationship(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=create-relationship.d.ts.map

package/dist/tools/create-relationship.js

@@ -2,10 +2,10 @@ 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';
@@ -43,7 +43,7 @@ function createRelationshipTx(db, params) {
     });
 }
 export function registerCreateRelationship(server, db) {
-    registerToolWithContract(server, 'create_relationship', CreateRelationshipInputSchema, CreateRelationshipResultSchema, wrapToolHandler(async (params) => executeToolSafely(async () => {
+    registerToolWithContract(server, 'create_relationship', wrapToolHandler(async (params) => executeToolSafely(async () => {
         const txResult = createRelationshipTx(db, params);
         if (!txResult.ok) {
             return createErrorResponse(txResult.code, txResult.message);
@@ -56,6 +56,6 @@ export function registerCreateRelationship(server, db) {
         });
         return createToolResponse({ created: txResult.created });
     }), {
-        progressMessage: (params) => `⊕ create_relationship: ${params.from_hash.slice(0, 8)}... -> ${params.to_hash.slice(0, 8)}... [${params.relation_type}]`,
+        progressMessage: (params) => `⊕ create_relationship: ${formatRelationshipPreview(params.from_hash, params.to_hash)} [${params.relation_type}]`,
     }));
 }

package/dist/tools/delete-memories.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerDeleteMemories(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=delete-memories.d.ts.map

package/dist/tools/delete-memories.js

@@ -2,18 +2,19 @@ import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { DELETE_MEMORY_SQL } from '../lib/sql.js';
 import { executeToolSafely, summarizeBatch } from '../lib/tool-execution.js';
 import { createToolResponse } from '../lib/tool-response.js';
-import { DeleteMemoriesInputSchema } from '../schemas/inputs.js';
-import { BatchResultSchema } from '../schemas/outputs.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) => executeToolSafely(async () => {
+    registerToolWithContract(server, 'delete_memories', wrapToolHandler(async (params) => executeToolSafely(async () => {
         const results = db.transaction(() => {
             const items = [];
             const stmt = db.prepareOnce(DELETE_MEMORY_SQL);

package/dist/tools/delete-memory.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerDeleteMemory(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=delete-memory.d.ts.map

package/dist/tools/delete-memory.js

@@ -2,22 +2,24 @@ import { logToolEvent, notifyMemoryResourceUpdated } from '../lib/mcp-utils.js';
 import { DELETE_MEMORY_SQL } from '../lib/sql.js';
 import { executeToolSafely } from '../lib/tool-execution.js';
 import { createToolResponse } from '../lib/tool-response.js';
-import { DeleteMemoryInputSchema } from '../schemas/inputs.js';
-import { DeleteResultSchema } 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 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) => executeToolSafely(async () => {
+    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);
         }
         return createToolResponse({ deleted, hash: params.hash });
     }), {
-        progressMessage: (params) => `⊖ delete_memory: ${params.hash.slice(0, 12)}... [single]`,
+        progressMessage: (params) => `⊖ delete_memory: ${formatHashPreview(params.hash)} [single]`,
     }));
 }

package/dist/tools/delete-relationship.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerDeleteRelationship(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=delete-relationship.d.ts.map

package/dist/tools/delete-relationship.js

@@ -1,30 +1,20 @@
-import { E_NOT_FOUND } from '../lib/errors.js';
 import { executeToolSafely } from '../lib/tool-execution.js';
-import { createErrorResponse, createToolResponse, } from '../lib/tool-response.js';
-import { DeleteRelationshipInputSchema } from '../schemas/inputs.js';
-import { DeleteRelationshipResultSchema } from '../schemas/outputs.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) => executeToolSafely(() => {
-        if (!deleteRelationship(db, params)) {
-            return createErrorResponse(E_NOT_FOUND, createNotFoundRelationshipMessage(params));
-        }
-        return createToolResponse(DELETE_RELATIONSHIP_RESULT);
+    registerToolWithContract(server, 'delete_relationship', wrapToolHandler((params) => executeToolSafely(() => {
+        const deleted = deleteRelationship(db, params);
+        return createToolResponse({ deleted });
     }), {
-        progressMessage: (params) => `⊖ delete_relationship: ${params.from_hash.slice(0, 8)}... -> ${params.to_hash.slice(0, 8)}... [${params.relation_type}]`,
+        progressMessage: (params) => `⊖ delete_relationship: ${formatRelationshipPreview(params.from_hash, params.to_hash)} [${params.relation_type}]`,
     }));
 }

package/dist/tools/get-memory.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerGetMemory(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=get-memory.d.ts.map

package/dist/tools/get-memory.js

@@ -3,10 +3,10 @@ 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);
 }
@@ -14,7 +14,7 @@ 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) => executeToolSafely(() => {
+    registerToolWithContract(server, 'get_memory', wrapToolHandler((params) => executeToolSafely(() => {
         const row = getMemoryRow(db, params.hash);
         if (!row) {
             return notFound(params.hash);
@@ -22,6 +22,6 @@ export function registerGetMemory(server, db) {
         const memory = parseMemoryRow(row);
         return createToolResponse({ ...memory });
     }), {
-        progressMessage: (params) => `⊙ get_memory: ${params.hash.slice(0, 12)}... [single]`,
+        progressMessage: (params) => `⊙ get_memory: ${formatHashPreview(params.hash)} [single]`,
     }));
 }

package/dist/tools/get-relationships.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerGetRelationships(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=get-relationships.d.ts.map

package/dist/tools/get-relationships.js

@@ -3,10 +3,10 @@ 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,
@@ -61,17 +61,21 @@ function toRelationshipWithMemory(row) {
     };
 }
 export function registerGetRelationships(server, db) {
-    registerToolWithContract(server, 'get_relationships', GetRelationshipsInputSchema, RelationshipResultSchema, wrapToolHandler((params) => executeToolSafely(() => {
-        if (!memoryExists(db, params.hash)) {
-            return createErrorResponse(E_NOT_FOUND, `Memory not found: ${params.hash}`);
-        }
-        const rows = loadRelationships(db, params.hash, params.direction);
-        const relationships = rows.map(toRelationshipWithMemory);
-        return createToolResponse({
-            relationships,
-            count: relationships.length,
+    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}`);
+            }
+            const rows = loadRelationships(db, params.hash, params.direction);
+            const relationships = rows.map(toRelationshipWithMemory);
+            return createToolResponse({
+                relationships,
+                count: relationships.length,
+            });
         });
     }), {
-        progressMessage: (params) => `⊙ get_relationships: ${params.hash.slice(0, 12)}... [${params.direction}]`,
+        progressMessage: (params) => `⊙ get_relationships: ${formatHashPreview(params.hash)} [${params.direction}]`,
     }));
 }

package/dist/tools/index.d.ts

@@ -4,4 +4,3 @@ type ToolRegistrar = (server: McpServer, db: TypedDb) => void;
 export declare const TOOL_REGISTRARS: readonly ToolRegistrar[];
 export declare function registerAllTools(server: McpServer, db: TypedDb): void;
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/memory-stats.d.ts

@@ -1,4 +1,3 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { TypedDb } from '../db/typed.js';
 export declare function registerMemoryStats(server: McpServer, db: TypedDb): void;
-//# sourceMappingURL=memory-stats.d.ts.map

package/dist/tools/memory-stats.js

@@ -1,8 +1,6 @@
 import { MEMORY_AGGREGATE_SQL, RELATIONSHIP_COUNT_SQL, TYPE_COUNTS_SQL, } from '../lib/sql.js';
 import { executeToolSafely } from '../lib/tool-execution.js';
 import { createToolResponse } from '../lib/tool-response.js';
-import { MemoryStatsInputSchema } from '../schemas/inputs.js';
-import { StatsResultSchema } from '../schemas/outputs.js';
 import { wrapToolHandler } from './progress.js';
 import { registerToolWithContract } from './register-contract.js';
 function toTypeCounts(rows) {
@@ -13,7 +11,7 @@ function toTypeCounts(rows) {
     return byType;
 }
 export function registerMemoryStats(server, db) {
-    registerToolWithContract(server, 'memory_stats', MemoryStatsInputSchema, StatsResultSchema, wrapToolHandler(() => executeToolSafely(() => {
+    registerToolWithContract(server, 'memory_stats', wrapToolHandler(() => executeToolSafely(() => {
         const aggregate = db
             .prepareOnce(MEMORY_AGGREGATE_SQL)
             .get();

package/dist/tools/progress.d.ts

@@ -26,10 +26,15 @@ interface WrappedHandlerOptions<TArgs> {
     completionMessage?: (args: TArgs, result: CallToolResult) => string;
     progressMessage: (args: TArgs) => string;
 }
+interface CompletionRunOptions {
+    reporter: Pick<ProgressReporter, 'flush'>;
+    completionCurrent: number | (() => number);
+    completionMessage: (result: CallToolResult) => string;
+}
 type ToolHandler<TArgs> = (args: TArgs, extra: ProgressContext) => Promise<CallToolResult> | CallToolResult;
 export declare function notifyProgress(extra: ProgressContext, progress: ProgressUpdate): Promise<void>;
 export declare function createProgressReporter(extra: ProgressContext, options?: ProgressReporterOptions): ProgressReporter;
 export declare function progressWithMessage(reporter: ProgressReporter, getMessage: (progress: ProgressSnapshot) => string): ProgressReporter<ProgressSnapshot>;
 export declare function wrapToolHandler<TArgs>(handler: ToolHandler<TArgs>, options: WrappedHandlerOptions<TArgs>): ToolHandler<TArgs>;
+export declare function runWithProgressCompletion(extra: ProgressContext, run: () => CallToolResult | Promise<CallToolResult>, options: CompletionRunOptions): Promise<CallToolResult>;
 export {};
-//# sourceMappingURL=progress.d.ts.map