claude-brain 0.14.4 → 0.15.1

package/VERSION

@@ -1 +1 @@
-0.14.4
+0.15.1

package/assets/CLAUDE.md

@@ -8,4 +8,4 @@ Use the `brain` tool ONLY when you want to:
 - Update something: "Changed my mind, use Postgres instead"
 - Delete something: "Remove the note about migrations"
 
-Everything else (session tracking, file captures, git commits, context loading) happens automatically.
+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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-brain",
-  "version": "0.14.4",
+  "version": "0.15.1",
   "description": "Local development assistant bridging Obsidian vaults with Claude Code via MCP",
   "type": "module",
   "main": "src/index.ts",
@@ -9,6 +9,7 @@
   },
   "files": [
     "src/**/*.ts",
+    "scripts/postinstall.mjs",
     "packs/",
     "assets/",
     "package.json",
@@ -19,6 +20,7 @@
     "LICENSE"
   ],
   "scripts": {
+    "postinstall": "node scripts/postinstall.mjs",
     "dev": "CLAUDE_BRAIN_HOME=. bun --watch src/index.ts",
     "build": "bun build src/index.ts --outdir dist --target bun",
     "build:binary": "bun build src/cli/bin.ts --compile --outfile claude-brain",

package/scripts/postinstall.mjs

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for claude-brain.
+ * Runs automatically after `npm install -g claude-brain` or `bun install -g claude-brain`.
+ * Pure Node.js — no TypeScript, no path aliases, no Bun APIs.
+ * Always exits 0 so it never blocks the install.
+ */
+
+import { mkdirSync, writeFileSync, readFileSync, existsSync, renameSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { homedir } from 'node:os'
+import { execSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+const PREFIX = '[claude-brain]'
+const HOME = join(homedir(), '.claude-brain')
+const CLAUDE_DIR = join(homedir(), '.claude')
+const CLAUDE_SETTINGS = join(CLAUDE_DIR, 'settings.json')
+const CLAUDE_MD_PATH = join(CLAUDE_DIR, 'CLAUDE.md')
+const HOOK_MARKER = 'claude-brain-hook'
+
+function log(msg) {
+  console.error(`${PREFIX} ${msg}`)
+}
+
+// ── Step 0: Skip if not a global install ─────────────────
+
+function shouldSkip() {
+  // CI environments
+  if (process.env.CI === 'true' || process.env.CI === '1') {
+    return 'CI environment detected'
+  }
+
+  // If we're inside a node_modules directory, it's a local install
+  const scriptDir = dirname(__filename)
+  if (scriptDir.includes('node_modules') && !scriptDir.includes('global')) {
+    // Check if this is actually a global install by looking deeper
+    // bun global installs go to ~/.bun/install/global/node_modules
+    // npm global installs go to /usr/local/lib/node_modules or ~/.npm-global
+    const isGlobalPath =
+      scriptDir.includes('.bun/install/global') ||
+      scriptDir.includes('/usr/local/lib/node_modules') ||
+      scriptDir.includes('/usr/lib/node_modules') ||
+      scriptDir.includes('npm-global') ||
+      scriptDir.includes('AppData/Roaming/npm')
+
+    if (!isGlobalPath) {
+      return 'local install (not global)'
+    }
+  }
+
+  return null
+}
+
+// ── Step 1: Create ~/.claude-brain/ ──────────────────────
+
+function setupHomeDirectory() {
+  if (existsSync(join(HOME, 'data'))) {
+    log('Home directory already initialized')
+    return true
+  }
+
+  log(`Setting up ${HOME}/...`)
+
+  const dirs = [
+    join(HOME, 'data'),
+    join(HOME, 'data', 'chroma'),
+    join(HOME, 'logs'),
+    join(HOME, 'vault'),
+    join(HOME, 'vault', 'Projects'),
+    join(HOME, 'vault', 'Global'),
+    join(HOME, 'hooks'),
+  ]
+
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true })
+  }
+
+  // Write default .env if not present
+  const envPath = join(HOME, '.env')
+  if (!existsSync(envPath)) {
+    writeFileSync(envPath, `# Claude Brain Configuration
+# Generated by postinstall
+VAULT_PATH=${join(HOME, 'vault')}
+LOG_LEVEL=info
+NODE_ENV=production
+
+# ChromaDB Configuration
+CHROMA_MODE=client-server
+CHROMA_HOST=localhost
+CHROMA_PORT=8000
+CHROMA_EMBEDDING_PROVIDER=transformers
+`, 'utf-8')
+  }
+
+  // Write default global standards
+  const standardsPath = join(HOME, 'vault', 'Global', 'standards.md')
+  if (!existsSync(standardsPath)) {
+    writeFileSync(standardsPath, `---
+type: global-standards
+last_updated: ${new Date().toISOString().split('T')[0]}
+---
+
+# Global Coding Standards
+
+## General
+- Write clear, readable code
+- Prefer explicit over implicit
+- Keep functions focused and small
+
+## TypeScript
+- Use strict mode
+- Prefer const over let
+- Add JSDoc comments for public APIs
+`, 'utf-8')
+  }
+
+  log('Home directory initialized')
+  return true
+}
+
+// ── Step 2: Install ChromaDB via pip ─────────────────────
+
+function installChromaDB() {
+  // Check if already installed
+  try {
+    execSync('chroma --version', { stdio: 'pipe', timeout: 5000 })
+    log('ChromaDB already installed')
+    return true
+  } catch {}
+
+  // Check for Python
+  let pythonCmd = null
+  for (const cmd of ['python3', 'python']) {
+    try {
+      const ver = execSync(`${cmd} --version`, { encoding: 'utf-8', stdio: 'pipe', timeout: 5000 })
+      if (ver.includes('3.')) {
+        pythonCmd = cmd
+        break
+      }
+    } catch {}
+  }
+
+  if (!pythonCmd) {
+    log('Python 3 not found — skipping ChromaDB install (SQLite fallback will be used)')
+    return false
+  }
+
+  log('Installing ChromaDB...')
+
+  const pipCommands = pythonCmd === 'python3'
+    ? ['pip3 install chromadb', 'python3 -m pip install chromadb']
+    : ['pip install chromadb', 'python -m pip install chromadb']
+
+  for (const cmd of pipCommands) {
+    try {
+      execSync(cmd, { stdio: 'pipe', timeout: 300_000 })
+      log('ChromaDB installed')
+      return true
+    } catch {}
+  }
+
+  log('ChromaDB install failed — SQLite fallback will be used')
+  return false
+}
+
+// ── Step 3: Register MCP server ──────────────────────────
+
+function registerMcpServer() {
+  // Check if claude CLI exists
+  try {
+    execSync('claude --version', { stdio: 'pipe', timeout: 5000 })
+  } catch {
+    log('Claude CLI not found — skipping MCP registration')
+    log('  Run manually: claude mcp add claude-brain -- claude-brain serve')
+    return false
+  }
+
+  // Check if already configured
+  try {
+    const result = execSync('claude mcp list', { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 })
+    if (result.includes('claude-brain')) {
+      log('MCP server already registered')
+      return true
+    }
+  } catch {}
+
+  // Register
+  try {
+    execSync('claude mcp add claude-brain -- claude-brain serve', {
+      stdio: 'pipe',
+      timeout: 15000,
+    })
+    log('Registered as MCP server in Claude Code')
+    return true
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    if (msg.includes('already') || msg.includes('exists')) {
+      log('MCP server already registered')
+      return true
+    }
+    log('MCP registration failed — run manually: claude mcp add claude-brain -- claude-brain serve')
+    return false
+  }
+}
+
+// ── Step 4: Install hooks ────────────────────────────────
+
+function installHooks() {
+  // Read existing settings
+  let settings = {}
+  if (existsSync(CLAUDE_SETTINGS)) {
+    try {
+      settings = JSON.parse(readFileSync(CLAUDE_SETTINGS, 'utf-8'))
+    } catch {}
+  }
+
+  // Check if already installed
+  function hasOurHooks(entries) {
+    if (!Array.isArray(entries)) return false
+    return entries.some(entry =>
+      entry && Array.isArray(entry.hooks) &&
+      entry.hooks.some(h => typeof h.command === 'string' && h.command.includes(HOOK_MARKER))
+    )
+  }
+
+  if (settings.hooks && (hasOurHooks(settings.hooks.PostToolUse) || hasOurHooks(settings.hooks.Stop))) {
+    log('Hooks already installed')
+    return true
+  }
+
+  // Build hook command
+  const scriptPath = join(HOME, 'hooks', 'brain-hook.ts')
+  function buildCmd(event) {
+    return `bun "${scriptPath}" --event ${event} # ${HOOK_MARKER}`
+  }
+
+  if (!settings.hooks) settings.hooks = {}
+
+  // PostToolUse
+  if (!settings.hooks.PostToolUse) settings.hooks.PostToolUse = []
+  settings.hooks.PostToolUse.push({
+    matcher: '',
+    hooks: [{ type: 'command', command: buildCmd('PostToolUse') }],
+  })
+
+  // Stop
+  if (!settings.hooks.Stop) settings.hooks.Stop = []
+  settings.hooks.Stop.push({
+    matcher: '',
+    hooks: [{ type: 'command', command: buildCmd('Stop') }],
+  })
+
+  // Write atomically
+  if (!existsSync(CLAUDE_DIR)) {
+    mkdirSync(CLAUDE_DIR, { recursive: true })
+  }
+  const tmpPath = CLAUDE_SETTINGS + '.tmp'
+  writeFileSync(tmpPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8')
+  renameSync(tmpPath, CLAUDE_SETTINGS)
+
+  log('Hooks installed')
+  return true
+}
+
+// ── Step 5: Install CLAUDE.md ────────────────────────────
+
+function installClaudeMd() {
+  // Find the assets/CLAUDE.md relative to this script
+  // scripts/postinstall.mjs → assets/CLAUDE.md
+  const assetsPath = join(__dirname, '..', 'assets', 'CLAUDE.md')
+
+  if (!existsSync(assetsPath)) {
+    log('CLAUDE.md asset not found — skipping')
+    return false
+  }
+
+  // Only install if no CLAUDE.md exists yet (don't overwrite user customizations)
+  if (existsSync(CLAUDE_MD_PATH)) {
+    // Check if it already mentions claude-brain
+    const existing = readFileSync(CLAUDE_MD_PATH, 'utf-8')
+    if (existing.includes('brain') || existing.includes('Brain')) {
+      log('CLAUDE.md already configured')
+      return true
+    }
+    // Append our section
+    const addition = readFileSync(assetsPath, 'utf-8')
+    writeFileSync(CLAUDE_MD_PATH, existing.trimEnd() + '\n\n' + addition, 'utf-8')
+    log('Appended brain instructions to existing CLAUDE.md')
+    return true
+  }
+
+  // Create new
+  if (!existsSync(CLAUDE_DIR)) {
+    mkdirSync(CLAUDE_DIR, { recursive: true })
+  }
+  const content = readFileSync(assetsPath, 'utf-8')
+  writeFileSync(CLAUDE_MD_PATH, content, 'utf-8')
+  log('Installed CLAUDE.md')
+  return true
+}
+
+// ── Main ─────────────────────────────────────────────────
+
+async function main() {
+  const skipReason = shouldSkip()
+  if (skipReason) {
+    log(`Skipping postinstall (${skipReason})`)
+    return
+  }
+
+  log('Running postinstall setup...')
+  console.error('')
+
+  const results = {
+    home: false,
+    chromadb: false,
+    mcp: false,
+    hooks: false,
+    claudemd: false,
+  }
+
+  try { results.home = setupHomeDirectory() } catch (e) { log(`Home setup failed: ${e.message}`) }
+  try { results.chromadb = installChromaDB() } catch (e) { log(`ChromaDB install failed: ${e.message}`) }
+  try { results.mcp = registerMcpServer() } catch (e) { log(`MCP registration failed: ${e.message}`) }
+  try { results.hooks = installHooks() } catch (e) { log(`Hook install failed: ${e.message}`) }
+  try { results.claudemd = installClaudeMd() } catch (e) { log(`CLAUDE.md install failed: ${e.message}`) }
+
+  console.error('')
+  log('Setup complete! Restart Claude Code to activate.')
+}
+
+main().catch(err => {
+  log(`Postinstall error: ${err.message}`)
+}).finally(() => {
+  process.exit(0)
+})

package/src/cli/auto-update.ts

@@ -0,0 +1,157 @@
+/**
+ * Background auto-update check for claude-brain.
+ * Runs on every `serve` start, rate-limited to 1 check per hour.
+ * All output to stderr (stdout reserved for MCP JSON-RPC).
+ * Never throws — all errors silently caught.
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { execSync } from 'node:child_process'
+import { getHomePaths } from '@/config/home'
+
+const CHECK_INTERVAL_MS = 60 * 60 * 1000 // 1 hour
+const TIMESTAMP_FILE = 'last-update-check'
+
+function getTimestampPath(): string {
+  return join(getHomePaths().data, TIMESTAMP_FILE)
+}
+
+function shouldCheck(): boolean {
+  const tsPath = getTimestampPath()
+  if (!existsSync(tsPath)) return true
+
+  try {
+    const lastCheck = parseInt(readFileSync(tsPath, 'utf-8').trim(), 10)
+    return Date.now() - lastCheck > CHECK_INTERVAL_MS
+  } catch {
+    return true
+  }
+}
+
+function writeTimestamp(): void {
+  const tsPath = getTimestampPath()
+  const dir = dirname(tsPath)
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true })
+  }
+  writeFileSync(tsPath, String(Date.now()), 'utf-8')
+}
+
+function getCurrentVersion(): string | null {
+  try {
+    // Read from our own package.json
+    const pkgPath = join(dirname(new URL(import.meta.url).pathname), '..', '..', 'package.json')
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'))
+      return pkg.version || null
+    }
+  } catch {}
+
+  // Fallback: read VERSION file
+  try {
+    const versionPath = join(dirname(new URL(import.meta.url).pathname), '..', '..', 'VERSION')
+    if (existsSync(versionPath)) {
+      return readFileSync(versionPath, 'utf-8').trim()
+    }
+  } catch {}
+
+  return null
+}
+
+function getLatestVersion(): string | null {
+  try {
+    const result = execSync('npm view claude-brain version', {
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 10_000,
+    })
+    return result.trim() || null
+  } catch {
+    return null
+  }
+}
+
+function isNewer(latest: string, current: string): boolean {
+  const parse = (v: string) => v.split('.').map(Number)
+  const [lMaj, lMin, lPat] = parse(latest)
+  const [cMaj, cMin, cPat] = parse(current)
+
+  if (lMaj !== cMaj) return lMaj > cMaj
+  if (lMin !== cMin) return lMin > cMin
+  return lPat > cPat
+}
+
+function performUpdate(): boolean {
+  // Try bun first, fallback to npm
+  const commands = [
+    'bun update -g claude-brain',
+    'npm update -g claude-brain',
+  ]
+
+  for (const cmd of commands) {
+    try {
+      execSync(cmd, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 120_000,
+      })
+      return true
+    } catch {}
+  }
+
+  return false
+}
+
+function postUpdateTasks(): void {
+  // Re-install hooks (idempotent)
+  try {
+    const { installHooks } = require('@/hooks/installer')
+    installHooks()
+  } catch {}
+
+  // Re-install CLAUDE.md if asset exists
+  try {
+    const { existsSync: exists, readFileSync: read, writeFileSync: write } = require('node:fs')
+    const { join: pjoin } = require('node:path')
+    const { homedir } = require('node:os')
+
+    const assetsPath = pjoin(dirname(new URL(import.meta.url).pathname), '..', '..', 'assets', 'CLAUDE.md')
+    const claudeMdPath = pjoin(homedir(), '.claude', 'CLAUDE.md')
+
+    if (exists(assetsPath)) {
+      if (!exists(claudeMdPath)) {
+        write(claudeMdPath, read(assetsPath, 'utf-8'), 'utf-8')
+      }
+    }
+  } catch {}
+}
+
+async function checkAndUpdate(): Promise<void> {
+  if (!shouldCheck()) return
+
+  writeTimestamp()
+
+  const current = getCurrentVersion()
+  if (!current) return
+
+  const latest = getLatestVersion()
+  if (!latest) return
+
+  if (!isNewer(latest, current)) return
+
+  console.error(`[claude-brain] Update available: ${current} → ${latest}`)
+
+  const updated = performUpdate()
+  if (updated) {
+    console.error(`[claude-brain] Updated to ${latest}`)
+    postUpdateTasks()
+  }
+}
+
+/**
+ * Fire-and-forget background update check.
+ * Call this from serve.ts — it never rejects.
+ */
+export function checkForUpdateInBackground(): Promise<void> {
+  return checkAndUpdate().catch(() => {})
+}

package/src/cli/commands/serve.ts

@@ -18,6 +18,12 @@ 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/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.14.4',
+  serverVersion: '0.15.1',
   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.14.4'),
+  serverVersion: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver format').default('0.15.1'),
 
   /** Logging level */
   logLevel: LogLevelSchema.default('info'),

package/src/hooks/installer.ts

@@ -5,6 +5,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, renameSync } from 'node:fs'
 import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { homedir } from 'node:os'
 import { getClaudeBrainHome } from '@/config/home'
 
