claude-brain 0.15.1 → 0.16.0

package/VERSION

@@ -1 +1 @@
-0.15.1
+0.16.0

package/assets/CLAUDE.md

@@ -1,11 +1,29 @@
 # Claude Brain
 
-Brain works automatically in the background — you don't need to call it.
+You have persistent memory via the `brain` tool. It remembers across sessions.
 
-Use the `brain` tool ONLY when you want to:
-- Explicitly store a decision: "I decided to use Redis for caching"
-- Ask a specific question: "What did we decide about auth?"
-- Update something: "Changed my mind, use Postgres instead"
-- Delete something: "Remove the note about migrations"
+## Session Start
+At the beginning of significant work sessions, check what you know:
+- `brain("What do I know about this project?")` — recalls past decisions, preferences, lessons
 
-Everything else (session tracking, file captures, git commits, context loading) happens automatically via invisible PostToolUse and Stop hooks in ~/.claude/settings.json. These hooks silently capture tool events and store patterns, decisions, and corrections without any explicit brain() call.
+## During Work
+Call brain when you make or encounter something worth remembering:
+- Decisions: `brain("I decided to use JWT over sessions because the app is stateless")`
+- Mistakes: `brain("The bug was caused by missing CORS credentials — fixed with credentials: include")`
+- Preferences: `brain("User prefers explicit error messages over generic 500s")`
+- Updates: `brain("Changed my mind, use Postgres instead of MySQL")`
+
+## Session End
+Before finishing significant work, store a 2-3 sentence summary:
+- `brain("Session summary: Built auth flow for expense tracker. Chose JWT for stateless architecture. Hit CORS issue on /api/login, fixed with credentials: include. User prefers Tailwind and explicit error handling.")`
+
+## What NOT to store
+- File paths or creation events (captured automatically)
+- Progress like "read file X" or "ran tests" (too granular)
+- Anything already in the codebase (just read the code)
+
+## Background
+Tool events are captured automatically via invisible PostToolUse/Stop hooks
+in ~/.claude/settings.json. These hooks capture installs, git commits, and
+build failures without any explicit brain() call. Your job is to add the
+WHY — the reasoning, preferences, and lessons that hooks cannot see.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",

package/src/cli/bin.ts

