@danielsimonjr/memory-mcp 11.1.1 → 12.2.3

package/dist/server/toolDefinitions.js

@@ -2,7 +2,7 @@
  * MCP Tool Definitions
  *
  * Extracted from MCPServer.ts to reduce file size and improve maintainability.
- * Contains all 59 tool schemas for the Knowledge Graph MCP Server.
+ * Contains all 106 tool schemas for the Knowledge Graph MCP Server.
  *
  * @module server/toolDefinitions
  */
@@ -14,7 +14,7 @@ export const toolDefinitions = [
     // ==================== ENTITY TOOLS ====================
     {
         name: 'create_entities',
-        description: 'Create multiple new entities in the knowledge graph',
+        description: 'Create multiple new entities in the knowledge graph. Supports v1.6 freshness (ttl/confidence), v1.8 project scoping, and η.4.4 bitemporal validity (validFrom/validUntil/observationMeta).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -30,6 +30,58 @@ export const toolDefinitions = [
                                 items: { type: 'string' },
                                 description: 'An array of observation contents associated with the entity',
                             },
+                            tags: {
+                                type: 'array',
+                                items: { type: 'string' },
+                                description: 'Optional lowercase tags for categorization',
+                            },
+                            importance: {
+                                type: 'number',
+                                minimum: 0,
+                                maximum: 10,
+                                description: 'Optional importance score (0-10) for prioritization',
+                            },
+                            parentId: {
+                                type: 'string',
+                                description: 'Optional parent entity name for hierarchical nesting',
+                            },
+                            ttl: {
+                                type: 'number',
+                                description: 'v1.6 freshness — seconds until entity is considered stale',
+                            },
+                            confidence: {
+                                type: 'number',
+                                minimum: 0,
+                                maximum: 1,
+                                description: 'v1.6 freshness — belief strength [0, 1]',
+                            },
+                            projectId: {
+                                type: 'string',
+                                description: 'v1.8 project scope identifier',
+                            },
+                            validFrom: {
+                                type: 'string',
+                                description: 'η.4.4 ISO 8601 — entity is valid from this instant. Absent ⇒ always valid since creation.',
+                            },
+                            validUntil: {
+                                type: 'string',
+                                description: 'η.4.4 ISO 8601 — entity is valid until this instant. Absent ⇒ still valid.',
+                            },
+                            observationMeta: {
+                                type: 'array',
+                                description: 'η.4.4 per-observation temporal metadata; indexed parallel to observations[] by content match',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        content: { type: 'string', description: 'Matches an entry in observations[] by exact content' },
+                                        validFrom: { type: 'string' },
+                                        validUntil: { type: 'string' },
+                                        recordedAt: { type: 'string', description: 'Bitemporal axis — when the fact was recorded' },
+                                    },
+                                    required: ['content'],
+                                    additionalProperties: false,
+                                },
+                            },
                         },
                         required: ['name', 'entityType', 'observations'],
                         additionalProperties: false,
@@ -81,6 +133,41 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // Phase 13: Project scoping + memory versioning tools
+    {
+        name: 'list_projects',
+        description: 'List all distinct project IDs in the knowledge graph. Returns sorted array of projectId values, excluding global/unscoped entities.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_entity_versions',
+        description: 'Get the latest version of an entity. If the entity has been superseded by newer versions (via contradiction detection), returns the most recent one.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Name of any entity in the version chain' },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_version_chain',
+        description: 'Get all versions of an entity in its version chain. Returns versions sorted by version number ascending. Works from any entity in the chain (resolves to root automatically).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Name of any entity in the version chain' },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
     // ==================== RELATION TOOLS ====================
     {
         name: 'create_relations',
@@ -133,6 +220,49 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // Phase 13: Temporal knowledge graph tools
+    {
+        name: 'invalidate_relation',
+        description: 'Mark a relation as no longer valid. Sets the validUntil timestamp on the matching active relation. Use for temporal facts that have ended (e.g., "Kai no longer works on Orion").',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                from: { type: 'string', description: 'Source entity name' },
+                relationType: { type: 'string', description: 'Relation type (e.g., works_on, assigned_to)' },
+                to: { type: 'string', description: 'Target entity name' },
+                ended: { type: 'string', description: 'ISO 8601 date when the relation ended. Defaults to now.' },
+            },
+            required: ['from', 'relationType', 'to'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'query_as_of',
+        description: 'Query relations valid at a specific point in time. Returns only relations where validFrom <= date AND (validUntil is undefined OR validUntil >= date). Time-travel query for temporal knowledge graphs.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Entity to query relations for' },
+                asOf: { type: 'string', description: 'ISO 8601 date to query at (e.g., "2026-01-15")' },
+                direction: { type: 'string', enum: ['outgoing', 'incoming', 'both'], description: 'Relation direction filter. Default: both.' },
+            },
+            required: ['entityName', 'asOf'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'timeline',
+        description: 'Get chronological relation history for an entity. Returns ALL relations (current and expired) sorted by validFrom ascending. Shows the full story of an entity over time.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Entity to get timeline for' },
+                direction: { type: 'string', enum: ['outgoing', 'incoming', 'both'], description: 'Relation direction filter. Default: both.' },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
     // ==================== OBSERVATION TOOLS ====================
     {
         name: 'add_observations',
@@ -327,6 +457,22 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // Phase 13: Semantic forget
+    {
+        name: 'forget_memory',
+        description: 'Forget (delete) observations matching the given content. Tries exact match first; falls back to semantic search at 0.85 similarity threshold if available. Supports dryRun to preview what would be deleted.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The content to forget (observation text)' },
+                threshold: { type: 'number', description: 'Semantic similarity threshold for fallback (default: 0.85)' },
+                projectId: { type: 'string', description: 'Optional project scope filter' },
+                dryRun: { type: 'boolean', description: 'If true, return what would be deleted without actually deleting' },
+            },
+            required: ['content'],
+            additionalProperties: false,
+        },
+    },
     // Phase 11 Sprint 2: Hybrid Search
     {
         name: 'hybrid_search',
@@ -454,7 +600,6 @@ export const toolDefinitions = [
                 tags: { type: 'array', items: { type: 'string' }, description: 'Optional tags filter' },
                 minImportance: { type: 'number', description: 'Optional minimum importance' },
                 maxImportance: { type: 'number', description: 'Optional maximum importance' },
-                searchType: { type: 'string', description: 'Type of search (basic, boolean, fuzzy, ranked)' },
                 description: { type: 'string', description: 'Optional description of the search' },
             },
             required: ['name', 'query'],
@@ -936,14 +1081,19 @@ export const toolDefinitions = [
     },
     {
         name: 'export_graph',
-        description: 'Export knowledge graph in various formats with optional brotli compression and streaming for large graphs',
+        description: 'Export knowledge graph in various formats with optional brotli compression and streaming for large graphs. Supports W3C Linked Data formats (turtle, rdf-xml, json-ld) added in η.5.4.',
         inputSchema: {
             type: 'object',
             properties: {
                 format: {
                     type: 'string',
-                    enum: ['json', 'csv', 'graphml', 'gexf', 'dot', 'markdown', 'mermaid'],
-                    description: 'Export format',
+                    enum: ['json', 'csv', 'graphml', 'gexf', 'dot', 'markdown', 'mermaid', 'turtle', 'rdf-xml', 'json-ld'],
+                    description: 'Export format. W3C Linked Data: turtle (RDF 1.1 Turtle), rdf-xml (RDF 1.1 XML with Statement reification for non-NCName predicates), json-ld (JSON-LD 1.1 with @context mapping to RDFS + DCTerms).',
+                },
+                redactPii: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'When true, scrub PII (email/SSN/credit-card/phone/IPv4) from observations before export. Uses η.6.3 PiiRedactor with default pattern bank.',
                 },
                 filter: {
                     type: 'object',
@@ -981,6 +1131,36 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // Phase 13: Conversation ingestion tool
+    {
+        name: 'ingest',
+        description: 'Ingest pre-normalized conversation data into the knowledge graph. Chunks messages by exchange pairs (user+assistant), creates entities with verbatim observations. Format-agnostic: normalize chat exports before calling.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                messages: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            role: { type: 'string', enum: ['user', 'assistant', 'system'] },
+                            content: { type: 'string' },
+                            timestamp: { type: 'string', description: 'Optional ISO 8601 timestamp' },
+                        },
+                        required: ['role', 'content'],
+                    },
+                    description: 'Array of conversation messages to ingest',
+                },
+                source: { type: 'string', description: 'Source identifier (e.g., filename, session ID)' },
+                projectId: { type: 'string', description: 'Project to scope ingested entities to' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Tags to apply to all created entities' },
+                chunkBy: { type: 'string', enum: ['exchange', 'paragraph', 'fixed'], description: 'Chunking strategy. Default: exchange (user+assistant pairs).' },
+                dryRun: { type: 'boolean', description: 'Preview without creating entities' },
+            },
+            required: ['messages'],
+            additionalProperties: false,
+        },
+    },
     // ==================== SEMANTIC SEARCH TOOLS (Phase 4 Sprint 12) ====================
     {
         name: 'semantic_search',
@@ -1030,6 +1210,1401 @@ export const toolDefinitions = [
             additionalProperties: false,
         },
     },
