claude-brain 0.15.2 → 0.17.0

package/src/server/http-api.ts

@@ -1,693 +1,761 @@
-/**
- * Simple HTTP API Server for Claude Brain
- * Provides basic REST API endpoints
- */
-
-import { Hono } from 'hono'
-import type { Logger } from 'pino'
-import type { Config } from '@/config'
-import { getMemoryService, getVaultService, isServicesInitialized } from '@/server/services'
-import { ResourceProvider } from '@/server/providers/resources'
-import type { MemoryManager } from '@/memory'
-import type { CapturedKnowledge, HookStats } from '@/hooks/types'
-import { SmartDeduplicator } from '@/hooks/deduplicator'
-import type { HookSessionTracker } from '@/hooks/session-tracker'
-
-export class HttpApiServer {
-  private app: Hono
-  private logger: Logger
-  private config: Config
-  private server?: any
-  private sessionTracker?: HookSessionTracker
-  private hookStats: HookStats = {
-    totalCaptured: 0,
-    totalSkipped: 0,
-    totalMerged: 0,
-    sessionsTracked: 0,
-    queueSize: 0,
-  }
-
-  constructor(config: Config, logger: Logger) {
-    this.config = config
-    this.logger = logger.child({ component: 'http-api' })
-    this.app = new Hono()
-    this.setupMiddleware()
-    this.setupRoutes()
-  }
-
-  private setupMiddleware(): void {
-    this.app.use('*', async (c, next) => {
-      c.header('Access-Control-Allow-Origin', '*')
-      c.header('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS')
-      c.header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
-      c.header('Content-Type', 'application/json')
-      await next()
-    })
-  }
-
-  /** Set the session tracker (called from serve.ts after initialization) */
-  setSessionTracker(tracker: HookSessionTracker): void {
-    this.sessionTracker = tracker
-  }
-
-  private setupRoutes(): void {
-    // Health check
-    this.app.get('/api/health', (c) => {
-      const initialized = isServicesInitialized()
-      return c.json({
-        success: true,
-        status: initialized ? 'ok' : 'initializing',
-        initialized,
-        timestamp: new Date().toISOString(),
-      })
-    })
-
-    // Projects endpoints
-    this.app.get('/api/projects/list', () => this.handleListProjects())
-    this.app.post('/api/projects/create', (c) => this.handleCreateProject(c))
-
-    // Simple context endpoints
-    this.app.get('/api/claude-brain/smart-context/:projectName', (c) => this.handleSmartContext(c))
-    this.app.get('/api/claude-brain/project-context/:projectName', (c) => this.handleProjectContext(c))
-    this.app.get('/api/claude-brain/recall-similar', (c) => this.handleRecallSimilar(c))
-    this.app.get('/api/claude-brain/get-decisions', () => this.handleGetDecisions())
-    this.app.get('/api/claude-brain/get-patterns', () => this.handleGetPatterns())
-    this.app.get('/api/claude-brain/get-corrections', () => this.handleGetCorrections())
-    this.app.post('/api/claude-brain/remember-decision', (c) => this.handleRememberDecision(c))
-    this.app.post('/api/claude-brain/recognize-pattern', (c) => this.handleRecognizePattern(c))
-    this.app.post('/api/claude-brain/record-correction', (c) => this.handleRecordCorrection(c))
-    this.app.post('/api/claude-brain/update-progress', (c) => this.handleUpdateProgress(c))
-
-    // Phase 17: Hook passive learning endpoints
-    this.app.post('/api/hooks/ingest', (c) => this.handleHookIngest(c))
-    this.app.post('/api/hooks/session-end', (c) => this.handleHookSessionEnd(c))
-    this.app.get('/api/hooks/status', () => this.handleHookStatus())
-
-    // Phase 23b: Expose brain://context/auto via HTTP for testability
-    this.app.get('/api/context/auto', () => this.handleContextAuto())
-  }
-
-  private async handleListProjects(): Promise<Response> {
-    try {
-      if (!isServicesInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const vaultService = getVaultService()
-      if (!vaultService) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const projectNames = await vaultService.listProjects()
-
-      const projects = []
-      for (const name of projectNames) {
-        try {
-          const metadata = await vaultService.getProjectMetadata(name)
-          projects.push({
-            id: name,
-            name,
-            description: metadata?.description || '',
-            techStack: metadata?.techStack || [],
-            status: metadata?.status || 'active',
-            tags: metadata?.tags || [],
-            createdAt: new Date().toISOString(),
-          })
-        } catch (error) {
-          // Skip projects that fail to load
-        }
-      }
-
-      return Response.json({ success: true, data: projects })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to list projects')
-      return Response.json(
-        { success: false, error: 'Failed to list projects' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleCreateProject(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        throw new Error('Vault service not initialized')
-      }
-
-      const normalizedName = body.name.replace(/\s+/g, '-').toLowerCase()
-      await vaultService.createProject(normalizedName)
-
-      const project = {
-        id: normalizedName,
-        name: normalizedName,
-        description: body.description || '',
-        techStack: body.techStack || [],
-        status: body.status || 'planning',
-        tags: body.tags || [],
-        createdAt: new Date().toISOString(),
-      }
-
-      return Response.json({ success: true, data: project })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to create project')
-      return Response.json(
-        { success: false, error: 'Failed to create project' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleSmartContext(c: any): Promise<Response> {
-    try {
-      const projectName = c.req.param('projectName')
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        return Response.json({ success: true, data: {} })
-      }
-
-      const context = await vaultService.getProjectContext(projectName)
-
-      return Response.json({
-        success: true,
-        data: {
-          description: context?.content || '',
-          tech_stack: [],
-          tags: [],
-          phase: 'setup',
-          completion: 0,
-          decisions: [],
-          patterns: [],
-        },
-      })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get smart context')
-      return Response.json(
-        { success: false, error: 'Failed to get context' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleProjectContext(c: any): Promise<Response> {
-    try {
-      const projectName = c.req.param('projectName')
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        return Response.json({ success: false, error: 'Vault service not available' }, { status: 500 })
-      }
-
-      const metadata = await vaultService.getProjectMetadata(projectName)
-
-      if (!metadata) {
-        return Response.json({ success: false, error: 'Project not found' }, { status: 404 })
-      }
-
-      return Response.json({
-        success: true,
-        data: {
-          project: {
-            id: projectName,
-            name: projectName,
-            description: metadata.description,
-            techStack: metadata.techStack,
-            status: metadata.status,
-            tags: metadata.tags,
-          },
-          progress: {
-            phase: metadata.currentPhase || 'setup',
-            completion: metadata.completionPercentage || 0,
-            completed_task: '',
-            next_steps: '',
-            notes: '',
-          },
-          decisions: [],
-          patterns: [],
-        },
-      })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get project context')
-      return Response.json(
-        { success: false, error: 'Failed to get project context' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRecallSimilar(c: any): Promise<Response> {
-    try {
-      const query = c.req.query('query') || ''
-
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const results = await memoryService.recallSimilar(query, {
-        limit: 10,
-        minSimilarity: 0.3,
-        projectFilter: undefined,
-      })
-
-      const memories = results.map((r: any) => ({
-        id: r.id,
-        type: 'memory',
-        title: r.description,
-        description: r.context || r.description,
-        timestamp: new Date().toISOString(),
-        project: r.project,
-        tags: r.tags,
-        context: r.context,
-        similarity: r.similarity || 0.8,
-      }))
-
-      return Response.json({ success: true, data: memories })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to recall similar memories')
-      return Response.json(
-        { success: false, error: 'Failed to search memories' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleGetDecisions(): Promise<Response> {
-    try {
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const patterns = await memoryService.getPatterns(undefined, 100)
-
-      const decisions = patterns
-        .filter((p: any) => p.pattern_type === 'solution')
-        .map((p: any) => ({
-          id: p.id,
-          decision: p.description,
-          context: p.context,
-          reasoning: p.context,
-          alternatives_considered: p.context,
-          tags: p.tags,
-          project: p.project,
-          timestamp: new Date().toISOString(),
-        }))
-
-      return Response.json({ success: true, data: decisions })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get decisions')
-      return Response.json(
-        { success: false, error: 'Failed to get decisions' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleGetPatterns(): Promise<Response> {
-    try {
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const patterns = await memoryService.getPatterns(undefined, 100)
-
-      return Response.json({ success: true, data: patterns })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get patterns')
-      return Response.json(
-        { success: false, error: 'Failed to get patterns' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleGetCorrections(): Promise<Response> {
-    try {
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json({ success: true, data: [] })
-      }
-
-      const corrections = await memoryService.getCorrections(undefined, 100)
-
-      return Response.json({ success: true, data: corrections })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get corrections')
-      return Response.json(
-        { success: false, error: 'Failed to get corrections' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRememberDecision(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        throw new Error('Memory service not initialized')
-      }
-
-      await memoryService.storePattern({
-        description: body.decision,
-        pattern_type: 'solution',
-        context: body.context,
-        project: body.project_name,
-        tags: body.tags,
-        confidence: 0.9,
-      })
-
-      return Response.json({ success: true, data: { message: 'Decision stored successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to remember decision')
-      return Response.json(
-        { success: false, error: 'Failed to store decision' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRecognizePattern(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        throw new Error('Memory service not initialized')
-      }
-
-      await memoryService.storePattern({
-        description: body.description,
-        pattern_type: body.pattern_type,
-        context: body.context,
-        example: body.example,
-        project: body.project_name,
-        tags: body.tags,
-        confidence: body.confidence || 0.8,
-      })
-
-      return Response.json({ success: true, data: { message: 'Pattern stored successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to recognize pattern')
-      return Response.json(
-        { success: false, error: 'Failed to store pattern' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleRecordCorrection(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const memoryService = getMemoryService()
-
-      if (!memoryService || !memoryService.isInitialized()) {
-        throw new Error('Memory service not initialized')
-      }
-
-      await memoryService.storeCorrection({
-        original: body.original,
-        correction: body.correction,
-        reasoning: body.reasoning,
-        context: body.context,
-        project: body.project_name,
-        confidence: body.confidence || 0.9,
-      })
-
-      return Response.json({ success: true, data: { message: 'Correction stored successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to record correction')
-      return Response.json(
-        { success: false, error: 'Failed to store correction' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleUpdateProgress(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const vaultService = getVaultService()
-
-      if (!vaultService) {
-        throw new Error('Vault service not initialized')
-      }
-
-      const updates: any = {}
-      if (body.completed_task) {
-        updates.status = `Completed: ${body.completed_task}`
-      }
-      if (body.next_steps) updates.next_steps = body.next_steps
-      if (body.notes) updates.notes = body.notes
-
-      await vaultService.updateProgress(body.project_name, updates)
-
-      return Response.json({ success: true, data: { message: 'Progress updated successfully' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to update progress')
-      return Response.json(
-        { success: false, error: 'Failed to update progress' },
-        { status: 500 }
-      )
-    }
-  }
-
-  // ─── Phase 23b: Context Auto Endpoint ────────────────────
-
-  private async handleContextAuto(): Promise<Response> {
-    try {
-      const resourceProvider = new ResourceProvider(this.logger)
-      const result = await resourceProvider.readResource('brain://context/auto')
-      const text = result?.contents?.[0]?.text || ''
-      return Response.json({ success: true, data: { content: text } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get auto context')
-      return Response.json(
-        { success: false, error: 'Failed to get auto context' },
-        { status: 500 }
-      )
-    }
-  }
-
-  // ─── Phase 17: Hook Endpoints ────────────────────────────
-
-  private async handleHookIngest(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const items: CapturedKnowledge[] = body.knowledge || []
-      const sessionId: string | undefined = body.sessionId
-
-      if (items.length === 0) {
-        return Response.json({ success: true, data: { stored: 0, skipped: 0, merged: 0 } })
-      }
-
-      const memoryService = getMemoryService()
-      if (!memoryService || !memoryService.isInitialized()) {
-        return Response.json(
-          { success: false, error: 'Memory service not initialized' },
-          { status: 503 }
-        )
-      }
-
-      const deduplicator = new SmartDeduplicator(this.config.hooks?.deduplication)
-      let stored = 0, skipped = 0, merged = 0
-
-      for (const knowledge of items) {
-        const action = await deduplicator.beforeStore(knowledge, memoryService)
-
-        switch (action.action) {
-          case 'skip':
-            skipped++
-            this.hookStats.totalSkipped++
-            break
-
-          case 'merge':
-            merged++
-            this.hookStats.totalMerged++
-            // For merge, we store as update — treat as new store with merged content
-            await this.storeKnowledge({ ...knowledge, content: action.mergedContent }, memoryService)
-            stored++
-            break
-
-          case 'store_new':
-            await this.storeKnowledge(knowledge, memoryService)
-            stored++
-            this.hookStats.totalCaptured++
-            break
-        }
-
-        // Track in session if sessionId provided
-        if (sessionId && this.sessionTracker) {
-          await this.sessionTracker.track(sessionId, knowledge)
-        }
-      }
-
-      this.hookStats.lastCaptureAt = new Date().toISOString()
-
-      this.logger.debug(
-        { stored, skipped, merged, sessionId },
-        'Hook ingest processed'
-      )
-
-      return Response.json({ success: true, data: { stored, skipped, merged } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to process hook ingest')
-      return Response.json(
-        { success: false, error: 'Failed to ingest hook data' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private async handleHookSessionEnd(c: any): Promise<Response> {
-    try {
-      const body = await c.req.json()
-      const sessionId: string | undefined = body.sessionId
-
-      if (!sessionId) {
-        return Response.json(
-          { success: false, error: 'sessionId required' },
-          { status: 400 }
-        )
-      }
-
-      if (this.sessionTracker) {
-        await this.sessionTracker.endSession(sessionId)
-        this.hookStats.sessionsTracked++
-      }
-
-      return Response.json({ success: true, data: { message: 'Session ended' } })
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to end hook session')
-      return Response.json(
-        { success: false, error: 'Failed to end session' },
-        { status: 500 }
-      )
-    }
-  }
-
-  private handleHookStatus(): Response {
-    const sessionStats = this.sessionTracker?.getStats()
-
-    return Response.json({
-      success: true,
-      data: {
-        ...this.hookStats,
-        activeSessions: sessionStats?.activeSessions ?? 0,
-        sessionItems: sessionStats?.totalItems ?? 0,
-        hooksEnabled: this.config.hooks?.enabled ?? true,
-      },
-    })
-  }
-
-  /** Route captured knowledge to the appropriate store method */
-  private async storeKnowledge(
-    knowledge: CapturedKnowledge,
-    memoryService: MemoryManager
-  ): Promise<void> {
-    const project = knowledge.project || 'unknown'
-
-    switch (knowledge.type) {
-      case 'decision':
-        await memoryService.rememberDecision(
-          project,
-          `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
-          knowledge.content,
-          `Auto-captured from ${knowledge.source}`,
-          { tags: knowledge.technologies }
-        )
-        break
-
-      case 'pattern':
-        await memoryService.storePattern({
-          project,
-          pattern_type: 'solution',
-          description: knowledge.content,
-          context: `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
-          confidence: knowledge.confidence,
-        })
-        break
-
-      case 'correction':
-        await memoryService.storeCorrection({
-          project,
-          original: knowledge.metadata.command || 'Unknown',
-          correction: knowledge.content,
-          reasoning: 'Auto-captured from hook passive learning',
-          context: `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
-          confidence: knowledge.confidence,
-        })
-        break
-
-      case 'progress': {
-        // Store in ChromaDB so it's searchable via brain tool
-        await memoryService.rememberDecision(
-          project,
-          `Captured via hook: ${knowledge.metadata.action || knowledge.metadata.source || 'progress'}`,
-          knowledge.content,
-          `Auto-captured from ${knowledge.source}`,
-          { tags: knowledge.technologies }
-        )
-
-        // Also update vault progress if project exists
-        const vaultService = getVaultService()
-        if (vaultService) {
-          try {
-            await vaultService.updateProgress(project, {
-              status: `Hook: ${knowledge.content.slice(0, 200)}`,
-            })
-          } catch {
-            // Vault might not have this project
-          }
-        }
-        break
-      }
-    }
-  }
-
-  async start(): Promise<void> {
-    const port = this.config.port || 3000
-
-    this.logger.info({
-      port,
-      environment: this.config.nodeEnv,
-    }, 'Starting HTTP API server...')
-
-    try {
-      this.server = Bun.serve({
-        port,
-        fetch: this.app.fetch,
-      })
-
-      this.logger.info({
-        port,
-        url: `http://localhost:${port}`,
-      }, 'HTTP API server started successfully')
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to start HTTP API server')
-      throw error
-    }
-  }
-
-  async stop(): Promise<void> {
-    if (this.server) {
-      this.logger.info('Stopping HTTP API server...')
-      this.server.stop()
-      this.logger.info('HTTP API server stopped')
-    }
-  }
-
-  getApp(): Hono {
-    return this.app
-  }
-}
+/**
+ * Simple HTTP API Server for Claude Brain
+ * Provides basic REST API endpoints
+ */
+
+import { Hono } from 'hono'
+import type { Logger } from 'pino'
+import type { Config } from '@/config'
+import { getMemoryService, getVaultService, isServicesInitialized } from '@/server/services'
+import { ResourceProvider } from '@/server/providers/resources'
+import type { MemoryManager } from '@/memory'
+import type { CapturedKnowledge, HookStats } from '@/hooks/types'
+import { SmartDeduplicator } from '@/hooks/deduplicator'
+import type { HookSessionTracker } from '@/hooks/session-tracker'
+
+export class HttpApiServer {
+  private app: Hono
+  private logger: Logger
+  private config: Config
+  private server?: any
+  private sessionTracker?: HookSessionTracker
+  private hookStats: HookStats = {
+    totalCaptured: 0,
+    totalSkipped: 0,
+    totalMerged: 0,
+    sessionsTracked: 0,
+    queueSize: 0,
+  }
+
+  constructor(config: Config, logger: Logger) {
+    this.config = config
+    this.logger = logger.child({ component: 'http-api' })
+    this.app = new Hono()
+    this.setupMiddleware()
+    this.setupRoutes()
+  }
+
+  private setupMiddleware(): void {
+    this.app.use('*', async (c, next) => {
+      c.header('Access-Control-Allow-Origin', '*')
+      c.header('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS')
+      c.header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
+      c.header('Content-Type', 'application/json')
+      await next()
+    })
+  }
+
+  /** Set the session tracker (called from serve.ts after initialization) */
+  setSessionTracker(tracker: HookSessionTracker): void {
+    this.sessionTracker = tracker
+  }
+
+  private setupRoutes(): void {
+    // Health check
+    this.app.get('/api/health', (c) => {
+      const initialized = isServicesInitialized()
+      return c.json({
+        success: true,
+        status: initialized ? 'ok' : 'initializing',
+        initialized,
+        timestamp: new Date().toISOString(),
+      })
+    })
+
+    // Projects endpoints
+    this.app.get('/api/projects/list', () => this.handleListProjects())
+    this.app.post('/api/projects/create', (c) => this.handleCreateProject(c))
+
+    // Simple context endpoints
+    this.app.get('/api/claude-brain/smart-context/:projectName', (c) => this.handleSmartContext(c))
+    this.app.get('/api/claude-brain/project-context/:projectName', (c) => this.handleProjectContext(c))
+    this.app.get('/api/claude-brain/recall-similar', (c) => this.handleRecallSimilar(c))
+    this.app.get('/api/claude-brain/get-decisions', () => this.handleGetDecisions())
+    this.app.get('/api/claude-brain/get-patterns', () => this.handleGetPatterns())
+    this.app.get('/api/claude-brain/get-corrections', () => this.handleGetCorrections())
+    this.app.post('/api/claude-brain/remember-decision', (c) => this.handleRememberDecision(c))
+    this.app.post('/api/claude-brain/recognize-pattern', (c) => this.handleRecognizePattern(c))
+    this.app.post('/api/claude-brain/record-correction', (c) => this.handleRecordCorrection(c))
+    this.app.post('/api/claude-brain/update-progress', (c) => this.handleUpdateProgress(c))
+
+    // Phase 17: Hook passive learning endpoints
+    this.app.post('/api/hooks/ingest', (c) => this.handleHookIngest(c))
+    this.app.post('/api/hooks/session-end', (c) => this.handleHookSessionEnd(c))
+    this.app.get('/api/hooks/status', () => this.handleHookStatus())
+
+    // Phase 26: Context injection for UserPromptSubmit/SessionStart hooks
+    this.app.get('/api/hooks/context-query', (c) => this.handleContextQuery(c))
+
+    // Phase 23b: Expose brain://context/auto via HTTP for testability
+    this.app.get('/api/context/auto', () => this.handleContextAuto())
+  }
+
+  private async handleListProjects(): Promise<Response> {
+    try {
+      if (!isServicesInitialized()) {
+        return Response.json({ success: true, data: [] })
+      }
+
+      const vaultService = getVaultService()
+      if (!vaultService) {
+        return Response.json({ success: true, data: [] })
+      }
+
+      const projectNames = await vaultService.listProjects()
+
+      const projects = []
+      for (const name of projectNames) {
+        try {
+          const metadata = await vaultService.getProjectMetadata(name)
+          projects.push({
+            id: name,
+            name,
+            description: metadata?.description || '',
+            techStack: metadata?.techStack || [],
+            status: metadata?.status || 'active',
+            tags: metadata?.tags || [],
+            createdAt: new Date().toISOString(),
+          })
+        } catch (error) {
+          // Skip projects that fail to load
+        }
+      }
+
+      return Response.json({ success: true, data: projects })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to list projects')
+      return Response.json(
+        { success: false, error: 'Failed to list projects' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleCreateProject(c: any): Promise<Response> {
+    try {
+      const body = await c.req.json()
+      const vaultService = getVaultService()
+
+      if (!vaultService) {
+        throw new Error('Vault service not initialized')
+      }
+
+      const normalizedName = body.name.replace(/\s+/g, '-').toLowerCase()
+      await vaultService.createProject(normalizedName)
+
+      const project = {
+        id: normalizedName,
+        name: normalizedName,
+        description: body.description || '',
+        techStack: body.techStack || [],
+        status: body.status || 'planning',
+        tags: body.tags || [],
+        createdAt: new Date().toISOString(),
+      }
+
+      return Response.json({ success: true, data: project })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to create project')
+      return Response.json(
+        { success: false, error: 'Failed to create project' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleSmartContext(c: any): Promise<Response> {
+    try {
+      const projectName = c.req.param('projectName')
+      const vaultService = getVaultService()
+
+      if (!vaultService) {
+        return Response.json({ success: true, data: {} })
+      }
+
+      const context = await vaultService.getProjectContext(projectName)
+
+      return Response.json({
+        success: true,
+        data: {
+          description: context?.content || '',
+          tech_stack: [],
+          tags: [],
+          phase: 'setup',
+          completion: 0,
+          decisions: [],
+          patterns: [],
+        },
+      })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get smart context')
+      return Response.json(
+        { success: false, error: 'Failed to get context' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleProjectContext(c: any): Promise<Response> {
+    try {
+      const projectName = c.req.param('projectName')
+      const vaultService = getVaultService()
+
+      if (!vaultService) {
+        return Response.json({ success: false, error: 'Vault service not available' }, { status: 500 })
+      }
+
+      const metadata = await vaultService.getProjectMetadata(projectName)
+
+      if (!metadata) {
+        return Response.json({ success: false, error: 'Project not found' }, { status: 404 })
+      }
+
+      return Response.json({
+        success: true,
+        data: {
+          project: {
+            id: projectName,
+            name: projectName,
+            description: metadata.description,
+            techStack: metadata.techStack,
+            status: metadata.status,
+            tags: metadata.tags,
+          },
+          progress: {
+            phase: metadata.currentPhase || 'setup',
+            completion: metadata.completionPercentage || 0,
+            completed_task: '',
+            next_steps: '',
+            notes: '',
+          },
+          decisions: [],
+          patterns: [],
+        },
+      })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get project context')
+      return Response.json(
+        { success: false, error: 'Failed to get project context' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleRecallSimilar(c: any): Promise<Response> {
+    try {
+      const query = c.req.query('query') || ''
+
+      const memoryService = getMemoryService()
+
+      if (!memoryService || !memoryService.isInitialized()) {
+        return Response.json({ success: true, data: [] })
+      }
+
+      const results = await memoryService.recallSimilar(query, {
+        limit: 10,
+        minSimilarity: 0.3,
+        projectFilter: undefined,
+      })
+
+      const memories = results.map((r: any) => ({
+        id: r.id,
+        type: 'memory',
+        title: r.description,
+        description: r.context || r.description,
+        timestamp: new Date().toISOString(),
+        project: r.project,
+        tags: r.tags,
+        context: r.context,
+        similarity: r.similarity || 0.8,
+      }))
+
+      return Response.json({ success: true, data: memories })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to recall similar memories')
+      return Response.json(
+        { success: false, error: 'Failed to search memories' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleGetDecisions(): Promise<Response> {
+    try {
+      const memoryService = getMemoryService()
+
+      if (!memoryService || !memoryService.isInitialized()) {
+        return Response.json({ success: true, data: [] })
+      }
+
+      const patterns = await memoryService.getPatterns(undefined, 100)
+
+      const decisions = patterns
+        .filter((p: any) => p.pattern_type === 'solution')
+        .map((p: any) => ({
+          id: p.id,
+          decision: p.description,
+          context: p.context,
+          reasoning: p.context,
+          alternatives_considered: p.context,
+          tags: p.tags,
+          project: p.project,
+          timestamp: new Date().toISOString(),
+        }))
+
+      return Response.json({ success: true, data: decisions })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get decisions')
+      return Response.json(
+        { success: false, error: 'Failed to get decisions' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleGetPatterns(): Promise<Response> {
+    try {
+      const memoryService = getMemoryService()
+
+      if (!memoryService || !memoryService.isInitialized()) {
+        return Response.json({ success: true, data: [] })
+      }
+
+      const patterns = await memoryService.getPatterns(undefined, 100)
+
+      return Response.json({ success: true, data: patterns })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get patterns')
+      return Response.json(
+        { success: false, error: 'Failed to get patterns' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleGetCorrections(): Promise<Response> {
+    try {
+      const memoryService = getMemoryService()
+
+      if (!memoryService || !memoryService.isInitialized()) {
+        return Response.json({ success: true, data: [] })
+      }
+
+      const corrections = await memoryService.getCorrections(undefined, 100)
+
+      return Response.json({ success: true, data: corrections })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get corrections')
+      return Response.json(
+        { success: false, error: 'Failed to get corrections' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleRememberDecision(c: any): Promise<Response> {
+    try {
+      const body = await c.req.json()
+      const memoryService = getMemoryService()
+
+      if (!memoryService || !memoryService.isInitialized()) {
+        throw new Error('Memory service not initialized')
+      }
+
+      await memoryService.storePattern({
+        description: body.decision,
+        pattern_type: 'solution',
+        context: body.context,
+        project: body.project_name,
+        tags: body.tags,
+        confidence: 0.9,
+      })
+
+      return Response.json({ success: true, data: { message: 'Decision stored successfully' } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to remember decision')
+      return Response.json(
+        { success: false, error: 'Failed to store decision' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleRecognizePattern(c: any): Promise<Response> {
+    try {
+      const body = await c.req.json()
+      const memoryService = getMemoryService()
+
+      if (!memoryService || !memoryService.isInitialized()) {
+        throw new Error('Memory service not initialized')
+      }
+
+      await memoryService.storePattern({
+        description: body.description,
+        pattern_type: body.pattern_type,
+        context: body.context,
+        example: body.example,
+        project: body.project_name,
+        tags: body.tags,
+        confidence: body.confidence || 0.8,
+      })
+
+      return Response.json({ success: true, data: { message: 'Pattern stored successfully' } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to recognize pattern')
+      return Response.json(
+        { success: false, error: 'Failed to store pattern' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleRecordCorrection(c: any): Promise<Response> {
+    try {
+      const body = await c.req.json()
+      const memoryService = getMemoryService()
+
+      if (!memoryService || !memoryService.isInitialized()) {
+        throw new Error('Memory service not initialized')
+      }
+
+      await memoryService.storeCorrection({
+        original: body.original,
+        correction: body.correction,
+        reasoning: body.reasoning,
+        context: body.context,
+        project: body.project_name,
+        confidence: body.confidence || 0.9,
+      })
+
+      return Response.json({ success: true, data: { message: 'Correction stored successfully' } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to record correction')
+      return Response.json(
+        { success: false, error: 'Failed to store correction' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleUpdateProgress(c: any): Promise<Response> {
+    try {
+      const body = await c.req.json()
+      const vaultService = getVaultService()
+
+      if (!vaultService) {
+        throw new Error('Vault service not initialized')
+      }
+
+      const updates: any = {}
+      if (body.completed_task) {
+        updates.status = `Completed: ${body.completed_task}`
+      }
+      if (body.next_steps) updates.next_steps = body.next_steps
+      if (body.notes) updates.notes = body.notes
+
+      await vaultService.updateProgress(body.project_name, updates)
+
+      return Response.json({ success: true, data: { message: 'Progress updated successfully' } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to update progress')
+      return Response.json(
+        { success: false, error: 'Failed to update progress' },
+        { status: 500 }
+      )
+    }
+  }
+
+  // ─── Phase 26: Context Query for Hook Injection ──────────
+
+  private async handleContextQuery(c: any): Promise<Response> {
+    try {
+      const query = c.req.query('query') || ''
+      const type = c.req.query('type') || ''
+      const cwd = c.req.query('cwd') || ''
+      const limit = parseInt(c.req.query('limit') || '5', 10)
+
+      const memoryService = getMemoryService()
+      if (!memoryService || !memoryService.isInitialized()) {
+        return Response.json({ success: true, context: '' })
+      }
+
+      // Extract project name from cwd (last path segment)
+      const projectName = cwd ? cwd.split('/').filter(Boolean).pop() : undefined
+
+      let contextParts: string[] = []
+
+      if (type === 'session-start') {
+        // Broader context for session start: recent decisions + patterns
+        const [recallText, patterns] = await Promise.all([
+          memoryService.recallSimilar(projectName || 'recent work', {
+            project: projectName,
+            limit: 5,
+            minSimilarity: 0.2,
+          }),
+          memoryService.getPatterns(projectName, { limit: 5 }),
+        ])
+
+        if (recallText && recallText.trim()) {
+          contextParts.push(recallText)
+        }
+
+        if (patterns && patterns.length > 0) {
+          const patternLines = patterns
+            .slice(0, 3)
+            .map((p: any) => `- Pattern: ${p.description}`)
+            .join('\n')
+          if (patternLines) {
+            contextParts.push(patternLines)
+          }
+        }
+      } else if (query) {
+        // Query-specific recall
+        const recallText = await memoryService.recallSimilar(query, {
+          project: projectName,
+          limit,
+          minSimilarity: 0.3,
+        })
+
+        if (recallText && recallText.trim()) {
+          contextParts.push(recallText)
+        }
+      }
+
+      const context = contextParts.join('\n')
+
+      return Response.json({ success: true, context })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get context for hook')
+      return Response.json({ success: true, context: '' })
+    }
+  }
+
+  // ─── Phase 23b: Context Auto Endpoint ────────────────────
+
+  private async handleContextAuto(): Promise<Response> {
+    try {
+      const resourceProvider = new ResourceProvider(this.logger)
+      const result = await resourceProvider.readResource('brain://context/auto')
+      const text = result?.contents?.[0]?.text || ''
+      return Response.json({ success: true, data: { content: text } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get auto context')
+      return Response.json(
+        { success: false, error: 'Failed to get auto context' },
+        { status: 500 }
+      )
+    }
+  }
+
+  // ─── Phase 17: Hook Endpoints ────────────────────────────
+
+  private async handleHookIngest(c: any): Promise<Response> {
+    try {
+      const body = await c.req.json()
+      const items: CapturedKnowledge[] = body.knowledge || []
+      const sessionId: string | undefined = body.sessionId
+
+      if (items.length === 0) {
+        return Response.json({ success: true, data: { stored: 0, skipped: 0, merged: 0 } })
+      }
+
+      const memoryService = getMemoryService()
+      if (!memoryService || !memoryService.isInitialized()) {
+        return Response.json(
+          { success: false, error: 'Memory service not initialized' },
+          { status: 503 }
+        )
+      }
+
+      const deduplicator = new SmartDeduplicator(this.config.hooks?.deduplication)
+      let stored = 0, skipped = 0, merged = 0
+
+      for (const knowledge of items) {
+        const action = await deduplicator.beforeStore(knowledge, memoryService)
+
+        switch (action.action) {
+          case 'skip':
+            skipped++
+            this.hookStats.totalSkipped++
+            break
+
+          case 'merge':
+            merged++
+            this.hookStats.totalMerged++
+            // For merge, we store as update — treat as new store with merged content
+            await this.storeKnowledge({ ...knowledge, content: action.mergedContent }, memoryService)
+            stored++
+            break
+
+          case 'store_new':
+            await this.storeKnowledge(knowledge, memoryService)
+            stored++
+            this.hookStats.totalCaptured++
+            break
+        }
+
+        // Track in session if sessionId provided
+        if (sessionId && this.sessionTracker) {
+          await this.sessionTracker.track(sessionId, knowledge)
+        }
+      }
+
+      this.hookStats.lastCaptureAt = new Date().toISOString()
+
+      this.logger.debug(
+        { stored, skipped, merged, sessionId },
+        'Hook ingest processed'
+      )
+
+      return Response.json({ success: true, data: { stored, skipped, merged } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to process hook ingest')
+      return Response.json(
+        { success: false, error: 'Failed to ingest hook data' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private async handleHookSessionEnd(c: any): Promise<Response> {
+    try {
+      const body = await c.req.json()
+      const sessionId: string | undefined = body.sessionId
+
+      if (!sessionId) {
+        return Response.json(
+          { success: false, error: 'sessionId required' },
+          { status: 400 }
+        )
+      }
+
+      if (this.sessionTracker) {
+        await this.sessionTracker.endSession(sessionId)
+        this.hookStats.sessionsTracked++
+      }
+
+      return Response.json({ success: true, data: { message: 'Session ended' } })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to end hook session')
+      return Response.json(
+        { success: false, error: 'Failed to end session' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleHookStatus(): Response {
+    const sessionStats = this.sessionTracker?.getStats()
+
+    return Response.json({
+      success: true,
+      data: {
+        ...this.hookStats,
+        activeSessions: sessionStats?.activeSessions ?? 0,
+        sessionItems: sessionStats?.totalItems ?? 0,
+        hooksEnabled: this.config.hooks?.enabled ?? true,
+      },
+    })
+  }
+
+  /** Route captured knowledge to the appropriate store method */
+  private async storeKnowledge(
+    knowledge: CapturedKnowledge,
+    memoryService: MemoryManager
+  ): Promise<void> {
+    const project = knowledge.project || 'unknown'
+
+    switch (knowledge.type) {
+      case 'decision':
+        await memoryService.rememberDecision(
+          project,
+          `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
+          knowledge.content,
+          `Auto-captured from ${knowledge.source}`,
+          { tags: knowledge.technologies }
+        )
+        break
+
+      case 'pattern':
+        await memoryService.storePattern({
+          project,
+          pattern_type: 'solution',
+          description: knowledge.content,
+          context: `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
+          confidence: knowledge.confidence,
+        })
+        break
+
+      case 'correction':
+        await memoryService.storeCorrection({
+          project,
+          original: knowledge.metadata.command || 'Unknown',
+          correction: knowledge.content,
+          reasoning: 'Auto-captured from hook passive learning',
+          context: `Captured via hook: ${knowledge.metadata.action || 'tool-use'}`,
+          confidence: knowledge.confidence,
+        })
+        break
+
+      case 'progress': {
+        // Store in ChromaDB so it's searchable via brain tool
+        await memoryService.rememberDecision(
+          project,
+          `Captured via hook: ${knowledge.metadata.action || knowledge.metadata.source || 'progress'}`,
+          knowledge.content,
+          `Auto-captured from ${knowledge.source}`,
+          { tags: knowledge.technologies }
+        )
+
+        // Also update vault progress if project exists
+        const vaultService = getVaultService()
+        if (vaultService) {
+          try {
+            await vaultService.updateProgress(project, {
+              status: `Hook: ${knowledge.content.slice(0, 200)}`,
+            })
+          } catch {
+            // Vault might not have this project
+          }
+        }
+        break
+      }
+    }
+  }
+
+  async start(): Promise<void> {
+    const port = this.config.port || 3000
+
+    this.logger.info({
+      port,
+      environment: this.config.nodeEnv,
+    }, 'Starting HTTP API server...')
+
+    try {
+      this.server = Bun.serve({
+        port,
+        fetch: this.app.fetch,
+      })
+
+      this.logger.info({
+        port,
+        url: `http://localhost:${port}`,
+      }, 'HTTP API server started successfully')
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to start HTTP API server')
+      throw error
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (this.server) {
+      this.logger.info('Stopping HTTP API server...')
+      this.server.stop()
+      this.logger.info('HTTP API server stopped')
+    }
+  }
+
+  getApp(): Hono {
+    return this.app
+  }
+}