code-graph-context 2.6.2 → 2.7.0

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

@@ -0,0 +1,343 @@
+/**
+ * Session Note Tools
+ * Save and recall cross-session observations, decisions, and insights
+ */
+import { z } from 'zod';
+import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
+import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
+const NOTE_CATEGORIES = ['architectural', 'bug', 'insight', 'decision', 'risk', 'todo'];
+const NOTE_SEVERITIES = ['info', 'warning', 'critical'];
+/**
+ * Cypher to create a SessionNote node, link it to code nodes via [:ABOUT],
+ * and link it to the latest SessionBookmark for the session via [:HAS_NOTE]
+ */
+const CREATE_SESSION_NOTE_QUERY = `
+  // Create the SessionNote node
+  CREATE (n:SessionNote {
+    id: $noteId,
+    projectId: $projectId,
+    sessionId: $sessionId,
+    agentId: $agentId,
+    topic: $topic,
+    content: $content,
+    category: $category,
+    severity: $severity,
+    createdAt: timestamp(),
+    expiresAt: $expiresAt
+  })
+
+  // Link to referenced code nodes (filter out internal coordination nodes)
+  WITH n
+  UNWIND CASE WHEN size($aboutNodeIds) = 0 THEN [null] ELSE $aboutNodeIds END AS aboutNodeId
+  WITH n, aboutNodeId
+  WHERE aboutNodeId IS NOT NULL
+  OPTIONAL MATCH (target)
+  WHERE target.id = aboutNodeId
+    AND target.projectId = $projectId
+    AND NOT target:SessionNote
+    AND NOT target:SessionBookmark
+    AND NOT target:Pheromone
+    AND NOT target:SwarmTask
+  WITH n, collect(target) AS targets
+  FOREACH (t IN targets | MERGE (n)-[:ABOUT]->(t))
+
+  // Link to the latest SessionBookmark for this session (if one exists)
+  WITH n
+  OPTIONAL MATCH (bm:SessionBookmark {projectId: $projectId, sessionId: $sessionId})
+  WITH n, bm ORDER BY bm.createdAt DESC
+  LIMIT 1
+  FOREACH (_ IN CASE WHEN bm IS NOT NULL THEN [1] ELSE [] END |
+    MERGE (bm)-[:HAS_NOTE]->(n)
+  )
+
+  RETURN n.id AS noteId
+`;
+/**
+ * Cypher to store the embedding vector on an existing SessionNote node
+ */
+const SET_NOTE_EMBEDDING_QUERY = `
+  MATCH (n:SessionNote {id: $noteId, projectId: $projectId})
+  SET n.embedding = $embedding
+  RETURN n.id AS noteId
+`;
+/**
+ * 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)
+`;
+/**
+ * Generate a unique note ID
+ */
+const generateNoteId = () => {
+    return `note_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
+};
+export const createSaveSessionNoteTool = (server) => {
+    server.registerTool(TOOL_NAMES.saveSessionNote, {
+        title: TOOL_METADATA[TOOL_NAMES.saveSessionNote].title,
+        description: TOOL_METADATA[TOOL_NAMES.saveSessionNote].description,
+        inputSchema: {
+            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)'),
+            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])'),
+            expiresInHours: z
+                .number()
+                .positive()
+                .optional()
+                .describe('Auto-expire after N hours. Omit for a permanent note.'),
+        },
+    }, async ({ projectId, sessionId, agentId, topic, content, category, severity = 'info', aboutNodeIds = [], expiresInHours, }) => {
+        const neo4jService = new Neo4jService();
+        const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
+        if (!projectResult.success) {
+            await neo4jService.close();
+            return projectResult.error;
+        }
+        const resolvedProjectId = projectResult.projectId;
+        try {
+            const noteId = generateNoteId();
+            const expiresAt = expiresInHours != null ? Date.now() + expiresInHours * 3600 * 1000 : null;
+            const createResult = await neo4jService.run(CREATE_SESSION_NOTE_QUERY, {
+                noteId,
+                projectId: resolvedProjectId,
+                sessionId,
+                agentId,
+                topic,
+                content,
+                category,
+                severity,
+                aboutNodeIds,
+                expiresAt,
+            });
+            if (createResult.length === 0) {
+                return createErrorResponse('Failed to create session note.');
+            }
+            // Ensure vector index exists (idempotent — IF NOT EXISTS)
+            let hasEmbedding = false;
+            try {
+                await neo4jService.run(QUERIES.CREATE_SESSION_NOTES_VECTOR_INDEX);
+                const embeddingsService = new EmbeddingsService();
+                const embeddingText = `${topic}\n\n${content}`;
+                const embedding = await embeddingsService.embedText(embeddingText);
+                await neo4jService.run(SET_NOTE_EMBEDDING_QUERY, {
+                    noteId,
+                    projectId: resolvedProjectId,
+                    embedding,
+                });
+                hasEmbedding = true;
+            }
+            catch (embErr) {
+                await debugLog('Session note embedding failed (non-fatal)', { error: String(embErr), noteId });
+            }
+            return createSuccessResponse(JSON.stringify({
+                success: true,
+                noteId,
+                topic,
+                category,
+                severity,
+                hasEmbedding,
+                expiresAt: expiresAt != null ? new Date(expiresAt).toISOString() : null,
+                projectId: resolvedProjectId,
+                sessionId,
+                agentId,
+            }, null, 2));
+        }
+        catch (error) {
+            await debugLog('Save session note error', { error: String(error) });
+            return createErrorResponse(error instanceof Error ? error : String(error));
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};
+export const createRecallSessionNotesTool = (server) => {
+    server.registerTool(TOOL_NAMES.recallSessionNotes, {
+        title: TOOL_METADATA[TOOL_NAMES.recallSessionNotes].title,
+        description: TOOL_METADATA[TOOL_NAMES.recallSessionNotes].description,
+        inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
+            query: z
+                .string()
+                .optional()
+                .describe('Natural language search query. When provided, triggers semantic vector search.'),
+            category: z
+                .enum(NOTE_CATEGORIES)
+                .optional()
+                .describe('Filter by category: architectural, bug, insight, decision, risk, todo'),
+            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)'),
+            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)'),
+        },
+    }, async ({ projectId, query, category, severity, sessionId, agentId, 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 rawNotes;
+            if (query) {
+                // Semantic search mode
+                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 {
+                // Filter-based search mode
+                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;
+                // Filter out null entries from optional ABOUT matches
+                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,
+                };
+            });
+            return createSuccessResponse(JSON.stringify({
+                count: notes.length,
+                projectId: resolvedProjectId,
+                searchMode: query ? 'semantic' : 'filter',
+                filters: {
+                    query: query ?? null,
+                    category: category ?? null,
+                    severity: severity ?? null,
+                    sessionId: sessionId ?? null,
+                    agentId: agentId ?? null,
+                },
+                notes,
+            }, null, 2));
+        }
+        catch (error) {
+            await debugLog('Recall session notes error', { error: String(error) });
+            return createErrorResponse(error instanceof Error ? error : String(error));
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};

package/dist/mcp/tools/swarm-claim-task.tool.js

@@ -261,12 +261,9 @@ export const createSwarmClaimTaskTool = (server) => {
                 .describe('Action: claim_and_start (RECOMMENDED: atomic claim+start), claim (reserve only), ' +
                 'start (begin work on claimed task), release (give up task), ' +
                 'abandon (release with tracking), force_start (recover from stuck claimed state)'),
-            releaseReason: z
-                .string()
-                .optional()
-                .describe('Reason for releasing/abandoning the task'),
+            releaseReason: z.string().optional().describe('Reason for releasing/abandoning the task'),
         },
-    }, async ({ projectId, swarmId, agentId, taskId, types, minPriority, action = 'claim_and_start', releaseReason, }) => {
+    }, async ({ projectId, swarmId, agentId, taskId, types, minPriority, action = 'claim_and_start', releaseReason }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -323,9 +320,7 @@ export const createSwarmClaimTaskTool = (server) => {
                             ? `Current state: ${currentState.status}, claimedBy: ${currentState.claimedBy || 'none'}`
                             : 'Task not found.'));
                 }
-                const abandonCount = typeof result[0].abandonCount === 'object'
-                    ? result[0].abandonCount.toNumber()
-                    : result[0].abandonCount;
+                const abandonCount = typeof result[0].abandonCount === 'object' ? result[0].abandonCount.toNumber() : result[0].abandonCount;
                 return createSuccessResponse(JSON.stringify({ action: 'abandoned', taskId: result[0].id, abandonCount }));
             }
             // Handle force_start action (recovery from stuck claimed state)
@@ -406,9 +401,7 @@ export const createSwarmClaimTaskTool = (server) => {
             }
             else {
                 // Auto-select highest priority available task with retry logic
-                const minPriorityScore = minPriority
-                    ? TASK_PRIORITIES[minPriority]
-                    : null;
+                const minPriorityScore = minPriority ? TASK_PRIORITIES[minPriority] : null;
                 // Retry loop to handle race conditions
                 while (retryCount < MAX_CLAIM_RETRIES) {
                     result = await neo4jService.run(CLAIM_NEXT_TASK_QUERY, {

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

@@ -96,7 +96,7 @@ export const createSwarmCleanupTool = (server) => {
                 .describe('Pheromone types to preserve (default: ["warning"])'),
             dryRun: z.boolean().optional().default(false).describe('Preview what would be deleted without deleting'),
         },
-    }, async ({ projectId, swarmId, agentId, all = false, includeTasks = true, keepTypes = ['warning'], dryRun = false }) => {
+    }, async ({ projectId, swarmId, agentId, all = false, includeTasks = true, keepTypes = ['warning'], dryRun = false, }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -139,7 +139,8 @@ export const createSwarmCleanupTool = (server) => {
                 if (swarmId && includeTasks) {
                     const taskResult = await neo4jService.run(COUNT_TASKS_BY_SWARM_QUERY, params);
                     taskCount = taskResult[0]?.count ?? 0;
-                    taskCount = typeof taskCount === 'object' && 'toNumber' in taskCount ? taskCount.toNumber() : taskCount;
+                    taskCount =
+                        typeof taskCount === 'object' && 'toNumber' in taskCount ? taskCount.toNumber() : taskCount;
                     taskStatuses = taskResult[0]?.statuses ?? [];
                 }
                 return createSuccessResponse(JSON.stringify({
@@ -147,14 +148,18 @@ export const createSwarmCleanupTool = (server) => {
                     dryRun: true,
                     mode,
                     pheromones: {
-                        wouldDelete: typeof pheromoneCount === 'object' && 'toNumber' in pheromoneCount ? pheromoneCount.toNumber() : pheromoneCount,
+                        wouldDelete: typeof pheromoneCount === 'object' && 'toNumber' in pheromoneCount
+                            ? pheromoneCount.toNumber()
+                            : pheromoneCount,
                         agents: pheromoneResult[0]?.agents ?? [],
                         types: pheromoneResult[0]?.types ?? [],
                     },
-                    tasks: swarmId && includeTasks ? {
-                        wouldDelete: taskCount,
-                        statuses: taskStatuses,
-                    } : null,
+                    tasks: swarmId && includeTasks
+                        ? {
+                            wouldDelete: taskCount,
+                            statuses: taskStatuses,
+                        }
+                        : null,
                     keepTypes,
                     projectId: resolvedProjectId,
                 }));
@@ -168,21 +173,28 @@ export const createSwarmCleanupTool = (server) => {
             if (swarmId && includeTasks) {
                 const taskResult = await neo4jService.run(CLEANUP_TASKS_BY_SWARM_QUERY, params);
                 tasksDeleted = taskResult[0]?.deleted ?? 0;
-                tasksDeleted = typeof tasksDeleted === 'object' && 'toNumber' in tasksDeleted ? tasksDeleted.toNumber() : tasksDeleted;
+                tasksDeleted =
+                    typeof tasksDeleted === 'object' && 'toNumber' in tasksDeleted
+                        ? tasksDeleted.toNumber()
+                        : tasksDeleted;
                 taskStatuses = taskResult[0]?.statuses ?? [];
             }
             return createSuccessResponse(JSON.stringify({
                 success: true,
                 mode,
                 pheromones: {
-                    deleted: typeof pheromonesDeleted === 'object' && 'toNumber' in pheromonesDeleted ? pheromonesDeleted.toNumber() : pheromonesDeleted,
+                    deleted: typeof pheromonesDeleted === 'object' && 'toNumber' in pheromonesDeleted
+                        ? pheromonesDeleted.toNumber()
+                        : pheromonesDeleted,
                     agents: pheromoneResult[0]?.agents ?? [],
                     types: pheromoneResult[0]?.types ?? [],
                 },
-                tasks: swarmId && includeTasks ? {
-                    deleted: tasksDeleted,
-                    statuses: taskStatuses,
-                } : null,
+                tasks: swarmId && includeTasks
+                    ? {
+                        deleted: tasksDeleted,
+                        statuses: taskStatuses,
+                    }
+                    : null,
                 keepTypes,
                 projectId: resolvedProjectId,
                 message: swarmId && includeTasks

package/dist/mcp/tools/swarm-complete-task.tool.js

@@ -249,45 +249,20 @@ export const createSwarmCompleteTaskTool = (server) => {
             action: z
                 .enum(['complete', 'fail', 'request_review', 'approve', 'reject', 'retry'])
                 .describe('Action to take on the task'),
-            summary: z
-                .string()
-                .optional()
-                .describe('Summary of what was done (required for complete/request_review)'),
+            summary: z.string().optional().describe('Summary of what was done (required for complete/request_review)'),
             artifacts: z
                 .record(z.unknown())
                 .optional()
                 .describe('Artifacts produced: { files: [], commits: [], pullRequests: [], notes: string }'),
-            filesChanged: z
-                .array(z.string())
-                .optional()
-                .describe('List of files that were modified'),
+            filesChanged: z.array(z.string()).optional().describe('List of files that were modified'),
             linesAdded: z.number().int().optional().describe('Number of lines added'),
             linesRemoved: z.number().int().optional().describe('Number of lines removed'),
-            reason: z
-                .string()
-                .optional()
-                .describe('Reason for failure (required if action=fail)'),
-            errorDetails: z
-                .string()
-                .optional()
-                .describe('Technical error details for debugging'),
-            retryable: z
-                .boolean()
-                .optional()
-                .default(true)
-                .describe('Whether the task can be retried after failure'),
-            reviewNotes: z
-                .string()
-                .optional()
-                .describe('Notes for the reviewer (for request_review)'),
-            reviewerId: z
-                .string()
-                .optional()
-                .describe('ID of the reviewer (required for approve/reject)'),
-            notes: z
-                .string()
-                .optional()
-                .describe('Approval/rejection notes'),
+            reason: z.string().optional().describe('Reason for failure (required if action=fail)'),
+            errorDetails: z.string().optional().describe('Technical error details for debugging'),
+            retryable: z.boolean().optional().default(true).describe('Whether the task can be retried after failure'),
+            reviewNotes: z.string().optional().describe('Notes for the reviewer (for request_review)'),
+            reviewerId: z.string().optional().describe('ID of the reviewer (required for approve/reject)'),
+            notes: z.string().optional().describe('Approval/rejection notes'),
             markAsFailed: z
                 .boolean()
                 .optional()

package/dist/mcp/tools/swarm-constants.js

@@ -14,6 +14,7 @@ export const PHEROMONE_CONFIG = {
     blocked: { halfLife: 5 * 60 * 1000, description: 'Stuck' },
     proposal: { halfLife: 60 * 60 * 1000, description: 'Awaiting approval' },
     needs_review: { halfLife: 30 * 60 * 1000, description: 'Review requested' },
+    session_context: { halfLife: 8 * 60 * 60 * 1000, description: 'Session working context marker' },
 };
 /**
  * Task status values for the blackboard task queue
@@ -76,7 +77,7 @@ export const WORKFLOW_STATES = ['exploring', 'claiming', 'modifying', 'completed
 /**
  * Flags can coexist with workflow states.
  */
-export const FLAG_TYPES = ['warning', 'proposal', 'needs_review'];
+export const FLAG_TYPES = ['warning', 'proposal', 'needs_review', 'session_context'];
 // ============================================================================
 // ORCHESTRATOR CONSTANTS
 // ============================================================================

package/dist/mcp/tools/swarm-get-tasks.tool.js

@@ -167,10 +167,7 @@ export const createSwarmGetTasksTool = (server) => {
                 .array(z.enum(TASK_STATUSES))
                 .optional()
                 .describe('Filter by task statuses (e.g., ["available", "in_progress"])'),
-            types: z
-                .array(z.enum(TASK_TYPES))
-                .optional()
-                .describe('Filter by task types (e.g., ["implement", "fix"])'),
+            types: z.array(z.enum(TASK_TYPES)).optional().describe('Filter by task types (e.g., ["implement", "fix"])'),
             claimedBy: z.string().optional().describe('Filter tasks claimed by a specific agent'),
             createdBy: z.string().optional().describe('Filter tasks created by a specific agent'),
             minPriority: z
@@ -241,7 +238,7 @@ export const createSwarmGetTasksTool = (server) => {
                     }
                 }
                 // Convert Neo4j integers
-                const convertTimestamp = (ts) => typeof ts === 'object' && ts?.toNumber ? ts.toNumber() : ts;
+                const convertTimestamp = (ts) => (typeof ts === 'object' && ts?.toNumber ? ts.toNumber() : ts);
                 task.createdAt = convertTimestamp(task.createdAt);
                 task.updatedAt = convertTimestamp(task.updatedAt);
                 task.claimedAt = convertTimestamp(task.claimedAt);
@@ -250,9 +247,7 @@ export const createSwarmGetTasksTool = (server) => {
                 return createSuccessResponse(JSON.stringify({ success: true, task }));
             }
             // Get list of tasks
-            const minPriorityScore = minPriority
-                ? TASK_PRIORITIES[minPriority]
-                : null;
+            const minPriorityScore = minPriority ? TASK_PRIORITIES[minPriority] : null;
             const tasksResult = await neo4jService.run(GET_TASKS_QUERY, {
                 projectId: resolvedProjectId,
                 swarmId: swarmId || null,
@@ -265,7 +260,7 @@ export const createSwarmGetTasksTool = (server) => {
                 limit: Math.floor(limit),
                 skip: Math.floor(skip),
             });
-            const convertTimestamp = (ts) => typeof ts === 'object' && ts?.toNumber ? ts.toNumber() : ts;
+            const convertTimestamp = (ts) => (typeof ts === 'object' && ts?.toNumber ? ts.toNumber() : ts);
             const tasks = tasksResult.map((t) => {
                 // Parse metadata if present
                 let metadata = t.metadata;
@@ -379,9 +374,7 @@ export const createSwarmGetTasksTool = (server) => {
                     status: w.type === 'modifying' ? 'working' : 'claiming',
                     lastActivity: typeof w.lastActivity === 'object' ? w.lastActivity.toNumber() : w.lastActivity,
                     nodesBeingWorked: typeof w.nodeCount === 'object' ? w.nodeCount.toNumber() : w.nodeCount,
-                    minutesSinceActivity: typeof w.minutesSinceActivity === 'object'
-                        ? w.minutesSinceActivity.toNumber()
-                        : w.minutesSinceActivity,
+                    minutesSinceActivity: typeof w.minutesSinceActivity === 'object' ? w.minutesSinceActivity.toNumber() : w.minutesSinceActivity,
                 }));
             }
             // Include dependency graph if requested

package/dist/mcp/tools/swarm-orchestrate.tool.js

@@ -14,7 +14,7 @@ import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
 import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
 import { TaskDecompositionHandler, } from '../handlers/task-decomposition.handler.js';
 import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
-import { TASK_PRIORITIES, generateSwarmId, ORCHESTRATOR_CONFIG, getHalfLife, } from './swarm-constants.js';
+import { TASK_PRIORITIES, generateSwarmId, ORCHESTRATOR_CONFIG, getHalfLife } from './swarm-constants.js';
 /**
  * Query to search for nodes matching the task description
  */
@@ -415,14 +415,16 @@ swarm_complete_task({
 ## IF STUCK
 swarm_complete_task({ ..., action: "fail", reason: "<WHY>", retryable: true })
 Then claim another task.`;
-    const taskCalls = agentIds.map(agentId => {
+    const taskCalls = agentIds
+        .map((agentId) => {
         const prompt = workerPrompt.replace(/\{AGENT_ID\}/g, agentId);
         return `Task({
   subagent_type: "general-purpose",
   run_in_background: false,
   prompt: \`${prompt}\`
 })`;
-    }).join('\n\n');
+    })
+        .join('\n\n');
     return `
 ## Worker Agent Instructions
 

package/dist/mcp/tools/swarm-pheromone.tool.js

@@ -41,11 +41,13 @@ const CREATE_PHEROMONE_QUERY = `
     p.intensity = $intensity,
     p.timestamp = timestamp(),
     p.data = $data,
-    p.halfLife = $halfLife
+    p.halfLife = $halfLife,
+    p.sessionId = $sessionId
   ON MATCH SET
     p.intensity = $intensity,
     p.timestamp = timestamp(),
-    p.data = $data
+    p.data = $data,
+    p.sessionId = COALESCE($sessionId, p.sessionId)
 
   // Create relationship to target node if it exists
   WITH p, target
@@ -73,7 +75,7 @@ export const createSwarmPheromoneTool = (server) => {
             nodeId: z.string().describe('The code node ID to mark with a pheromone'),
             type: z
                 .enum(PHEROMONE_TYPES)
-                .describe('Type of pheromone: exploring (browsing), modifying (active work), claiming (ownership), completed (done), warning (danger), blocked (stuck), proposal (awaiting approval), needs_review (review request)'),
+                .describe('Type of pheromone: exploring (browsing), modifying (active work), claiming (ownership), completed (done), warning (danger), blocked (stuck), proposal (awaiting approval), needs_review (review request), session_context (session working set)'),
             intensity: z
                 .number()
                 .min(0)
@@ -83,6 +85,10 @@ export const createSwarmPheromoneTool = (server) => {
                 .describe('Pheromone intensity from 0.0 to 1.0 (default: 1.0)'),
             agentId: z.string().describe('Unique identifier for the agent leaving the pheromone'),
             swarmId: z.string().describe('Swarm ID for grouping related agents (e.g., "swarm_xyz")'),
+            sessionId: z
+                .string()
+                .optional()
+                .describe('Session identifier for cross-session recovery (e.g., conversation ID)'),
             data: z
                 .record(z.unknown())
                 .optional()
@@ -93,7 +99,7 @@ export const createSwarmPheromoneTool = (server) => {
                 .default(false)
                 .describe('If true, removes the pheromone instead of creating/updating it'),
         },
-    }, async ({ projectId, nodeId, type, intensity = 1.0, agentId, swarmId, data, remove = false }) => {
+    }, async ({ projectId, nodeId, type, intensity = 1.0, agentId, swarmId, sessionId, data, remove = false }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -159,6 +165,7 @@ export const createSwarmPheromoneTool = (server) => {
                 intensity,
                 agentId,
                 swarmId,
+                sessionId: sessionId ?? null,
                 data: dataJson,
                 halfLife,
             });