code-graph-context 2.14.1 → 3.0.0

package/dist/mcp/tools/parse-typescript-project.tool.js

@@ -70,17 +70,11 @@ export const createParseTypescriptProjectTool = (server) => {
             configFileGlobs: z
                 .array(z.string())
                 .optional()
-                .describe('Custom glob patterns for config files (default: all JSON, YAML, .env, Dockerfile, .sh, .py)')
+                .describe('Custom glob patterns for config files')
                 .default(CONFIG_FILE_PATTERNS.defaultGlobs),
-            projectId: z
-                .string()
-                .optional()
-                .describe('Optional project ID override. If not provided, auto-generated from projectPath'),
+            projectId: z.string().optional().describe('Project ID override; auto-generated from projectPath if omitted'),
             clearExisting: z.boolean().optional().describe('Clear existing graph data for this project first'),
-            excludeNodeTypes: z
-                .array(z.string())
-                .optional()
-                .describe('Node types to skip during parsing, e.g. ["TestFile", "Parameter"]'),
+            excludeNodeTypes: z.array(z.string()).optional().describe('Node types to skip during parsing'),
             projectType: z
                 .enum(['nestjs', 'fairsquare', 'both', 'vanilla', 'auto'])
                 .optional()
@@ -90,7 +84,7 @@ export const createParseTypescriptProjectTool = (server) => {
                 .number()
                 .optional()
                 .default(100)
-                .describe('Files per chunk for streaming import (default: 50). Set to 0 to disable streaming.'),
+                .describe('Files per chunk for streaming import. Set to 0 to disable streaming.'),
             useStreaming: z
                 .enum(['auto', 'always', 'never'])
                 .optional()
@@ -100,17 +94,13 @@ export const createParseTypescriptProjectTool = (server) => {
                 .boolean()
                 .optional()
                 .default(true)
-                .describe('Run parsing in background and return job ID immediately. Use check_parse_status to monitor.'),
+                .describe('Run in background and return job ID immediately; poll with check_parse_status'),
             watch: z
                 .boolean()
                 .optional()
                 .default(false)
-                .describe('Start file watching after parse completes. Only works with async: false.'),
-            watchDebounceMs: z
-                .number()
-                .optional()
-                .default(1000)
-                .describe('Debounce delay for watch mode in milliseconds (default: 1000)'),
+                .describe('Start file watching after parse completes; requires async: false'),
+            watchDebounceMs: z.number().optional().default(1000).describe('Debounce delay for watch mode in milliseconds'),
         },
     }, async ({ tsconfigPath, projectPath, projectId, configFileGlobs, clearExisting, projectType = 'auto', chunkSize = 100, useStreaming = 'auto', async: asyncMode = false, watch = false, watchDebounceMs = 1000, }) => {
         try {

package/dist/mcp/tools/search-codebase.tool.js

@@ -7,7 +7,7 @@ import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
 import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
 import { TOOL_NAMES, TOOL_METADATA, DEFAULTS } from '../constants.js';
 import { TraversalHandler } from '../handlers/traversal.handler.js';
-import { createErrorResponse, createSuccessResponse, debugLog, sanitizeNumericInput, resolveProjectIdOrError, } from '../utils.js';
+import { createEmptyResponse, createErrorResponse, debugLog, sanitizeNumericInput, resolveProjectIdOrError, } from '../utils.js';
 export const createSearchCodebaseTool = (server) => {
     server.registerTool(TOOL_NAMES.searchCodebase, {
         title: TOOL_METADATA[TOOL_NAMES.searchCodebase].title,
@@ -19,41 +19,28 @@ export const createSearchCodebaseTool = (server) => {
                 .number()
                 .int()
                 .optional()
-                .describe(`Maximum depth to traverse relationships (default: ${DEFAULTS.traversalDepth}, max: 10)`)
+                .describe('Maximum relationship traversal depth')
                 .default(DEFAULTS.traversalDepth),
-            maxNodesPerChain: z
-                .number()
-                .int()
-                .optional()
-                .describe('Maximum chains to show per depth level (default: 5, applied independently at each depth)')
-                .default(5),
-            skip: z.number().int().optional().describe('Number of results to skip for pagination (default: 0)').default(0),
-            includeCode: z
-                .boolean()
-                .optional()
-                .describe('Include source code snippets in results (default: true)')
-                .default(true),
+            maxNodesPerChain: z.number().int().optional().describe('Maximum chains to show per depth level').default(5),
+            skip: z.number().int().optional().describe('Results to skip for pagination').default(0),
+            includeCode: z.boolean().optional().describe('Include source code snippets in results').default(true),
             snippetLength: z
                 .number()
                 .int()
                 .optional()
-                .describe(`Length of code snippets to include (default: ${DEFAULTS.codeSnippetLength})`)
+                .describe('Code snippet character limit')
                 .default(DEFAULTS.codeSnippetLength),
             topK: z
                 .number()
                 .int()
                 .optional()
-                .describe('Number of top vector matches to return (default: 3, max: 10). The best match is traversed; others shown as alternatives.')
+                .describe('Number of top vector matches; best match is traversed, others shown as alternatives')
                 .default(3),
-            minSimilarity: z
-                .number()
-                .optional()
-                .describe('Minimum similarity score threshold (0.0-1.0). Results below this are filtered out. Default: 0.65')
-                .default(0.65),
+            minSimilarity: z.number().optional().describe('Minimum similarity score threshold').default(0.65),
             useWeightedTraversal: z
                 .boolean()
                 .optional()
-                .describe('Use weighted traversal strategy that scores each node for relevance (default: false)')
+                .describe('Score each traversed node for relevance; higher quality but slower')
                 .default(true),
         },
     }, async ({ projectId, query, maxDepth = DEFAULTS.traversalDepth, maxNodesPerChain = 5, skip = 0, includeCode = true, snippetLength = DEFAULTS.codeSnippetLength, topK = 3, minSimilarity = 0.65, useWeightedTraversal = true, }) => {
@@ -81,15 +68,13 @@ export const createSearchCodebaseTool = (server) => {
                 minSimilarity,
             });
             if (vectorResults.length === 0) {
-                return createSuccessResponse(`No code found with similarity >= ${minSimilarity}. ` +
-                    `Try rephrasing your query or lowering the minSimilarity threshold. Query: "${query}"`);
+                return createEmptyResponse(`No code found with similarity >= ${minSimilarity}`, 'Try rephrasing your query or lowering the minSimilarity threshold.');
             }
             // Filter results that meet the similarity threshold
             const qualifiedResults = vectorResults.filter((r) => r.score >= minSimilarity);
             if (qualifiedResults.length === 0) {
                 const bestScore = vectorResults[0].score;
-                return createSuccessResponse(`No sufficiently relevant code found. Best match score: ${bestScore.toFixed(3)} ` +
-                    `(threshold: ${minSimilarity}). Try rephrasing your query.`);
+                return createEmptyResponse(`No sufficiently relevant code found (best match: ${bestScore.toFixed(3)}, threshold: ${minSimilarity})`, 'Try rephrasing your query or lowering minSimilarity.');
             }
             // Best match — traverse from this node
             const bestMatch = qualifiedResults[0];

package/dist/mcp/tools/session-bookmark.tool.js

@@ -5,7 +5,7 @@
 import { z } from 'zod';
 import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
 import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
-import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
+import { createEmptyResponse, createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog, } from '../utils.js';
 /**
  * Neo4j query to create a SessionBookmark node and link to code nodes
  */
@@ -125,7 +125,7 @@ export const createSaveSessionBookmarkTool = (server) => {
             projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
             sessionId: z.string().describe('Unique session identifier (e.g., conversation ID) for cross-session recovery'),
             agentId: z.string().describe('Agent identifier for this bookmark'),
-            summary: z.string().min(10).describe('Brief summary of current work state (min 10 characters)'),
+            summary: z.string().min(10).describe('Brief summary of current work state'),
             workingSetNodeIds: z
                 .array(z.string())
                 .describe('Code node IDs currently being focused on (from search_codebase or traverse_from_node)'),
@@ -207,7 +207,7 @@ export const createRestoreSessionBookmarkTool = (server) => {
                 .boolean()
                 .optional()
                 .default(true)
-                .describe('Include source code snippets for working set nodes (default: true)'),
+                .describe('Include source code snippets for working set nodes'),
             snippetLength: z
                 .number()
                 .int()
@@ -215,7 +215,7 @@ export const createRestoreSessionBookmarkTool = (server) => {
                 .max(5000)
                 .optional()
                 .default(500)
-                .describe('Maximum characters per code snippet (default: 500)'),
+                .describe('Max characters per code snippet'),
         },
     }, async ({ projectId, sessionId, agentId, includeCode = true, snippetLength = 500 }) => {
         const neo4jService = new Neo4jService();
@@ -233,13 +233,9 @@ export const createRestoreSessionBookmarkTool = (server) => {
                 agentId: agentId ?? null,
             });
             if (bookmarkRows.length === 0) {
-                return createSuccessResponse(JSON.stringify({
-                    success: false,
-                    message: sessionId
-                        ? `No bookmark found for session "${sessionId}"${agentId ? ` and agent "${agentId}"` : ''}`
-                        : `No bookmarks found for this project${agentId ? ` and agent "${agentId}"` : ''}`,
-                    projectId: resolvedProjectId,
-                }));
+                return createEmptyResponse(sessionId
+                    ? `No bookmark found for session "${sessionId}" in project ${resolvedProjectId}`
+                    : `No bookmarks found for project ${resolvedProjectId}`, 'Save a bookmark first with save_session_bookmark, or check the sessionId.');
             }
             const bm = bookmarkRows[0];
             // Fetch working set nodes linked in the graph

package/dist/mcp/tools/session-cleanup.tool.js

@@ -70,12 +70,8 @@ export const createCleanupSessionTool = (server) => {
                 .max(50)
                 .optional()
                 .default(3)
-                .describe('Number of most recent bookmarks to keep per session (default: 3)'),
-            dryRun: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('Preview what would be deleted without deleting (default: false)'),
+                .describe('Recent bookmarks to keep per session'),
+            dryRun: z.boolean().optional().default(false).describe('Preview what would be deleted without deleting'),
         },
     }, async ({ projectId, keepBookmarks = 3, dryRun = false }) => {
         const neo4jService = new Neo4jService();

package/dist/mcp/tools/session-note.tool.js

@@ -145,19 +145,11 @@ export const createSaveSessionNoteTool = (server) => {
             projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
             sessionId: z.string().describe('Session identifier (e.g., conversation ID or session name)'),
             agentId: z.string().describe('Agent identifier that is saving the note'),
-            topic: z.string().min(3).max(100).describe('Short topic label for the note (3-100 characters)'),
-            content: z.string().min(10).describe('Full observation text (minimum 10 characters)'),
+            topic: z.string().min(3).max(100).describe('Short topic label for the note'),
+            content: z.string().min(10).describe('Full observation text'),
             category: z.enum(NOTE_CATEGORIES).describe('Category: architectural, bug, insight, decision, risk, or todo'),
-            severity: z
-                .enum(NOTE_SEVERITIES)
-                .optional()
-                .default('info')
-                .describe('Severity level: info (default), warning, or critical'),
-            aboutNodeIds: z
-                .array(z.string())
-                .optional()
-                .default([])
-                .describe('Code node IDs this note is about (links to graph nodes via [:ABOUT])'),
+            severity: z.enum(NOTE_SEVERITIES).optional().default('info').describe('Severity level'),
+            aboutNodeIds: z.array(z.string()).optional().default([]).describe('Code node IDs this note is about'),
             expiresInHours: z
                 .number()
                 .positive()
@@ -246,21 +238,14 @@ export const createRecallSessionNotesTool = (server) => {
             severity: z.enum(NOTE_SEVERITIES).optional().describe('Filter by severity: info, warning, critical'),
             sessionId: z.string().optional().describe('Filter by session ID'),
             agentId: z.string().optional().describe('Filter by agent ID'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(50)
-                .optional()
-                .default(10)
-                .describe('Maximum number of notes to return (default: 10, max: 50)'),
+            limit: z.number().int().min(1).max(50).optional().default(10).describe('Maximum number of notes to return'),
             minSimilarity: z
                 .number()
                 .min(0)
                 .max(1)
                 .optional()
                 .default(0.3)
-                .describe('Minimum similarity score for vector search (0.0-1.0, default: 0.3)'),
+                .describe('Minimum similarity score for vector search'),
         },
     }, async ({ projectId, query, category, severity, sessionId, agentId, limit = 10, minSimilarity = 0.3 }) => {
         const neo4jService = new Neo4jService();

package/dist/mcp/tools/session-recall.tool.js

@@ -0,0 +1,293 @@
+/**
+ * Session Recall Tool
+ * Unified tool merging restore_session_bookmark and recall_session_notes
+ */
+import { z } from 'zod';
+import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { createEmptyResponse, createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog, } from '../utils.js';
+const NOTE_CATEGORIES = ['architectural', 'bug', 'insight', 'decision', 'risk', 'todo'];
+const NOTE_SEVERITIES = ['info', 'warning', 'critical'];
+/**
+ * Neo4j query to find the most recent SessionBookmark matching filters
+ */
+const FIND_BOOKMARK_QUERY = `
+  MATCH (b:SessionBookmark)
+  WHERE b.projectId = $projectId
+    AND ($sessionId IS NULL OR b.sessionId = $sessionId)
+    AND ($agentId IS NULL OR b.agentId = $agentId)
+  RETURN b.id AS id,
+         b.projectId AS projectId,
+         b.sessionId AS sessionId,
+         b.agentId AS agentId,
+         b.summary AS summary,
+         b.workingSetNodeIds AS workingSetNodeIds,
+         b.taskContext AS taskContext,
+         b.findings AS findings,
+         b.nextSteps AS nextSteps,
+         b.metadata AS metadata,
+         b.createdAt AS createdAt,
+         b.updatedAt AS updatedAt
+  ORDER BY b.createdAt DESC
+  LIMIT 1
+`;
+/**
+ * Neo4j query to get code nodes referenced by a bookmark
+ */
+const GET_BOOKMARK_WORKING_SET_QUERY = `
+  MATCH (b:SessionBookmark {id: $bookmarkId, projectId: $projectId})-[:REFERENCES]->(target)
+  WHERE NOT target:Pheromone
+    AND NOT target:SwarmTask
+    AND NOT target:SessionBookmark
+    AND NOT target:SessionNote
+  RETURN target.id AS id,
+         target.projectId AS projectId,
+         labels(target)[0] AS type,
+         target.name AS name,
+         target.filePath AS filePath,
+         CASE WHEN $includeCode THEN target.sourceCode ELSE null END AS sourceCode,
+         target.coreType AS coreType,
+         target.semanticType AS semanticType,
+         target.startLine AS startLine,
+         target.endLine AS endLine
+  ORDER BY target.filePath, target.startLine
+`;
+/**
+ * Semantic (vector) search for session notes
+ */
+const VECTOR_SEARCH_NOTES_QUERY = `
+  CALL db.index.vector.queryNodes('session_notes_idx', toInteger($limit * 10), $queryEmbedding)
+  YIELD node AS n, score
+  WHERE n.projectId = $projectId
+    AND (n.expiresAt IS NULL OR n.expiresAt > timestamp())
+    AND ($category IS NULL OR n.category = $category)
+    AND ($severity IS NULL OR n.severity = $severity)
+    AND ($sessionId IS NULL OR n.sessionId = $sessionId)
+    AND ($agentId IS NULL OR n.agentId = $agentId)
+    AND score >= $minSimilarity
+
+  OPTIONAL MATCH (n)-[:ABOUT]->(codeNode)
+  WHERE NOT codeNode:SessionNote
+    AND NOT codeNode:SessionBookmark
+    AND NOT codeNode:Pheromone
+    AND NOT codeNode:SwarmTask
+
+  RETURN
+    n.id AS id,
+    n.topic AS topic,
+    n.content AS content,
+    n.category AS category,
+    n.severity AS severity,
+    n.agentId AS agentId,
+    n.sessionId AS sessionId,
+    n.createdAt AS createdAt,
+    n.expiresAt AS expiresAt,
+    score AS relevance,
+    collect(DISTINCT {id: codeNode.id, name: codeNode.name, filePath: codeNode.filePath}) AS aboutNodes
+
+  ORDER BY score DESC
+  LIMIT toInteger($limit)
+`;
+/**
+ * Filter-based (non-semantic) search for session notes
+ */
+const FILTER_SEARCH_NOTES_QUERY = `
+  MATCH (n:SessionNote)
+  WHERE n.projectId = $projectId
+    AND (n.expiresAt IS NULL OR n.expiresAt > timestamp())
+    AND ($category IS NULL OR n.category = $category)
+    AND ($severity IS NULL OR n.severity = $severity)
+    AND ($sessionId IS NULL OR n.sessionId = $sessionId)
+    AND ($agentId IS NULL OR n.agentId = $agentId)
+
+  OPTIONAL MATCH (n)-[:ABOUT]->(codeNode)
+  WHERE NOT codeNode:SessionNote
+    AND NOT codeNode:SessionBookmark
+    AND NOT codeNode:Pheromone
+    AND NOT codeNode:SwarmTask
+
+  RETURN
+    n.id AS id,
+    n.topic AS topic,
+    n.content AS content,
+    n.category AS category,
+    n.severity AS severity,
+    n.agentId AS agentId,
+    n.sessionId AS sessionId,
+    n.createdAt AS createdAt,
+    n.expiresAt AS expiresAt,
+    null AS relevance,
+    collect(DISTINCT {id: codeNode.id, name: codeNode.name, filePath: codeNode.filePath}) AS aboutNodes
+
+  ORDER BY n.createdAt DESC
+  LIMIT toInteger($limit)
+`;
+export const createSessionRecallTool = (server) => {
+    server.registerTool(TOOL_NAMES.sessionRecall, {
+        title: TOOL_METADATA[TOOL_NAMES.sessionRecall].title,
+        description: TOOL_METADATA[TOOL_NAMES.sessionRecall].description,
+        inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path'),
+            sessionId: z.string().optional().describe('Session ID to restore (latest bookmark + all notes)'),
+            agentId: z.string().optional().describe('Filter by agent ID'),
+            query: z.string().optional().describe('Semantic search query for notes'),
+            category: z.enum(NOTE_CATEGORIES).optional().describe('Filter notes by category'),
+            severity: z.enum(NOTE_SEVERITIES).optional().describe('Filter notes by severity'),
+            includeCode: z.boolean().optional().default(true).describe('Include source code for working set nodes'),
+            snippetLength: z.number().int().optional().default(500).describe('Code snippet character limit'),
+            limit: z.number().int().min(1).max(50).optional().default(10).describe('Maximum notes to return'),
+            minSimilarity: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .default(0.3)
+                .describe('Minimum similarity for semantic search'),
+        },
+    }, async ({ projectId, sessionId, agentId, query, category, severity, includeCode = true, snippetLength = 500, limit = 10, minSimilarity = 0.3, }) => {
+        const neo4jService = new Neo4jService();
+        const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
+        if (!projectResult.success) {
+            await neo4jService.close();
+            return projectResult.error;
+        }
+        const resolvedProjectId = projectResult.projectId;
+        try {
+            let bookmark = null;
+            let workingSet = [];
+            let staleNodeIds = [];
+            // If sessionId provided, fetch the latest bookmark and its working set
+            if (sessionId) {
+                const bookmarkRows = await neo4jService.run(FIND_BOOKMARK_QUERY, {
+                    projectId: resolvedProjectId,
+                    sessionId,
+                    agentId: agentId ?? null,
+                });
+                if (bookmarkRows.length > 0) {
+                    const bm = bookmarkRows[0];
+                    const workingSetRows = await neo4jService.run(GET_BOOKMARK_WORKING_SET_QUERY, {
+                        bookmarkId: bm.id,
+                        projectId: resolvedProjectId,
+                        includeCode,
+                    });
+                    workingSet = workingSetRows.map((row) => {
+                        const node = {
+                            id: row.id,
+                            type: row.type,
+                            name: row.name,
+                            filePath: row.filePath,
+                            coreType: row.coreType,
+                            semanticType: row.semanticType,
+                            startLine: typeof row.startLine === 'object' && row.startLine?.toNumber
+                                ? row.startLine.toNumber()
+                                : row.startLine,
+                            endLine: typeof row.endLine === 'object' && row.endLine?.toNumber ? row.endLine.toNumber() : row.endLine,
+                        };
+                        if (includeCode && row.sourceCode) {
+                            const code = row.sourceCode;
+                            if (code.length <= snippetLength) {
+                                node.sourceCode = code;
+                            }
+                            else {
+                                const half = Math.floor(snippetLength / 2);
+                                node.sourceCode =
+                                    code.substring(0, half) + '\n\n... [truncated] ...\n\n' + code.substring(code.length - half);
+                                node.truncated = true;
+                            }
+                        }
+                        return node;
+                    });
+                    const foundIds = new Set(workingSetRows.map((r) => r.id));
+                    const storedIds = Array.isArray(bm.workingSetNodeIds) ? bm.workingSetNodeIds : [];
+                    staleNodeIds = storedIds.filter((id) => !foundIds.has(id));
+                    bookmark = {
+                        id: bm.id,
+                        projectId: resolvedProjectId,
+                        sessionId: bm.sessionId,
+                        agentId: bm.agentId,
+                        summary: bm.summary,
+                        taskContext: bm.taskContext,
+                        findings: bm.findings,
+                        nextSteps: bm.nextSteps,
+                        metadata: bm.metadata ? JSON.parse(bm.metadata) : null,
+                        createdAt: typeof bm.createdAt === 'object' && bm.createdAt?.toNumber ? bm.createdAt.toNumber() : bm.createdAt,
+                        updatedAt: typeof bm.updatedAt === 'object' && bm.updatedAt?.toNumber ? bm.updatedAt.toNumber() : bm.updatedAt,
+                    };
+                }
+            }
+            // Fetch notes — semantic if query provided, filter-based otherwise
+            let rawNotes;
+            if (query) {
+                const embeddingsService = new EmbeddingsService();
+                const queryEmbedding = await embeddingsService.embedText(query);
+                rawNotes = await neo4jService.run(VECTOR_SEARCH_NOTES_QUERY, {
+                    projectId: resolvedProjectId,
+                    queryEmbedding,
+                    limit: Math.floor(limit),
+                    minSimilarity,
+                    category: category ?? null,
+                    severity: severity ?? null,
+                    sessionId: sessionId ?? null,
+                    agentId: agentId ?? null,
+                });
+            }
+            else {
+                rawNotes = await neo4jService.run(FILTER_SEARCH_NOTES_QUERY, {
+                    projectId: resolvedProjectId,
+                    limit: Math.floor(limit),
+                    category: category ?? null,
+                    severity: severity ?? null,
+                    sessionId: sessionId ?? null,
+                    agentId: agentId ?? null,
+                });
+            }
+            const notes = rawNotes.map((row) => {
+                const createdAt = typeof row.createdAt === 'object' && row.createdAt?.toNumber ? row.createdAt.toNumber() : row.createdAt;
+                const expiresAt = typeof row.expiresAt === 'object' && row.expiresAt?.toNumber ? row.expiresAt.toNumber() : row.expiresAt;
+                const aboutNodes = (row.aboutNodes ?? []).filter((n) => n?.id != null);
+                return {
+                    id: row.id,
+                    topic: row.topic,
+                    content: row.content,
+                    category: row.category,
+                    severity: row.severity,
+                    relevance: row.relevance != null ? Math.round(row.relevance * 1000) / 1000 : null,
+                    agentId: row.agentId,
+                    sessionId: row.sessionId,
+                    createdAt,
+                    expiresAt,
+                    aboutNodes,
+                };
+            });
+            if (!bookmark && notes.length === 0) {
+                return createEmptyResponse(sessionId
+                    ? `No bookmark or notes found for session "${sessionId}" in project ${resolvedProjectId}`
+                    : `No notes found for project ${resolvedProjectId}`, query
+                    ? 'Try a different query, or lower minSimilarity.'
+                    : 'Save notes or bookmarks with session_save.');
+            }
+            return createSuccessResponse(JSON.stringify({
+                success: true,
+                projectId: resolvedProjectId,
+                searchMode: query ? 'semantic' : 'filter',
+                bookmark,
+                workingSet,
+                staleNodeIds,
+                notes,
+                stats: {
+                    notesCount: notes.length,
+                    workingSetFound: workingSet.length,
+                    workingSetStale: staleNodeIds.length,
+                },
+            }, null, 2));
+        }
+        catch (error) {
+            await debugLog('Session recall error', { error: String(error) });
+            return createErrorResponse(error instanceof Error ? error : String(error));
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};