@@ -32,6 +32,7 @@ function printHelp() {
     ['install', 'Register as MCP server in Claude Code'],
     ['uninstall', 'Remove MCP server from Claude Code'],
     ['update', 'Update package and refresh CLAUDE.md'],
+    ['refresh', 'Kill all, update to latest, and setup everything'],
     ['chroma', 'Manage ChromaDB server (start/stop/status)'],
     ['hooks', 'Manage passive learning hooks (install/uninstall/status)'],
     ['git-hook', 'Manage git post-commit hook (install/uninstall/status)'],
@@ -115,6 +116,12 @@ async function main() {
       break
     }
 
+    case 'refresh': {
+      const { runRefresh } = await import('./commands/refresh')
+      await runRefresh()
+      break
+    }
+
     case 'chroma': {
       const { runChroma } = await import('./commands/chroma')
       await runChroma()

package/src/cli/commands/refresh.ts

@@ -0,0 +1,323 @@
+/**
+ * claude-brain refresh — One-command update & restart.
+ * Kill all instances → install latest → setup ChromaDB/MCP/hooks → verify.
+ * Cross-platform: macOS/Linux and Windows.
+ */
+
+import { execSync } from 'node:child_process'
+import { existsSync, readFileSync, unlinkSync } from 'node:fs'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { fileURLToPath } from 'url'
+import { getHomePaths } from '@/config/home'
+import { ensureHomeDirectory } from '@/cli/auto-setup'
+import { ensureChromaRunning } from '@/cli/commands/chroma'
+import { installHooks, isHooksInstalled } from '@/hooks/installer'
+import {
+  renderLogo, theme, heading, successText, errorText, warningText, dimText,
+  box, withSpinner,
+} from '@/cli/ui/index.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const PACKAGE_ROOT = path.resolve(__dirname, '..', '..', '..')
+
+const isWindows = process.platform === 'win32'
+
+function getInstalledVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf-8'))
+    return pkg.version || 'unknown'
+  } catch {
+    return 'unknown'
+  }
+}
+
+function getLatestVersion(): string | null {
+  try {
+    const result = execSync('npm view claude-brain version', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 15_000,
+    })
+    return result.trim()
+  } catch {
+    return null
+  }
+}
+
+/** Kill processes matching a pattern, excluding our own PID. */
+function killByPattern(pattern: string): boolean {
+  const myPid = process.pid
+  try {
+    if (isWindows) {
+      // Get matching PIDs, filter out ourselves, then kill
+      const result = execSync(
+        `wmic process where "commandline like '%${pattern}%' and processid != ${myPid}" get processid /format:list`,
+        { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 }
+      )
+      const pids = result.match(/ProcessId=(\d+)/g)?.map(m => m.split('=')[1]) || []
+      for (const pid of pids) {
+        try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'pipe', timeout: 5000 }) } catch {}
+      }
+      return pids.length > 0
+    } else {
+      // Get matching PIDs via pgrep, exclude our own, then kill each
+      const result = execSync(`pgrep -f "${pattern}"`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+      })
+      const pids = result.trim().split('\n').filter(p => p && Number(p) !== myPid)
+      for (const pid of pids) {
+        try { process.kill(Number(pid), 'SIGKILL') } catch {}
+      }
+      return pids.length > 0
+    }
+  } catch {
+    return false
+  }
+}
+
+/** Kill any process listening on a given port, excluding our own PID. */
+function killByPort(port: number): boolean {
+  const myPid = process.pid
+  try {
+    if (isWindows) {
+      const result = execSync(`netstat -ano | findstr :${port} | findstr LISTENING`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+      })
+      const pids = new Set(
+        result.split('\n')
+          .map(line => line.trim().split(/\s+/).pop())
+          .filter(p => p && Number(p) !== myPid)
+      )
+      for (const pid of pids) {
+        try { execSync(`taskkill /F /PID ${pid}`, { stdio: 'pipe', timeout: 5000 }) } catch {}
+      }
+      return pids.size > 0
+    } else {
+      const raw = execSync(`lsof -ti :${port}`, {
+        encoding: 'utf-8', stdio: 'pipe', timeout: 5000,
+      }).trim()
+      if (raw) {
+        const pids = raw.split('\n').filter(p => p && Number(p) !== myPid)
+        for (const pid of pids) {
+          try { process.kill(Number(pid), 'SIGKILL') } catch {}
+        }
+        return pids.length > 0
+      }
+    }
+  } catch {}
+  return false
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function isMcpConfigured(): boolean {
+  try {
+    const result = execSync('claude mcp list', {
+      encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
+    })
+    return result.includes('claude-brain')
+  } catch {
+    return false
+  }
+}
+
+function registerMcp(): boolean {
+  try {
+    execSync('claude mcp add claude-brain -- claude-brain serve', {
+      encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 10_000,
+    })
+    return true
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    // Already registered is fine
+    return msg.includes('already') || msg.includes('exists')
+  }
+}
+
+function isChromaReachable(): boolean {
+  for (const apiVersion of ['v2', 'v1']) {
+    try {
+      execSync(`curl -sf http://localhost:8000/api/${apiVersion}/heartbeat`, {
+        stdio: 'pipe', timeout: 3000,
+      })
+      return true
+    } catch {}
+  }
+  return false
+}
+
+// ── Main ──────────────────────────────────────────────────
+
+export async function runRefresh() {
+  console.log()
+  console.log(renderLogo())
+  console.log()
+  console.log(heading('Refresh — Kill, Update, Setup'))
+  console.log()
+
+  const versionBefore = getInstalledVersion()
+  const results: Array<[string, 'ok' | 'warn' | 'fail', string]> = []
+
+  // ── Step 1: Kill all running instances ──────────────────
+
+  await withSpinner('Stopping all claude-brain processes', async () => {
+    // Kill claude-brain processes
+    killByPattern('claude-brain')
+
+    // Kill ChromaDB
+    if (isWindows) {
+      killByPattern('chroma.exe')
+    } else {
+      killByPattern('chroma run')
+    }
+
+    // Kill by port (HTTP API 3333, ChromaDB 8000)
+    killByPort(3333)
+    killByPort(8000)
+
+    // Clean up stale PID file
+    const pidPath = path.join(getHomePaths().data, 'chroma.pid')
+    if (existsSync(pidPath)) {
+      try { unlinkSync(pidPath) } catch {}
+    }
+
+    // Let ports release
+    await sleep(2000)
+  })
+  results.push(['Kill processes', 'ok', 'All instances stopped'])
+  console.log(successText('  All instances stopped'))
+  console.log()
+
+  // ── Step 2: Install latest version ──────────────────────
+
+  const latestVersion = await withSpinner('Checking npm for latest version', async () => getLatestVersion())
+
+  if (latestVersion) {
+    console.log(dimText(`  Installed: v${versionBefore}  →  Latest: v${latestVersion}`))
+  }
+
+  if (latestVersion && latestVersion !== versionBefore) {
+    try {
+      await withSpinner(`Installing claude-brain@${latestVersion}`, async () => {
+        try {
+          execSync('bun install -g claude-brain@latest', {
+            encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 120_000,
+          })
+        } catch {
+          // Fallback to npm
+          execSync('npm install -g claude-brain@latest', {
+            encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 120_000,
+          })
+        }
+      })
+      results.push(['Update', 'ok', `v${versionBefore} → v${latestVersion}`])
+      console.log(successText(`  Updated: v${versionBefore} → v${latestVersion}`))
+    } catch {
+      results.push(['Update', 'fail', 'Install failed — try manually: bun install -g claude-brain@latest'])
+      console.log(warningText('  Update failed. Try manually: bun install -g claude-brain@latest'))
+    }
+  } else {
+    results.push(['Update', 'ok', `v${versionBefore} is latest`])
+    console.log(successText(`  Already on latest (v${versionBefore})`))
+  }
+  console.log()
+
+  // ── Step 3: Full setup ──────────────────────────────────
+
+  // 3a. Home directory
+  await withSpinner('Ensuring home directory', async () => {
+    ensureHomeDirectory()
+  })
+  results.push(['Home dir', 'ok', '~/.claude-brain/'])
+  console.log(successText('  Home directory ready'))
+
+  // 3b. ChromaDB
+  const chromaOk = await withSpinner('Starting ChromaDB', async () => {
+    return ensureChromaRunning({ silent: true })
+  })
+  if (chromaOk) {
+    results.push(['ChromaDB', 'ok', 'Running on port 8000'])
+    console.log(successText('  ChromaDB running'))
+  } else {
+    results.push(['ChromaDB', 'warn', 'Not available — install with: claude-brain chroma install'])
+    console.log(warningText('  ChromaDB not available (install with: claude-brain chroma install)'))
+  }
+
+  // 3c. Hooks
+  await withSpinner('Installing hooks', async () => {
+    installHooks()
+  })
+  const hooksOk = isHooksInstalled()
+  if (hooksOk) {
+    results.push(['Hooks', 'ok', 'Installed in ~/.claude/settings.json'])
+    console.log(successText('  Hooks installed'))
+  } else {
+    results.push(['Hooks', 'warn', 'Hook installation issue'])
+    console.log(warningText('  Hooks may not be fully installed'))
+  }
+
+  // 3d. CLAUDE.md
+  const assetsPath = path.join(PACKAGE_ROOT, 'assets', 'CLAUDE.md')
+  const claudeDir = path.join(os.homedir(), '.claude')
+  const destPath = path.join(claudeDir, 'CLAUDE.md')
+
+  if (existsSync(assetsPath)) {
+    await withSpinner('Updating CLAUDE.md', async () => {
+      await fs.mkdir(claudeDir, { recursive: true })
+      await fs.copyFile(assetsPath, destPath)
+    })
+    results.push(['CLAUDE.md', 'ok', '~/.claude/CLAUDE.md'])
+    console.log(successText('  CLAUDE.md updated'))
+  } else {
+    results.push(['CLAUDE.md', 'warn', 'Asset not found in package'])
+    console.log(warningText('  CLAUDE.md asset not found, skipping'))
+  }
+
+  // 3e. MCP registration
+  const mcpOk = await withSpinner('Checking MCP registration', async () => {
+    if (isMcpConfigured()) return true
+    return registerMcp()
+  })
+  if (mcpOk) {
+    results.push(['MCP', 'ok', 'Registered in Claude Code'])
+    console.log(successText('  MCP server registered'))
+  } else {
+    results.push(['MCP', 'warn', 'Run manually: claude-brain install'])
+    console.log(warningText('  MCP registration failed — run: claude-brain install'))
+  }
+
+  console.log()
+
+  // ── Step 4: Verify & report ─────────────────────────────
+
+  const chromaVerified = isChromaReachable()
+  if (!chromaVerified && chromaOk) {
+    // Update result if it was ok but now unreachable
+    const idx = results.findIndex(r => r[0] === 'ChromaDB')
+    if (idx >= 0) results[idx] = ['ChromaDB', 'warn', 'Started but not responding yet']
+  }
+
+  // Build summary
+  const statusIcon = (s: 'ok' | 'warn' | 'fail') =>
+    s === 'ok' ? successText('✓') : s === 'warn' ? warningText('⚠') : errorText('✗')
+
+  const summaryLines = results.map(
+    ([label, status, detail]) => `  ${statusIcon(status)} ${theme.bold(label!.padEnd(12))} ${dimText(detail!)}`
+  )
+
+  const allOk = results.every(r => r[1] === 'ok')
+
+  console.log(box([
+    heading(allOk ? 'Refresh complete!' : 'Refresh complete (with warnings)'),
+    '',
+    ...summaryLines,
+    '',
+    dimText('Verify: claude-brain health'),
+  ].join('\n'), allOk ? 'Done' : 'Done'))
+  console.log()
+}