+    // ==================== REF INDEX ====================
+    {
+        name: 'register_ref',
+        description: 'Register a stable alias (ref) pointing to an entity name in the RefIndex for O(1) lookups',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Stable alias string to register' },
+                entityName: { type: 'string', description: 'Entity name this ref resolves to' },
+                description: { type: 'string', description: 'Optional human-readable description of this ref' },
+            },
+            required: ['ref', 'entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'resolve_ref',
+        description: 'Resolve a stable alias (ref) to its entity name via the RefIndex',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Alias string to resolve' },
+            },
+            required: ['ref'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'deregister_ref',
+        description: 'Remove a stable alias (ref) from the RefIndex',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Alias string to deregister' },
+            },
+            required: ['ref'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'list_refs',
+        description: 'List all registered refs in the RefIndex, optionally filtered by entity name',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Optional: filter refs by entity name' },
+            },
+            additionalProperties: false,
+        },
+    },
+    // ==================== ARTIFACT ====================
+    {
+        name: 'create_artifact',
+        description: 'Create an artifact entity (tool output, code snippet, API response, etc.) with a stable auto-generated ref',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'Artifact content stored as an entity observation' },
+                toolName: { type: 'string', description: 'Name of the tool or source that produced this artifact' },
+                artifactType: {
+                    type: 'string',
+                    enum: ['tool_output', 'code_snippet', 'api_response', 'search_result', 'file_content', 'user_input'],
+                    description: 'Category of artifact for structured filtering',
+                },
+                description: { type: 'string', description: 'Optional human-readable description' },
+                sessionId: { type: 'string', description: 'Optional session context for grouping related artifacts' },
+            },
+            required: ['content', 'toolName', 'artifactType'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_artifact',
+        description: 'Retrieve an artifact entity by its stable ref or entity name',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Stable ref or entity name (e.g. "bash-2026-03-24-a3f2")' },
+            },
+            required: ['ref'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'list_artifacts',
+        description: 'List all artifact entities, with optional filtering by tool name, type, or date',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                toolName: { type: 'string', description: 'Filter by originating tool name' },
+                artifactType: {
+                    type: 'string',
+                    enum: ['tool_output', 'code_snippet', 'api_response', 'search_result', 'file_content', 'user_input'],
+                    description: 'Filter by artifact category',
+                },
+                since: { type: 'string', description: 'Only return artifacts created at or after this ISO 8601 date' },
+            },
+            additionalProperties: false,
+        },
+    },
+    // ==================== TEMPORAL SEARCH ====================
+    {
+        name: 'search_by_time',
+        description: 'Search entities using a natural language time expression (e.g. "last week", "yesterday", "in January")',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Natural language time expression to parse and search' },
+                field: {
+                    type: 'string',
+                    enum: ['createdAt', 'lastModified', 'any'],
+                    description: 'Which timestamp field to filter on (default: any)',
+                },
+                includeUndated: {
+                    type: 'boolean',
+                    description: 'If true, treat entities with no timestamps as matching (default: false)',
+                },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== DISTILLATION ====================
+    {
+        name: 'configure_distillation',
+        description: 'Configure the distillation pipeline policy (default, noop, or none) that filters memories before context formatting',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                policy: {
+                    type: 'string',
+                    enum: ['default', 'noop', 'none'],
+                    description: 'Policy to apply: default (relevance+freshness+dedup), noop (pass-through), none (clear pipeline)',
+                },
+            },
+            required: ['policy'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== FRESHNESS ====================
+    {
+        name: 'check_freshness',
+        description: 'Calculate the freshness score (0–1) for a specific entity based on its TTL and confidence',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Name of the entity to check freshness for' },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_stale_entities',
+        description: 'Return all entities whose freshness score is below a threshold',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                threshold: {
+                    type: 'number',
+                    description: 'Freshness threshold (0–1). Entities below this score are considered stale (default: 0.5)',
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_expired_entities',
+        description: 'Return all entities that have passed their TTL expiry',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'refresh_entity',
+        description: 'Reset freshness for an entity by updating its creation timestamp to now and resetting confidence to 1.0',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Name of the entity to refresh' },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'freshness_report',
+        description: 'Generate a freshness report across all entities showing fresh, stale, and expired counts',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                threshold: {
+                    type: 'number',
+                    description: 'Freshness threshold for fresh/stale categorisation (default: 0.5)',
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    // ==================== LLM QUERY PLANNER ====================
+    {
+        name: 'query_natural_language',
+        description: 'Decompose a natural language query into a structured search plan and return matching entities',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Natural language query to plan and execute' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== GOVERNANCE ====================
+    {
+        name: 'set_governance_policy',
+        description: 'Set the active governance policy controlling which write operations (create, update, delete) are permitted for future requests',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                canCreate: { type: 'boolean', description: 'Whether entity creation is allowed (default: true)' },
+                canUpdate: { type: 'boolean', description: 'Whether entity updates are allowed (default: true)' },
+                canDelete: { type: 'boolean', description: 'Whether entity deletion is allowed (default: true)' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'audit_query',
+        description: 'Query the audit log for operations matching filter criteria (operation type, agent ID, entity name, date range)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                operation: {
+                    type: 'string',
+                    enum: ['create', 'update', 'delete', 'merge', 'archive'],
+                    description: 'Filter by operation type',
+                },
+                agentId: { type: 'string', description: 'Filter by agent identifier' },
+                entityName: { type: 'string', description: 'Filter by entity name' },
+                since: { type: 'string', description: 'Only entries at or after this ISO 8601 timestamp' },
+                until: { type: 'string', description: 'Only entries at or before this ISO 8601 timestamp' },
+                limit: { type: 'number', description: 'Maximum number of results to return (default: 50)' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'audit_history',
+        description: 'Get the full audit history for a specific entity in chronological order',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Name of the entity to retrieve audit history for' },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'rollback_operation',
+        description: 'Reverse a specific committed operation using its audit entry ID (restores entity to before-snapshot)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                auditEntryId: { type: 'string', description: 'ID of the audit entry to reverse' },
+            },
+            required: ['auditEntryId'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== ROLE PROFILES ====================
+    {
+        name: 'set_agent_role',
+        description: 'Apply a built-in role profile (researcher, planner, executor, reviewer, coordinator) to adjust salience weights and context budgets',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role: {
+                    type: 'string',
+                    enum: ['researcher', 'planner', 'executor', 'reviewer', 'default'],
+                    description: 'Role to apply to the agent memory system',
+                },
+            },
+            required: ['role'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'list_role_profiles',
+        description: 'List all built-in role profiles with their salience weight and context budget configurations',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    // ==================== ENTROPY FILTER ====================
+    {
+        name: 'enable_entropy_filter',
+        description: 'Enable or disable the Shannon entropy gate that drops low-information memories during consolidation',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                enabled: { type: 'boolean', description: 'Whether to enable the entropy filter' },
+                minEntropy: {
+                    type: 'number',
+                    description: 'Minimum entropy threshold in bits (default: 1.5). Higher = stricter filtering.',
+                },
+                minLength: {
+                    type: 'number',
+                    description: 'Minimum text length before entropy is evaluated (default: 10)',
+                },
+            },
+            required: ['enabled'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'compute_entropy',
+        description: 'Compute the Shannon entropy of a text string (in bits per character)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text to compute entropy for' },
+                minEntropy: {
+                    type: 'number',
+                    description: 'Optional: check if text passes this minimum entropy threshold',
+                },
+            },
+            required: ['text'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== CONSOLIDATION ====================
+    {
+        name: 'start_consolidation',
+        description: 'Start the background consolidation scheduler that periodically deduplicates and merges memories',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                intervalMs: {
+                    type: 'number',
+                    description: 'Interval between consolidation runs in milliseconds (default: 3600000 = 1 hour)',
+                },
+                autoMergeDuplicates: {
+                    type: 'boolean',
+                    description: 'Enable duplicate detection and merge after each consolidation (default: false)',
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'stop_consolidation',
+        description: 'Stop the background consolidation scheduler',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'run_consolidation_now',
+        description: 'Run a consolidation cycle on demand, independently of the scheduled interval',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    // ==================== MEMORY FORMATTER ====================
+    {
+        name: 'format_with_salience_budget',
+        description: 'Format memories for LLM prompt consumption with proportional token allocation based on salience scores',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityNames: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Names of entities (memories) to format',
+                },
+                salienceScores: {
+                    type: 'object',
+                    additionalProperties: { type: 'number' },
+                    description: 'Map of entityName → salience score (0–1) for proportional allocation',
+                },
+                totalTokenBudget: {
+                    type: 'number',
+                    description: 'Maximum total token budget for the formatted output',
+                },
+                header: { type: 'string', description: 'Optional header text to prepend' },
+                separator: { type: 'string', description: 'Optional separator between memories (default: newline)' },
+            },
+            required: ['entityNames', 'salienceScores', 'totalTokenBudget'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== COLLABORATIVE SYNTHESIS ====================
+    {
+        name: 'synthesize_collaborative_context',
+        description: 'Synthesize context by traversing the graph neighbourhood from a seed entity and merging high-salience neighbors across agents',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                seedEntityName: { type: 'string', description: 'Name of the entity to start traversal from' },
+                maxDepth: { type: 'number', description: 'Maximum BFS depth to traverse from seed (default: 2)' },
+                minNeighborSalience: {
+                    type: 'number',
+                    description: 'Minimum salience score for a neighbor to be included (default: 0.3)',
+                },
+                maxNeighbors: { type: 'number', description: 'Maximum number of neighbor entities to include (default: 20)' },
+                queryText: { type: 'string', description: 'Optional query text for salience context scoring' },
+                currentTask: { type: 'string', description: 'Optional current task identifier for salience context' },
+            },
+            required: ['seedEntityName'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== FAILURE DISTILLATION ====================
+    {
+        name: 'distill_failure',
+        description: 'Distill lessons from a failed session by tracing the causal chain and extracting actionable insights',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'ID of the failed session to analyze' },
+                minLessonConfidence: {
+                    type: 'number',
+                    description: 'Minimum confidence required for a lesson to be persisted (default: 0.6)',
+                },
+                maxCauseChainLength: {
+                    type: 'number',
+                    description: 'Maximum depth to follow causal chains (default: 5)',
+                },
+            },
+            required: ['sessionId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'end_session',
+        description: 'End a session and trigger failure distillation if the session outcome was a failure',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'ID of the session to end' },
+                outcome: {
+                    type: 'string',
+                    enum: ['success', 'failure', 'partial'],
+                    description: 'Outcome of the session',
+                },
+                distillFailures: {
+                    type: 'boolean',
+                    description: 'Whether to automatically distill lessons on failure outcome (default: true)',
+                },
+            },
+            required: ['sessionId', 'outcome'],
+            additionalProperties: false,
+        },
+    },
+    // Phase 13: User profile + agent diary tools
+    {
+        name: 'get_profile',
+        description: 'Get the user profile. Returns static facts (long-lived preferences) and dynamic facts (recent session context). Profiles are scoped by projectId.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectId: { type: 'string', description: 'Optional project scope. Omit for global profile.' },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'update_profile',
+        description: 'Add a fact to the user profile. Static facts are long-lived (preferences, role, tools). Dynamic facts are recent (current project, active work).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: { type: 'string', description: 'The fact to add' },
+                type: { type: 'string', enum: ['static', 'dynamic'], description: 'Fact type: static (long-lived) or dynamic (recent)' },
+                projectId: { type: 'string', description: 'Optional project scope' },
+            },
+            required: ['content', 'type'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'diary_write',
+        description: 'Write a timestamped diary entry for a specialist agent. Each agent gets its own persistent diary (entity: diary-{agentId}). Use for code review findings, architecture decisions, ops incidents, etc.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Agent identifier (e.g., reviewer, architect, ops). Alphanumeric + hyphens/underscores only.' },
+                entry: { type: 'string', description: 'The diary entry content' },
+                topic: { type: 'string', description: 'Optional topic tag for filtering (e.g., security, performance)' },
+            },
+            required: ['agentId', 'entry'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'diary_read',
+        description: 'Read recent diary entries for a specialist agent. Returns entries in reverse chronological order. Optionally filter by topic.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Agent identifier' },
+                lastN: { type: 'number', description: 'Number of recent entries to return. Default: 10.' },
+                topic: { type: 'string', description: 'Optional topic filter' },
+            },
+            required: ['agentId'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== COGNITIVE LOAD ====================
+    {
+        name: 'analyze_cognitive_load',
+        description: 'Analyze the cognitive load of a set of entities: token density, redundancy ratio, diversity score, and composite load score',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityNames: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Names of entities to analyze',
+                },
+                loadThreshold: {
+                    type: 'number',
+                    description: 'Load score threshold above which context is considered overloaded (default: 0.7)',
+                },
+            },
+            required: ['entityNames'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'adaptive_reduce_memories',
+        description: 'Adaptively reduce a set of memories until their cognitive load falls below the configured threshold by removing low-salience redundant memories',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityNames: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Names of entities to reduce',
+                },
+                salienceScores: {
+                    type: 'object',
+                    additionalProperties: { type: 'number' },
+                    description: 'Map of entityName → salience score (0–1) for prioritizing removal',
+                },
+                loadThreshold: {
+                    type: 'number',
+                    description: 'Target load threshold to reduce below (default: 0.7)',
+                },
+            },
+            required: ['entityNames', 'salienceScores'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== DREAM ENGINE TOOLS ====================
+    {
+        name: 'dream_start',
+        description: 'Start the DreamEngine background memory maintenance. Runs 8 phases (temporal anchoring, freshness sweep, entropy pruning, consolidation, compression, entity enrichment, pattern promotion, graph hygiene) on a configurable interval.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                intervalMs: {
+                    type: 'number',
+                    description: 'Interval between dream cycles in milliseconds (default: 14400000 = 4 hours)',
+                },
+                runOnSessionEnd: {
+                    type: 'boolean',
+                    description: 'Run a dream cycle automatically when endSession() is called (default: true)',
+                },
+                maxDurationMs: {
+                    type: 'number',
+                    description: 'Hard limit on total cycle wall-clock time in milliseconds (default: 60000 = 60s)',
+                },
+                phases: {
+                    type: 'object',
+                    description: 'Per-phase enable/disable flags',
+                    properties: {
+                        temporalAnchoring: { type: 'boolean', description: 'Phase 1: Resolve relative date references to absolute ISO timestamps' },
+                        freshnessSweep: { type: 'boolean', description: 'Phase 2: Flag stale entities, decay confidence, expire TTL records' },
+                        entropyPruning: { type: 'boolean', description: 'Phase 3: Remove observations whose Shannon entropy is below threshold' },
+                        consolidation: { type: 'boolean', description: 'Phase 4: Merge working-memory items into long-term storage' },
+                        compression: { type: 'boolean', description: 'Phase 5: Deduplicate near-identical entities above similarity threshold' },
+                        entityEnrichment: { type: 'boolean', description: 'Phase 6: Auto-generate summary observations for entity enrichment' },
+                        patternPromotion: { type: 'boolean', description: 'Phase 7: Detect recurring observation themes and promote to semantic memory' },
+                        graphHygiene: { type: 'boolean', description: 'Phase 8: Orphan detection and dangling-relation cleanup' },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'dream_stop',
+        description: 'Stop the DreamEngine background process.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'dream_run_now',
+        description: 'Run a single dream cycle immediately. Returns detailed per-phase results.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                phases: {
+                    type: 'object',
+                    description: 'Per-phase enable/disable flags for this cycle',
+                    properties: {
+                        temporalAnchoring: { type: 'boolean', description: 'Phase 1: Resolve relative date references to absolute ISO timestamps' },
+                        freshnessSweep: { type: 'boolean', description: 'Phase 2: Flag stale entities, decay confidence, expire TTL records' },
+                        entropyPruning: { type: 'boolean', description: 'Phase 3: Remove observations whose Shannon entropy is below threshold' },
+                        consolidation: { type: 'boolean', description: 'Phase 4: Merge working-memory items into long-term storage' },
+                        compression: { type: 'boolean', description: 'Phase 5: Deduplicate near-identical entities above similarity threshold' },
+                        entityEnrichment: { type: 'boolean', description: 'Phase 6: Auto-generate summary observations for entity enrichment' },
+                        patternPromotion: { type: 'boolean', description: 'Phase 7: Detect recurring observation themes and promote to semantic memory' },
+                        graphHygiene: { type: 'boolean', description: 'Phase 8: Orphan detection and dangling-relation cleanup' },
+                    },
+                    additionalProperties: false,
+                },
+            },
+            additionalProperties: false,
+        },
+    },
+    // Phase 13: Config tool
+    // TODO: set_project_scope requires server state management (activeProjectId on MCPServer)
+    // Skipped in this pass — implement when MCPServer exposes mutable server state to handlers.
+    // ==================== SESSION & WORKING MEMORY TOOLS ====================
+    {
+        name: 'session_start',
+        description: 'Start a new agent session via AgentMemoryManager. Tracks session lifecycle, enables working memory, and supports session chaining. Returns a SessionEntity with id and timestamps.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                taskDescription: { type: 'string', description: 'Description of the task for this session' },
+                parentSessionId: { type: 'string', description: 'ID of a parent session to chain from' },
+                metadata: { type: 'object', description: 'Arbitrary metadata to attach to the session' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'session_end',
+        description: 'End an agent session via AgentMemoryManager with summary generation and working memory promotion. Unlike end_session (which handles failure distillation on graph entities), this manages the full agent session lifecycle.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'The session ID to end' },
+                status: { type: 'string', enum: ['completed', 'abandoned'], description: 'Session completion status (default: completed)' },
+            },
+            required: ['sessionId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'session_checkpoint',
+        description: 'Create a checkpoint snapshot of the current session state for later restore',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'The session ID to checkpoint' },
+                name: { type: 'string', description: 'Optional human-readable name for the checkpoint' },
+            },
+            required: ['sessionId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'session_restore',
+        description: 'Restore a session from a previously created checkpoint',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                checkpointId: { type: 'string', description: 'The checkpoint ID to restore from' },
+            },
+            required: ['checkpointId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'add_working_memory',
+        description: 'Create a TTL-based short-term working memory entry scoped to a session. Working memories auto-expire and can be promoted to long-term storage.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'Session ID this memory belongs to' },
+                content: { type: 'string', description: 'The memory content' },
+                taskId: { type: 'string', description: 'Optional task ID for task-scoped memory' },
+                importance: { type: 'number', description: 'Importance score (0-10)' },
+                ttlHours: { type: 'number', description: 'Time-to-live in hours (default: 24)' },
+            },
+            required: ['sessionId', 'content'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'promote_working_memory',
+        description: 'Promote a working memory entry to long-term episodic or semantic storage',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryName: { type: 'string', description: 'Name of the working memory entity to promote' },
+                targetType: { type: 'string', enum: ['episodic', 'semantic'], description: 'Target memory type (default: episodic)' },
+            },
+            required: ['memoryName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'confirm_memory',
+        description: 'Boost a memory\'s confidence score without resetting its timestamp. Unlike refresh_entity (which resets to 1.0), this incrementally increases confidence.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryName: { type: 'string', description: 'Name of the memory entity to confirm' },
+                confidenceBoost: { type: 'number', description: 'Amount to boost confidence by (default: 0.1)' },
+            },
+            required: ['memoryName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'clear_expired_memories',
+        description: 'Remove all working memories that have exceeded their TTL. Complements get_expired_entities (which lists but does not delete).',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'wake_up',
+        description: 'Initialize a 4-layer memory stack context (~600 tokens). L0 loads profile identity, L1 loads top entities by importance. Returns a compact boot context for LLM consumption.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                compress: { type: 'boolean', description: 'Apply n-gram compression to reduce token count (default: false)' },
+            },
+            additionalProperties: false,
+        },
+    },
+    // ==================== AUTO-ENHANCEMENT TOOLS ====================
+    {
+        name: 'auto_link_observations',
+        description: 'Detect entity mentions in observation text and suggest cross-reference relations. Unlike normalize_observations (which resolves pronouns/dates), this finds entity name mentions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Observation text to scan for entity mentions' },
+            },
+            required: ['text'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'extract_facts',
+        description: 'Extract structured facts from observation text using rule-based extraction',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text to extract facts from' },
+            },
+            required: ['text'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'detect_contradictions',
+        description: 'Find conflicting observations within an entity using semantic similarity',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Entity to check for contradictions' },
+                threshold: { type: 'number', description: 'Similarity threshold for contradiction detection (0-1, default: 0.85)', minimum: 0, maximum: 1 },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'consolidate_session',
+        description: 'Run the full ConsolidationPipeline on a session: promote working memory, merge duplicates, summarize, and extract patterns. Unlike run_consolidation_now (which runs the dedup scheduler), this is a comprehensive session-scoped pipeline.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: { type: 'string', description: 'Session ID to consolidate' },
+            },
+            required: ['sessionId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'detect_patterns',
+        description: 'Detect recurring token-based patterns across observations of a given entity type',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityType: { type: 'string', description: 'Entity type to analyze for patterns' },
+                minOccurrences: { type: 'number', description: 'Minimum occurrences to qualify as a pattern (default: 3)' },
+            },
+            required: ['entityType'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'summarize_entity',
+        description: 'Auto-summarize redundant observations within a single entity. Unlike compress_graph (which merges similar entities), this condenses observations within one entity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Entity whose observations to summarize' },
+                threshold: { type: 'number', description: 'Similarity threshold for merging observations (0-1)', minimum: 0, maximum: 1 },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'priority_dedup',
+        description: 'Smart priority-based deduplication that keeps the highest-scored entity per duplicate group (importance > recency > observation count > tags)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                dryRun: { type: 'boolean', description: 'If true, report what would be deduplicated without making changes' },
+            },
+            additionalProperties: false,
+        },
+    },
+    // ==================== CONTEXT COMPRESSION TOOLS ====================
+    {
+        name: 'compress_context',
+        description: 'Compress text using n-gram abbreviation with a legend for token-efficient context loading. Unlike format_with_salience_budget (which allocates token budget), this does text-level compression.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text to compress' },
+                level: { type: 'string', enum: ['light', 'medium', 'aggressive'], description: 'Compression level (default: medium)' },
+            },
+            required: ['text'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== DECAY & SALIENCE TOOLS ====================
+    {
+        name: 'run_decay_cycle',
+        description: 'Run a single pass of time-based importance decay across all agent memories. Returns count of decayed and forgotten memories.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_decayed_memories',
+        description: 'List memories whose importance has fallen below a threshold due to time-based decay. Unlike get_stale_entities (which uses freshness timestamps), this uses decay engine importance calculations.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                threshold: { type: 'number', description: 'Importance threshold (default: 0.1)' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'forget_weak_memories',
+        description: 'Bulk-delete memories that fell below a decay threshold. Unlike forget_memory (content match) or archive_entities (criteria-based move), this uses decay-based importance scoring.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                threshold: { type: 'number', description: 'Importance threshold below which to forget' },
+                maxCount: { type: 'number', description: 'Maximum number of memories to forget' },
+                dryRun: { type: 'boolean', description: 'If true, report what would be forgotten without deleting' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'reinforce_memory',
+        description: 'Boost a memory\'s decay resistance by increasing confirmation count and/or confidence. Unlike refresh_entity (timestamp reset) or set_importance (static score), this modulates the decay model.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryName: { type: 'string', description: 'Name of the memory to reinforce' },
+                confirmationBoost: { type: 'number', description: 'Amount to boost confirmation count' },
+                confidenceBoost: { type: 'number', description: 'Amount to boost confidence score' },
+            },
+            required: ['memoryName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'score_salience',
+        description: 'Calculate 5-component relevance score for an entity: baseImportance, recencyBoost, frequencyBoost, contextRelevance, noveltyBoost. Use with format_with_salience_budget to score then format.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Entity to score' },
+                queryText: { type: 'string', description: 'Optional query text for context relevance' },
+                taskDescription: { type: 'string', description: 'Optional task description for task relevance' },
+                sessionId: { type: 'string', description: 'Optional session ID for session relevance' },
+            },
+            required: ['entityName'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== MULTI-AGENT TOOLS ====================
+    {
+        name: 'register_agent',
+        description: 'Register an agent for multi-agent operations with identity metadata. Unlike set_agent_role (which applies a role profile), this registers agent identity with type, trust level, and capabilities.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Unique agent identifier' },
+                type: { type: 'string', description: 'Agent type (e.g., assistant, specialist, coordinator)' },
+                trustLevel: { type: 'number', description: 'Trust level (0-1)', minimum: 0, maximum: 1 },
+                capabilities: { type: 'array', items: { type: 'string' }, description: 'List of agent capabilities' },
+            },
+            required: ['agentId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'search_cross_agent',
+        description: 'Search across agent memories with trust-weighted scoring and visibility filtering',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                requestingAgentId: { type: 'string', description: 'Agent ID making the request' },
+                query: { type: 'string', description: 'Search query' },
+                agentIds: { type: 'array', items: { type: 'string' }, description: 'Optional list of agent IDs to search across' },
+            },
+            required: ['requestingAgentId', 'query'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'set_memory_visibility',
+        description: 'Set the visibility of a memory entity for multi-agent access control. Auto-promotes plain entities to AgentEntity (stamps agentId/memoryType/etc.) instead of failing silently. Supports η.5.5.b extensions: allowedRoles (role gate), visibleFrom/visibleUntil (time-window gate).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memoryName: { type: 'string', description: 'Name of the memory entity' },
+                agentId: { type: 'string', description: 'Agent ID that owns the memory' },
+                visibility: { type: 'string', enum: ['private', 'team', 'org', 'shared', 'public'], description: 'Visibility level' },
+                allowedRoles: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'η.5.5.b — Optional role gate. When set, requesting agents whose AgentMetadata.role is NOT in this list are denied even if the visibility level would grant. AND-combined with the level check.',
+                },
+                visibleFrom: {
+                    type: 'string',
+                    description: 'η.5.5.b — ISO 8601. Memory becomes visible at this instant. Absent ⇒ visible since creation. Denies even the owner before this time.',
+                },
+                visibleUntil: {
+                    type: 'string',
+                    description: 'η.5.5.b — ISO 8601. Memory stops being visible at this instant. Useful for shared drafts that expire on a known handoff date.',
+                },
+            },
+            required: ['memoryName', 'agentId', 'visibility'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_visible_memories',
+        description: 'Get all memories visible to a specific agent based on visibility rules and trust levels',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Agent ID to check visibility for' },
+            },
+            required: ['agentId'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'resolve_agent_conflict',
+        description: 'Resolve a conflict between two agent memories using a specified strategy',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                primaryMemory: { type: 'string', description: 'Name of the first conflicting memory' },
+                conflictingMemory: { type: 'string', description: 'Name of the second conflicting memory' },
+                strategy: { type: 'string', enum: ['most_recent', 'highest_confidence', 'most_confirmations', 'trusted_agent'], description: 'Conflict resolution strategy (default: most_recent)' },
+            },
+            required: ['primaryMemory', 'conflictingMemory'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== OBSERVABILITY TOOLS ====================
+    {
+        name: 'visualize_graph',
+        description: 'Generate a self-contained interactive HTML page with a D3.js force-directed graph visualization. Nodes are colored by type and sized by importance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                maxEntities: { type: 'number', description: 'Maximum entities to include (default: 100)' },
+                title: { type: 'string', description: 'Title for the graph visualization' },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'split_transcript',
+        description: 'Split concatenated multi-session transcripts into per-session chunks via delimiter detection. Preprocessing step before ingest.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Raw transcript text to split' },
+            },
+            required: ['text'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'estimate_query_cost',
+        description: 'Estimate execution cost (time, tokens) for all available search methods on a given query. Unlike analyze_query (which extracts entities/complexity), this predicts per-method performance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query to estimate cost for' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_context_profile',
+        description: 'Get a ContextWindowManager profile configuration (salience weights, retrieval strategy). Unlike get_profile (user profile facts), this returns context-aware retrieval settings.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Profile name to retrieve' },
+            },
+            required: ['name'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== η.4.4 BITEMPORAL ENTITY TOOLS ====================
+    {
+        name: 'invalidate_entity',
+        description: 'η.4.4 — Mark an entity as no longer valid by setting validUntil. Idempotent. Does not delete the entity — entity_as_of still returns it for past asOf timestamps. Orthogonal to v1.8 supersession.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Entity name' },
+                ended: { type: 'string', description: 'ISO 8601 timestamp; defaults to current time' },
+            },
+            required: ['name'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'entity_as_of',
+        description: 'η.4.4 — Time-travel query for an entity. Returns the entity at a given point in time, or null if it was already invalidated then. An entity is valid at asOf when validFrom <= asOf AND (validUntil is undefined OR validUntil >= asOf).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Entity name' },
+                asOf: { type: 'string', description: 'ISO 8601 date string to query at' },
+            },
+            required: ['name', 'asOf'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'entity_timeline',
+        description: 'η.4.4 — Get all temporal versions of an entity in chronological order (by validFrom asc, with unbounded entities last). Returns the v1.8 supersession chain when one exists.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Entity name (any version in the chain)' },
+            },
+            required: ['name'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'invalidate_observation',
+        description: 'η.4.4 — Mark a specific observation on an entity as no longer valid. Creates a parallel observationMeta[] entry if absent. Throws if observation not found on entity.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Entity name' },
+                content: { type: 'string', description: 'Exact observation content to invalidate' },
+                ended: { type: 'string', description: 'ISO 8601 timestamp; defaults to current time' },
+            },
+            required: ['entityName', 'content'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'observations_as_of',
+        description: 'η.4.4 — Get observations valid at a given point in time. Observations with no observationMeta entry are treated as unbounded (always-valid).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entityName: { type: 'string', description: 'Entity name' },
+                asOf: { type: 'string', description: 'ISO 8601 date string' },
+            },
+            required: ['entityName', 'asOf'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== η.5.5 OCC + ATTRIBUTION TOOLS ====================
+    {
+        name: 'update_entity',
+        description: 'η.5.5.c — Update an entity with optional optimistic concurrency control. Pass expectedVersion to assert the live entity is at that version; throws VersionConflictError on mismatch. Omit for legacy last-write-wins. OCC-guarded writes auto-increment version.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Entity name to update' },
+                updates: {
+                    type: 'object',
+                    description: 'Partial entity object — fields to change',
+                    additionalProperties: true,
+                },
+                expectedVersion: {
+                    type: 'number',
+                    description: 'OCC: assert the live entity is at this version. Throws VersionConflictError on mismatch.',
+                },
+            },
+            required: ['name', 'updates'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== η.6.1 RBAC TOOLS ====================
+    {
+        name: 'rbac_assign_role',
+        description: 'η.6.1 — Grant a role to an agent. Roles: reader (read), writer (read+write), admin (read+write+delete), owner (all four). Optional resourceType narrows to one type; optional scope narrows to a name prefix; optional validUntil expires the grant.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string', description: 'Agent identifier' },
+                role: { type: 'string', description: 'Role name (reader, writer, admin, owner, or custom)' },
+                resourceType: { type: 'string', enum: ['entity', 'relation', 'observation', 'session', 'artifact'], description: 'Optional resource-type narrow' },
+                scope: { type: 'string', description: 'Optional name prefix (e.g. "project-x:")' },
+                validFrom: { type: 'string', description: 'ISO 8601 — assignment becomes active' },
+                validUntil: { type: 'string', description: 'ISO 8601 — assignment expires' },
+                notes: { type: 'string', description: 'Free-form notes (e.g. ticket reference)' },
+            },
+            required: ['agentId', 'role'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'rbac_revoke_role',
+        description: 'η.6.1 — Remove a specific role assignment. Matching is by agentId + role + resourceType (exact, including undefined).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                role: { type: 'string' },
+                resourceType: { type: 'string', enum: ['entity', 'relation', 'observation', 'session', 'artifact'] },
+            },
+            required: ['agentId', 'role'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'rbac_check_permission',
+        description: 'η.6.1 — Check whether an agent can perform an action on a resource type. Falls back to defaultRole=reader for agents with no assignments.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                action: { type: 'string', enum: ['read', 'write', 'delete', 'manage'] },
+                resourceType: { type: 'string', enum: ['entity', 'relation', 'observation', 'session', 'artifact'] },
+                resourceName: { type: 'string', description: 'Optional resource name for scope-prefix matching' },
+                now: { type: 'string', description: 'Optional time override for hypothetical-time queries' },
+            },
+            required: ['agentId', 'action', 'resourceType'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'rbac_list_assignments',
+        description: 'η.6.1 — List role assignments for an agent (active or all).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agentId: { type: 'string' },
+                activeOnly: { type: 'boolean', default: false, description: 'If true, filter by current time' },
+                now: { type: 'string', description: 'Optional time override (only meaningful when activeOnly=true)' },
+            },
+            required: ['agentId'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== 3B.4 PROCEDURAL MEMORY TOOLS ====================
+    {
+        name: 'add_procedure',
+        description: '3B.4 — Persist a new procedural memory (executable how-to sequence). Steps are ordered (1-indexed) with optional fallback chains. Auto-generates id when omitted. Distinct from semantic facts and episodic events.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Optional stable id; auto-generated if omitted' },
+                name: { type: 'string', description: 'Human-readable name' },
+                description: { type: 'string' },
+                steps: {
+                    type: 'array',
+                    description: 'Ordered step list',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            order: { type: 'number', description: '1-indexed step order' },
+                            action: { type: 'string', description: 'Caller-meaningful action identifier' },
+                            parameters: { type: 'object', description: 'Parameter map (string → string)', additionalProperties: { type: 'string' } },
+                            fallback: { type: 'object', description: 'Optional fallback step on failure' },
+                            timeout: { type: 'number', description: 'Caller-enforced max duration in ms' },
+                        },
+                        required: ['order', 'action', 'parameters'],
+                    },
+                },
+                triggers: { type: 'array', items: { type: 'string' }, description: 'Free-form trigger phrases for matching' },
+            },
+            required: ['steps'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_procedure',
+        description: '3B.4 — Load a procedure by id.',
+        inputSchema: {
+            type: 'object',
+            properties: { id: { type: 'string' } },
+            required: ['id'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'match_procedure',
+        description: '3B.4 — Token-overlap match a context description against stored procedures. Returns ranked matches with Jaccard-like scores.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                context: { type: 'string', description: 'Context description to match against' },
+                threshold: { type: 'number', minimum: 0, maximum: 1, default: 0, description: 'Minimum match score' },
+                candidateIds: { type: 'array', items: { type: 'string' }, description: 'Optional procedure ids to match against (default: all)' },
+            },
+            required: ['context'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'refine_procedure',
+        description: '3B.4 — Apply caller feedback after a procedure execution. Increments executionCount and updates successRate via EWMA (α=0.2).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                succeeded: { type: 'boolean' },
+                notes: { type: 'string' },
+                recordedAt: { type: 'string' },
+            },
+            required: ['id', 'succeeded'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'get_procedure_step',
+        description: '3B.4 — Load a specific step from a procedure by 1-indexed order, OR get the next step relative to currentOrder.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                order: { type: 'number', description: '1-indexed step to fetch' },
+                next: { type: 'boolean', description: 'If true, returns the step after `order` instead of step `order` itself' },
+            },
+            required: ['id', 'order'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== 3B.5 ACTIVE RETRIEVAL TOOL ====================
+    {
+        name: 'adaptive_retrieve',
+        description: '3B.5 — Run iterative query-rewriting retrieval. Up to maxRounds of (search → score coverage → rewrite). Stops early when coverage ≥ minCoverage or no expansion tokens. Pure symbolic — no LLM provider required.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string' },
+                budgetTokens: { type: 'number', description: 'Optional token budget; rejects retrieval if cost exceeds budget' },
+                maxRounds: { type: 'number', default: 3 },
+                minCoverage: { type: 'number', minimum: 0, maximum: 1, default: 0.6 },
+                resultsPerRound: { type: 'number', default: 10 },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== 3B.6 CAUSAL REASONING TOOLS ====================
+    {
+        name: 'find_causes',
+        description: '3B.6 — Find causal chains ending at the named effect. Searches paths from candidate causes via causal relation types (causes/enables/prevents/precedes/correlates). Sorted by score = product of per-edge causalStrength.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                effect: { type: 'string', description: 'Target entity name (effect)' },
+                candidates: { type: 'array', items: { type: 'string' }, description: 'Candidate cause entity names' },
+                maxDepth: { type: 'number', default: 6 },
+            },
+            required: ['effect', 'candidates'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'find_effects',
+        description: '3B.6 — Find causal chains starting at the named cause and reaching any candidate effect. Symmetric counterpart to find_causes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                cause: { type: 'string' },
+                candidates: { type: 'array', items: { type: 'string' } },
+                maxDepth: { type: 'number', default: 6 },
+            },
+            required: ['cause', 'candidates'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'counterfactual_query',
+        description: '3B.6 — "What if we remove edge (removeFrom → removeTo)? Is predict still reachable from seed?" Returns chains from seed to predict that DO NOT use the removed edge. Pure: does not mutate the graph.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                seed: { type: 'string' },
+                removeFrom: { type: 'string' },
+                removeTo: { type: 'string' },
+                predict: { type: 'string' },
+                maxDepth: { type: 'number', default: 6 },
+            },
+            required: ['seed', 'removeFrom', 'removeTo', 'predict'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'detect_causal_cycles',
+        description: '3B.6 — Detect cycles in the causal subgraph rooted at seed. CAVEAT: treats prevents as a directed edge, not as logical negation — prevents+enables triangles ARE flagged.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                seed: { type: 'string' },
+                maxDepth: { type: 'number', default: 6 },
+            },
+            required: ['seed'],
+            additionalProperties: false,
+        },
+    },
+    // ==================== 3B.7 WORLD MODEL TOOLS ====================
+    {
+        name: 'get_world_state',
+        description: '3B.7 — Capture a fresh snapshot of the live graph: entitiesByName + takenAt timestamp + size. Capped at maxSnapshotSize (default 1000); over-cap prefers high-importance entities.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'validate_fact_against_world',
+        description: '3B.7 — Validate a candidate observation against a target entity. Delegates to MemoryValidator.validateConsistency. Returns null if no validator is wired.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                observation: { type: 'string' },
+                entityName: { type: 'string' },
+            },
+            required: ['observation', 'entityName'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'predict_outcome',
+        description: '3B.7 — Predict downstream effects of an action by walking the causal subgraph. Delegates to CausalReasoner.findEffects.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', description: 'Action entity name' },
+                candidates: { type: 'array', items: { type: 'string' }, description: 'Candidate effect entity names' },
+            },
+            required: ['action', 'candidates'],
+            additionalProperties: false,
+        },
+    },
 ];
 // Tool categories are documented in CLAUDE.md for reference:
 // - Entity Operations: create_entities, delete_entities, read_graph, open_nodes