knoxis-collab 1.1.2 → 1.4.0

package/knoxis-collab.js

@@ -38,8 +38,22 @@
 const { spawn, spawnSync } = require('child_process');
 const crypto = require('crypto');
 const https = require('https');
+
+// Create HTTP agents with connection keep-alive
+const httpAgent = new (require('http').Agent)({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 10
+});
+
+const httpsAgent = new https.Agent({
+  keepAlive: true,
+  keepAliveMsecs: 1000,
+  maxSockets: 10
+});
 const readline = require('readline');
 const fs = require('fs');
+const fsPromises = require('fs').promises;
 const path = require('path');
 const os = require('os');
 
@@ -71,7 +85,20 @@ const cliArgs = parseArgs();
 const WORKSPACE = cliArgs.workspace || process.env.KNOXIS_WORKSPACE || process.cwd();
 
 // Load config
-function loadConfig() {
+async function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const data = await fsPromises.readFile(CONFIG_PATH, 'utf8');
+      return JSON.parse(data);
+    }
+  } catch (e) {
+    console.error(`Failed to load config: ${e.message}`);
+  }
+  return {};
+}
+
+// Synchronous config load for initialization
+function loadConfigSync() {
   try {
     if (fs.existsSync(CONFIG_PATH)) {
       return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
@@ -80,7 +107,7 @@ function loadConfig() {
   return {};
 }
 
-const config = loadConfig();
+const config = loadConfigSync();
 const GROQ_API_KEY = process.env.GROQ_API_KEY || config.groqApiKey || '';
 const BACKEND_URL = process.env.KNOXIS_BACKEND_URL || config.backendUrl || '';
 const USER_ID = process.env.KNOXIS_USER_ID || config.userId || '';
@@ -153,12 +180,44 @@ let isClaudeRunning = false;
 let activeClaudeProc = null;
 const conversationHistory = [];    // Groq message history
 const dispatchSummaries = [];      // Short summaries of what Claude did each dispatch
+const MAX_DISPATCH_SUMMARIES = 20; // Limit dispatch summaries for memory
+const aiInsights = {                // AI decision-making layer state
+  projectType: null,
+  complexity: 'medium',
+  patterns: [],
+  risks: [],
+  suggestions: [],
+  contextCache: new Map(),
+  decisionHistory: [],
+  feedbackHistory: [],             // User feedback on AI suggestions
+  patternWeights: new Map(),       // Learned weights for patterns
+  suggestionScores: new Map()      // Performance scores for suggestions
+};
+
+// Feedback state for current session
+const feedbackState = {
+  pendingFeedback: null,            // Current suggestion awaiting feedback
+  lastSuggestions: [],              // Last set of suggestions shown
+  feedbackPromptShown: false,       // Whether we've prompted for feedback
+  awaitingRating: false             // Whether we're waiting for a rating
+};
+
+// Code review and commenting state
+const codeReview = {
+  pendingReviews: [],              // Code blocks awaiting review
+  reviewHistory: [],               // Past code reviews
+  inlineComments: new Map(),      // File -> line -> comment mapping
+  activeReviewSession: null,      // Current review session ID
+  autoReviewEnabled: false,       // Auto-review on code changes
+  lastReviewedCode: null           // Cache last reviewed code
+};
 
 // ═══════════════════════════════════════════════════════════════
-//  SESSION LOG
+//  SESSION LOG & PERSISTENCE
 // ═══════════════════════════════════════════════════════════════
 
 const sessionDir = path.join(WORKSPACE, '.knoxis', 'sessions');
+const feedbackFile = path.join(WORKSPACE, '.knoxis', 'ai-feedback.json');
 try { fs.mkdirSync(sessionDir, { recursive: true }); } catch (e) {}
 
 const logFile = path.join(
@@ -166,9 +225,213 @@ const logFile = path.join(
   `${new Date().toISOString().replace(/[:.]/g, '-')}-collab-${SESSION_ID.slice(0, 8)}.log`
 );
 
+// Async logging with queue for better performance
+const logQueue = [];
+let logTimer = null;
+
 function log(entry) {
   const line = `[${new Date().toISOString()}] ${entry}\n`;
-  try { fs.appendFileSync(logFile, line); } catch (e) {}
+  logQueue.push(line);
+
+  // Batch write logs every 100ms
+  if (!logTimer) {
+    logTimer = setTimeout(async () => {
+      if (logQueue.length > 0) {
+        const batch = logQueue.splice(0, logQueue.length).join('');
+        try {
+          await fsPromises.appendFile(logFile, batch);
+        } catch (e) {
+          console.error(`Log write failed: ${e.message}`);
+        }
+      }
+      logTimer = null;
+    }, 100);
+  }
+}
+
+// Load persisted feedback data
+async function loadFeedbackData() {
+  try {
+    if (fs.existsSync(feedbackFile)) {
+      const content = await fsPromises.readFile(feedbackFile, 'utf8');
+      const data = JSON.parse(content);
+
+      // Restore pattern weights
+      if (data.patternWeights) {
+        Object.entries(data.patternWeights).forEach(([pattern, weight]) => {
+          aiInsights.patternWeights.set(pattern, weight);
+        });
+      }
+
+      // Restore suggestion scores
+      if (data.suggestionScores) {
+        Object.entries(data.suggestionScores).forEach(([suggestion, score]) => {
+          aiInsights.suggestionScores.set(suggestion, score);
+        });
+      }
+
+      // Load recent feedback history (last 50 items)
+      if (data.feedbackHistory) {
+        aiInsights.feedbackHistory = data.feedbackHistory.slice(-50);
+      }
+
+      log(`Loaded feedback data: ${aiInsights.patternWeights.size} patterns, ${aiInsights.suggestionScores.size} suggestions`);
+    }
+  } catch (e) {
+    log(`Failed to load feedback data: ${e.message}`);
+  }
+}
+
+// Save feedback data for persistence
+async function saveFeedbackData() {
+  try {
+    const data = {
+      version: '1.0',
+      lastUpdated: new Date().toISOString(),
+      patternWeights: Object.fromEntries(aiInsights.patternWeights),
+      suggestionScores: Object.fromEntries(aiInsights.suggestionScores),
+      feedbackHistory: aiInsights.feedbackHistory.slice(-50) // Keep last 50
+    };
+
+    await fsPromises.writeFile(feedbackFile, JSON.stringify(data, null, 2));
+    log(`Saved feedback data: ${aiInsights.patternWeights.size} patterns, ${aiInsights.suggestionScores.size} suggestions`);
+  } catch (e) {
+    log(`Failed to save feedback data: ${e.message}`);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+//  CODE REVIEW AND COMMENTING FUNCTIONS
+// ═══════════════════════════════════════════════════════════════
+
+// Review code with inline comments
+async function reviewCode(code, filePath, startLine = 1) {
+  const reviewId = crypto.randomUUID().substring(0, 8);
+  codeReview.activeReviewSession = reviewId;
+
+  const review = {
+    id: reviewId,
+    timestamp: Date.now(),
+    filePath: filePath,
+    code: code,
+    startLine: startLine,
+    comments: [],
+    summary: null
+  };
+
+  // Call Groq for code review
+  const userPrompt = `You are a senior code reviewer. Review the following code and provide:
+1. Inline comments for specific lines (format: "Line X: comment")
+2. General feedback and suggestions
+3. Identify potential issues, bugs, or improvements
+Be constructive and specific. Focus on code quality, performance, security, and maintainability.
+
+Review this code from ${filePath} starting at line ${startLine}:
+
+${code}`;
+
+  try {
+    const reviewResponse = await callGroq(
+      [{ role: 'user', content: userPrompt }],
+      projectContext
+    );
+
+    // Extract text from Groq response object
+    const reviewText = reviewResponse.message || JSON.stringify(reviewResponse);
+
+    // Parse inline comments from response
+    const lines = reviewText.split('\n');
+    const inlineCommentPattern = /^Line\s+(\d+):\s*(.+)/i;
+
+    lines.forEach(line => {
+      const match = line.match(inlineCommentPattern);
+      if (match) {
+        const lineNum = parseInt(match[1]) + startLine - 1;
+        const comment = match[2].trim();
+
+        review.comments.push({
+          line: lineNum,
+          comment: comment,
+          severity: detectSeverity(comment)
+        });
+
+        // Store in inline comments map
+        if (!codeReview.inlineComments.has(filePath)) {
+          codeReview.inlineComments.set(filePath, new Map());
+        }
+        codeReview.inlineComments.get(filePath).set(lineNum, comment);
+      }
+    });
+
+    review.summary = reviewText;
+    codeReview.reviewHistory.push(review);
+
+    // Keep review history bounded
+    if (codeReview.reviewHistory.length > 10) {
+      codeReview.reviewHistory.shift();
+    }
+
+    return review;
+  } catch (e) {
+    log(`Code review failed: ${e.message}`);
+    return null;
+  }
+}
+
+// Detect severity of comment (error, warning, info)
+function detectSeverity(comment) {
+  const lowerComment = comment.toLowerCase();
+  if (lowerComment.includes('error') || lowerComment.includes('bug') ||
+      lowerComment.includes('critical') || lowerComment.includes('security')) {
+    return 'error';
+  } else if (lowerComment.includes('warning') || lowerComment.includes('potential') ||
+             lowerComment.includes('consider') || lowerComment.includes('performance')) {
+    return 'warning';
+  }
+  return 'info';
+}
+
+// Format and display code review results
+function displayCodeReview(review) {
+  if (!review) return;
+
+  console.log(`\n  ${C.cyan}━━━ Code Review (${review.id}) ━━━${C.reset}`);
+  console.log(`  ${C.dim}File: ${review.filePath}${C.reset}`);
+
+  // Display inline comments
+  if (review.comments.length > 0) {
+    console.log(`\n  ${C.bold}Inline Comments:${C.reset}`);
+    review.comments.forEach(comment => {
+      const icon = comment.severity === 'error' ? '❌' :
+                   comment.severity === 'warning' ? '⚠️' : '💡';
+      console.log(`    ${icon} ${C.dim}Line ${comment.line}:${C.reset} ${comment.comment}`);
+    });
+  }
+
+  // Display summary
+  console.log(`\n  ${C.bold}Review Summary:${C.reset}`);
+  const summaryLines = review.summary.split('\n').slice(0, 10);
+  summaryLines.forEach(line => {
+    if (line.trim()) console.log(`    ${line}`);
+  });
+
+  console.log(`\n  ${C.dim}Review saved. Use /reviews to see history.${C.reset}\n`);
+}
+
+// Extract code from Claude's output for review
+function extractCodeFromOutput(output) {
+  const codeBlocks = [];
+  const codeBlockPattern = /```(\w+)?\n([\s\S]*?)```/g;
+  let match;
+
+  while ((match = codeBlockPattern.exec(output)) !== null) {
+    codeBlocks.push({
+      language: match[1] || 'unknown',
+      code: match[2].trim()
+    });
+  }
+
+  return codeBlocks;
 }
 
 // ═══════════════════════════════════════════════════════════════
@@ -188,6 +451,66 @@ const C = {
   white: '\x1b[37m',
 };
 
+// ─── LOADING SPINNER ───
+class LoadingSpinner {
+  constructor() {
+    this.frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    this.interval = null;
+    this.frameIndex = 0;
+    this.message = '';
+    this.active = false;
+    this.startTime = null;
+  }
+
+  start(message = 'Processing') {
+    if (this.active) return;
+
+    this.active = true;
+    this.message = message;
+    this.frameIndex = 0;
+    this.startTime = Date.now();
+
+    // Clear line first
+    process.stdout.write('\r' + ' '.repeat(80) + '\r');
+
+    // Only update spinner if output is visible (not in verbose mode)
+    this.interval = setInterval(() => {
+      if (!this.active || verbose) {
+        // Stop updating if verbose mode is on
+        return;
+      }
+
+      const elapsed = Math.round((Date.now() - this.startTime) / 1000);
+      const frame = this.frames[this.frameIndex];
+      const timeStr = elapsed > 0 ? ` (${elapsed}s)` : '';
+
+      process.stdout.write(`\r  ${C.blue}${frame} ${this.message}...${timeStr}${C.reset}${''.padEnd(30)}`);
+
+      this.frameIndex = (this.frameIndex + 1) % this.frames.length;
+    }, 80);
+  }
+
+  update(message) {
+    this.message = message;
+  }
+
+  stop(clearLine = true) {
+    if (!this.active) return;
+
+    this.active = false;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+
+    if (clearLine) {
+      process.stdout.write('\r' + ' '.repeat(80) + '\r');
+    }
+  }
+}
+
+const spinner = new LoadingSpinner();
+
 function printHeader() {
   console.log('');
   console.log(`${C.cyan}╔══════════════════════════════════════════════════════════════╗${C.reset}`);
@@ -202,7 +525,9 @@ function printHeader() {
   console.log(`  ${C.dim}Log:${C.reset}      ${path.basename(logFile)}`);
   console.log('');
   console.log(`  ${C.dim}Talk to Knoxis naturally. He dispatches to Claude when needed.${C.reset}`);
-  console.log(`  ${C.dim}Commands: /status  /verbose  /diff  /log  /exit${C.reset}`);
+  console.log(`  ${C.dim}Commands: /status  /verbose  /diff  /log  /ai  /feedback  /review  /exit${C.reset}`);
+  console.log(`  ${C.dim}Quick feedback: 👍 or +1 (good), 👎 or -1 (needs improvement)${C.reset}`);
+  console.log(`  ${C.dim}Code review: /review [file] or /autoreview to toggle${C.reset}`);
   console.log('');
 }
 
@@ -228,13 +553,15 @@ function printClaudeLine(text) {
 }
 
 function printClaudeStatus(status) {
-  if (!verbose) {
+  // Deprecated - using spinner instead
+  if (!verbose && !spinner.active) {
     process.stdout.write(`\r  ${C.blue}  ⟳ Claude: ${status}${C.reset}${''.padEnd(20)}`);
   }
 }
 
 function clearClaudeStatus() {
-  if (!verbose) {
+  // Deprecated - using spinner instead
+  if (!verbose && !spinner.active) {
     process.stdout.write('\r' + ' '.repeat(80) + '\r');
   }
 }
@@ -262,11 +589,326 @@ function loadInitialTask() {
 }
 
 // ═══════════════════════════════════════════════════════════════
-//  DETECT PROJECT CONTEXT (lightweight)
+//  AI DECISION-MAKING LAYER
+// ═══════════════════════════════════════════════════════════════
+
+class AIDecisionEngine {
+  constructor() {
+    this.contextWindow = 10; // Number of recent interactions to consider
+    this.patternLibrary = {
+      'refactoring': ['refactor', 'clean', 'optimize', 'improve', 'restructure'],
+      'bugfix': ['fix', 'bug', 'error', 'issue', 'problem', 'broken'],
+      'feature': ['add', 'implement', 'create', 'build', 'new feature'],
+      'testing': ['test', 'spec', 'coverage', 'unit test', 'integration'],
+      'documentation': ['document', 'readme', 'docs', 'comment', 'explain'],
+      'performance': ['slow', 'performance', 'optimize', 'speed', 'latency'],
+      'security': ['security', 'vulnerability', 'auth', 'encryption', 'secure']
+    };
+  }
+
+  analyzeIntent(userInput) {
+    const input = userInput.toLowerCase();
+    const detectedPatterns = [];
+
+    for (const [pattern, keywords] of Object.entries(this.patternLibrary)) {
+      if (keywords.some(keyword => input.includes(keyword))) {
+        detectedPatterns.push(pattern);
+      }
+    }
+
+    const baseConfidence = detectedPatterns.length > 0 ? 0.8 + (detectedPatterns.length * 0.05) : 0.3;
+    const adjustedConfidence = this.getAdjustedConfidence(baseConfidence, detectedPatterns);
+
+    return {
+      patterns: detectedPatterns,
+      priority: this.calculatePriority(detectedPatterns),
+      confidence: adjustedConfidence,
+      baseConfidence: baseConfidence
+    };
+  }
+
+  calculatePriority(patterns) {
+    const priorityMap = {
+      'security': 'critical',
+      'bugfix': 'high',
+      'performance': 'high',
+      'feature': 'medium',
+      'refactoring': 'medium',
+      'testing': 'low',
+      'documentation': 'low'
+    };
+
+    for (const pattern of ['security', 'bugfix', 'performance', 'feature', 'refactoring', 'testing', 'documentation']) {
+      if (patterns.includes(pattern)) return priorityMap[pattern];
+    }
+    return 'medium';
+  }
+
+  analyzeComplexity(task, projectContext) {
+    let complexity = 1; // Base complexity
+
+    // Factor in task characteristics
+    if (task.length > 200) complexity += 0.5;
+    if (task.includes('multiple') || task.includes('several')) complexity += 1;
+    if (task.includes('architecture') || task.includes('design')) complexity += 1.5;
+    if (task.includes('simple') || task.includes('quick')) complexity -= 0.5;
+
+    // Factor in project size (if detectable)
+    if (projectContext.includes('large') || projectContext.includes('enterprise')) complexity += 1;
+
+    // Factor in detected patterns
+    const patterns = this.analyzeIntent(task).patterns;
+    if (patterns.includes('refactoring')) complexity += 1;
+    if (patterns.includes('security')) complexity += 1.5;
+    if (patterns.length > 2) complexity += 0.5 * patterns.length;
+
+    // Normalize to categories
+    if (complexity < 1.5) return 'simple';
+    if (complexity < 3) return 'medium';
+    if (complexity < 5) return 'complex';
+    return 'very_complex';
+  }
+
+  generateContextualInsights(userInput, conversationHistory, projectContext) {
+    const intent = this.analyzeIntent(userInput);
+    const complexity = this.analyzeComplexity(userInput, projectContext);
+
+    const insights = {
+      intent: intent,
+      complexity: complexity,
+      recommendations: [],
+      warnings: [],
+      contextEnhancements: []
+    };
+
+    // Generate recommendations based on patterns
+    if (intent.patterns.includes('bugfix')) {
+      insights.recommendations.push('Consider adding tests to prevent regression');
+      insights.contextEnhancements.push('Include error logs and stack traces if available');
+    }
+
+    if (intent.patterns.includes('feature')) {
+      insights.recommendations.push('Break down into smaller, testable components');
+      insights.contextEnhancements.push('Consider edge cases and error handling');
+    }
+
+    if (intent.patterns.includes('performance')) {
+      insights.recommendations.push('Profile before optimizing');
+      insights.contextEnhancements.push('Include current performance metrics');
+    }
+
+    if (intent.patterns.includes('security')) {
+      insights.warnings.push('Security changes require careful review');
+      insights.recommendations.push('Follow OWASP guidelines');
+      insights.contextEnhancements.push('Consider threat modeling');
+    }
+
+    // Add complexity-based insights
+    if (complexity === 'very_complex') {
+      insights.warnings.push('This task appears complex - consider breaking it down');
+      insights.recommendations.push('Start with a design document or architecture diagram');
+    }
+
+    if (complexity === 'simple') {
+      insights.recommendations.push('This looks straightforward - should be quick to implement');
+    }
+
+    // Historical pattern analysis
+    if (conversationHistory.length > 5) {
+      const recentTopics = this.analyzeRecentTopics(conversationHistory);
+      if (recentTopics.length > 0) {
+        insights.contextEnhancements.push(`Recent focus areas: ${recentTopics.join(', ')}`);
+      }
+    }
+
+    return insights;
+  }
+
+  analyzeRecentTopics(history) {
+    const recentMessages = history.slice(-5);
+    const topics = new Set();
+
+    recentMessages.forEach(msg => {
+      if (msg.role === 'user') {
+        const intent = this.analyzeIntent(msg.content);
+        intent.patterns.forEach(p => topics.add(p));
+      }
+    });
+
+    return Array.from(topics);
+  }
+
+  enrichClaudePrompt(originalPrompt, insights, projectContext) {
+    let enrichedPrompt = originalPrompt;
+
+    // Add context header
+    const contextHeader = `[AI CONTEXT ANALYSIS]
+Intent: ${insights.intent.patterns.join(', ') || 'general'}
+Priority: ${insights.intent.priority}
+Complexity: ${insights.complexity}
+Confidence: ${(insights.intent.confidence * 100).toFixed(0)}%\n\n`;
+
+    // Add recommendations if any
+    if (insights.recommendations.length > 0) {
+      enrichedPrompt = contextHeader +
+        `[RECOMMENDATIONS]\n${insights.recommendations.map(r => `- ${r}`).join('\n')}\n\n` +
+        originalPrompt;
+    } else {
+      enrichedPrompt = contextHeader + originalPrompt;
+    }
+
+    // Add warnings if any
+    if (insights.warnings.length > 0) {
+      enrichedPrompt += `\n\n[IMPORTANT WARNINGS]\n${insights.warnings.map(w => `⚠️ ${w}`).join('\n')}`;
+    }
+
+    // Add context enhancements
+    if (insights.contextEnhancements.length > 0) {
+      enrichedPrompt += `\n\n[ADDITIONAL CONTEXT]\n${insights.contextEnhancements.map(c => `- ${c}`).join('\n')}`;
+    }
+
+    return enrichedPrompt;
+  }
+
+  recordDecision(userInput, decision, outcome) {
+    const MAX_DECISION_HISTORY = 20;
+
+    aiInsights.decisionHistory.push({
+      timestamp: new Date().toISOString(),
+      input: userInput.slice(0, 100),
+      decision: decision,
+      outcome: outcome
+    });
+
+    // Keep only last N decisions for memory management
+    if (aiInsights.decisionHistory.length > MAX_DECISION_HISTORY) {
+      aiInsights.decisionHistory.shift();
+    }
+  }
+
+  suggestNextSteps(claudeOutput, originalTask) {
+    const suggestions = [];
+    const outputLower = claudeOutput.toLowerCase();
+
+    // Analyze what was done
+    if (outputLower.includes('created') || outputLower.includes('added')) {
+      suggestions.push('Test the new functionality');
+      suggestions.push('Review the generated code for edge cases');
+    }
+
+    if (outputLower.includes('fixed') || outputLower.includes('resolved')) {
+      suggestions.push('Verify the fix works as expected');
+      suggestions.push('Add a test to prevent regression');
+    }
+
+    if (outputLower.includes('refactored') || outputLower.includes('improved')) {
+      suggestions.push('Run existing tests to ensure nothing broke');
+      suggestions.push('Check performance impact');
+    }
+
+    if (outputLower.includes('error') || outputLower.includes('failed')) {
+      suggestions.push('Review error messages for root cause');
+      suggestions.push('Check logs for additional context');
+    }
+
+    // Apply learned weights from feedback
+    const weightedSuggestions = this.applyFeedbackWeights(
+      suggestions.length > 0 ? suggestions : ['Review the changes', 'Test the implementation']
+    );
+
+    return weightedSuggestions;
+  }
+
+  // Apply learned weights from user feedback
+  applyFeedbackWeights(suggestions) {
+    return suggestions.map(suggestion => {
+      const score = aiInsights.suggestionScores.get(suggestion) || 0;
+      return { text: suggestion, score: score };
+    }).sort((a, b) => b.score - a.score).map(s => s.text);
+  }
+
+  // Process user feedback and update learning
+  processFeedback(feedback) {
+    const { type, rating, text, context, suggestions } = feedback;
+
+    // Record feedback
+    aiInsights.feedbackHistory.push({
+      timestamp: new Date().toISOString(),
+      type: type,
+      rating: rating,
+      text: text || '',
+      context: context,
+      suggestions: suggestions
+    });
+
+    // Update pattern weights based on feedback
+    if (context && context.patterns) {
+      context.patterns.forEach(pattern => {
+        const currentWeight = aiInsights.patternWeights.get(pattern) || 1.0;
+        const adjustment = rating === 'up' ? 0.1 : rating === 'down' ? -0.1 : 0;
+        aiInsights.patternWeights.set(pattern, Math.max(0.1, Math.min(2.0, currentWeight + adjustment)));
+      });
+    }
+
+    // Update suggestion scores
+    if (suggestions) {
+      suggestions.forEach(suggestion => {
+        const currentScore = aiInsights.suggestionScores.get(suggestion) || 0;
+        const scoreAdjustment = rating === 'up' ? 1 : rating === 'down' ? -1 : 0;
+        aiInsights.suggestionScores.set(suggestion, currentScore + scoreAdjustment);
+      });
+    }
+
+    // Keep feedback history bounded for memory management
+    const MAX_FEEDBACK_HISTORY = 100;
+    if (aiInsights.feedbackHistory.length > MAX_FEEDBACK_HISTORY) {
+      // Remove oldest entries
+      aiInsights.feedbackHistory.splice(0, aiInsights.feedbackHistory.length - MAX_FEEDBACK_HISTORY);
+    }
+
+    // Save feedback data after processing
+    saveFeedbackData(); // Fire and forget for performance
+
+    return {
+      processed: true,
+      message: this.generateFeedbackResponse(rating, text)
+    };
+  }
+
+  // Generate response based on feedback
+  generateFeedbackResponse(rating, text) {
+    if (rating === 'up') {
+      return text ? `Thanks for the positive feedback! Noted: "${text}"` : 'Thanks for the positive feedback!';
+    } else if (rating === 'down') {
+      return text ? `I appreciate the feedback. I'll improve based on: "${text}"` : 'Thanks for the feedback. I\'ll work on improving.';
+    } else if (text) {
+      return `Feedback noted: "${text}"`;
+    }
+    return 'Feedback recorded. Thank you!';
+  }
+
+  // Get feedback-adjusted confidence
+  getAdjustedConfidence(baseConfidence, patterns) {
+    let adjustedConfidence = baseConfidence;
+
+    patterns.forEach(pattern => {
+      const weight = aiInsights.patternWeights.get(pattern) || 1.0;
+      adjustedConfidence *= weight;
+    });
+
+    return Math.max(0.1, Math.min(1.0, adjustedConfidence));
+  }
+}
+
+const aiEngine = new AIDecisionEngine();
+
+// ═══════════════════════════════════════════════════════════════
+//  DETECT PROJECT CONTEXT (enhanced with AI analysis)
 // ═══════════════════════════════════════════════════════════════
 
 function detectProject() {
   const info = [];
+  let techStack = [];
 
   try {
     const pkgPath = path.join(WORKSPACE, 'package.json');
@@ -274,34 +916,72 @@ function detectProject() {
       const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
       info.push(`Node.js project: ${pkg.name || 'unknown'}`);
       if (pkg.description) info.push(pkg.description);
+
+      // Analyze dependencies for AI insights
+      if (pkg.dependencies) {
+        if (pkg.dependencies['react']) techStack.push('React');
+        if (pkg.dependencies['vue']) techStack.push('Vue');
+        if (pkg.dependencies['express']) techStack.push('Express');
+        if (pkg.dependencies['next']) techStack.push('Next.js');
+        aiInsights.projectType = 'nodejs';
+      }
     }
   } catch (e) {}
 
   try {
     const pomPath = path.join(WORKSPACE, 'pom.xml');
-    if (fs.existsSync(pomPath)) info.push('Java/Maven project (pom.xml)');
+    if (fs.existsSync(pomPath)) {
+      info.push('Java/Maven project (pom.xml)');
+      techStack.push('Java', 'Maven');
+      aiInsights.projectType = 'java-maven';
+    }
   } catch (e) {}
 
   try {
     const gradlePath = path.join(WORKSPACE, 'build.gradle');
-    if (fs.existsSync(gradlePath)) info.push('Java/Gradle project');
+    if (fs.existsSync(gradlePath)) {
+      info.push('Java/Gradle project');
+      techStack.push('Java', 'Gradle');
+      aiInsights.projectType = 'java-gradle';
+    }
   } catch (e) {}
 
   try {
     const nextPath = path.join(WORKSPACE, 'next.config.js');
     const nextPath2 = path.join(WORKSPACE, 'next.config.mjs');
-    if (fs.existsSync(nextPath) || fs.existsSync(nextPath2)) info.push('Next.js app');
+    if (fs.existsSync(nextPath) || fs.existsSync(nextPath2)) {
+      info.push('Next.js app');
+      techStack.push('Next.js');
+    }
   } catch (e) {}
 
-  // Git branch
+  // Git branch - use cached value or async check
   try {
-    const result = spawnSync('git', ['branch', '--show-current'], { cwd: WORKSPACE, stdio: 'pipe' });
-    if (result.status === 0) {
-      const branch = result.stdout.toString().trim();
-      if (branch) info.push(`Git branch: ${branch}`);
+    // For initial detection, still use sync but add caching
+    if (!aiInsights.contextCache.has('gitBranch')) {
+      const result = spawnSync('git', ['branch', '--show-current'], {
+        cwd: WORKSPACE,
+        stdio: 'pipe',
+        shell: false // Prevent shell injection
+      });
+      if (result.status === 0) {
+        const branch = result.stdout.toString().trim();
+        if (branch) {
+          aiInsights.contextCache.set('gitBranch', branch);
+          info.push(`Git branch: ${branch}`);
+        }
+      }
+    } else {
+      const cachedBranch = aiInsights.contextCache.get('gitBranch');
+      info.push(`Git branch: ${cachedBranch}`);
     }
   } catch (e) {}
 
+  // Store detected patterns in AI insights
+  if (techStack.length > 0) {
+    aiInsights.patterns = techStack;
+  }
+
   return info.join(' · ');
 }
 
@@ -400,8 +1080,10 @@ function callGroq(messages, projectContext) {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(payload)
-        }
+          'Content-Length': Buffer.byteLength(payload),
+          'Connection': 'keep-alive'
+        },
+        agent: url.protocol === 'https:' ? httpsAgent : httpAgent // Use keep-alive agent
       };
     } else {
       // Direct Groq API call (legacy / developer override)
@@ -412,8 +1094,10 @@ function callGroq(messages, projectContext) {
         headers: {
           'Content-Type': 'application/json',
           'Authorization': `Bearer ${GROQ_API_KEY}`,
-          'Content-Length': Buffer.byteLength(payload)
-        }
+          'Content-Length': Buffer.byteLength(payload),
+          'Connection': 'keep-alive'
+        },
+        agent: httpsAgent // Use keep-alive agent
       };
     }
 
@@ -491,7 +1175,11 @@ function dispatchToClaude(prompt) {
 
     log(`DISPATCH #${claudeDispatches}:\n${prompt}`);
 
-    const proc = spawn(CLAUDE_BIN, args, {
+    // On Windows, spawn with shell requires a single command string to avoid DEP0190
+    const spawnCmd = IS_WIN ? `"${CLAUDE_BIN}" ${args.join(' ')}` : CLAUDE_BIN;
+    const spawnArgs = IS_WIN ? [] : args;
+
+    const proc = spawn(spawnCmd, spawnArgs, {
       cwd: WORKSPACE,
       env: { ...process.env },
       stdio: ['pipe', 'pipe', 'pipe'],
@@ -504,14 +1192,19 @@ function dispatchToClaude(prompt) {
     let outputLines = 0;
     const startTime = Date.now();
 
+    // Start spinner when Claude begins processing
+    if (!verbose) {
+      spinner.start('Claude is processing');
+    }
+
     proc.stdout.on('data', (chunk) => {
       const text = chunk.toString();
       stdout += text;
       outputLines += text.split('\n').filter(l => l.trim()).length;
       printClaudeLine(text);
       if (!verbose) {
-        const elapsed = Math.round((Date.now() - startTime) / 1000);
-        printClaudeStatus(`working... ${outputLines} lines, ${elapsed}s`);
+        // Update spinner with progress info
+        spinner.update(`Claude is processing (${outputLines} lines)`);
       }
     });
 
@@ -525,6 +1218,11 @@ function dispatchToClaude(prompt) {
     proc.on('close', (code) => {
       isClaudeRunning = false;
       activeClaudeProc = null;
+
+      // Stop spinner
+      if (!verbose) {
+        spinner.stop();
+      }
       clearClaudeStatus();
 
       const elapsed = Math.round((Date.now() - startTime) / 1000);
@@ -540,6 +1238,11 @@ function dispatchToClaude(prompt) {
     proc.on('error', (err) => {
       isClaudeRunning = false;
       activeClaudeProc = null;
+
+      // Stop spinner on error
+      if (!verbose) {
+        spinner.stop();
+      }
       clearClaudeStatus();
       reject(err);
     });
@@ -553,21 +1256,35 @@ function dispatchToClaude(prompt) {
 //  CONVERSATION MANAGEMENT
 // ═══════════════════════════════════════════════════════════════
 
-// Keep conversation history bounded. Always keep first 2 messages (greeting context)
-// and last 18 messages. Truncate long assistant messages.
+// Keep conversation history bounded with efficient memory management
+// Always keep first 2 messages (greeting context) and last 18 messages
 function trimHistory() {
   const MAX_MESSAGES = 24;
-  if (conversationHistory.length <= MAX_MESSAGES) return;
+  const MAX_MESSAGE_LENGTH = 5000; // Truncate individual messages too
+
+  if (conversationHistory.length <= MAX_MESSAGES) {
+    // Still truncate long messages even if under message limit
+    conversationHistory.forEach(msg => {
+      if (msg.content && msg.content.length > MAX_MESSAGE_LENGTH) {
+        msg.content = msg.content.substring(0, MAX_MESSAGE_LENGTH) + '... [truncated]';
+      }
+    });
+    return;
+  }
 
   const keep = 2; // greeting exchange
-  const tail = MAX_MESSAGES - keep;
-  const trimmed = [
-    ...conversationHistory.slice(0, keep),
-    { role: 'user', content: '[Earlier conversation trimmed for context. See dispatch summaries in system prompt for work done.]' },
-    ...conversationHistory.slice(-tail)
-  ];
-  conversationHistory.length = 0;
-  conversationHistory.push(...trimmed);
+  const tail = MAX_MESSAGES - keep - 1; // -1 for the trim notice
+
+  // Use splice for efficient in-place modification
+  const trimNotice = { role: 'user', content: '[Earlier conversation trimmed for context. See dispatch summaries in system prompt for work done.]' };
+  conversationHistory.splice(keep, conversationHistory.length - keep - tail, trimNotice);
+
+  // Truncate long messages
+  conversationHistory.forEach(msg => {
+    if (msg.content && msg.content.length > MAX_MESSAGE_LENGTH) {
+      msg.content = msg.content.substring(0, MAX_MESSAGE_LENGTH) + '... [truncated]';
+    }
+  });
 }
 
 // Truncate Claude output for Groq review (Groq doesn't need the full thing)
@@ -584,10 +1301,15 @@ function truncateForReview(output, maxChars) {
 //  COMMAND HANDLERS
 // ═══════════════════════════════════════════════════════════════
 
-function handleCommand(input) {
+async function handleCommand(input) {
   const cmd = input.toLowerCase().trim();
 
   if (cmd === '/exit' || cmd === '/quit' || cmd === '/q') {
+    // Save feedback data before exit
+    if (aiInsights.feedbackHistory.length > 0) {
+      saveFeedbackData(); // Fire and forget on exit
+      console.log(`  ${C.green}✓ AI learning saved${C.reset}`);
+    }
     log('SESSION END (user exit)');
     console.log(`\n  ${C.dim}Session ended. ${claudeDispatches} dispatches to Claude.${C.reset}`);
     console.log(`  ${C.dim}Log: ${logFile}${C.reset}\n`);
@@ -618,18 +1340,37 @@ function handleCommand(input) {
 
   if (cmd === '/diff') {
     try {
-      const result = spawnSync('git', ['diff', '--stat'], { cwd: WORKSPACE, stdio: 'pipe' });
-      const output = result.stdout.toString().trim();
-      if (output) {
-        console.log(`\n  ${C.dim}Git changes in workspace:${C.reset}`);
-        output.split('\n').forEach(line => console.log(`  ${C.dim}  ${line}${C.reset}`));
-      } else {
-        console.log(`\n  ${C.dim}No uncommitted changes.${C.reset}`);
-      }
+      // Use spawn instead of spawnSync for better performance
+      const { spawn } = require('child_process');
+      const gitDiff = spawn('git', ['diff', '--stat'], {
+        cwd: WORKSPACE,
+        stdio: 'pipe',
+        shell: false // Prevent shell injection
+      });
+
+      let output = '';
+      gitDiff.stdout.on('data', (data) => {
+        output += data.toString();
+      });
+
+      gitDiff.on('close', (code) => {
+        if (code === 0 && output.trim()) {
+          console.log(`\n  ${C.dim}Git changes in workspace:${C.reset}`);
+          output.trim().split('\n').forEach(line => console.log(`  ${C.dim}  ${line}${C.reset}`));
+        } else {
+          console.log(`\n  ${C.dim}No uncommitted changes.${C.reset}`);
+        }
+        console.log('');
+      });
+
+      gitDiff.on('error', () => {
+        console.log(`\n  ${C.dim}Not a git repository or git not available.${C.reset}`);
+        console.log('');
+      });
     } catch (e) {
-      console.log(`\n  ${C.dim}Not a git repository or git not available.${C.reset}`);
+      console.log(`\n  ${C.dim}Error running git diff.${C.reset}`);
+      console.log('');
     }
-    console.log('');
     return true;
   }
 
@@ -638,6 +1379,147 @@ function handleCommand(input) {
     return true;
   }
 
+  if (cmd === '/ai') {
+    console.log(`\n  ${C.cyan}${C.bold}AI Decision Layer Status${C.reset}`);
+    console.log(`  ${C.dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}\n`);
+    console.log(`  ${C.dim}Project Type:${C.reset}     ${aiInsights.projectType || 'Not detected'}`);
+    console.log(`  ${C.dim}Tech Stack:${C.reset}       ${aiInsights.patterns.length > 0 ? aiInsights.patterns.join(', ') : 'Not detected'}`);
+    console.log(`  ${C.dim}Complexity:${C.reset}       ${aiInsights.complexity}`);
+    console.log(`  ${C.dim}Context Cache:${C.reset}    ${aiInsights.contextCache.size} items`);
+    console.log(`  ${C.dim}Decision History:${C.reset} ${aiInsights.decisionHistory.length} decisions`);
+    console.log(`  ${C.dim}Feedback Count:${C.reset}   ${aiInsights.feedbackHistory.length} items`);
+
+    // Show pattern weights if any have been adjusted
+    const adjustedPatterns = Array.from(aiInsights.patternWeights.entries())
+      .filter(([_, weight]) => weight !== 1.0);
+    if (adjustedPatterns.length > 0) {
+      console.log(`\n  ${C.dim}Learned Pattern Weights:${C.reset}`);
+      adjustedPatterns.forEach(([pattern, weight]) => {
+        const indicator = weight > 1.0 ? '↑' : '↓';
+        console.log(`    ${pattern}: ${weight.toFixed(2)} ${indicator}`);
+      });
+    }
+
+    if (aiInsights.decisionHistory.length > 0) {
+      console.log(`\n  ${C.dim}Recent Decisions:${C.reset}`);
+      aiInsights.decisionHistory.slice(-3).forEach((decision, i) => {
+        const time = new Date(decision.timestamp).toLocaleTimeString();
+        console.log(`    ${i + 1}. ${time} - ${decision.decision} (${decision.input.slice(0, 30)}...)`);
+      });
+    }
+
+    if (conversationHistory.length > 2) {
+      const recentInput = conversationHistory.filter(m => m.role === 'user').slice(-1)[0];
+      if (recentInput) {
+        const quickInsights = aiEngine.analyzeIntent(recentInput.content);
+        if (quickInsights.patterns.length > 0) {
+          console.log(`\n  ${C.dim}Last Intent Analysis:${C.reset}`);
+          console.log(`    Patterns: ${quickInsights.patterns.join(', ')}`);
+          console.log(`    Priority: ${quickInsights.priority}`);
+          console.log(`    Confidence: ${(quickInsights.confidence * 100).toFixed(0)}%`);
+          if (quickInsights.baseConfidence !== quickInsights.confidence) {
+            console.log(`    Adjusted from: ${(quickInsights.baseConfidence * 100).toFixed(0)}% (feedback-based)`);
+          }
+        }
+      }
+    }
+    console.log('');
+    return true;
+  }
+
+  if (cmd === '/feedback' || cmd === '/fb') {
+    console.log(`\n  ${C.cyan}${C.bold}Feedback System${C.reset}`);
+    console.log(`  ${C.dim}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}\n`);
+
+    if (feedbackState.lastSuggestions.length > 0) {
+      console.log(`  ${C.dim}Last suggestions:${C.reset}`);
+      feedbackState.lastSuggestions.forEach((sugg, i) => {
+        console.log(`    ${i + 1}. ${sugg}`);
+      });
+      console.log(`\n  ${C.green}Rate with: +1 (good) or -1 (needs improvement)${C.reset}`);
+      console.log(`  ${C.green}Or provide detailed feedback: /feedback "your text here"${C.reset}`);
+      feedbackState.awaitingRating = true;
+    } else {
+      console.log(`  ${C.dim}No recent suggestions to rate.${C.reset}`);
+    }
+
+    if (aiInsights.feedbackHistory.length > 0) {
+      console.log(`\n  ${C.dim}Recent feedback:${C.reset}`);
+      aiInsights.feedbackHistory.slice(-3).forEach((fb, i) => {
+        const time = new Date(fb.timestamp).toLocaleTimeString();
+        const icon = fb.rating === 'up' ? '👍' : fb.rating === 'down' ? '👎' : '💬';
+        console.log(`    ${time} ${icon} ${fb.text ? fb.text.slice(0, 40) + '...' : ''}`);
+      });
+    }
+
+    console.log('');
+    return true;
+  }
+
+  // Code review commands
+  if (cmd === '/review') {
+    const args = input.split(' ').slice(1);
+
+    if (args.length === 0) {
+      // Review last Claude output if available
+      if (dispatchSummaries.length > 0) {
+        const lastOutput = dispatchSummaries[dispatchSummaries.length - 1];
+        const codeBlocks = extractCodeFromOutput(lastOutput);
+
+        if (codeBlocks.length > 0) {
+          console.log(`\n  ${C.cyan}Reviewing code from last Claude output...${C.reset}\n`);
+          for (const block of codeBlocks) {
+            const review = await reviewCode(block.code, `<inline-${block.language}>`, 1);
+            displayCodeReview(review);
+          }
+        } else {
+          console.log(`  ${C.yellow}No code found in last output. Use: /review [file]${C.reset}\n`);
+        }
+      } else {
+        console.log(`  ${C.yellow}No recent output to review. Use: /review [file]${C.reset}\n`);
+      }
+    } else {
+      // Review specific file
+      const filePath = path.resolve(WORKSPACE, args[0]);
+      try {
+        const fileContent = await fsPromises.readFile(filePath, 'utf8');
+        console.log(`\n  ${C.cyan}Reviewing ${path.basename(filePath)}...${C.reset}\n`);
+        const review = await reviewCode(fileContent, filePath, 1);
+        displayCodeReview(review);
+      } catch (e) {
+        console.log(`  ${C.red}Error reading file: ${e.message}${C.reset}\n`);
+      }
+    }
+    return true;
+  }
+
+  if (cmd === '/autoreview') {
+    codeReview.autoReviewEnabled = !codeReview.autoReviewEnabled;
+    const status = codeReview.autoReviewEnabled ? 'ENABLED' : 'DISABLED';
+    console.log(`\n  ${C.green}Auto-review ${status}${C.reset}`);
+    console.log(`  ${C.dim}Code will ${codeReview.autoReviewEnabled ? '' : 'not '}be automatically reviewed after Claude outputs.${C.reset}\n`);
+    return true;
+  }
+
+  if (cmd === '/reviews') {
+    if (codeReview.reviewHistory.length === 0) {
+      console.log(`\n  ${C.dim}No code reviews yet.${C.reset}\n`);
+    } else {
+      console.log(`\n  ${C.cyan}━━━ Code Review History ━━━${C.reset}`);
+      codeReview.reviewHistory.slice(-5).forEach(review => {
+        const time = new Date(review.timestamp).toLocaleTimeString();
+        const commentCount = review.comments.length;
+        const errorCount = review.comments.filter(c => c.severity === 'error').length;
+        const warningCount = review.comments.filter(c => c.severity === 'warning').length;
+
+        console.log(`  ${C.dim}${time}${C.reset} [${review.id}] ${review.filePath}`);
+        console.log(`    ${errorCount} errors, ${warningCount} warnings, ${commentCount} total comments`);
+      });
+      console.log('');
+    }
+    return true;
+  }
+
   return false;
 }
 
@@ -646,14 +1528,77 @@ function handleCommand(input) {
 // ═══════════════════════════════════════════════════════════════
 
 let projectContext = '';
+let inputDebounceTimer = null;
+const INPUT_DEBOUNCE_MS = 100;
+
+// Debounced input handler
+function debouncedHandleUserInput(input, rl) {
+  if (inputDebounceTimer) {
+    clearTimeout(inputDebounceTimer);
+  }
+
+  inputDebounceTimer = setTimeout(() => {
+    inputDebounceTimer = null;
+    handleUserInput(input, rl);
+  }, INPUT_DEBOUNCE_MS);
+}
 
 async function handleUserInput(input, rl) {
   const trimmed = input.trim();
   if (!trimmed) return;
 
+  // Handle quick feedback (thumbs up/down, +1/-1)
+  if (trimmed === '👍' || trimmed === '+1' || trimmed === '++' ||
+      trimmed === '👎' || trimmed === '-1' || trimmed === '--') {
+
+    const rating = (trimmed === '👍' || trimmed === '+1' || trimmed === '++') ? 'up' : 'down';
+
+    if (feedbackState.lastSuggestions.length > 0) {
+      const feedback = {
+        type: 'quick',
+        rating: rating,
+        text: null,
+        context: feedbackState.pendingFeedback,
+        suggestions: feedbackState.lastSuggestions
+      };
+
+      const result = aiEngine.processFeedback(feedback);
+      console.log(`\n  ${C.green}${result.message}${C.reset}\n`);
+      log(`FEEDBACK: ${rating} for suggestions`);
+
+      // Clear feedback state
+      feedbackState.awaitingRating = false;
+      feedbackState.feedbackPromptShown = false;
+      return;
+    } else {
+      console.log(`\n  ${C.yellow}No recent suggestions to rate. Use /feedback to see feedback options.${C.reset}\n`);
+      return;
+    }
+  }
+
+  // Handle detailed feedback with text
+  if (trimmed.startsWith('/feedback "') || trimmed.startsWith('/fb "')) {
+    const match = trimmed.match(/^\/(?:feedback|fb)\s+"([^"]+)"/);
+    if (match) {
+      const feedbackText = match[1];
+      const feedback = {
+        type: 'detailed',
+        rating: null,
+        text: feedbackText,
+        context: feedbackState.pendingFeedback,
+        suggestions: feedbackState.lastSuggestions
+      };
+
+      const result = aiEngine.processFeedback(feedback);
+      console.log(`\n  ${C.green}${result.message}${C.reset}\n`);
+      log(`FEEDBACK: "${feedbackText}"`);
+      return;
+    }
+  }
+
   // Handle slash commands
   if (trimmed.startsWith('/')) {
-    if (handleCommand(trimmed)) return;
+    if (await handleCommand(trimmed)) return;
     // Unknown command — pass through to Knoxis
   }
 
@@ -670,27 +1615,71 @@ async function handleUserInput(input, rl) {
   try {
     // Send to Knoxis (Groq)
     trimHistory();
+
+    // Show spinner while Knoxis is thinking
+    spinner.start('Knoxis is thinking');
     const response = await callGroq(conversationHistory, projectContext);
+    spinner.stop();
 
     if (response.action === 'dispatch' && response.claudePrompt) {
       // ─── DISPATCH TO CLAUDE ───
       printKnoxis(response.message);
       log(`KNOXIS (dispatch): ${response.message}`);
 
+      // ─── AI DECISION LAYER: Analyze and Enrich ───
+      const insights = aiEngine.generateContextualInsights(trimmed, conversationHistory, projectContext);
+
+      // Show AI insights if verbose mode
+      if (verbose && (insights.recommendations.length > 0 || insights.warnings.length > 0)) {
+        console.log(`\n  ${C.cyan}AI Insights:${C.reset}`);
+        if (insights.intent.patterns.length > 0) {
+          console.log(`  ${C.dim}  Intent: ${insights.intent.patterns.join(', ')} (${insights.intent.priority} priority)${C.reset}`);
+        }
+        console.log(`  ${C.dim}  Complexity: ${insights.complexity}${C.reset}`);
+        if (insights.recommendations.length > 0) {
+          console.log(`  ${C.dim}  Recommendations:${C.reset}`);
+          insights.recommendations.forEach(r => console.log(`  ${C.dim}    • ${r}${C.reset}`));
+        }
+        if (insights.warnings.length > 0) {
+          console.log(`  ${C.yellow}  Warnings:${C.reset}`);
+          insights.warnings.forEach(w => console.log(`  ${C.yellow}    ⚠ ${w}${C.reset}`));
+        }
+        console.log('');
+      }
+
+      // Enrich Claude prompt with AI insights
+      const enrichedPrompt = aiEngine.enrichClaudePrompt(response.claudePrompt, insights, projectContext);
+
+      // Record AI decision
+      aiEngine.recordDecision(trimmed, 'dispatch_enriched', insights);
+
       // Record the assistant dispatch decision
       conversationHistory.push({
         role: 'assistant',
-        content: JSON.stringify({ action: 'dispatch', message: response.message })
+        content: JSON.stringify({ action: 'dispatch', message: response.message, aiInsights: insights })
       });
 
       printDivider('Dispatching to Claude Code', C.blue);
-      if (!verbose) printClaudeStatus('starting...');
 
       try {
-        const result = await dispatchToClaude(response.claudePrompt);
+        const result = await dispatchToClaude(enrichedPrompt);
 
         printDivider(`Claude finished (${result.elapsed}s, ${result.lines} lines)`, C.green);
 
+        // Auto-review code if enabled
+        if (codeReview.autoReviewEnabled) {
+          const codeBlocks = extractCodeFromOutput(result.output);
+          if (codeBlocks.length > 0) {
+            console.log(`\n  ${C.cyan}Auto-reviewing code...${C.reset}`);
+            for (const block of codeBlocks) {
+              const review = await reviewCode(block.code, `<${block.language}>`, 1);
+              if (review && review.comments.length > 0) {
+                displayCodeReview(review);
+              }
+            }
+          }
+        }
+
         // Send output to Knoxis for review
         const reviewMessages = [
           ...conversationHistory,
@@ -700,18 +1689,45 @@ async function handleUserInput(input, rl) {
           }
         ];
 
+        spinner.start('Knoxis is reviewing Claude\'s work');
         const review = await callGroq(reviewMessages, projectContext);
+        spinner.stop();
         printKnoxis(review.message);
         log(`KNOXIS (review): ${review.message}`);
 
-        // Track dispatch summary (short version for system prompt context)
+        // ─── AI DECISION LAYER: Suggest Next Steps ───
+        const nextSteps = aiEngine.suggestNextSteps(result.output, trimmed);
+        if (nextSteps.length > 0) {
+          console.log(`\n  ${C.cyan}AI Suggested Next Steps:${C.reset}`);
+          nextSteps.forEach((step, i) => {
+            console.log(`  ${C.dim}  ${i + 1}. ${step}${C.reset}`);
+          });
+
+          // Store suggestions for feedback
+          feedbackState.lastSuggestions = nextSteps;
+          feedbackState.pendingFeedback = insights;
+
+          // Prompt for feedback (but don't be annoying)
+          if (!feedbackState.feedbackPromptShown) {
+            console.log(`\n  ${C.dim}💡 Rate suggestions with +1 (helpful) or -1 (not helpful)${C.reset}`);
+            feedbackState.feedbackPromptShown = true;
+          }
+          console.log('');
+        }
+
+        // Track dispatch summary and full output for code review
         const shortSummary = review.message.split('\n')[0].slice(0, 150);
-        dispatchSummaries.push(shortSummary);
+        dispatchSummaries.push(result.output); // Store full output for review command
+        codeReview.lastReviewedCode = result.output; // Cache for quick access
 
-        // Add review to history
+        // Add review to history with AI suggestions
         conversationHistory.push({
           role: 'assistant',
-          content: JSON.stringify({ action: 'respond', message: review.message })
+          content: JSON.stringify({
+            action: 'respond',
+            message: review.message,
+            aiNextSteps: nextSteps
+          })
         });
 
       } catch (claudeErr) {
@@ -776,12 +1792,20 @@ async function main() {
   // Detect project
   projectContext = detectProject();
 
+  // Load feedback data from previous sessions
+  await loadFeedbackData();
+
   // Print header
   printHeader();
   if (projectContext) {
     console.log(`  ${C.dim}${projectContext}${C.reset}\n`);
   }
 
+  // Show if we have learned patterns
+  if (aiInsights.patternWeights.size > 0 || aiInsights.suggestionScores.size > 0) {
+    console.log(`  ${C.green}✓ Loaded AI learning from ${aiInsights.feedbackHistory.length} previous feedback items${C.reset}\n`);
+  }
+
   log(`SESSION START: ${SESSION_ID}`);
   log(`WORKSPACE: ${WORKSPACE}`);
   log(`PROJECT: ${projectContext}`);
@@ -795,6 +1819,9 @@ async function main() {
 
   // Handle Ctrl+C — kill Claude if running, otherwise exit
   process.on('SIGINT', () => {
+    // Stop any active spinner
+    spinner.stop();
+
     if (isClaudeRunning && activeClaudeProc) {
       console.log(`\n\n  ${C.yellow}Cancelling Claude...${C.reset}\n`);
       try { activeClaudeProc.kill('SIGTERM'); } catch (e) {}
@@ -802,6 +1829,10 @@ async function main() {
         try { if (activeClaudeProc) activeClaudeProc.kill('SIGKILL'); } catch (e) {}
       }, 3000);
     } else {
+      // Save feedback data before exit
+      if (aiInsights.feedbackHistory.length > 0) {
+        saveFeedbackData(); // Fire and forget on exit
+      }
       log('SESSION END (Ctrl+C)');
       console.log(`\n\n  ${C.dim}Session ended. ${claudeDispatches} dispatches to Claude.${C.reset}`);
       console.log(`  ${C.dim}Log: ${logFile}${C.reset}\n`);
@@ -819,21 +1850,42 @@ async function main() {
       conversationHistory.push({ role: 'user', content: greetingContent });
       log(`INITIAL TASK: ${initialTask}`);
 
+      spinner.start('Initializing session');
       const greeting = await callGroq(conversationHistory, projectContext);
+      spinner.stop();
 
       if (greeting.action === 'dispatch' && greeting.claudePrompt) {
         printKnoxis(greeting.message);
+
+        // AI insights for initial task
+        const insights = aiEngine.generateContextualInsights(initialTask, conversationHistory, projectContext);
+        const enrichedPrompt = aiEngine.enrichClaudePrompt(greeting.claudePrompt, insights, projectContext);
+        aiEngine.recordDecision(initialTask, 'initial_dispatch', insights);
+
         conversationHistory.push({
           role: 'assistant',
-          content: JSON.stringify({ action: 'dispatch', message: greeting.message })
+          content: JSON.stringify({ action: 'dispatch', message: greeting.message, aiInsights: insights })
         });
 
         printDivider('Dispatching to Claude Code', C.blue);
-        if (!verbose) printClaudeStatus('starting...');
 
-        const result = await dispatchToClaude(greeting.claudePrompt);
+        const result = await dispatchToClaude(enrichedPrompt);
         printDivider(`Claude finished (${result.elapsed}s, ${result.lines} lines)`, C.green);
 
+        // Auto-review code if enabled
+        if (codeReview.autoReviewEnabled) {
+          const codeBlocks = extractCodeFromOutput(result.output);
+          if (codeBlocks.length > 0) {
+            console.log(`\n  ${C.cyan}Auto-reviewing code...${C.reset}`);
+            for (const block of codeBlocks) {
+              const review = await reviewCode(block.code, `<${block.language}>`, 1);
+              if (review && review.comments.length > 0) {
+                displayCodeReview(review);
+              }
+            }
+          }
+        }
+
         const reviewMessages = [
           ...conversationHistory,
           {
@@ -842,9 +1894,12 @@ async function main() {
           }
         ];
 
+        spinner.start('Knoxis is reviewing Claude\'s work');
         const review = await callGroq(reviewMessages, projectContext);
+        spinner.stop();
         printKnoxis(review.message);
-        dispatchSummaries.push(review.message.split('\n')[0].slice(0, 150));
+        dispatchSummaries.push(result.output); // Store full output for review command
+        codeReview.lastReviewedCode = result.output; // Cache for quick access
         conversationHistory.push({
           role: 'assistant',
           content: JSON.stringify({ action: 'respond', message: review.message })
@@ -864,7 +1919,9 @@ async function main() {
         content: `[SYSTEM: Collaborative session started. Workspace: ${WORKSPACE}. Project: ${projectContext || 'unknown'}. Greet the user briefly (1-2 sentences) and ask what they want to work on.]`
       });
 
+      spinner.start('Initializing session');
       const greeting = await callGroq(conversationHistory, projectContext);
+      spinner.stop();
       printKnoxis(greeting.message);
       conversationHistory.push({
         role: 'assistant',