claude-brain 0.30.2 → 0.30.3

package/src/hooks/passive-classifier.ts

@@ -1,397 +1,397 @@
-/**
- * Phase 17: Passive Classifier
- * Extracts knowledge from tool outputs using lightweight pattern matching.
- * No embeddings needed — runs fast enough for hook context (<200ms).
- */
-
-import type { HookInput, CapturedKnowledge } from './types'
-
-/** Phrases that indicate a decision was made */
-const DECISION_PHRASES = [
-  'i recommend', 'you should use', 'the best approach', 'i suggest',
-  'better to use', 'prefer using', 'go with', 'choose', 'instead of',
-  'the right choice', 'decided to', "let's use", 'we will use',
-  'the solution is', 'implement using', 'going with', 'switching to',
-  'adopting', 'we chose', 'the plan is to'
-]
-
-/** Phrases indicating a correction or lesson */
-const CORRECTION_PHRASES = [
-  'the bug was', 'the issue was', 'the problem was', 'mistake was',
-  'should have', 'should not have', "shouldn't have",
-  'lesson learned', "don't use", 'avoid using', 'never use',
-  'the fix is', 'the fix was', 'fixed by', 'solved by'
-]
-
-/** Package install patterns for bash commands */
-const INSTALL_PATTERNS = [
-  /(?:npm|yarn|pnpm|bun)\s+(?:install|add|i)\s+(.+)/i,
-  /pip\s+install\s+(.+)/i,
-  /cargo\s+add\s+(.+)/i,
-  /go\s+get\s+(.+)/i,
-  /gem\s+install\s+(.+)/i,
-]
-
-/** Git operation patterns */
-const GIT_PATTERNS = [
-  /git\s+commit\s+.*-m\s+["'](.+?)["']/i,
-  /git\s+merge\s+(\S+)/i,
-  /git\s+checkout\s+-b\s+(\S+)/i,
-  /git\s+branch\s+(\S+)/i,
-]
-
-/** Test/build command patterns */
-const BUILD_PATTERNS = [
-  /(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:test|build|lint|typecheck|check)/i,
-  /(?:jest|vitest|pytest|cargo\s+test|go\s+test)/i,
-]
-
-/** Bash commands to skip (low signal) */
-const SKIP_COMMANDS = new Set([
-  'cd', 'ls', 'cat', 'head', 'tail', 'pwd', 'echo', 'clear', 'which', 'whoami',
-  'date', 'env', 'printenv', 'export', 'source', 'alias', 'history',
-])
-
-/** File extension to technology mapping */
-const EXT_TO_TECH: Record<string, string> = {
-  '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript', '.jsx': 'javascript',
-  '.py': 'python', '.rs': 'rust', '.go': 'go', '.java': 'java',
-  '.rb': 'ruby', '.php': 'php', '.swift': 'swift', '.kt': 'kotlin',
-  '.vue': 'vue', '.svelte': 'svelte', '.astro': 'astro',
-  '.css': 'css', '.scss': 'sass', '.less': 'less',
-  '.sql': 'sql', '.graphql': 'graphql', '.gql': 'graphql',
-  '.yml': 'yaml', '.yaml': 'yaml', '.toml': 'toml',
-  '.dockerfile': 'docker', '.prisma': 'prisma',
-}
-
-/** Path segments that indicate file role */
-const PATH_ROLE_MAP: Record<string, string> = {
-  'test': 'testing', 'tests': 'testing', '__tests__': 'testing', 'spec': 'testing',
-  'src': 'source', 'lib': 'library', 'utils': 'utility', 'helpers': 'utility',
-  'components': 'component', 'pages': 'page', 'routes': 'routing',
-  'api': 'api', 'server': 'server', 'client': 'client',
-  'config': 'configuration', 'scripts': 'scripting',
-  'hooks': 'hooks', 'middleware': 'middleware', 'types': 'types',
-}
-
-export class PassiveClassifier {
-  /**
-   * Classify a hook event and extract knowledge if found.
-   * Returns null if no knowledge worth capturing.
-   */
-  classify(input: HookInput): CapturedKnowledge | null {
-    const toolName = input.tool_name?.toLowerCase()
-    if (!toolName) return null
-
-    switch (toolName) {
-      case 'edit':
-      case 'write':
-        return this.classifyFileEdit(input)
-      case 'bash':
-        return this.classifyBashCommand(input)
-      default:
-        // Read, Glob, Grep — skip (read-only, low signal)
-        return null
-    }
-  }
-
-  private classifyFileEdit(input: HookInput): CapturedKnowledge | null {
-    const toolInput = input.tool_input
-    if (!toolInput) return null
-
-    const filePath = (toolInput.file_path || toolInput.path || '') as string
-    if (!filePath) return null
-
-    const technologies = this.extractTechFromPath(filePath)
-    const role = this.extractRoleFromPath(filePath)
-
-    // Check if the edit content contains decision language
-    const content = toolInput.new_string || toolInput.content || ''
-    const responseText = this.extractResponseText(input.tool_response)
-
-    // 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') {
-      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(),
-        }
-      }
-
-      // 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
-    if (typeof content === 'string' && content.length > 50) {
-      const decisionInContent = this.detectDecisionLanguage(content)
-      if (decisionInContent) {
-        return {
-          type: 'decision',
-          confidence: 0.75,
-          content: decisionInContent,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies,
-          metadata: { filePath, role, action: 'edit' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Check tool response for decision language
-    if (responseText) {
-      const decisionInResponse = this.detectDecisionLanguage(responseText)
-      if (decisionInResponse) {
-        return {
-          type: 'decision',
-          confidence: 0.7,
-          content: decisionInResponse,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies,
-          metadata: { filePath, role, action: 'edit' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    return null
-  }
-
-  private classifyBashCommand(input: HookInput): CapturedKnowledge | 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
-
-    // If all sub-commands are skip-worthy, bail
-    const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase()
-    if (firstWord && SKIP_COMMANDS.has(firstWord)) return null
-
-    // Package installs
-    for (const pattern of INSTALL_PATTERNS) {
-      const match = command.match(pattern)
-      if (match) {
-        const packages = match[1]?.trim()
-        if (packages) {
-          return {
-            type: 'decision',
-            confidence: 0.85,
-            content: `Installed package(s): ${packages}`,
-            project: this.extractProjectFromCwd(input.cwd),
-            technologies: this.extractTechFromPackages(packages),
-            metadata: { command: rawCommand, action: 'install' },
-            source: 'hook-passive',
-            timestamp: new Date().toISOString(),
-          }
-        }
-      }
-    }
-
-    // Git operations
-    for (const pattern of GIT_PATTERNS) {
-      const match = command.match(pattern)
-      if (match) {
-        return {
-          type: 'progress',
-          confidence: 0.8,
-          content: `Git: ${command.trim().slice(0, 200)}`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: ['git'],
-          metadata: { command: rawCommand, action: 'git' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // 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(buildCommand)) {
-        const responseText = this.extractResponseText(input.tool_response)
-        const failed = responseText?.toLowerCase().includes('fail') ||
-                       responseText?.toLowerCase().includes('error')
-
-        if (failed) {
-          return {
-            type: 'correction',
-            confidence: 0.75,
-            content: `Build/test failure: ${buildCommand.trim().slice(0, 100)}`,
-            project: this.extractProjectFromCwd(input.cwd),
-            technologies: [],
-            metadata: { command: rawCommand, action: 'build', failed: true },
-            source: 'hook-passive',
-            timestamp: new Date().toISOString(),
-          }
-        }
-
-        return {
-          type: 'progress',
-          confidence: 0.7,
-          content: `Ran: ${buildCommand.trim().slice(0, 200)}`,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: [],
-          metadata: { command: rawCommand, action: 'build', failed: false },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    // Check response text for decision/correction language
-    const responseText = this.extractResponseText(input.tool_response)
-    if (responseText) {
-      const correction = this.detectCorrectionLanguage(responseText)
-      if (correction) {
-        return {
-          type: 'correction',
-          confidence: 0.7,
-          content: correction,
-          project: this.extractProjectFromCwd(input.cwd),
-          technologies: [],
-          metadata: { command: rawCommand, action: 'bash' },
-          source: 'hook-passive',
-          timestamp: new Date().toISOString(),
-        }
-      }
-    }
-
-    return null
-  }
-
-  /** Extract technology names from file path based on extension */
-  private extractTechFromPath(filePath: string): string[] {
-    const techs: string[] = []
-    const ext = filePath.match(/\.[a-z]+$/i)?.[0]?.toLowerCase()
-    if (ext && EXT_TO_TECH[ext]) {
-      techs.push(EXT_TO_TECH[ext])
-    }
-
-    // Check for Dockerfile without extension
-    const basename = filePath.split(/[/\\]/).pop()?.toLowerCase() || ''
-    if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) {
-      techs.push('docker')
-    }
-    if (basename === 'docker-compose.yml' || basename === 'docker-compose.yaml') {
-      techs.push('docker')
-    }
-
-    return techs
-  }
-
-  /** Extract file role from path segments */
-  private extractRoleFromPath(filePath: string): string | undefined {
-    const segments = filePath.toLowerCase().split(/[/\\]/)
-    for (const segment of segments) {
-      if (PATH_ROLE_MAP[segment]) return PATH_ROLE_MAP[segment]
-    }
-    return undefined
-  }
-
-  /** Extract technology names from package install strings */
-  private extractTechFromPackages(packages: string): string[] {
-    return packages
-      .split(/\s+/)
-      .filter(p => !p.startsWith('-') && p.length > 1)
-      .map(p => p.replace(/@[^/]+$/, '')) // strip version
-      .slice(0, 10) // limit
-  }
-
-  /** Detect decision language in text, return the relevant sentence */
-  private detectDecisionLanguage(text: string): string | null {
-    const lower = text.toLowerCase()
-    for (const phrase of DECISION_PHRASES) {
-      const idx = lower.indexOf(phrase)
-      if (idx !== -1) {
-        // Extract surrounding context (up to 300 chars)
-        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
-        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
-        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
-        if (sentence.length > 10) return sentence
-      }
-    }
-    return null
-  }
-
-  /** Detect correction/lesson language in text */
-  private detectCorrectionLanguage(text: string): string | null {
-    const lower = text.toLowerCase()
-    for (const phrase of CORRECTION_PHRASES) {
-      const idx = lower.indexOf(phrase)
-      if (idx !== -1) {
-        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
-        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
-        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
-        if (sentence.length > 10) return sentence
-      }
-    }
-    return null
-  }
-
-  /** Extract project name from cwd (last directory segment) */
-  private extractProjectFromCwd(cwd: string): string | undefined {
-    if (!cwd) return undefined
-    // 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()
-    }
-    return undefined
-  }
-
-  /** Extract text content from tool_response */
-  private extractResponseText(response: HookInput['tool_response']): string | null {
-    if (!response) return null
-
-    if (typeof response.content === 'string') {
-      return response.content.slice(0, 2000)
-    }
-
-    if (Array.isArray(response.content)) {
-      const texts = response.content
-        .filter(block => block.type === 'text' && block.text)
-        .map(block => block.text!)
-      return texts.join('\n').slice(0, 2000) || null
-    }
-
-    return null
-  }
-}
+/**
+ * Phase 17: Passive Classifier
+ * Extracts knowledge from tool outputs using lightweight pattern matching.
+ * No embeddings needed — runs fast enough for hook context (<200ms).
+ */
+
+import type { HookInput, CapturedKnowledge } from './types'
+
+/** Phrases that indicate a decision was made */
+const DECISION_PHRASES = [
+  'i recommend', 'you should use', 'the best approach', 'i suggest',
+  'better to use', 'prefer using', 'go with', 'choose', 'instead of',
+  'the right choice', 'decided to', "let's use", 'we will use',
+  'the solution is', 'implement using', 'going with', 'switching to',
+  'adopting', 'we chose', 'the plan is to'
+]
+
+/** Phrases indicating a correction or lesson */
+const CORRECTION_PHRASES = [
+  'the bug was', 'the issue was', 'the problem was', 'mistake was',
+  'should have', 'should not have', "shouldn't have",
+  'lesson learned', "don't use", 'avoid using', 'never use',
+  'the fix is', 'the fix was', 'fixed by', 'solved by'
+]
+
+/** Package install patterns for bash commands */
+const INSTALL_PATTERNS = [
+  /(?:npm|yarn|pnpm|bun)\s+(?:install|add|i)\s+(.+)/i,
+  /pip\s+install\s+(.+)/i,
+  /cargo\s+add\s+(.+)/i,
+  /go\s+get\s+(.+)/i,
+  /gem\s+install\s+(.+)/i,
+]
+
+/** Git operation patterns */
+const GIT_PATTERNS = [
+  /git\s+commit\s+.*-m\s+["'](.+?)["']/i,
+  /git\s+merge\s+(\S+)/i,
+  /git\s+checkout\s+-b\s+(\S+)/i,
+  /git\s+branch\s+(\S+)/i,
+]
+
+/** Test/build command patterns */
+const BUILD_PATTERNS = [
+  /(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?(?:test|build|lint|typecheck|check)/i,
+  /(?:jest|vitest|pytest|cargo\s+test|go\s+test)/i,
+]
+
+/** Bash commands to skip (low signal) */
+const SKIP_COMMANDS = new Set([
+  'cd', 'ls', 'cat', 'head', 'tail', 'pwd', 'echo', 'clear', 'which', 'whoami',
+  'date', 'env', 'printenv', 'export', 'source', 'alias', 'history',
+])
+
+/** File extension to technology mapping */
+const EXT_TO_TECH: Record<string, string> = {
+  '.ts': 'typescript', '.tsx': 'typescript', '.js': 'javascript', '.jsx': 'javascript',
+  '.py': 'python', '.rs': 'rust', '.go': 'go', '.java': 'java',
+  '.rb': 'ruby', '.php': 'php', '.swift': 'swift', '.kt': 'kotlin',
+  '.vue': 'vue', '.svelte': 'svelte', '.astro': 'astro',
+  '.css': 'css', '.scss': 'sass', '.less': 'less',
+  '.sql': 'sql', '.graphql': 'graphql', '.gql': 'graphql',
+  '.yml': 'yaml', '.yaml': 'yaml', '.toml': 'toml',
+  '.dockerfile': 'docker', '.prisma': 'prisma',
+}
+
+/** Path segments that indicate file role */
+const PATH_ROLE_MAP: Record<string, string> = {
+  'test': 'testing', 'tests': 'testing', '__tests__': 'testing', 'spec': 'testing',
+  'src': 'source', 'lib': 'library', 'utils': 'utility', 'helpers': 'utility',
+  'components': 'component', 'pages': 'page', 'routes': 'routing',
+  'api': 'api', 'server': 'server', 'client': 'client',
+  'config': 'configuration', 'scripts': 'scripting',
+  'hooks': 'hooks', 'middleware': 'middleware', 'types': 'types',
+}
+
+export class PassiveClassifier {
+  /**
+   * Classify a hook event and extract knowledge if found.
+   * Returns null if no knowledge worth capturing.
+   */
+  classify(input: HookInput): CapturedKnowledge | null {
+    const toolName = input.tool_name?.toLowerCase()
+    if (!toolName) return null
+
+    switch (toolName) {
+      case 'edit':
+      case 'write':
+        return this.classifyFileEdit(input)
+      case 'bash':
+        return this.classifyBashCommand(input)
+      default:
+        // Read, Glob, Grep — skip (read-only, low signal)
+        return null
+    }
+  }
+
+  private classifyFileEdit(input: HookInput): CapturedKnowledge | null {
+    const toolInput = input.tool_input
+    if (!toolInput) return null
+
+    const filePath = (toolInput.file_path || toolInput.path || '') as string
+    if (!filePath) return null
+
+    const technologies = this.extractTechFromPath(filePath)
+    const role = this.extractRoleFromPath(filePath)
+
+    // Check if the edit content contains decision language
+    const content = toolInput.new_string || toolInput.content || ''
+    const responseText = this.extractResponseText(input.tool_response)
+
+    // 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') {
+      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(),
+        }
+      }
+
+      // 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
+    if (typeof content === 'string' && content.length > 50) {
+      const decisionInContent = this.detectDecisionLanguage(content)
+      if (decisionInContent) {
+        return {
+          type: 'decision',
+          confidence: 0.75,
+          content: decisionInContent,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'edit' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    // Check tool response for decision language
+    if (responseText) {
+      const decisionInResponse = this.detectDecisionLanguage(responseText)
+      if (decisionInResponse) {
+        return {
+          type: 'decision',
+          confidence: 0.7,
+          content: decisionInResponse,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies,
+          metadata: { filePath, role, action: 'edit' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    return null
+  }
+
+  private classifyBashCommand(input: HookInput): CapturedKnowledge | 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
+
+    // If all sub-commands are skip-worthy, bail
+    const firstWord = command.trim().split(/\s+/)[0]?.toLowerCase()
+    if (firstWord && SKIP_COMMANDS.has(firstWord)) return null
+
+    // Package installs
+    for (const pattern of INSTALL_PATTERNS) {
+      const match = command.match(pattern)
+      if (match) {
+        const packages = match[1]?.trim()
+        if (packages) {
+          return {
+            type: 'decision',
+            confidence: 0.85,
+            content: `Installed package(s): ${packages}`,
+            project: this.extractProjectFromCwd(input.cwd),
+            technologies: this.extractTechFromPackages(packages),
+            metadata: { command: rawCommand, action: 'install' },
+            source: 'hook-passive',
+            timestamp: new Date().toISOString(),
+          }
+        }
+      }
+    }
+
+    // Git operations
+    for (const pattern of GIT_PATTERNS) {
+      const match = command.match(pattern)
+      if (match) {
+        return {
+          type: 'progress',
+          confidence: 0.8,
+          content: `Git: ${command.trim().slice(0, 200)}`,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies: ['git'],
+          metadata: { command: rawCommand, action: 'git' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    // 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(buildCommand)) {
+        const responseText = this.extractResponseText(input.tool_response)
+        const failed = responseText?.toLowerCase().includes('fail') ||
+                       responseText?.toLowerCase().includes('error')
+
+        if (failed) {
+          return {
+            type: 'correction',
+            confidence: 0.75,
+            content: `Build/test failure: ${buildCommand.trim().slice(0, 100)}`,
+            project: this.extractProjectFromCwd(input.cwd),
+            technologies: [],
+            metadata: { command: rawCommand, action: 'build', failed: true },
+            source: 'hook-passive',
+            timestamp: new Date().toISOString(),
+          }
+        }
+
+        return {
+          type: 'progress',
+          confidence: 0.7,
+          content: `Ran: ${buildCommand.trim().slice(0, 200)}`,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies: [],
+          metadata: { command: rawCommand, action: 'build', failed: false },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    // Check response text for decision/correction language
+    const responseText = this.extractResponseText(input.tool_response)
+    if (responseText) {
+      const correction = this.detectCorrectionLanguage(responseText)
+      if (correction) {
+        return {
+          type: 'correction',
+          confidence: 0.7,
+          content: correction,
+          project: this.extractProjectFromCwd(input.cwd),
+          technologies: [],
+          metadata: { command: rawCommand, action: 'bash' },
+          source: 'hook-passive',
+          timestamp: new Date().toISOString(),
+        }
+      }
+    }
+
+    return null
+  }
+
+  /** Extract technology names from file path based on extension */
+  private extractTechFromPath(filePath: string): string[] {
+    const techs: string[] = []
+    const ext = filePath.match(/\.[a-z]+$/i)?.[0]?.toLowerCase()
+    if (ext && EXT_TO_TECH[ext]) {
+      techs.push(EXT_TO_TECH[ext])
+    }
+
+    // Check for Dockerfile without extension
+    const basename = filePath.split(/[/\\]/).pop()?.toLowerCase() || ''
+    if (basename === 'dockerfile' || basename.startsWith('dockerfile.')) {
+      techs.push('docker')
+    }
+    if (basename === 'docker-compose.yml' || basename === 'docker-compose.yaml') {
+      techs.push('docker')
+    }
+
+    return techs
+  }
+
+  /** Extract file role from path segments */
+  private extractRoleFromPath(filePath: string): string | undefined {
+    const segments = filePath.toLowerCase().split(/[/\\]/)
+    for (const segment of segments) {
+      if (PATH_ROLE_MAP[segment]) return PATH_ROLE_MAP[segment]
+    }
+    return undefined
+  }
+
+  /** Extract technology names from package install strings */
+  private extractTechFromPackages(packages: string): string[] {
+    return packages
+      .split(/\s+/)
+      .filter(p => !p.startsWith('-') && p.length > 1)
+      .map(p => p.replace(/@[^/]+$/, '')) // strip version
+      .slice(0, 10) // limit
+  }
+
+  /** Detect decision language in text, return the relevant sentence */
+  private detectDecisionLanguage(text: string): string | null {
+    const lower = text.toLowerCase()
+    for (const phrase of DECISION_PHRASES) {
+      const idx = lower.indexOf(phrase)
+      if (idx !== -1) {
+        // Extract surrounding context (up to 300 chars)
+        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
+        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
+        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
+        if (sentence.length > 10) return sentence
+      }
+    }
+    return null
+  }
+
+  /** Detect correction/lesson language in text */
+  private detectCorrectionLanguage(text: string): string | null {
+    const lower = text.toLowerCase()
+    for (const phrase of CORRECTION_PHRASES) {
+      const idx = lower.indexOf(phrase)
+      if (idx !== -1) {
+        const start = Math.max(0, text.lastIndexOf('\n', idx) + 1)
+        const end = Math.min(text.length, text.indexOf('\n', idx + phrase.length))
+        const sentence = text.slice(start, end === -1 ? Math.min(idx + 300, text.length) : end).trim()
+        if (sentence.length > 10) return sentence
+      }
+    }
+    return null
+  }
+
+  /** Extract project name from cwd (last directory segment) */
+  private extractProjectFromCwd(cwd: string): string | undefined {
+    if (!cwd) return undefined
+    // 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()
+    }
+    return undefined
+  }
+
+  /** Extract text content from tool_response */
+  private extractResponseText(response: HookInput['tool_response']): string | null {
+    if (!response) return null
+
+    if (typeof response.content === 'string') {
+      return response.content.slice(0, 2000)
+    }
+
+    if (Array.isArray(response.content)) {
+      const texts = response.content
+        .filter(block => block.type === 'text' && block.text)
+        .map(block => block.text!)
+      return texts.join('\n').slice(0, 2000) || null
+    }
+
+    return null
+  }
+}