AI-written code interpolated a user-supplied commit hash unquoted into a shell command passed to execSync, enabling command injection on the MCP server.

@@ -39,6 +40,7 @@ class LLMKnowledgeBaseServer {   private server: Server;   private memory: MemoryManager;   private migration: any;+  private autoLearn: AutoLearnManager | null = null;   private isShuttingDown = false;    constructor() {@@ -69,6 +71,24 @@ class LLMKnowledgeBaseServer {       log('🔗 MCP client connecting...');       const result = await originalConnect(transport);       log('✅ MCP client connected successfully');++      // Auto-initialize auto-learning if project detected+      const projectInfo = this.memory.getProjectInfo();+      if (projectInfo && !this.autoLearn) {+        try {+          log('🎓 Auto-initializing learning system...');+          this.autoLearn = new AutoLearnManager(this.memory);+          const initResult = await this.autoLearn.initialize(projectInfo.root, true);+          if (initResult.success) {+            log(`✅ Auto-learning initialized: git hooks=${initResult.gitHooksInstalled}, agents=${initResult.agentsInstalled}`);+          } else {+            log(`⚠️  Auto-learning initialization incomplete: ${initResult.errors.join(', ')}`);+          }+        } catch (error) {+          log(`⚠️  Auto-learning initialization failed: ${error instanceof Error ? error.message : String(error)}`);+        }+      }+       return result;     }; @@ -718,6 +738,55 @@ class LLMKnowledgeBaseServer {             additionalProperties: false,           },         },+        {+          name: 'autolearn.status',+          description: 'Get auto-learning system status and hook installation state',+          inputSchema: {+            type: 'object',+            properties: {},+            additionalProperties: false,+          },+        },+        {+          name: 'autolearn.init',+          description: 'Initialize auto-learning system for current project',+          inputSchema: {+            type: 'object',+            properties: {+              autoInstall: { type: 'boolean', description: 'Auto-install hooks if missing (default: true)' },+            },+            additionalProperties: false,+          },+        },+        {+          name: 'autolearn.processQueue',+          description: 'Process queued auto-learning events from git commits',+          inputSchema: {+            type: 'object',+            properties: {},+            additionalProperties: false,+          },+        },+        {+          name: 'autolearn.captureCommit',+          description: 'Manually capture a git commit for auto-learning',+          inputSchema: {+            type: 'object',+            properties: {+              commitHash: { type: 'string', description: 'Commit hash (default: HEAD)' },+            },+            additionalProperties: false,+          },+        },+        {+          name: 'autolearn.installGlobally',+          description: 'Install auto-learning hooks and agents globally',+          inputSchema: {+            type: 'object',

+ */++import { execSync } from 'child_process';+import { existsSync, readFileSync, writeFileSync, chmodSync, mkdirSync } from 'fs';+import * as path from 'path';+import type { GitCommitInfo, HookStatus, AutoLearnConfig } from '../types/AutoLearning.js';++function log(message: string, ...args: any[]) {+  console.error(`[GitHooksManager] ${new Date().toISOString()} ${message}`, ...args);+}++export class GitHooksManager {+  private projectRoot: string;+  private hooksDir: string;+  private config: AutoLearnConfig['gitHooks'];++  constructor(projectRoot: string, config: AutoLearnConfig['gitHooks']) {+    this.projectRoot = projectRoot;+    this.hooksDir = path.join(projectRoot, '.git', 'hooks');+    this.config = config;+  }++  /**+   * Install all auto-learning git hooks+   */+  async installHooks(): Promise<HookStatus[]> {+    const results: HookStatus[] = [];++    // Ensure .git/hooks directory exists+    if (!existsSync(this.hooksDir)) {+      try {+        mkdirSync(this.hooksDir, { recursive: true });+      } catch (error) {+        log('Failed to create hooks directory:', error);+        return [];+      }+    }++    // Install commit-msg hook (parse #kb tags)+    results.push(await this.installCommitMsgHook());++    // Install post-commit hook (capture diffs)+    if (this.config.captureDiffs) {+      results.push(await this.installPostCommitHook());+    }++    return results;+  }++  /**+   * Uninstall auto-learning git hooks+   */+  async uninstallHooks(): Promise<void> {+    const hooks = ['commit-msg', 'post-commit'];++    for (const hookName of hooks) {+      const hookPath = path.join(this.hooksDir, hookName);++      if (existsSync(hookPath)) {+        try {+          const content = readFileSync(hookPath, 'utf8');++          // Only remove if it's our hook (check for marker)+          if (content.includes('# LLM-MEMORY-MCP-AUTOLEARN')) {+            const fs = await import('fs/promises');+            await fs.unlink(hookPath);+            log(`Uninstalled ${hookName} hook`);+          }+        } catch (error) {+          log(`Failed to uninstall ${hookName} hook:`, error);+        }+      }+    }+  }++  /**+   * Check status of installed hooks+   */+  async checkHooksStatus(): Promise<HookStatus[]> {+    const hooks = ['commit-msg', 'post-commit'];+    const results: HookStatus[] = [];++    for (const hookName of hooks) {+      const hookPath = path.join(this.hooksDir, hookName);+      const installed = existsSync(hookPath);

+ * materializing them into searchable memories.+ */++import { MemoryManager } from '../MemoryManager.js';+import { GitHooksManager } from './GitHooksManager.js';+import type {+  AutoLearnEvent,+  AutoLearnContext,+  AutoLearnConfig,+  AutoLearnResult,+  DetectedPattern,+  GitCommitInfo+} from '../types/AutoLearning.js';+import type { MemoryItem, MemoryType } from '../types/Memory.js';+import { ulid } from '../util/ulid.js';+import { redactSecrets } from '../utils/secretFilter.js';+import * as path from 'path';++function log(message: string, ...args: any[]) {+  console.error(`[AutoLearner] ${new Date().toISOString()} ${message}`, ...args);+}++export class AutoLearner {+  private memory: MemoryManager;+  private config: AutoLearnConfig;+  private gitHooks?: GitHooksManager;+  private projectRoot?: string;+  private patternCache: Map<string, DetectedPattern> = new Map();++  constructor(memory: MemoryManager, config: AutoLearnConfig) {+    this.memory = memory;+    this.config = config;+  }++  /**+   * Initialize git hooks (if enabled)+   */+  async initialize(projectRoot: string): Promise<void> {+    this.projectRoot = projectRoot;++    if (this.config.gitHooks.enabled) {+      this.gitHooks = new GitHooksManager(projectRoot, this.config.gitHooks);++      try {+        const statuses = await this.gitHooks.installHooks();+        const installed = statuses.filter(s => s.installed).length;+        log(`Installed ${installed}/${statuses.length} git hooks for auto-learning`);+      } catch (error) {+        log('Failed to install git hooks:', error);+      }+    }+  }++  /**+   * Capture an auto-learning event+   */+  async captureEvent(event: AutoLearnEvent): Promise<AutoLearnResult> {+    if (!this.config.enabled) {+      return { success: false, skipped: 'Auto-learning is disabled' };+    }++    // Check if this event type should be captured+    if (!this.config.captureTypes.includes(event.type)) {+      return { success: false, skipped: `Event type '${event.type}' not enabled for capture` };+    }++    // Apply filters+    const filterResult = this.applyFilters(event.context);+    if (!filterResult.passed) {+      return { success: false, skipped: filterResult.reason };+    }++    // Materialize the event into a memory+    try {+      const memory = await this.materializeMemory(event);+      const memoryId = await this.memory.upsert(memory);++      log(`Captured ${event.type} event as ${memory.type} memory: ${memoryId}`);++      // Update pattern detection if enabled+      if (this.config.insights.enabled && event.type === 'pattern') {+        await this.updatePatternDetection(event.context);+      }++      return {