@@ -169,7 +170,9 @@ function copyHookScript(): void {
     mkdirSync(destDir, { recursive: true })
   }
 
-  const srcDir = dirname(new URL(import.meta.url).pathname)
+  // Use Bun's import.meta.dir if available, otherwise fileURLToPath for Windows compat
+  // (new URL(...).pathname returns "/C:/..." on Windows, breaking existsSync)
+  const srcDir = (import.meta as any).dir ?? dirname(fileURLToPath(import.meta.url))
 
   for (const file of HOOK_FILES) {
     const srcPath = join(srcDir, file)

package/src/hooks/passive-classifier.ts

@@ -111,6 +111,36 @@ export class PassiveClassifier {
 
     // Check for new file creation (Write tool)
     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(),
+          }
+        }
+      }
+
       return {
         type: 'pattern',
         confidence: 0.7,
@@ -161,10 +191,19 @@ export class PassiveClassifier {
   }
 
   private classifyBashCommand(input: HookInput): CapturedKnowledge | null {
-    const command = (input.tool_input?.command || '') as string
-    if (!command || command.length < 3) return null
+    const rawCommand = (input.tool_input?.command || '') as string
+    if (!rawCommand || rawCommand.length < 3) return null
+
+    // Split compound commands (cd "..." && bun add react) into sub-commands
+    const subCommands = rawCommand.split(/\s*(?:&&|\|\||;)\s*/).map(s => s.trim()).filter(Boolean)
+
+    // Find the first meaningful sub-command (skip cd, export, etc.)
+    const command = subCommands.find(sub => {
+      const firstWord = sub.split(/\s+/)[0]?.toLowerCase()
+      return !firstWord || !SKIP_COMMANDS.has(firstWord)
+    }) || rawCommand
 
-    // Skip low-signal commands
+    // If all sub-commands are skip-worthy, bail
     const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase()
     if (firstWord && SKIP_COMMANDS.has(firstWord)) return null
 
@@ -180,7 +219,7 @@ export class PassiveClassifier {
             content: `Installed package(s): ${packages}`,
             project: this.extractProjectFromCwd(input.cwd),
             technologies: this.extractTechFromPackages(packages),
-            metadata: { command, action: 'install' },
+            metadata: { command: rawCommand, action: 'install' },
             source: 'hook-passive',
             timestamp: new Date().toISOString(),
           }
@@ -198,16 +237,17 @@ export class PassiveClassifier {
           content: `Git: ${command.trim().slice(0, 200)}`,
           project: this.extractProjectFromCwd(input.cwd),
           technologies: ['git'],
-          metadata: { command, action: 'git' },
+          metadata: { command: rawCommand, action: 'git' },
           source: 'hook-passive',
           timestamp: new Date().toISOString(),
         }
       }
     }
 
