claude-brain 0.30.2 → 0.31.1

package/src/server/services.ts

@@ -1,720 +1,720 @@
-/**
- * Shared Services Module
- * Provides access to initialized services for tool handlers
- */
-
-import type { Logger } from 'pino'
-import { existsSync } from 'fs'
-import * as path from 'path'
-import { MemoryManager } from '@/memory'
-import { VaultManager } from '@/vault'
-import { ContextManager } from '@/context'
-import { Phase12Manager } from '@/automation/phase12-manager'
-import { RetrievalService } from '@/retrieval/service'
-import { RetrievalPipeline } from '@/retrieval/pipeline'
-import { InMemoryKnowledgeGraph } from '@/knowledge/graph/memory-graph'
-import { GraphSearchEngine } from '@/knowledge/graph/search'
-import { KnowledgeGraphBuilder } from '@/knowledge/graph/builder'
-import { CrossReferenceLinker } from '@/knowledge/graph/linker'
-import { EpisodeManager } from '@/memory/episodic/manager'
-import { HookSessionTracker } from '@/hooks/session-tracker'
-import type { Config } from '@/config'
-import type { CodeIndexer } from '@/code-intelligence/indexer'
-import type { CodeQuery } from '@/code-intelligence/query'
-import type { MemoryCodeLinker } from '@/code-intelligence/linker'
-import { SemanticCache } from '@/intelligence/optimization/semantic-cache'
-import { PrecomputeEngine } from '@/intelligence/optimization/precompute'
-import { MemoryArchiver } from '@/memory/consolidation/archiver'
-import { ImportanceScorer } from '@/memory/consolidation/scorer'
-import { ModelManager } from '@/intelligence/model-manager'
-import { InferenceRouter } from '@/intelligence/inference-router'
-
-export interface KnowledgeGraphServiceContainer {
-  graph: InMemoryKnowledgeGraph
-  search: GraphSearchEngine
-  builder: KnowledgeGraphBuilder
-  linker: CrossReferenceLinker
-}
-
-/**
- * Container for all shared services
- */
-export interface Services {
-  memory: MemoryManager
-  vault: VaultManager
-  context: ContextManager
-  phase12: Phase12Manager
-  retrieval: RetrievalService | null
-  retrievalPipeline: RetrievalPipeline | null
-  knowledgeGraph: KnowledgeGraphServiceContainer | null
-  episodeManager: EpisodeManager | null
-  sessionTracker: HookSessionTracker | null
-  semanticCache: SemanticCache | null
-  precompute: PrecomputeEngine | null
-  archiver: MemoryArchiver | null
-  codeIndexer: CodeIndexer | null
-  codeQuery: CodeQuery | null
-  codeLinker: MemoryCodeLinker | null
-  modelManager: ModelManager | null
-  inferenceRouter: InferenceRouter | null
-  logger: Logger
-  config: Config
-}
-
-// Singleton services instance
-let services: Services | null = null
-let initializationPromise: Promise<void> | null = null
-let archiveTimer: ReturnType<typeof setInterval> | null = null
-
-/**
- * Initialize all services
- * Should be called once during server startup
- */
-export async function initializeServices(config: Config, logger: Logger): Promise<Services> {
-  // If already initialized, return existing services
-  if (services) {
-    logger.debug('Services already initialized')
-    return services
-  }
-
-  // If initialization is in progress, wait for it
-  if (initializationPromise) {
-    await initializationPromise
-    return services!
-  }
-
-  // Start initialization
-  initializationPromise = (async () => {
-    const serviceLogger = logger.child({ component: 'services' })
-    serviceLogger.info('Initializing services...')
-
-    // Phase 30: Auto-create vault path if it doesn't exist (zero-config)
-    if (!config.vaultPath) {
-      const { getHomePaths } = await import('@/config/home')
-      config.vaultPath = getHomePaths().vault
-      serviceLogger.info({ vaultPath: config.vaultPath }, 'Auto-detected vault path')
-    }
-
-    if (!existsSync(config.vaultPath)) {
-      try {
-        const { mkdirSync } = await import('node:fs')
-        mkdirSync(config.vaultPath, { recursive: true })
-        mkdirSync(path.join(config.vaultPath, 'Projects'), { recursive: true })
-        mkdirSync(path.join(config.vaultPath, 'Global'), { recursive: true })
-        serviceLogger.info({ vaultPath: config.vaultPath }, 'Created vault directory')
-      } catch (error) {
-        serviceLogger.warn({ error, vaultPath: config.vaultPath }, 'Failed to create vault directory, continuing without vault writes')
-      }
-    } else {
-      const projectsPath = path.join(config.vaultPath, 'Projects')
-      if (!existsSync(projectsPath)) {
-        try {
-          const { mkdirSync } = await import('node:fs')
-          mkdirSync(projectsPath, { recursive: true })
-        } catch {
-          serviceLogger.warn({ projectsPath }, 'Failed to create Projects directory')
-        }
-      }
-    }
-
-    // Initialize Memory Manager
-    // Phase 26: ChromaDB is now opt-in (default false), FTS5 is primary
-    const useChromaDB = config.chromadb?.enabled ?? false
-    const memory = new MemoryManager(config.dbPath, logger, useChromaDB)
-    await memory.initialize()
-    serviceLogger.info({ chromadb: useChromaDB }, 'Memory service initialized')
-
-    // Initialize Vault Manager
-    const vault = new VaultManager(config.vaultPath, logger, {
-      cacheEnabled: config.cacheSize > 0,
-      watchEnabled: config.enableFileWatch
-    })
-    await vault.initialize()
-    serviceLogger.info('Vault service initialized')
-
-    // Initialize Context Manager
-    const context = new ContextManager(logger, vault, memory)
-    serviceLogger.info('Context service initialized')
-
-    // Initialize Phase 12 Manager
-    const phase12 = new Phase12Manager(logger, vault, memory, context)
-    await phase12.initialize()
-    serviceLogger.info('Phase 12 service initialized')
-
-    // Initialize Retrieval Service (Phase 13) — requires ChromaDB
-    let retrieval: RetrievalService | null = null
-    if ((config.retrieval?.feedback?.enabled || config.retrieval?.enabled) && memory.isChromaDBEnabled()) {
-      retrieval = new RetrievalService(
-        logger,
-        memory.chroma.collections,
-        memory.chroma.embeddings!,
-        config.retrieval
-      )
-      await retrieval.initialize()
-      serviceLogger.info('Retrieval service initialized')
-    } else if (config.retrieval?.enabled && !memory.isChromaDBEnabled()) {
-      serviceLogger.warn('Retrieval service requires ChromaDB, skipping initialization')
-    }
-
-    // Initialize Retrieval Pipeline (Phase 19) — hybrid search with BM25 + semantic + fusion
-    let retrievalPipeline: RetrievalPipeline | null = null
-    if (config.retrieval?.enabled && memory.isChromaDBEnabled()) {
-      try {
-        retrievalPipeline = new RetrievalPipeline(
-          logger,
-          memory.chroma.collections,
-          memory.chroma.embeddings!,
-          config.retrieval
-        )
-        await retrievalPipeline.initialize()
-        serviceLogger.info('Retrieval pipeline initialized (hybrid search)')
-      } catch (error) {
-        serviceLogger.warn({ error }, 'Failed to initialize retrieval pipeline, continuing without hybrid search')
-      }
-    }
-
-    // Initialize Knowledge Graph Service (Phase 14)
-    let knowledgeGraph: KnowledgeGraphServiceContainer | null = null
-    if (config.knowledge?.graph?.enabled !== false) {
-      try {
-        const graph = new InMemoryKnowledgeGraph(logger)
-        // Use absolute path from getHomePaths() if persistPath not configured
-        const { getHomePaths: getHomePathsKG } = await import('@/config/home')
-        const graphPersistPath = config.knowledge?.graph?.persistPath || getHomePathsKG().knowledgeGraph
-
-        // Load existing graph from disk
-        await graph.load(graphPersistPath)
-
-        const search = new GraphSearchEngine(graph, logger)
-        const builder = new KnowledgeGraphBuilder(graph, logger)
-        await builder.initialize()
-        const linker = new CrossReferenceLinker(graph, logger)
-
-        // Start auto-save
-        const autoSaveInterval = (config.knowledge?.graph?.autoSaveInterval || 60) * 1000
-        graph.startAutoSave(graphPersistPath, autoSaveInterval)
-
-        knowledgeGraph = { graph, search, builder, linker }
-
-        // Migrate existing decisions if graph is empty (requires ChromaDB)
-        if (graph.getNodeCount() === 0 && memory.isChromaDBEnabled()) {
-          serviceLogger.info('Empty graph detected, migrating existing decisions...')
-          const migrationResult = await builder.migrateExistingDecisions(memory.chroma.collections)
-          serviceLogger.info(
-            { processed: migrationResult.processed, errors: migrationResult.errors },
-            'Initial graph migration complete'
-          )
-        } else if (graph.getNodeCount() === 0) {
-          serviceLogger.info('Empty graph detected, but ChromaDB unavailable — graph will populate as new decisions are stored')
-        }
-
-        // Hook builder into decision storage for real-time graph population
-        // Uses MemoryManager listener so it works for both ChromaDB and SQLite paths
-        memory.addDecisionStoredListener((input) => {
-          builder.processDecision(input)
-        })
-
-        // Hook builder into decision deletion for graph synchronization
-        memory.addDecisionDeletedListener((id) => {
-          builder.removeDecision(id)
-
-          // Phase 20: Also unlink from active episodes
-          if (episodeManager) {
-            episodeManager.unlinkDecision(id)
-          }
-
-          // Phase 20: Invalidate semantic cache for deleted decisions
-          if (semanticCache) {
-            semanticCache.clear()
-          }
-        })
-
-        serviceLogger.info(
-          { nodes: graph.getNodeCount(), edges: graph.getEdgeCount() },
-          'Knowledge graph service initialized'
-        )
-      } catch (error) {
-        serviceLogger.warn({ error }, 'Failed to initialize knowledge graph, continuing without it')
-      }
-    }
-
-    // Initialize Episode Manager (Phase 14) — requires ChromaDB
-    let episodeManager: EpisodeManager | null = null
-    if (config.knowledge?.episodic?.enabled !== false && memory.isChromaDBEnabled()) {
-      try {
-        episodeManager = new EpisodeManager(
-          logger,
-          memory.chroma.collections,
-          memory.chroma.embeddings,
-          { sessionGapMinutes: config.knowledge?.episodic?.sessionGapMinutes || 30 }
-        )
-        serviceLogger.info('Episode manager initialized')
-      } catch (error) {
-        serviceLogger.warn({ error }, 'Failed to initialize episode manager, continuing without it')
-      }
-    }
-
-    // Initialize Session Tracker (Phase 21) — promoted from serve.ts
-    let sessionTracker: HookSessionTracker | null = null
-    if (config.hooks?.enabled !== false) {
-      try {
-        sessionTracker = new HookSessionTracker(logger, episodeManager, config.hooks?.sessions, memory)
-        serviceLogger.info('Session tracker initialized')
-      } catch (error) {
-        serviceLogger.warn({ error }, 'Failed to initialize session tracker, continuing without it')
-      }
-    }
-
-    // Initialize Semantic Cache & Precompute (Phase 15) — requires ChromaDB
-    let semanticCache: SemanticCache | null = null
-    let precompute: PrecomputeEngine | null = null
-    if (config.advancedIntelligence?.enabled !== false && config.advancedIntelligence?.cache?.enabled !== false && memory.isChromaDBEnabled()) {
-      try {
-        const cacheConfig = config.advancedIntelligence?.cache || {}
-        semanticCache = new SemanticCache(logger, {
-          maxSize: cacheConfig.maxSize || 1000,
-          ttlMs: cacheConfig.ttlMs || 60 * 60 * 1000,
-          similarityThreshold: cacheConfig.similarityThreshold || 0.80,
-          embeddings: memory.chroma.embeddings
-        })
-
-        precompute = new PrecomputeEngine(logger, memory.chroma.collections, semanticCache)
-        await precompute.initialize()
-        precompute.startAutoRefresh(5 * 60 * 1000) // Refresh every 5 minutes
-
-        serviceLogger.info('Phase 15 semantic cache & precompute initialized')
-      } catch (error) {
-        serviceLogger.warn({ error }, 'Failed to initialize Phase 15 caching, continuing without it')
-      }
-    }
-
-    // Initialize Memory Archiver — periodic archival of low-importance memories
-    let archiver: MemoryArchiver | null = null
-    const consolidation = config.knowledge?.consolidation
-    if (consolidation?.enabled !== false && memory.isChromaDBEnabled()) {
-      try {
-        const scorer = new ImportanceScorer(logger, consolidation?.weights)
-        archiver = new MemoryArchiver(
-          logger,
-          memory.chroma.collections,
-          scorer,
-          memory.chroma.embeddings
-        )
-
-        const intervalMinutes = consolidation?.archiveIntervalMinutes ?? 60
-        if (intervalMinutes > 0) {
-          const threshold = consolidation?.archiveThreshold ?? 0.2
-          archiveTimer = setInterval(async () => {
-            try {
-              const result = await archiver!.archiveLowImportance(threshold)
-              if (result.archivedCount > 0) {
-                serviceLogger.info(
-                  { archived: result.archivedCount, threshold },
-                  'Periodic archival sweep complete'
-                )
-              }
-            } catch (error) {
-              serviceLogger.warn({ error }, 'Periodic archival sweep failed')
-            }
-          }, intervalMinutes * 60 * 1000)
-          serviceLogger.info(
-            { intervalMinutes, threshold: consolidation?.archiveThreshold ?? 0.2 },
-            'Memory archiver initialized with periodic sweep'
-          )
-        } else {
-          serviceLogger.info('Memory archiver initialized (periodic sweep disabled)')
-        }
-      } catch (error) {
-        serviceLogger.warn({ error }, 'Failed to initialize memory archiver, continuing without it')
-      }
-    }
-
-    // Initialize Code Intelligence (Phase 28)
-    let codeIndexer: CodeIndexer | null = null
-    let codeQuery: CodeQuery | null = null
-    let codeLinker: MemoryCodeLinker | null = null
-    let codeDbInstance: import('bun:sqlite').Database | null = null
-    if (config.codeIntelligence?.enabled !== false) {
-      try {
-        const { Database } = await import('bun:sqlite')
-        const { resolve, dirname } = await import('node:path')
-        const { mkdirSync, existsSync } = await import('node:fs')
-        const { getClaudeBrainHome } = await import('@/config/home')
-        const codeDbDir = resolve(getClaudeBrainHome(), 'data')
-        if (!existsSync(codeDbDir)) {
-          mkdirSync(codeDbDir, { recursive: true })
-        }
-        const codeDbPath = resolve(codeDbDir, 'code.db')
-        const codeDb = new Database(codeDbPath)
-        codeDb.exec('PRAGMA journal_mode=WAL')
-        codeDbInstance = codeDb
-
-        const { CodeParser } = await import('@/code-intelligence/parser')
-        const { CodeIndexer: CodeIndexerClass } = await import('@/code-intelligence/indexer')
-        const { CodeQuery: CodeQueryClass } = await import('@/code-intelligence/query')
-
-        const parser = new CodeParser()
-        await parser.initialize()
-
-        codeIndexer = new CodeIndexerClass(codeDb, parser, serviceLogger)
-        await codeIndexer.initialize()
-
-        codeQuery = new CodeQueryClass(codeDb, serviceLogger)
-
-        serviceLogger.info('Code intelligence service initialized')
-      } catch (error) {
-        serviceLogger.warn({ error }, 'Failed to initialize code intelligence, continuing without it')
-      }
-    }
-
-    // Initialize MemoryCodeLinker (Phase 29)
-    try {
-      const { MemoryCodeLinker: LinkerClass } = await import('@/code-intelligence/linker')
-      const memoryDb = memory.database.getDb()
-      codeLinker = new LinkerClass(memoryDb, codeDbInstance, serviceLogger)
-      serviceLogger.info('Code linker initialized')
-    } catch (error) {
-      serviceLogger.warn({ error }, 'Failed to initialize code linker, continuing without it')
-    }
-
-    // Initialize SLM Model Manager & Inference Router
-    let modelManager: ModelManager | null = null
-    let inferenceRouter: InferenceRouter | null = null
-    try {
-      const slmModelsDir = config.slm?.modelsDir?.replace(/^~/, require('os').homedir())
-      modelManager = new ModelManager(serviceLogger, slmModelsDir)
-      inferenceRouter = new InferenceRouter(serviceLogger, config, modelManager)
-      const slmEnabled = config.slm?.enabled ?? false
-      serviceLogger.info({ enabled: slmEnabled }, 'SLM inference router initialized')
-    } catch (error) {
-      serviceLogger.warn({ error }, 'Failed to initialize SLM inference, continuing with regex only')
-    }
-
-    // Wire SLM inference into PatternRecognizer (Phase 4C)
-    if (inferenceRouter && phase12) {
-      phase12.patterns.setInferenceRouter(inferenceRouter)
-      serviceLogger.info('SLM inference wired into PatternRecognizer')
-    }
-
-    // SLM startup detection: log model availability and configuration state
-    if (modelManager) {
-      const modelStatus = modelManager.getStatus()
-      const modelsDir = modelManager.getModelsDir()
-      const availableCount = Object.values(modelStatus).filter(s => s.available).length
-      const slmEnabled = config.slm?.enabled ?? false
-
-      if (availableCount > 0 && !slmEnabled) {
-        serviceLogger.info(
-          { count: availableCount, modelsDir },
-          `Found ${availableCount} ONNX models in ${modelsDir}. SLM is disabled. Run "claude-brain models enable all" to activate local inference.`
-        )
-      } else if (availableCount > 0 && slmEnabled) {
-        const tasks = config.slm?.tasks ?? {}
-        const enabledTasks = Object.entries(tasks)
-          .filter(([_, mode]) => mode === 'model' || mode === 'both')
-          .map(([task]) => task)
-        serviceLogger.info(
-          { count: availableCount, enabledTasks },
-          `SLM active: ${enabledTasks.length} tasks using local model inference`
-        )
-
-        // Check onnxruntime availability when SLM is enabled
-        const onnxAvailable = await modelManager.isOnnxAvailable()
-        if (!onnxAvailable) {
-          serviceLogger.warn('SLM enabled but onnxruntime-node not installed. Run: bun add onnxruntime-node')
-        }
-      } else if (availableCount === 0 && slmEnabled) {
-        serviceLogger.warn(
-          { modelsDir },
-          `SLM enabled but no models found in ${modelsDir}. Run "claude-brain models download" to install models.`
-        )
-      }
-    }
-
-    // Store services
-    services = {
-      memory,
-      vault,
-      context,
-      phase12,
-      retrieval,
-      retrievalPipeline,
-      knowledgeGraph,
-      episodeManager,
-      sessionTracker,
-      semanticCache,
-      precompute,
-      archiver,
-      codeIndexer,
-      codeQuery,
-      codeLinker,
-      modelManager,
-      inferenceRouter,
-      logger,
-      config
-    }
-
-    serviceLogger.info('All services initialized successfully')
-  })()
-
-  await initializationPromise
-  return services!
-}
-
-/**
- * Get initialized services
- * Throws if services not initialized
- */
-export function getServices(): Services {
-  if (!services) {
-    throw new Error('Services not initialized. Call initializeServices() first.')
-  }
-  return services
-}
-
-/**
- * Get memory service
- * Throws if not initialized
- */
-export function getMemoryService(): MemoryManager {
-  return getServices().memory
-}
-
-/**
- * Get vault service
- * Throws if not initialized
- */
-export function getVaultService(): VaultManager {
-  return getServices().vault
-}
-
-export function getContextService(): ContextManager {
-  return getServices().context
-}
-
-/**
- * Get Phase 12 service
- * Throws if not initialized
- */
-export function getPhase12Service(): Phase12Manager {
-  return getServices().phase12
-}
-
-/**
- * Get Retrieval service
- * Returns null if retrieval is not enabled
- */
-export function getRetrievalService(): RetrievalService | null {
-  return getServices().retrieval
-}
-
-/**
- * Get Retrieval Pipeline (Phase 19)
- * Returns null if hybrid search is not enabled
- */
-export function getRetrievalPipeline(): RetrievalPipeline | null {
-  return getServices().retrievalPipeline
-}
-
-/**
- * Get Knowledge Graph service
- * Returns null if knowledge graph is not enabled
- */
-export function getKnowledgeGraphService(): KnowledgeGraphServiceContainer | null {
-  return getServices().knowledgeGraph
-}
-
-/**
- * Get Episode Manager service
- * Returns null if episodic memory is not enabled
- */
-export function getEpisodeService(): EpisodeManager | null {
-  return getServices().episodeManager
-}
-
-/**
- * Get Session Tracker service
- * Returns null if hooks are not enabled
- */
-export function getSessionTracker(): HookSessionTracker | null {
-  return getServices().sessionTracker
-}
-
-/**
- * Get Semantic Cache service
- * Returns null if caching is not enabled
- */
-export function getSemanticCacheService(): SemanticCache | null {
-  return getServices().semanticCache
-}
-
-/**
- * Get Precompute Engine service
- * Returns null if caching is not enabled
- */
-export function getPrecomputeService(): PrecomputeEngine | null {
-  return getServices().precompute
-}
-
-/**
- * Get Memory Archiver service
- * Returns null if consolidation is not enabled
- */
-export function getArchiverService(): MemoryArchiver | null {
-  return getServices().archiver
-}
-
-/**
- * Get Code Indexer service (Phase 28)
- * Returns null if code intelligence is not enabled
- */
-export function getCodeIndexer(): CodeIndexer | null {
-  return services?.codeIndexer ?? null
-}
-
-/**
- * Get Code Query service (Phase 28)
- * Returns null if code intelligence is not enabled
- */
-export function getCodeQuery(): CodeQuery | null {
-  return services?.codeQuery ?? null
-}
-
-/**
- * Get Code Linker service (Phase 29)
- * Returns null if not initialized
- */
-export function getCodeLinker(): MemoryCodeLinker | null {
-  return services?.codeLinker ?? null
-}
-
-/**
- * Get Model Manager (SLM Upgrade)
- * Returns null if SLM is not initialized
- */
-export function getModelManager(): ModelManager | null {
-  return services?.modelManager ?? null
-}
-
-/**
- * Get Inference Router (SLM Upgrade)
- * Returns null if SLM is not initialized
- */
-export function getInferenceRouter(): InferenceRouter | null {
-  return services?.inferenceRouter ?? null
-}
-
-/**
- * Check if services are initialized
- */
-export function isServicesInitialized(): boolean {
-  return services !== null
-}
-
-/**
- * Inject services for testing
- * Allows tests to provide mock services without going through initializeServices
- * @internal - Only use in tests
- */
-export function _injectServicesForTesting(testServices: Services | null): void {
-  services = testServices
-}
-
-/**
- * Reset services for testing
- * Clears the services singleton without proper shutdown
- * @internal - Only use in tests
- */
-export function _resetServicesForTesting(): void {
-  services = null
-  initializationPromise = null
-  if (archiveTimer) {
-    clearInterval(archiveTimer)
-    archiveTimer = null
-  }
-}
-
-/**
- * Shutdown all services gracefully
- */
-export async function shutdownServices(): Promise<void> {
-  if (!services) {
-    return
-  }
-
-  const serviceLogger = services.logger.child({ component: 'services' })
-  serviceLogger.info('Shutting down services...')
-
-  // End all active sessions
-  if (services.sessionTracker) {
-    try {
-      await services.sessionTracker.endAllSessions()
-      serviceLogger.info('Session tracker shut down')
-    } catch (error) {
-      serviceLogger.error({ error }, 'Failed to end sessions on shutdown')
-    }
-  }
-
-  // Save and stop knowledge graph
-  if (services.knowledgeGraph) {
-    services.knowledgeGraph.graph.stopAutoSave()
-    // Use absolute path from getHomePaths() if persistPath not configured
-    const { getHomePaths } = await import('@/config/home')
-    const persistPath = services.config.knowledge?.graph?.persistPath || getHomePaths().knowledgeGraph
-    try {
-      await services.knowledgeGraph.graph.save(persistPath)
-      serviceLogger.info('Knowledge graph saved on shutdown')
-    } catch (error) {
-      serviceLogger.error({ error }, 'Failed to save knowledge graph on shutdown')
-    }
-  }
-
-  // Stop precompute auto-refresh
-  if (services.precompute) {
-    services.precompute.stopAutoRefresh()
-    serviceLogger.info('Precompute engine stopped')
-  }
-
-  // Clear semantic cache
-  if (services.semanticCache) {
-    services.semanticCache.clear()
-    serviceLogger.info('Semantic cache cleared')
-  }
-
-  // Stop archival timer
-  if (archiveTimer) {
-    clearInterval(archiveTimer)
-    archiveTimer = null
-    serviceLogger.info('Memory archiver stopped')
-  }
-
-  // Shut down code intelligence
-  if (services.codeIndexer) {
-    try {
-      serviceLogger.info('Code intelligence shut down')
-    } catch (error) {
-      serviceLogger.error({ error }, 'Failed to shut down code intelligence')
-    }
-  }
-
-  // Unload SLM models (releases ONNX sessions)
-  if (services.modelManager) {
-    await services.modelManager.unloadAll()
-    serviceLogger.info('SLM models unloaded')
-  }
-
-  // Cleanup Phase 12
-  services.phase12.cleanup()
-
-  // Stop vault watcher
-  services.vault.stopWatching()
-
-  // Close memory database
-  services.memory.close()
-
-  // Clear reference
-  services = null
-  initializationPromise = null
-
-  serviceLogger.info('All services shut down')
-}
+/**
+ * Shared Services Module
+ * Provides access to initialized services for tool handlers
+ */
+
+import type { Logger } from 'pino'
+import { existsSync } from 'fs'
+import * as path from 'path'
+import { MemoryManager } from '@/memory'
+import { VaultManager } from '@/vault'
+import { ContextManager } from '@/context'
+import { Phase12Manager } from '@/automation/phase12-manager'
+import { RetrievalService } from '@/retrieval/service'
+import { RetrievalPipeline } from '@/retrieval/pipeline'
+import { InMemoryKnowledgeGraph } from '@/knowledge/graph/memory-graph'
+import { GraphSearchEngine } from '@/knowledge/graph/search'
+import { KnowledgeGraphBuilder } from '@/knowledge/graph/builder'
+import { CrossReferenceLinker } from '@/knowledge/graph/linker'
+import { EpisodeManager } from '@/memory/episodic/manager'
+import { HookSessionTracker } from '@/hooks/session-tracker'
+import type { Config } from '@/config'
+import type { CodeIndexer } from '@/code-intelligence/indexer'
+import type { CodeQuery } from '@/code-intelligence/query'
+import type { MemoryCodeLinker } from '@/code-intelligence/linker'
+import { SemanticCache } from '@/intelligence/optimization/semantic-cache'
+import { PrecomputeEngine } from '@/intelligence/optimization/precompute'
+import { MemoryArchiver } from '@/memory/consolidation/archiver'
+import { ImportanceScorer } from '@/memory/consolidation/scorer'
+import { ModelManager } from '@/intelligence/model-manager'
+import { InferenceRouter } from '@/intelligence/inference-router'
+
+export interface KnowledgeGraphServiceContainer {
+  graph: InMemoryKnowledgeGraph
+  search: GraphSearchEngine
+  builder: KnowledgeGraphBuilder
+  linker: CrossReferenceLinker
+}
+
+/**
+ * Container for all shared services
+ */
+export interface Services {
+  memory: MemoryManager
+  vault: VaultManager
+  context: ContextManager
+  phase12: Phase12Manager
+  retrieval: RetrievalService | null
+  retrievalPipeline: RetrievalPipeline | null
+  knowledgeGraph: KnowledgeGraphServiceContainer | null
+  episodeManager: EpisodeManager | null
+  sessionTracker: HookSessionTracker | null
+  semanticCache: SemanticCache | null
+  precompute: PrecomputeEngine | null
+  archiver: MemoryArchiver | null
+  codeIndexer: CodeIndexer | null
+  codeQuery: CodeQuery | null
+  codeLinker: MemoryCodeLinker | null
+  modelManager: ModelManager | null
+  inferenceRouter: InferenceRouter | null
+  logger: Logger
+  config: Config
+}
+
+// Singleton services instance
+let services: Services | null = null
+let initializationPromise: Promise<void> | null = null
+let archiveTimer: ReturnType<typeof setInterval> | null = null
+
+/**
+ * Initialize all services
+ * Should be called once during server startup
+ */
+export async function initializeServices(config: Config, logger: Logger): Promise<Services> {
+  // If already initialized, return existing services
+  if (services) {
+    logger.debug('Services already initialized')
+    return services
+  }
+
+  // If initialization is in progress, wait for it
+  if (initializationPromise) {
+    await initializationPromise
+    return services!
+  }
+
+  // Start initialization
+  initializationPromise = (async () => {
+    const serviceLogger = logger.child({ component: 'services' })
+    serviceLogger.info('Initializing services...')
+
+    // Phase 30: Auto-create vault path if it doesn't exist (zero-config)
+    if (!config.vaultPath) {
+      const { getHomePaths } = await import('@/config/home')
+      config.vaultPath = getHomePaths().vault
+      serviceLogger.info({ vaultPath: config.vaultPath }, 'Auto-detected vault path')
+    }
+
+    if (!existsSync(config.vaultPath)) {
+      try {
+        const { mkdirSync } = await import('node:fs')
+        mkdirSync(config.vaultPath, { recursive: true })
+        mkdirSync(path.join(config.vaultPath, 'Projects'), { recursive: true })
+        mkdirSync(path.join(config.vaultPath, 'Global'), { recursive: true })
+        serviceLogger.info({ vaultPath: config.vaultPath }, 'Created vault directory')
+      } catch (error) {
+        serviceLogger.warn({ error, vaultPath: config.vaultPath }, 'Failed to create vault directory, continuing without vault writes')
+      }
+    } else {
+      const projectsPath = path.join(config.vaultPath, 'Projects')
+      if (!existsSync(projectsPath)) {
+        try {
+          const { mkdirSync } = await import('node:fs')
+          mkdirSync(projectsPath, { recursive: true })
+        } catch {
+          serviceLogger.warn({ projectsPath }, 'Failed to create Projects directory')
+        }
+      }
+    }
+
+    // Initialize Memory Manager
+    // Phase 26: ChromaDB is now opt-in (default false), FTS5 is primary
+    const useChromaDB = config.chromadb?.enabled ?? false
+    const memory = new MemoryManager(config.dbPath, logger, useChromaDB)
+    await memory.initialize()
+    serviceLogger.info({ chromadb: useChromaDB }, 'Memory service initialized')
+
+    // Initialize Vault Manager
+    const vault = new VaultManager(config.vaultPath, logger, {
+      cacheEnabled: config.cacheSize > 0,
+      watchEnabled: config.enableFileWatch
+    })
+    await vault.initialize()
+    serviceLogger.info('Vault service initialized')
+
+    // Initialize Context Manager
+    const context = new ContextManager(logger, vault, memory)
+    serviceLogger.info('Context service initialized')
+
+    // Initialize Phase 12 Manager
+    const phase12 = new Phase12Manager(logger, vault, memory, context)
+    await phase12.initialize()
+    serviceLogger.info('Phase 12 service initialized')
+
+    // Initialize Retrieval Service (Phase 13) — requires ChromaDB
+    let retrieval: RetrievalService | null = null
+    if ((config.retrieval?.feedback?.enabled || config.retrieval?.enabled) && memory.isChromaDBEnabled()) {
+      retrieval = new RetrievalService(
+        logger,
+        memory.chroma.collections,
+        memory.chroma.embeddings!,
+        config.retrieval
+      )
+      await retrieval.initialize()
+      serviceLogger.info('Retrieval service initialized')
+    } else if (config.retrieval?.enabled && !memory.isChromaDBEnabled()) {
+      serviceLogger.warn('Retrieval service requires ChromaDB, skipping initialization')
+    }
+
+    // Initialize Retrieval Pipeline (Phase 19) — hybrid search with BM25 + semantic + fusion
+    let retrievalPipeline: RetrievalPipeline | null = null
+    if (config.retrieval?.enabled && memory.isChromaDBEnabled()) {
+      try {
+        retrievalPipeline = new RetrievalPipeline(
+          logger,
+          memory.chroma.collections,
+          memory.chroma.embeddings!,
+          config.retrieval
+        )
+        await retrievalPipeline.initialize()
+        serviceLogger.info('Retrieval pipeline initialized (hybrid search)')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize retrieval pipeline, continuing without hybrid search')
+      }
+    }
+
+    // Initialize Knowledge Graph Service (Phase 14)
+    let knowledgeGraph: KnowledgeGraphServiceContainer | null = null
+    if (config.knowledge?.graph?.enabled !== false) {
+      try {
+        const graph = new InMemoryKnowledgeGraph(logger)
+        // Use absolute path from getHomePaths() if persistPath not configured
+        const { getHomePaths: getHomePathsKG } = await import('@/config/home')
+        const graphPersistPath = config.knowledge?.graph?.persistPath || getHomePathsKG().knowledgeGraph
+
+        // Load existing graph from disk
+        await graph.load(graphPersistPath)
+
+        const search = new GraphSearchEngine(graph, logger)
+        const builder = new KnowledgeGraphBuilder(graph, logger)
+        await builder.initialize()
+        const linker = new CrossReferenceLinker(graph, logger)
+
+        // Start auto-save
+        const autoSaveInterval = (config.knowledge?.graph?.autoSaveInterval || 60) * 1000
+        graph.startAutoSave(graphPersistPath, autoSaveInterval)
+
+        knowledgeGraph = { graph, search, builder, linker }
+
+        // Migrate existing decisions if graph is empty (requires ChromaDB)
+        if (graph.getNodeCount() === 0 && memory.isChromaDBEnabled()) {
+          serviceLogger.info('Empty graph detected, migrating existing decisions...')
+          const migrationResult = await builder.migrateExistingDecisions(memory.chroma.collections)
+          serviceLogger.info(
+            { processed: migrationResult.processed, errors: migrationResult.errors },
+            'Initial graph migration complete'
+          )
+        } else if (graph.getNodeCount() === 0) {
+          serviceLogger.info('Empty graph detected, but ChromaDB unavailable — graph will populate as new decisions are stored')
+        }
+
+        // Hook builder into decision storage for real-time graph population
+        // Uses MemoryManager listener so it works for both ChromaDB and SQLite paths
+        memory.addDecisionStoredListener((input) => {
+          builder.processDecision(input)
+        })
+
+        // Hook builder into decision deletion for graph synchronization
+        memory.addDecisionDeletedListener((id) => {
+          builder.removeDecision(id)
+
+          // Phase 20: Also unlink from active episodes
+          if (episodeManager) {
+            episodeManager.unlinkDecision(id)
+          }
+
+          // Phase 20: Invalidate semantic cache for deleted decisions
+          if (semanticCache) {
+            semanticCache.clear()
+          }
+        })
+
+        serviceLogger.info(
+          { nodes: graph.getNodeCount(), edges: graph.getEdgeCount() },
+          'Knowledge graph service initialized'
+        )
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize knowledge graph, continuing without it')
+      }
+    }
+
+    // Initialize Episode Manager (Phase 14) — requires ChromaDB
+    let episodeManager: EpisodeManager | null = null
+    if (config.knowledge?.episodic?.enabled !== false && memory.isChromaDBEnabled()) {
+      try {
+        episodeManager = new EpisodeManager(
+          logger,
+          memory.chroma.collections,
+          memory.chroma.embeddings,
+          { sessionGapMinutes: config.knowledge?.episodic?.sessionGapMinutes || 30 }
+        )
+        serviceLogger.info('Episode manager initialized')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize episode manager, continuing without it')
+      }
+    }
+
+    // Initialize Session Tracker (Phase 21) — promoted from serve.ts
+    let sessionTracker: HookSessionTracker | null = null
+    if (config.hooks?.enabled !== false) {
+      try {
+        sessionTracker = new HookSessionTracker(logger, episodeManager, config.hooks?.sessions, memory)
+        serviceLogger.info('Session tracker initialized')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize session tracker, continuing without it')
+      }
+    }
+
+    // Initialize Semantic Cache & Precompute (Phase 15) — requires ChromaDB
+    let semanticCache: SemanticCache | null = null
+    let precompute: PrecomputeEngine | null = null
+    if (config.advancedIntelligence?.enabled !== false && config.advancedIntelligence?.cache?.enabled !== false && memory.isChromaDBEnabled()) {
+      try {
+        const cacheConfig = config.advancedIntelligence?.cache || {}
+        semanticCache = new SemanticCache(logger, {
+          maxSize: cacheConfig.maxSize || 1000,
+          ttlMs: cacheConfig.ttlMs || 60 * 60 * 1000,
+          similarityThreshold: cacheConfig.similarityThreshold || 0.80,
+          embeddings: memory.chroma.embeddings
+        })
+
+        precompute = new PrecomputeEngine(logger, memory.chroma.collections, semanticCache)
+        await precompute.initialize()
+        precompute.startAutoRefresh(5 * 60 * 1000) // Refresh every 5 minutes
+
+        serviceLogger.info('Phase 15 semantic cache & precompute initialized')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize Phase 15 caching, continuing without it')
+      }
+    }
+
+    // Initialize Memory Archiver — periodic archival of low-importance memories
+    let archiver: MemoryArchiver | null = null
+    const consolidation = config.knowledge?.consolidation
+    if (consolidation?.enabled !== false && memory.isChromaDBEnabled()) {
+      try {
+        const scorer = new ImportanceScorer(logger, consolidation?.weights)
+        archiver = new MemoryArchiver(
+          logger,
+          memory.chroma.collections,
+          scorer,
+          memory.chroma.embeddings
+        )
+
+        const intervalMinutes = consolidation?.archiveIntervalMinutes ?? 60
+        if (intervalMinutes > 0) {
+          const threshold = consolidation?.archiveThreshold ?? 0.2
+          archiveTimer = setInterval(async () => {
+            try {
+              const result = await archiver!.archiveLowImportance(threshold)
+              if (result.archivedCount > 0) {
+                serviceLogger.info(
+                  { archived: result.archivedCount, threshold },
+                  'Periodic archival sweep complete'
+                )
+              }
+            } catch (error) {
+              serviceLogger.warn({ error }, 'Periodic archival sweep failed')
+            }
+          }, intervalMinutes * 60 * 1000)
+          serviceLogger.info(
+            { intervalMinutes, threshold: consolidation?.archiveThreshold ?? 0.2 },
+            'Memory archiver initialized with periodic sweep'
+          )
+        } else {
+          serviceLogger.info('Memory archiver initialized (periodic sweep disabled)')
+        }
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize memory archiver, continuing without it')
+      }
+    }
+
+    // Initialize Code Intelligence (Phase 28)
+    let codeIndexer: CodeIndexer | null = null
+    let codeQuery: CodeQuery | null = null
+    let codeLinker: MemoryCodeLinker | null = null
+    let codeDbInstance: import('bun:sqlite').Database | null = null
+    if (config.codeIntelligence?.enabled !== false) {
+      try {
+        const { Database } = await import('bun:sqlite')
+        const { resolve, dirname } = await import('node:path')
+        const { mkdirSync, existsSync } = await import('node:fs')
+        const { getClaudeBrainHome } = await import('@/config/home')
+        const codeDbDir = resolve(getClaudeBrainHome(), 'data')
+        if (!existsSync(codeDbDir)) {
+          mkdirSync(codeDbDir, { recursive: true })
+        }
+        const codeDbPath = resolve(codeDbDir, 'code.db')
+        const codeDb = new Database(codeDbPath)
+        codeDb.exec('PRAGMA journal_mode=WAL')
+        codeDbInstance = codeDb
+
+        const { CodeParser } = await import('@/code-intelligence/parser')
+        const { CodeIndexer: CodeIndexerClass } = await import('@/code-intelligence/indexer')
+        const { CodeQuery: CodeQueryClass } = await import('@/code-intelligence/query')
+
+        const parser = new CodeParser()
+        await parser.initialize()
+
+        codeIndexer = new CodeIndexerClass(codeDb, parser, serviceLogger)
+        await codeIndexer.initialize()
+
+        codeQuery = new CodeQueryClass(codeDb, serviceLogger)
+
+        serviceLogger.info('Code intelligence service initialized')
+      } catch (error) {
+        serviceLogger.warn({ error }, 'Failed to initialize code intelligence, continuing without it')
+      }
+    }
+
+    // Initialize MemoryCodeLinker (Phase 29)
+    try {
+      const { MemoryCodeLinker: LinkerClass } = await import('@/code-intelligence/linker')
+      const memoryDb = memory.database.getDb()
+      codeLinker = new LinkerClass(memoryDb, codeDbInstance, serviceLogger)
+      serviceLogger.info('Code linker initialized')
+    } catch (error) {
+      serviceLogger.warn({ error }, 'Failed to initialize code linker, continuing without it')
+    }
+
+    // Initialize SLM Model Manager & Inference Router
+    let modelManager: ModelManager | null = null
+    let inferenceRouter: InferenceRouter | null = null
+    try {
+      const slmModelsDir = config.slm?.modelsDir?.replace(/^~/, require('os').homedir())
+      modelManager = new ModelManager(serviceLogger, slmModelsDir)
+      inferenceRouter = new InferenceRouter(serviceLogger, config, modelManager)
+      const slmEnabled = config.slm?.enabled ?? false
+      serviceLogger.info({ enabled: slmEnabled }, 'SLM inference router initialized')
+    } catch (error) {
+      serviceLogger.warn({ error }, 'Failed to initialize SLM inference, continuing with regex only')
+    }
+
+    // Wire SLM inference into PatternRecognizer (Phase 4C)
+    if (inferenceRouter && phase12) {
+      phase12.patterns.setInferenceRouter(inferenceRouter)
+      serviceLogger.info('SLM inference wired into PatternRecognizer')
+    }
+
+    // SLM startup detection: log model availability and configuration state
+    if (modelManager) {
+      const modelStatus = modelManager.getStatus()
+      const modelsDir = modelManager.getModelsDir()
+      const availableCount = Object.values(modelStatus).filter(s => s.available).length
+      const slmEnabled = config.slm?.enabled ?? false
+
+      if (availableCount > 0 && !slmEnabled) {
+        serviceLogger.info(
+          { count: availableCount, modelsDir },
+          `Found ${availableCount} ONNX models in ${modelsDir}. SLM is disabled. Run "claude-brain models enable all" to activate local inference.`
+        )
+      } else if (availableCount > 0 && slmEnabled) {
+        const tasks = config.slm?.tasks ?? {}
+        const enabledTasks = Object.entries(tasks)
+          .filter(([_, mode]) => mode === 'model' || mode === 'both')
+          .map(([task]) => task)
+        serviceLogger.info(
+          { count: availableCount, enabledTasks },
+          `SLM active: ${enabledTasks.length} tasks using local model inference`
+        )
+
+        // Check onnxruntime availability when SLM is enabled
+        const onnxAvailable = await modelManager.isOnnxAvailable()
+        if (!onnxAvailable) {
+          serviceLogger.warn('SLM enabled but onnxruntime-node not installed. Run: bun add onnxruntime-node')
+        }
+      } else if (availableCount === 0 && slmEnabled) {
+        serviceLogger.warn(
+          { modelsDir },
+          `SLM enabled but no models found in ${modelsDir}. Run "claude-brain models download" to install models.`
+        )
+      }
+    }
+
+    // Store services
+    services = {
+      memory,
+      vault,
+      context,
+      phase12,
+      retrieval,
+      retrievalPipeline,
+      knowledgeGraph,
+      episodeManager,
+      sessionTracker,
+      semanticCache,
+      precompute,
+      archiver,
+      codeIndexer,
+      codeQuery,
+      codeLinker,
+      modelManager,
+      inferenceRouter,
+      logger,
+      config
+    }
+
+    serviceLogger.info('All services initialized successfully')
+  })()
+
+  await initializationPromise
+  return services!
+}
+
+/**
+ * Get initialized services
+ * Throws if services not initialized
+ */
+export function getServices(): Services {
+  if (!services) {
+    throw new Error('Services not initialized. Call initializeServices() first.')
+  }
+  return services
+}
+
+/**
+ * Get memory service
+ * Throws if not initialized
+ */
+export function getMemoryService(): MemoryManager {
+  return getServices().memory
+}
+
+/**
+ * Get vault service
+ * Throws if not initialized
+ */
+export function getVaultService(): VaultManager {
+  return getServices().vault
+}
+
+export function getContextService(): ContextManager {
+  return getServices().context
+}
+
+/**
+ * Get Phase 12 service
+ * Throws if not initialized
+ */
+export function getPhase12Service(): Phase12Manager {
+  return getServices().phase12
+}
+
+/**
+ * Get Retrieval service
+ * Returns null if retrieval is not enabled
+ */
+export function getRetrievalService(): RetrievalService | null {
+  return getServices().retrieval
+}
+
+/**
+ * Get Retrieval Pipeline (Phase 19)
+ * Returns null if hybrid search is not enabled
+ */
+export function getRetrievalPipeline(): RetrievalPipeline | null {
+  return getServices().retrievalPipeline
+}
+
+/**
+ * Get Knowledge Graph service
+ * Returns null if knowledge graph is not enabled
+ */
+export function getKnowledgeGraphService(): KnowledgeGraphServiceContainer | null {
+  return getServices().knowledgeGraph
+}
+
+/**
+ * Get Episode Manager service
+ * Returns null if episodic memory is not enabled
+ */
+export function getEpisodeService(): EpisodeManager | null {
+  return getServices().episodeManager
+}
+
+/**
+ * Get Session Tracker service
+ * Returns null if hooks are not enabled
+ */
+export function getSessionTracker(): HookSessionTracker | null {
+  return getServices().sessionTracker
+}
+
+/**
+ * Get Semantic Cache service
+ * Returns null if caching is not enabled
+ */
+export function getSemanticCacheService(): SemanticCache | null {
+  return getServices().semanticCache
+}
+
+/**
+ * Get Precompute Engine service
+ * Returns null if caching is not enabled
+ */
+export function getPrecomputeService(): PrecomputeEngine | null {
+  return getServices().precompute
+}
+
+/**
+ * Get Memory Archiver service
+ * Returns null if consolidation is not enabled
+ */
+export function getArchiverService(): MemoryArchiver | null {
+  return getServices().archiver
+}
+
+/**
+ * Get Code Indexer service (Phase 28)
+ * Returns null if code intelligence is not enabled
+ */
+export function getCodeIndexer(): CodeIndexer | null {
+  return services?.codeIndexer ?? null
+}
+
+/**
+ * Get Code Query service (Phase 28)
+ * Returns null if code intelligence is not enabled
+ */
+export function getCodeQuery(): CodeQuery | null {
+  return services?.codeQuery ?? null
+}
+
+/**
+ * Get Code Linker service (Phase 29)
+ * Returns null if not initialized
+ */
+export function getCodeLinker(): MemoryCodeLinker | null {
+  return services?.codeLinker ?? null
+}
+
+/**
+ * Get Model Manager (SLM Upgrade)
+ * Returns null if SLM is not initialized
+ */
+export function getModelManager(): ModelManager | null {
+  return services?.modelManager ?? null
+}
+
+/**
+ * Get Inference Router (SLM Upgrade)
+ * Returns null if SLM is not initialized
+ */
+export function getInferenceRouter(): InferenceRouter | null {
+  return services?.inferenceRouter ?? null
+}
+
+/**
+ * Check if services are initialized
+ */
+export function isServicesInitialized(): boolean {
+  return services !== null
+}
+
+/**
+ * Inject services for testing
+ * Allows tests to provide mock services without going through initializeServices
+ * @internal - Only use in tests
+ */
+export function _injectServicesForTesting(testServices: Services | null): void {
+  services = testServices
+}
+
+/**
+ * Reset services for testing
+ * Clears the services singleton without proper shutdown
+ * @internal - Only use in tests
+ */
+export function _resetServicesForTesting(): void {
+  services = null
+  initializationPromise = null
+  if (archiveTimer) {
+    clearInterval(archiveTimer)
+    archiveTimer = null
+  }
+}
+
+/**
+ * Shutdown all services gracefully
+ */
+export async function shutdownServices(): Promise<void> {
+  if (!services) {
+    return
+  }
+
+  const serviceLogger = services.logger.child({ component: 'services' })
+  serviceLogger.info('Shutting down services...')
+
+  // End all active sessions
+  if (services.sessionTracker) {
+    try {
+      await services.sessionTracker.endAllSessions()
+      serviceLogger.info('Session tracker shut down')
+    } catch (error) {
+      serviceLogger.error({ error }, 'Failed to end sessions on shutdown')
+    }
+  }
+
+  // Save and stop knowledge graph
+  if (services.knowledgeGraph) {
+    services.knowledgeGraph.graph.stopAutoSave()
+    // Use absolute path from getHomePaths() if persistPath not configured
+    const { getHomePaths } = await import('@/config/home')
+    const persistPath = services.config.knowledge?.graph?.persistPath || getHomePaths().knowledgeGraph
+    try {
+      await services.knowledgeGraph.graph.save(persistPath)
+      serviceLogger.info('Knowledge graph saved on shutdown')
+    } catch (error) {
+      serviceLogger.error({ error }, 'Failed to save knowledge graph on shutdown')
+    }
+  }
+
+  // Stop precompute auto-refresh
+  if (services.precompute) {
+    services.precompute.stopAutoRefresh()
+    serviceLogger.info('Precompute engine stopped')
+  }
+
+  // Clear semantic cache
+  if (services.semanticCache) {
+    services.semanticCache.clear()
+    serviceLogger.info('Semantic cache cleared')
+  }
+
+  // Stop archival timer
+  if (archiveTimer) {
+    clearInterval(archiveTimer)
+    archiveTimer = null
+    serviceLogger.info('Memory archiver stopped')
+  }
+
+  // Shut down code intelligence
+  if (services.codeIndexer) {
+    try {
+      serviceLogger.info('Code intelligence shut down')
+    } catch (error) {
+      serviceLogger.error({ error }, 'Failed to shut down code intelligence')
+    }
+  }
+
+  // Unload SLM models (releases ONNX sessions)
+  if (services.modelManager) {
+    await services.modelManager.unloadAll()
+    serviceLogger.info('SLM models unloaded')
+  }
+
+  // Cleanup Phase 12
+  services.phase12.cleanup()
+
+  // Stop vault watcher
+  services.vault.stopWatching()
+
+  // Close memory database
+  services.memory.close()
+
+  // Clear reference
+  services = null
+  initializationPromise = null
+
+  serviceLogger.info('All services shut down')
+}