package/src/cli/commands/serve.ts

@@ -18,12 +18,6 @@ export async function runServe() {
   // Auto-initialize home directory on first run
   ensureHomeDirectory()
 
-  // Background auto-update (non-blocking)
-  try {
-    const { checkForUpdateInBackground } = await import('@/cli/auto-update')
-    checkForUpdateInBackground().catch(() => {})
-  } catch {}
-
   // Auto-install Claude Code hooks (idempotent, non-fatal)
   try {
     const { installHooks } = await import('@/hooks/installer')

package/src/cli/commands/update.ts

@@ -116,6 +116,9 @@ export async function runUpdate() {
     '',
     dimText('Run health check to verify:'),
     `  ${theme.bold('claude-brain health')}`,
+    '',
+    dimText('For a full kill + update + restart:'),
+    `  ${theme.bold('claude-brain refresh')}`,
   ].join('\n'), 'Done'))
   console.log()
 }

package/src/config/defaults.ts

@@ -3,7 +3,7 @@ import type { PartialConfig } from './schema'
 /** Default configuration values for Claude Brain */
 export const defaultConfig: PartialConfig = {
   serverName: 'claude-brain',
-  serverVersion: '0.15.1',
+  serverVersion: '0.16.0',
   logLevel: 'info',
   logFilePath: './logs/claude-brain.log',
   dbPath: './data/memory.db',

package/src/config/schema.ts

@@ -284,7 +284,7 @@ export const ConfigSchema = z.object({
   serverName: z.string().default('claude-brain'),
 
   /** Server version in semver format */
-  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.15.1'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.16.0'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/hooks/brain-hook.ts

@@ -54,7 +54,23 @@ export async function main(): Promise<void> {
 
   const port = parseInt(process.env.CLAUDE_BRAIN_PORT || '3000', 10)
 
-  // Process the hook event
+  // For Stop events: trigger session-end summarization regardless of classification
+  if (input.hook_event_name === 'Stop' && input.session_id) {
+    try {
+      await fetch(`http://localhost:${port}/api/hooks/session-end`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ sessionId: input.session_id }),
+        signal: AbortSignal.timeout(5000),
+      })
+    } catch {
+      // Server unreachable — session summary lost, acceptable tradeoff
+    }
+    process.exit(0)
+    return
+  }
+
+  // Process the hook event (non-Stop events only)
   const capture = new BrainCapture({ enabled: true })
   const knowledge = capture.process(input)
 

package/src/hooks/passive-classifier.ts

@@ -109,48 +109,45 @@ export class PassiveClassifier {
     const content = toolInput.new_string || toolInput.content || ''
     const responseText = this.extractResponseText(input.tool_response)
 
-    // Check for new file creation (Write tool)
+    // For Write tool: only capture if content contains decision or correction language
+    // Plain file creations ("Created file: X") are noise — zero recall value
     if (input.tool_name?.toLowerCase() === 'write') {
-      // Check file content for decision/correction language before defaulting to pattern
-      if (typeof content === 'string' && content.length > 50) {
-        const decisionInContent = this.detectDecisionLanguage(content)
-        if (decisionInContent) {
-          return {
-            type: 'decision',
-            confidence: 0.8,
-            content: decisionInContent,
-            project: this.extractProjectFromCwd(input.cwd),
-            technologies,
-            metadata: { filePath, role, action: 'create' },
-            source: 'hook-passive',
-            timestamp: new Date().toISOString(),
-          }
-        }
-        const correctionInContent = this.detectCorrectionLanguage(content)
-        if (correctionInContent) {
-          return {
-            type: 'correction',
-            confidence: 0.75,
-            content: correctionInContent,
-            project: this.extractProjectFromCwd(input.cwd),
-            technologies,
-            metadata: { filePath, role, action: 'create' },
-            source: 'hook-passive',
-            timestamp: new Date().toISOString(),
-          }
+      const writeContent = typeof content === 'string' ? content : ''
+      const writeResponse = responseText || ''
+      const combined = writeContent + ' ' + writeResponse
+
+      // Check for decision language in file content or response
+      const decisionInWrite = this.detectDecisionLanguage(combined)
+      if (decisionInWrite) {
+        return {
+          type: 'decision',
+          confidence: 0.75,
+          content: decisionInWrite,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'create' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
         }
       }
 
-      return {
-        type: 'pattern',
-        confidence: 0.7,
-        content: `Created ${role ? role + ' ' : ''}file: ${this.shortenPath(filePath)}${technologies.length ? ` (${technologies.join(', ')})` : ''}`,
-        project: this.extractProjectFromCwd(input.cwd),
-        technologies,
-        metadata: { filePath, role, action: 'create' },
-        source: 'hook-passive',
-        timestamp: new Date().toISOString(),
+      // Check for correction language
+      const correctionInWrite = this.detectCorrectionLanguage(combined)
+      if (correctionInWrite) {
+        return {
+          type: 'correction',
+          confidence: 0.75,
+          content: correctionInWrite,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'create' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
       }
+
+      // No decision or correction language found — skip this file creation
+      return null
     }
 
     // For edits, only capture if they look significant

package/src/hooks/session-tracker.ts

@@ -134,46 +134,83 @@ export class HookSessionTracker {
 
   /**
    * Build a structured summary from session items.
-   * Format: "Did: ...; Decided: ...; Files: ..."
+   * Phase 25: Natural sentence format with project context, deduplication, noise filtering.
    */
   private buildStructuredSummary(session: SessionState): string {
-    const actions: string[] = []
-    const decisions: string[] = []
-    const files = new Set<string>()
+    const decisions = session.items.filter(i => i.type === 'decision')
+    const corrections = session.items.filter(i => i.type === 'correction')
+    const progress = session.items.filter(i => i.type === 'progress')
 
+    // Extract unique technologies across all items
+    const techs = new Set<string>()
     for (const item of session.items) {
-      // Extract file paths from metadata
-      if (item.metadata?.file_path) {
-        files.add(item.metadata.file_path)
-      }
+      for (const t of item.technologies) techs.add(t)
+    }
+
+    // Extract unique files touched
+    const files = new Set<string>()
+    for (const item of session.items) {
+      const filePath = item.metadata?.filePath || item.metadata?.file_path
+      if (filePath) files.add(filePath as string)
       if (item.metadata?.files) {
         for (const f of Array.isArray(item.metadata.files) ? item.metadata.files : [item.metadata.files]) {
-          files.add(f)
+          files.add(f as string)
         }
       }
-
-      if (item.type === 'decision') {
-        decisions.push(item.content.slice(0, 80))
-      } else if (item.type === 'progress') {
-        actions.push(item.content.slice(0, 80))
-      } else if (item.type === 'pattern' || item.type === 'correction') {
-        actions.push(`[${item.type}] ${item.content.slice(0, 60)}`)
-      }
     }
 
     const parts: string[] = []
-    if (actions.length > 0) {
-      parts.push(`Did: ${actions.slice(0, 5).join('; ')}`)
+
+    // Project and tech context
+    const project = session.project || 'unknown project'
+    if (techs.size > 0) {
+      parts.push(`Worked on ${project} using ${Array.from(techs).slice(0, 5).join(', ')}`)
+    } else {
+      parts.push(`Worked on ${project}`)
     }
+
+    // Key decisions (deduplicated, max 3)
     if (decisions.length > 0) {
-      parts.push(`Decided: ${decisions.slice(0, 3).join('; ')}`)
+      const uniqueDecisions = this.deduplicateByPrefix(decisions.map(d => d.content), 3)
+      parts.push(`Decisions: ${uniqueDecisions.join('. ')}`)
     }
+
+    // What was done (git commits and installs only — skip file creation noise)
+    const meaningfulProgress = progress.filter(p =>
+      p.metadata?.action === 'git' || p.metadata?.action === 'install' ||
+      (p.metadata?.action === 'build' && p.metadata?.failed)
+    )
+    if (meaningfulProgress.length > 0) {
+      const uniqueProgress = this.deduplicateByPrefix(meaningfulProgress.map(p => p.content), 3)
+      parts.push(`Progress: ${uniqueProgress.join('. ')}`)
+    }
+
+    // Lessons learned (always valuable, keep all)
+    if (corrections.length > 0) {
+      parts.push(`Lessons: ${corrections.map(c => c.content).join('. ')}`)
+    }
+
+    // File count (not full list — just a signal of scope)
     if (files.size > 0) {
-      const fileList = [...files].slice(0, 8)
-      parts.push(`Files: ${fileList.join(', ')}`)
+      parts.push(`Touched ${files.size} file${files.size > 1 ? 's' : ''}`)
     }
 
-    return parts.join('. ') || `Session with ${session.items.length} events`
+    return parts.join('. ') || 'Session with no significant events captured.'
+  }
+
+  /** Deduplicate strings by checking if one starts with the first 30 chars of another */
+  private deduplicateByPrefix(items: string[], max: number): string[] {
+    const seen = new Set<string>()
+    const result: string[] = []
+    for (const item of items) {
+      const prefix = item.slice(0, 30).toLowerCase()
+      if (!seen.has(prefix)) {
+        seen.add(prefix)
+        result.push(item)
+        if (result.length >= max) break
+      }
+    }
+    return result
   }
 
   private async summarizeAndPersist(session: SessionState): Promise<void> {