-    // Test/build runs
+    // Test/build runs — check all sub-commands since test may follow cd
+    const buildCommand = subCommands.find(sub => BUILD_PATTERNS.some(p => p.test(sub))) || command
     for (const pattern of BUILD_PATTERNS) {
-      if (pattern.test(command)) {
+      if (pattern.test(buildCommand)) {
         const responseText = this.extractResponseText(input.tool_response)
         const failed = responseText?.toLowerCase().includes('fail') ||
                        responseText?.toLowerCase().includes('error')
@@ -216,10 +256,10 @@ export class PassiveClassifier {
           return {
             type: 'correction',
             confidence: 0.75,
-            content: `Build/test failure: ${command.trim().slice(0, 100)}`,
+            content: `Build/test failure: ${buildCommand.trim().slice(0, 100)}`,
             project: this.extractProjectFromCwd(input.cwd),
             technologies: [],
-            metadata: { command, action: 'build', failed: true },
+            metadata: { command: rawCommand, action: 'build', failed: true },
             source: 'hook-passive',
             timestamp: new Date().toISOString(),
           }
@@ -228,10 +268,10 @@ export class PassiveClassifier {
         return {
           type: 'progress',
           confidence: 0.7,
-          content: `Ran: ${command.trim().slice(0, 200)}`,
+          content: `Ran: ${buildCommand.trim().slice(0, 200)}`,
           project: this.extractProjectFromCwd(input.cwd),
           technologies: [],
-          metadata: { command, action: 'build', failed: false },
+          metadata: { command: rawCommand, action: 'build', failed: false },
           source: 'hook-passive',
           timestamp: new Date().toISOString(),
         }
@@ -249,7 +289,7 @@ export class PassiveClassifier {
           content: correction,
           project: this.extractProjectFromCwd(input.cwd),
           technologies: [],
-          metadata: { command, action: 'bash' },
+          metadata: { command: rawCommand, action: 'bash' },
           source: 'hook-passive',
           timestamp: new Date().toISOString(),
         }
@@ -281,7 +321,7 @@ export class PassiveClassifier {
 
   /** Extract file role from path segments */
   private extractRoleFromPath(filePath: string): string | undefined {
-    const segments = filePath.toLowerCase().split('/')
+    const segments = filePath.toLowerCase().split(/[/\\]/)
     for (const segment of segments) {
       if (PATH_ROLE_MAP[segment]) return PATH_ROLE_MAP[segment]
     }
@@ -331,7 +371,8 @@ export class PassiveClassifier {
   /** Extract project name from cwd (last directory segment) */
   private extractProjectFromCwd(cwd: string): string | undefined {
     if (!cwd) return undefined
-    const parts = cwd.split('/').filter(Boolean)
+    // Split on both / and \ for cross-platform support
+    const parts = cwd.split(/[/\\]/).filter(Boolean)
     const last = parts.pop()
     if (last && last.length > 1 && last.length < 50) {
       return last.replace(/\s+/g, '-').toLowerCase()
@@ -341,7 +382,7 @@ export class PassiveClassifier {
 
   /** Shorten a file path for display */
   private shortenPath(filePath: string): string {
-    const parts = filePath.split('/')
+    const parts = filePath.split(/[/\\]/)
     if (parts.length <= 3) return filePath
     return `.../${parts.slice(-3).join('/')}`
   }

package/src/memory/chroma/embeddings.ts

@@ -135,7 +135,7 @@ export class OpenAIEmbeddingProvider implements EmbeddingProvider {
 export function createEmbeddingProvider(
   logger: Logger,
   config: ChromaConfig
-): EmbeddingProvider {
+): EmbeddingProvider | undefined {
   switch (config.embeddingProvider) {
     case 'openai':
       if (!config.openaiApiKey) {
@@ -148,6 +148,8 @@ export function createEmbeddingProvider(
 
     case 'default':
     default:
-      return new DefaultEmbeddingProvider()
+      // Return undefined so store/search code falls through to queryTexts path
+      // (ChromaDB's built-in auto-embedding)
+      return undefined
   }
 }

package/src/memory/chroma/index.ts

@@ -23,7 +23,7 @@ export class ChromaManager {
   public collections: CollectionManager
   public store: ChromaMemoryStore
   public search: ChromaSearchEngine
-  public embeddings: EmbeddingProvider
+  public embeddings: EmbeddingProvider | undefined
 
   private initialized: boolean = false