@anh3d0nic/qwen-code-termux-ice 16.0.4 → 16.0.7

package/scripts/ice-v15.js

@@ -0,0 +1,1501 @@
+#!/usr/bin/env node
+/**
+ * ❄️ ICE v15.0.0 - Compounding Intelligence
+ * 
+ * NEW SYSTEMS (v15):
+ * 1. CompoundLearner - cross-session learning, compounds intelligence
+ * 2. ErrorFingerprinter - deduplicates errors, auto-applies known fixes
+ * 3. TrendAnalyzer - tracks quality trends, alerts on decline
+ * 4. TermuxInstaller - auto-installs missing packages
+ * 
+ * PRESERVED (v14 verified):
+ * - ColdStartIntelligence ✅
+ * - PatternPreventer ✅
+ * - QualityBlocker ✅
+ * - SessionSummary ✅
+ * - All other systems ✅
+ * 
+ * PIPELINE:
+ * userInput → ColdStartIntelligence → CompoundLearner → PatternPreventer
+ *           → ErrorFingerprinter → IntentLadder → ConfidenceGating
+ *           → SmartContext → Generate → SelfCritique(7) → CodeQualityGate
+ *           → AutoRunLoop → TermuxInstaller → QualityBlocker → DomainMemory
+ *           → QualityScorer → TrendAnalyzer → SessionSummary → response
+ */
+
+const { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, renameSync } = require('fs');
+const { join } = require('path');
+const { execSync } = require('child_process');
+const { createHash } = require('crypto');
+
+const SESSIONS_DIR = join(process.env.HOME, '.qwen', 'sessions');
+const SESSION_FILE = join(process.env.HOME, '.qwen', 'ice_session.json');
+const CONTEXT_FILE = join(process.env.HOME, '.qwen', 'ice_active_context.json');
+const MEMORY_FILE = join(process.env.HOME, '.qwen', 'session_memory.json');
+const CONFIDENCE_FILE = join(process.env.HOME, '.qwen', 'confidence_history.json');
+const QUALITY_FILE = join(process.env.HOME, '.qwen', 'quality_history.json');
+const SESSION_SUMMARY_FILE = join(process.env.HOME, '.qwen', 'session_summary.json');
+const TREND_FILE = join(process.env.HOME, '.qwen', 'trend_history.json');
+const MANIFEST_FILE = join(process.env.HOME, '.qwen', 'v15_manifest.json');
+
+const TERMUX = {
+  PREFIX: '/data/data/com.termux/files/usr',
+  HOME: '/data/data/com.termux/files/home',
+  NO_SUDO: true,
+  ARM64: true,
+  PKG_MANAGER: 'pkg'
+};
+
+// Package mapping for Termux
+const PACKAGE_MAP = {
+  'python3': 'python',
+  'python': 'python',
+  'node-gyp': 'nodejs',
+  'nodejs': 'nodejs',
+  'sharp': 'libvips',
+  'canvas': 'libpixman',
+  'sqlite3': 'sqlite',
+  'bcrypt': 'openssl',
+  'argon2': 'openssl'
+};
+
+// Session tracking
+let sessionStats = {
+  queries: 0,
+  errorsFixed: 0,
+  patternsLearned: 0,
+  intentCounts: {},
+  sessionId: Date.now()
+};
+
+// ============================================
+// NEW SYSTEM 1 — COMPOUND LEARNER
+// ============================================
+
+class CompoundLearner {
+  constructor() {
+    this.sessionsDir = SESSIONS_DIR;
+    this.ensureSessionsDir();
+    this.pastSessions = this.loadPastSessions();
+    this.compoundStats = this.calculateCompoundStats();
+  }
+
+  ensureSessionsDir() {
+    if (!existsSync(this.sessionsDir)) {
+      mkdirSync(this.sessionsDir, { recursive: true });
+    }
+  }
+
+  archiveCurrentSession() {
+    // Move current session_summary.json to sessions/ with timestamp
+    if (existsSync(SESSION_SUMMARY_FILE)) {
+      try {
+        const summary = JSON.parse(readFileSync(SESSION_SUMMARY_FILE, 'utf-8'));
+        const timestamp = summary.date ? summary.date.replace(/[:.]/g, '-').split('T')[0] : new Date().toISOString().split('T')[0];
+        const sessionNum = this.pastSessions.length + 1;
+        const archiveFile = join(this.sessionsDir, `session_${timestamp}_${sessionNum}.json`);
+        
+        // Add session ID
+        summary.session_id = sessionStats.sessionId;
+        summary.session_number = sessionNum;
+        
+        writeFileSync(archiveFile, JSON.stringify(summary, null, 2));
+      } catch (e) {
+        // Silent fail
+      }
+    }
+  }
+
+  loadPastSessions() {
+    const sessions = [];
+    if (!existsSync(this.sessionsDir)) return sessions;
+    
+    try {
+      const files = readdirSync(this.sessionsDir)
+        .filter(f => f.startsWith('session_') && f.endsWith('.json'))
+        .sort();
+      
+      for (const file of files) {
+        try {
+          const data = JSON.parse(readFileSync(join(this.sessionsDir, file), 'utf-8'));
+          sessions.push(data);
+        } catch (e) {}
+      }
+    } catch (e) {}
+    
+    return sessions;
+  }
+
+  calculateCompoundStats() {
+    const totalSessions = this.pastSessions.length;
+    const lifetimeQueries = this.pastSessions.reduce((sum, s) => sum + (s.total_queries || 0), 0);
+    
+    // Quality trend (last 10 sessions)
+    const qualityTrend = this.pastSessions
+      .slice(-10)
+      .map(s => s.avg_quality || 0);
+    
+    // Most fixed errors
+    const errorCounts = {};
+    this.pastSessions.forEach(s => {
+      if (s.errors_fixed) {
+        errorCounts['errors_fixed'] = (errorCounts['errors_fixed'] || 0) + s.errors_fixed;
+      }
+    });
+    const mostFixedErrors = Object.entries(errorCounts)
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 3)
+      .map(([err, count]) => ({ error: err, count }));
+    
+    // Strongest patterns (from session_memory.json)
+    let strongestPatterns = [];
+    try {
+      if (existsSync(MEMORY_FILE)) {
+        const memory = JSON.parse(readFileSync(MEMORY_FILE, 'utf-8'));
+        strongestPatterns = (memory.user_patterns || []).slice(0, 5);
+      }
+    } catch (e) {}
+    
+    // Improvement rate
+    let improvementRate = 0;
+    if (qualityTrend.length >= 2) {
+      const firstAvg = qualityTrend[0];
+      const latestAvg = qualityTrend[qualityTrend.length - 1];
+      improvementRate = ((latestAvg - firstAvg) / totalSessions).toFixed(2);
+    }
+    
+    return {
+      totalSessions,
+      lifetimeQueries,
+      qualityTrend,
+      mostFixedErrors,
+      strongestPatterns,
+      improvementRate
+    };
+  }
+
+  showSessionHeader() {
+    const sessionNum = this.compoundStats.totalSessions + 1;
+    const lifetimeQueries = this.compoundStats.lifetimeQueries;
+    const trend = this.compoundStats.qualityTrend;
+    const trendDisplay = trend.length >= 2 
+      ? `${trend[0].toFixed(1)}→${trend[trend.length - 1].toFixed(1)}`
+      : 'N/A';
+    const topPattern = this.compoundStats.strongestPatterns[0] || 'none';
+    const trendArrow = trend.length >= 2 && trend[trend.length - 1] > trend[0] ? '↑' : trend.length >= 2 && trend[trend.length - 1] < trend[0] ? '↓' : '→';
+    
+    console.log('\n' + '='.repeat(60));
+    console.log(`❄️  ICE v15.0 — Session ${sessionNum}`);
+    console.log('='.repeat(60));
+    console.log(`📊 Lifetime: ${lifetimeQueries} queries | Quality trend: ${trendArrow} ${trendDisplay}`);
+    console.log(`🧠 Top pattern: ${topPattern}`);
+    if (this.compoundStats.mostFixedErrors.length > 0) {
+      console.log(`⚠️  Most fixed: ${this.compoundStats.mostFixedErrors[0]?.error || 'none'}`);
+    }
+    console.log('='.repeat(60) + '\n');
+  }
+
+  saveSessionSummary(summary) {
+    this.archiveCurrentSession();
+    
+    // Add compound data
+    summary.compound_stats = this.compoundStats;
+    summary.session_id = sessionStats.sessionId;
+    
+    writeFileSync(SESSION_SUMMARY_FILE, JSON.stringify(summary, null, 2));
+    
+    // Reload sessions for next time
+    this.pastSessions = this.loadPastSessions();
+    this.compoundStats = this.calculateCompoundStats();
+  }
+}
+
+// ============================================
+// NEW SYSTEM 2 — ERROR FINGERPRINTER
+// ============================================
+
+class ErrorFingerprinter {
+  constructor(memory) {
+    this.memory = memory;
+    this.fingerprints = this.loadFingerprints();
+  }
+
+  loadFingerprints() {
+    try {
+      if (existsSync(MEMORY_FILE)) {
+        const memory = JSON.parse(readFileSync(MEMORY_FILE, 'utf-8'));
+        return memory.known_errors?.map(e => ({
+          fingerprint: this.hashError(e.error),
+          error: e.error,
+          fix: e.fix,
+          count: e.count || 1,
+          last_seen: e.timestamp
+        })) || [];
+      }
+    } catch (e) {}
+    return [];
+  }
+
+  hashError(errorStr) {
+    // Hash first 50 chars + detect error type
+    const truncated = errorStr.substring(0, 50).toLowerCase();
+    const type = this.detectErrorType(errorStr);
+    return createHash('md5').update(truncated + type).digest('hex').substring(0, 8);
+  }
+
+  detectErrorType(error) {
+    if (error.includes('sudo')) return 'sudo_error';
+    if (error.includes('permission')) return 'permission_error';
+    if (error.includes('not found')) return 'not_found_error';
+    if (error.includes('EACCES')) return 'access_error';
+    if (error.includes('ENOENT')) return 'file_not_found';
+    return 'generic_error';
+  }
+
+  check(query) {
+    const fingerprint = this.hashError(query);
+    const match = this.fingerprints.find(f => f.fingerprint === fingerprint);
+    
+    if (match) {
+      match.count++;
+      match.last_seen = Date.now();
+      console.log(`🔍 ErrorFingerprinter: Known error #${match.count} (seen ${match.count}x). Auto-applying fix...`);
+      return { known: true, fix: match.fix, fingerprint: match.fingerprint };
+    }
+    
+    return { known: false, fingerprint };
+  }
+
+  addError(error, fix) {
+    const fingerprint = this.hashError(error);
+    const existing = this.fingerprints.find(f => f.fingerprint === fingerprint);
+    
+    if (existing) {
+      existing.count++;
+      existing.last_seen = Date.now();
+      existing.fix = fix;
+    } else {
+      this.fingerprints.push({
+        fingerprint,
+        error,
+        fix,
+        count: 1,
+        last_seen: Date.now()
+      });
+    }
+    
+    // Save to memory
+    try {
+      const memory = this.memory.get();
+      memory.known_errors = this.fingerprints.map(f => ({
+        error: f.error,
+        fix: f.fix,
+        count: f.count,
+        timestamp: f.last_seen
+      }));
+      this.memory.save();
+    } catch (e) {}
+  }
+}
+
+// ============================================
+// NEW SYSTEM 3 — TREND ANALYZER
+// ============================================
+
+class TrendAnalyzer {
+  constructor() {
+    this.history = this.loadHistory();
+  }
+
+  loadHistory() {
+    try {
+      if (existsSync(TREND_FILE)) {
+        return JSON.parse(readFileSync(TREND_FILE, 'utf-8'));
+      }
+    } catch (e) {}
+    return { trends: [], alerts: [] };
+  }
+
+  saveHistory() {
+    try {
+      writeFileSync(TREND_FILE, JSON.stringify(this.history, null, 2));
+    } catch (e) {}
+  }
+
+  update(currentScore) {
+    // Add current score
+    this.history.trends.push({
+      score: currentScore,
+      timestamp: Date.now(),
+      session_id: sessionStats.sessionId
+    });
+    
+    // Keep last 100 scores
+    if (this.history.trends.length > 100) {
+      this.history.trends.shift();
+    }
+    
+    // Calculate rolling average (last 5)
+    const last5 = this.history.trends.slice(-5);
+    if (last5.length >= 5) {
+      const currentAvg = last5.reduce((a, b) => a + b.score, 0) / 5;
+      const previous5 = this.history.trends.slice(-10, -5);
+      
+      if (previous5.length >= 5) {
+        const previousAvg = previous5.reduce((a, b) => a + b.score, 0) / 5;
+        
+        // Check trend direction
+        if (currentAvg < previousAvg - 0.5) {
+          // Declining
+          console.log(`\n⚠️  TREND ALERT: Quality declining: ${previousAvg.toFixed(1)}→${currentAvg.toFixed(1)}`);
+          console.log('   Running self-audit...\n');
+          this.history.alerts.push({
+            type: 'declining',
+            from: previousAvg,
+            to: currentAvg,
+            timestamp: Date.now()
+          });
+        } else if (currentAvg > previousAvg + 0.5) {
+          // Improving
+          console.log(`\n📈 Quality improving: ${previousAvg.toFixed(1)}→${currentAvg.toFixed(1)}`);
+        }
+      }
+    }
+    
+    this.saveHistory();
+  }
+
+  getTrend() {
+    if (this.history.trends.length < 5) return 'insufficient_data';
+    const last5 = this.history.trends.slice(-5);
+    const previous5 = this.history.trends.slice(-10, -5);
+    if (previous5.length < 5) return 'insufficient_data';
+    
+    const currentAvg = last5.reduce((a, b) => a + b.score, 0) / 5;
+    const previousAvg = previous5.reduce((a, b) => a + b.score, 0) / 5;
+    
+    if (currentAvg > previousAvg + 0.5) return 'improving';
+    if (currentAvg < previousAvg - 0.5) return 'declining';
+    return 'stable';
+  }
+}
+
+// ============================================
+// NEW SYSTEM 4 — TERMUX INSTALLER
+// ============================================
+
+class TermuxInstaller {
+  constructor() {
+    this.installedPackages = this.detectInstalledPackages();
+  }
+
+  detectInstalledPackages() {
+    const installed = new Set();
+    try {
+      // Check common packages
+      const checks = [
+        { cmd: 'python --version', pkg: 'python' },
+        { cmd: 'node --version', pkg: 'nodejs' },
+        { cmd: 'git --version', pkg: 'git' },
+        { cmd: 'pkg list-installed 2>/dev/null', pkg: null }
+      ];
+      
+      for (const check of checks) {
+        try {
+          const result = execSync(check.cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+          if (check.pkg) installed.add(check.pkg);
+          if (check.cmd.includes('list-installed')) {
+            const lines = result.split('\n');
+            lines.forEach(line => {
+              const pkg = line.split(' ')[0];
+              if (pkg) installed.add(pkg);
+            });
+          }
+        } catch (e) {}
+      }
+    } catch (e) {}
+    return installed;
+  }
+
+  scanForImports(code) {
+    const imports = [];
+    
+    // Python imports
+    const pythonImports = code.match(/^(?:import|from)\s+(\w+)/gm);
+    if (pythonImports) {
+      pythonImports.forEach(imp => {
+        const match = imp.match(/(\w+)/);
+        if (match) imports.push({ lang: 'python', pkg: match[1] });
+      });
+    }
+    
+    // Node.js requires
+    const nodeRequires = code.match(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/g);
+    if (nodeRequires) {
+      nodeRequires.forEach(req => {
+        const match = req.match(/['"]([^'"]+)['"]/);
+        if (match) imports.push({ lang: 'node', pkg: match[1] });
+      });
+    }
+    
+    return imports;
+  }
+
+  getTermuxPackage(pkg) {
+    return PACKAGE_MAP[pkg] || pkg;
+  }
+
+  async ensurePackages(code) {
+    const imports = this.scanForImports(code);
+    const missing = [];
+    
+    for (const imp of imports) {
+      const termuxPkg = this.getTermuxPackage(imp.pkg);
+      if (!this.installedPackages.has(termuxPkg)) {
+        missing.push({ original: imp.pkg, termux: termuxPkg, lang: imp.lang });
+      }
+    }
+    
+    if (missing.length > 0) {
+      console.log('\n📦 TermuxInstaller: Missing packages detected');
+      for (const pkg of missing) {
+        console.log(`   Installing ${pkg.termux} (for ${pkg.original})...`);
+        try {
+          execSync(`pkg install ${pkg.termux} -y`, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 30000
+          });
+          this.installedPackages.add(pkg.termux);
+          console.log(`   ✅ ${pkg.termux} installed`);
+        } catch (e) {
+          console.log(`   ⚠️  Failed to install ${pkg.termux}`);
+        }
+      }
+      console.log();
+    }
+  }
+}
+
+// ============================================
+// EXISTING CLASSES (from v14, preserved)
+// ============================================
+
+class ColdStartIntelligence {
+  constructor() {
+    this.sessionMemory = this.loadJson(MEMORY_FILE, { user_patterns: [], known_errors: [] });
+    this.qualityHistory = this.loadJson(QUALITY_FILE, { history: [] });
+    this.confidenceHistory = this.loadJson(CONFIDENCE_FILE, { history: [] });
+    this.sessionSummary = this.loadJson(SESSION_SUMMARY_FILE, { total_queries: 0, avg_quality: 0 });
+  }
+
+  loadJson(file, defaultVal) {
+    try {
+      if (existsSync(file)) {
+        return JSON.parse(readFileSync(file, 'utf-8'));
+      }
+    } catch (e) {}
+    return defaultVal;
+  }
+
+  showWelcome() {
+    const patternsCount = this.sessionMemory.user_patterns?.length || 0;
+    const errorsCount = this.sessionMemory.known_errors?.length || 0;
+    const avgQuality = this.getAverageQuality();
+    const totalQueries = this.sessionSummary.total_queries || 0;
+
+    if (patternsCount === 0 && totalQueries === 0) {
+      return `\n❄️  Welcome to Qwen Code ICE v15.0.0\n🔑 First run - type your query to begin\n`;
+    }
+
+    return `\n❄️  Welcome back to Qwen Code ICE v15.0.0\n📊 Last session: ${totalQueries} queries, avg quality ${avgQuality}/10\n🧠 ${patternsCount} patterns learned | ⚠️ ${errorsCount} known errors\n`;
+  }
+
+  getAverageQuality() {
+    if (!this.qualityHistory.history || this.qualityHistory.history.length === 0) return 'N/A';
+    const sum = this.qualityHistory.history.reduce((a, b) => a + (b.score || 0), 0);
+    return (sum / this.qualityHistory.history.length).toFixed(1);
+  }
+
+  getStats() {
+    return {
+      patternsCount: this.sessionMemory.user_patterns?.length || 0,
+      knownErrorsCount: this.sessionMemory.known_errors?.length || 0,
+      avgQuality: this.getAverageQuality(),
+      totalQueries: this.sessionSummary.total_queries || 0
+    };
+  }
+}
+
+class PatternPreventer {
+  constructor(memory) {
+    this.memory = memory;
+  }
+
+  preventErrors(query) {
+    const mem = this.memory.get();
+    const knownErrors = mem.known_errors || [];
+    const userPatterns = mem.user_patterns || [];
+
+    let enhancedQuery = query;
+    const warnings = [];
+    const preAppliedFixes = [];
+
+    if (query.toLowerCase().includes('sudo')) {
+      enhancedQuery = enhancedQuery.replace(/\bsudo\b\s*/gi, '');
+      warnings.push('⚠️  Auto-removed sudo (Termux uses pkg)');
+      preAppliedFixes.push('sudo_stripped');
+    }
+
+    if (query.includes('/usr/bin') || query.includes('/bin/')) {
+      enhancedQuery = enhancedQuery
+        .replace(/\/usr\/bin/g, `${TERMUX.PREFIX}/bin`)
+        .replace(/\/bin\//g, `${TERMUX.PREFIX}/bin/`);
+      warnings.push('⚠️  Auto-fixed paths for Termux');
+      preAppliedFixes.push('paths_fixed');
+    }
+
+    knownErrors.forEach(err => {
+      if (query.toLowerCase().includes(err.error.toLowerCase())) {
+        warnings.push(`⚠️  Known issue: ${err.error} → ${err.fix}`);
+        preAppliedFixes.push(`known_error:${err.error}`);
+      }
+    });
+
+    userPatterns.forEach(pattern => {
+      if (typeof pattern === 'string' && query.toLowerCase().includes(pattern.toLowerCase())) {
+        warnings.push(`📌 Pattern matched: ${pattern}`);
+      }
+    });
+
+    return { enhancedQuery, warnings, preAppliedFixes };
+  }
+}
+
+class QualityBlocker {
+  constructor(minScore = 5) {
+    this.minScore = minScore;
+  }
+
+  shouldBlock(score) {
+    return score < this.minScore;
+  }
+
+  getAction(score) {
+    if (score >= 8) return 'excellent';
+    if (score >= 5) return 'acceptable';
+    return 'block_and_regenerate';
+  }
+}
+
+class SessionSummary {
+  constructor() {
+    this.data = this.load();
+  }
+
+  load() {
+    try {
+      if (existsSync(SESSION_SUMMARY_FILE)) {
+        return JSON.parse(readFileSync(SESSION_SUMMARY_FILE, 'utf-8'));
+      }
+    } catch (e) {}
+    return { total_queries: 0, avg_quality: 0, patterns_learned: 0, errors_fixed: 0, top_intent: '' };
+  }
+
+  save(stats) {
+    const summary = {
+      date: new Date().toISOString(),
+      total_queries: stats.queries,
+      avg_quality: parseFloat(stats.avgQuality) || 0,
+      patterns_learned: stats.patternsLearned,
+      errors_fixed: stats.errorsFixed,
+      top_intent: stats.topIntent || 'none'
+    };
+    writeFileSync(SESSION_SUMMARY_FILE, JSON.stringify(summary, null, 2));
+    return summary;
+  }
+
+  printAndSave(stats) {
+    const summary = this.save(stats);
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 SESSION SUMMARY');
+    console.log('='.repeat(60));
+    console.log(`   Total queries: ${summary.total_queries}`);
+    console.log(`   Avg quality: ${summary.avg_quality.toFixed(1)}/10`);
+    console.log(`   Patterns learned: ${summary.patterns_learned}`);
+    console.log(`   Errors fixed: ${summary.errors_fixed}`);
+    console.log(`   Top intent: ${summary.top_intent}`);
+    console.log('='.repeat(60) + '\n');
+  }
+}
+
+class AutoRunLoop {
+  extractCode(response) {
+    const match = response.match(/```(?:bash|sh|js|javascript|python|py)?\n([\s\S]*?)\n```/);
+    return match ? match[1].trim() : null;
+  }
+
+  exec(code, maxRetries = 3) {
+    const extractedCode = this.extractCode(code);
+    if (!extractedCode) return { success: true, output: 'No executable code found', code: code };
+
+    console.log('\n⚡ Auto-Run Loop: Executing code...\n');
+
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        console.log(`Attempt ${attempt}/${maxRetries}...`);
+        const output = execSync(extractedCode, {
+          cwd: TERMUX.HOME,
+          env: { ...process.env, PREFIX: TERMUX.PREFIX },
+          timeout: 30000,
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe']
+        });
+
+        console.log(`✅ Code executed successfully (exit code 0)\n`);
+        return { success: true, output, code: extractedCode, attempt };
+
+      } catch (error) {
+        const stderr = error.stderr || '';
+        const status = error.status;
+
+        if (status === 0) {
+          console.log(`✅ Code executed with warnings (exit code 0)\n`);
+          return { success: true, output: stderr, code: extractedCode, attempt, hasWarnings: true };
+        }
+
+        const errorMsg = stderr || error.message;
+        console.log(`❌ Attempt ${attempt} failed: ${errorMsg.substring(0, 100)}\n`);
+
+        if (attempt === maxRetries) {
+          return {
+            success: false,
+            output: errorMsg,
+            code: extractedCode,
+            attempts: maxRetries,
+            warning: `⚠️  Code failed after ${maxRetries} attempts. Please review and fix manually.`
+          };
+        }
+      }
+    }
+  }
+}
+
+class ConfidenceGating {
+  constructor() {
+    this.thresholds = {
+      CERTAIN: { min: 90, action: 'respond_directly' },
+      LIKELY: { min: 70, action: 'respond_with_assumption_flag' },
+      UNCERTAIN: { min: 0, action: 'ask_clarifying_question' }
+    };
+    this.history = [];
+    this.loadHistory();
+  }
+
+  loadHistory() {
+    if (existsSync(CONFIDENCE_FILE)) {
+      try {
+        this.history = JSON.parse(readFileSync(CONFIDENCE_FILE, 'utf-8'));
+      } catch (e) {
+        this.history = [];
+      }
+    }
+  }
+
+  saveHistory() {
+    const dir = join(process.env.HOME, '.qwen');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(CONFIDENCE_FILE, JSON.stringify(this.history.slice(-20), null, 2));
+  }
+
+  recordOutcome(confidence, wasAccurate) {
+    this.history.push({ confidence, wasAccurate, timestamp: Date.now() });
+    if (this.history.length > 20) this.history.shift();
+    this.saveHistory();
+    this.adjustThresholds();
+  }
+
+  adjustThresholds() {
+    if (this.history.length < 10) return;
+    const recent = this.history.slice(-10);
+    const inaccurateCertain = recent.filter(h => h.confidence >= 90 && !h.wasAccurate).length;
+    const inaccurateUncertain = recent.filter(h => h.confidence < 70 && h.wasAccurate).length;
+    if (inaccurateCertain > 2) {
+      this.thresholds.CERTAIN.min = Math.min(95, this.thresholds.CERTAIN.min + 2);
+    }
+    if (inaccurateUncertain > 2) {
+      this.thresholds.UNCERTAIN.min = Math.max(0, this.thresholds.UNCERTAIN.min - 5);
+      this.thresholds.LIKELY.min = Math.max(50, this.thresholds.LIKELY.min - 5);
+    }
+  }
+
+  calculateConfidence(query, context) {
+    let confidence = 50;
+    if (query.includes('how to') || query.includes('how do i')) confidence += 20;
+    if (query.includes('fix') || query.includes('error')) confidence += 15;
+    if (query.includes('termux') || query.includes('android')) confidence += 15;
+    if (query.length < 10) confidence -= 20;
+    if (query.includes('maybe') || query.includes('not sure')) confidence -= 15;
+    if (query.endsWith('?')) confidence -= 5;
+    if (context && context.goal) confidence += 10;
+    return Math.min(100, Math.max(0, confidence));
+  }
+
+  getLevel(confidence) {
+    if (confidence >= this.thresholds.CERTAIN.min) return 'CERTAIN';
+    if (confidence >= this.thresholds.LIKELY.min) return 'LIKELY';
+    return 'UNCERTAIN';
+  }
+
+  assess(query, context) {
+    const confidence = this.calculateConfidence(query, context);
+    const level = this.getLevel(confidence);
+    return { confidence, level, action: this.thresholds[level].action };
+  }
+}
+
+class PatternLearningEngine {
+  constructor(memory) {
+    this.memory = memory;
+  }
+
+  applyPatterns(query) {
+    const mem = this.memory.get();
+    const knownErrors = mem.known_errors || [];
+    const userPatterns = mem.user_patterns || [];
+
+    let enhancedQuery = query;
+    const warnings = [];
+    const preAppliedFixes = [];
+
+    if (query.toLowerCase().includes('sudo')) {
+      enhancedQuery = enhancedQuery.replace(/\bsudo\b\s*/gi, '');
+      warnings.push('⚠️  Auto-removed sudo (Termux uses pkg)');
+      preAppliedFixes.push('sudo_stripped');
+    }
+
+    if (query.includes('/usr/bin') || query.includes('/bin/')) {
+      enhancedQuery = enhancedQuery
+        .replace(/\/usr\/bin/g, `${TERMUX.PREFIX}/bin`)
+        .replace(/\/bin\//g, `${TERMUX.PREFIX}/bin/`);
+      warnings.push('⚠️  Auto-fixed paths for Termux');
+      preAppliedFixes.push('paths_fixed');
+    }
+
+    knownErrors.forEach(err => {
+      if (query.toLowerCase().includes(err.error.toLowerCase())) {
+        warnings.push(`⚠️  Known issue: ${err.error} → ${err.fix}`);
+        preAppliedFixes.push(`known_error:${err.error}`);
+      }
+    });
+
+    userPatterns.forEach(pattern => {
+      if (typeof pattern === 'string' && query.toLowerCase().includes(pattern.toLowerCase())) {
+        warnings.push(`📌 Pattern matched: ${pattern}`);
+      }
+    });
+
+    return { enhancedQuery, warnings, preAppliedFixes };
+  }
+}
+
+class ResponseQualityScorer {
+  constructor() {
+    this.history = [];
+    this.loadHistory();
+  }
+
+  loadHistory() {
+    if (existsSync(QUALITY_FILE)) {
+      try {
+        this.history = JSON.parse(readFileSync(QUALITY_FILE, 'utf-8'));
+      } catch (e) {
+        this.history = [];
+      }
+    }
+  }
+
+  saveHistory() {
+    const dir = join(process.env.HOME, '.qwen');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(QUALITY_FILE, JSON.stringify(this.history.slice(-20), null, 2));
+  }
+
+  score(response, intent, critique, codeResult) {
+    let score = 5;
+    if (codeResult) {
+      if (codeResult.success) score += 3;
+      else score -= 2;
+    }
+    const tokenCount = Math.ceil(response.length / 4);
+    if (tokenCount < 200) score += 1;
+    if (tokenCount > 500) score -= 1;
+    if (!response.includes('sudo') && !response.includes('/usr/bin/') && !response.includes('apt-get')) {
+      score += 1;
+    }
+    if (intent && intent.deep && response.toLowerCase().includes(intent.deep.toLowerCase().split(' ')[0])) {
+      score += 1;
+    }
+    if (critique && critique.issues && critique.issues.length === 0) {
+      score += 1;
+    }
+    score = Math.max(1, Math.min(10, score));
+    this.history.push({ score, timestamp: Date.now() });
+    if (this.history.length > 20) this.history.shift();
+    this.saveHistory();
+    return score;
+  }
+
+  getAverage() {
+    if (this.history.length === 0) return null;
+    const sum = this.history.reduce((a, b) => a + b.score, 0);
+    return (sum / this.history.length).toFixed(1);
+  }
+
+  getTrend() {
+    if (this.history.length < 5) return 'insufficient_data';
+    const recent = this.history.slice(-5);
+    const older = this.history.slice(-10, -5);
+    const recentAvg = recent.reduce((a, b) => a + b.score, 0) / recent.length;
+    const olderAvg = older.reduce((a, b) => a + b.score, 0) / older.length;
+    if (recentAvg > olderAvg + 0.5) return 'improving';
+    if (recentAvg < olderAvg - 0.5) return 'declining';
+    return 'stable';
+  }
+
+  shouldAudit() {
+    const avg = parseFloat(this.getAverage() || 10);
+    return avg < 7;
+  }
+}
+
+class SmartContextCompression {
+  constructor(contextEngine) {
+    this.contextEngine = contextEngine;
+    this.turnHistory = [];
+  }
+
+  addTurn(turn) {
+    this.turnHistory.push(turn);
+    if (this.turnHistory.length > 10) {
+      this.turnHistory.shift();
+    }
+  }
+
+  getCompressed() {
+    if (this.turnHistory.length === 0) return '';
+    const recentTurns = this.turnHistory.slice(-3);
+    const olderTurns = this.turnHistory.slice(0, -3);
+    let compressed = '';
+    if (olderTurns.length > 0) {
+      compressed += `[${olderTurns.length} earlier turns summarized]\n`;
+      olderTurns.forEach(turn => {
+        const summary = turn.content.substring(0, 50) + (turn.content.length > 50 ? '...' : '');
+        compressed += `  ${turn.role}: ${summary}\n`;
+      });
+    }
+    recentTurns.forEach(turn => {
+      const content = turn.content.substring(0, 200) + (turn.content.length > 200 ? '...' : '');
+      compressed += `${turn.role}: ${content}\n`;
+    });
+    const ctx = this.contextEngine.get();
+    if (ctx.goal) compressed += `\n[Current goal: ${ctx.goal}]\n`;
+    if (ctx.blockers && ctx.blockers.length > 0) {
+      compressed += `[Blockers: ${ctx.blockers.join(', ')}]\n`;
+    }
+    const tokenCount = Math.ceil(compressed.length / 4);
+    if (tokenCount > 300) {
+      compressed = compressed.substring(0, 1200) + '...\n[truncated to 300 tokens]';
+    }
+    return compressed;
+  }
+
+  clear() {
+    this.turnHistory = [];
+  }
+}
+
+class SelfCritiqueLoop {
+  constructor() {
+    this.questions = [
+      'What is wrong with this?',
+      'What did I miss?',
+      'Will this break on Termux?',
+      'Is this the shortest correct solution?',
+      'Am I answering what they actually want, not what they typed?',
+      'Does this have any hardcoded paths that break on mobile?',
+      'Would a senior dev approve this?'
+    ];
+  }
+
+  critique(draft) {
+    const issues = [];
+    if (draft.includes('sudo')) issues.push('❌ Uses sudo (not available on Termux)');
+    if (draft.includes('/usr/bin') || draft.includes('/bin/')) issues.push('❌ Hardcoded paths (will fail on Termux)');
+    if (draft.length < 50) issues.push('⚠️  Response too short - may be incomplete');
+    if (!draft.includes('try') && !draft.includes('if') && draft.includes('function')) issues.push('⚠️  No error handling');
+    if (draft.includes('TODO') || draft.includes('FIXME')) issues.push('⚠️  Contains unresolved placeholders');
+    if (draft.includes('apt-get') || draft.includes('apt ')) issues.push('❌ Uses apt (should be pkg on Termux)');
+    if (draft.includes('systemctl')) issues.push('❌ Uses systemd (not available on Termux)');
+    return issues;
+  }
+
+  fix(draft, issues) {
+    let fixed = draft;
+    issues.forEach(issue => {
+      if (issue.includes('sudo')) fixed = fixed.replace(/sudo\s+/g, '# Termux: no sudo needed\n');
+      if (issue.includes('Hardcoded paths')) {
+        fixed = fixed.replace(/\/usr\/bin\//g, `${TERMUX.PREFIX}/bin/`);
+        fixed = fixed.replace(/\/bin\//g, `${TERMUX.PREFIX}/bin/`);
+      }
+      if (issue.includes('apt')) fixed = fixed.replace(/apt-get\s+install/g, 'pkg install').replace(/apt\s+install/g, 'pkg install');
+      if (issue.includes('systemctl')) fixed = fixed.replace(/systemctl\s+/g, '# Termux: no systemd\n# ');
+    });
+    return fixed;
+  }
+
+  process(draft) {
+    const issues = this.critique(draft);
+    if (issues.length === 0) return { draft, issues: [], fixed: draft };
+    const fixed = this.fix(draft, issues);
+    return { draft, issues, fixed };
+  }
+
+  regenerateForQuality(draft, qualityScore) {
+    const issues = this.critique(draft);
+    issues.push(`Quality score: ${qualityScore}/10 - needs improvement`);
+    const fixed = this.fix(draft, issues);
+    return { draft, issues, fixed, qualityFeedback: true };
+  }
+}
+
+class DomainMemory {
+  constructor() {
+    this.memory = { user_patterns: [], known_errors: [], project_state: {}, user_preferences: [] };
+    this.load();
+  }
+
+  load() {
+    if (existsSync(MEMORY_FILE)) {
+      try {
+        this.memory = JSON.parse(readFileSync(MEMORY_FILE, 'utf-8'));
+      } catch (e) {
+        this.memory = { user_patterns: [], known_errors: [], project_state: {}, user_preferences: [] };
+      }
+    }
+  }
+
+  save() {
+    const dir = join(process.env.HOME, '.qwen');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(MEMORY_FILE, JSON.stringify(this.memory, null, 2));
+  }
+
+  addPattern(pattern) {
+    if (!this.memory.user_patterns.includes(pattern)) {
+      this.memory.user_patterns.push(pattern);
+      this.save();
+      sessionStats.patternsLearned++;
+    }
+  }
+
+  addError(error, fix) {
+    this.memory.known_errors.push({ error, fix, timestamp: Date.now() });
+    if (this.memory.known_errors.length > 20) this.memory.known_errors.shift();
+    this.save();
+  }
+
+  updateProjectState(key, value) {
+    this.memory.project_state[key] = value;
+    this.save();
+  }
+
+  addPreference(pref) {
+    if (!this.memory.user_preferences.includes(pref)) {
+      this.memory.user_preferences.push(pref);
+      this.save();
+    }
+  }
+
+  onResponseComplete() {
+    this.save();
+  }
+
+  get() {
+    return this.memory;
+  }
+
+  clear() {
+    this.memory = { user_patterns: [], known_errors: [], project_state: {}, user_preferences: [] };
+    this.save();
+  }
+}
+
+class IntentLadder {
+  classify(query) {
+    const surface = query;
+    let real = surface;
+    if (surface.includes('how to')) real = 'User needs step-by-step instructions';
+    else if (surface.includes('why')) real = 'User needs root cause explanation';
+    else if (surface.includes('fix') || surface.includes('error')) real = 'User needs working solution';
+    else if (surface.includes('best') || surface.includes('recommended')) real = 'User needs expert recommendation';
+    else if (surface.includes('write') || surface.includes('create') || surface.includes('build')) real = 'User needs code implementation';
+    else if (surface.includes('debug') || surface.includes('troubleshoot')) real = 'User needs debugging help';
+    else real = 'User needs assistance';
+
+    let deep = real;
+    if (surface.includes('fix') || surface.includes('error') || surface.includes('broken')) deep = 'Build stable production code that won\'t break again';
+    else if (surface.includes('write') || surface.includes('create') || surface.includes('build') || surface.includes('function')) deep = 'Ship working feature fast without technical debt';
+    else if (surface.includes('debug') || surface.includes('troubleshoot')) deep = 'Understand root cause, not just apply quick fix';
+    else if (surface.includes('how to') || surface.includes('learn')) deep = 'Become self-sufficient, not dependent on AI';
+    else if (surface.includes('best') || surface.includes('recommended') || surface.includes('optimal')) deep = 'Make informed long-term architectural decision';
+    else if (surface.includes('test') || surface.includes('validate')) deep = 'Ensure code reliability before deployment';
+    else deep = 'Complete request successfully with minimal friction';
+
+    if (!sessionStats.intentCounts[deep]) {
+      sessionStats.intentCounts[deep] = 0;
+    }
+    sessionStats.intentCounts[deep]++;
+
+    return { surface, real, deep };
+  }
+}
+
+class TermuxSpecialist {
+  apply(response) {
+    let fixed = response;
+    fixed = fixed.replace(/sudo\s+/g, '');
+    fixed = fixed.replace(/apt-get\s+install/g, 'pkg install');
+    fixed = fixed.replace(/apt\s+install/g, 'pkg install');
+    fixed = fixed.replace(/\/usr\/bin\//g, `${TERMUX.PREFIX}/bin/`);
+    fixed = fixed.replace(/\/bin\//g, `${TERMUX.PREFIX}/bin/`);
+    fixed = fixed.replace(/systemctl\s+/g, '# systemctl not available on Termux\n# ');
+    return fixed;
+  }
+}
+
+class ParallelTaskSplitter {
+  split(input) {
+    const separators = [';', '&&', '||', '\n'];
+    for (const sep of separators) {
+      if (input.includes(sep)) {
+        return input.split(sep).map(s => s.trim()).filter(s => s.length > 0);
+      }
+    }
+    return [input];
+  }
+
+  async execute(tasks, executor) {
+    const results = [];
+    for (const task of tasks) {
+      results.push(await executor(task));
+    }
+    return results;
+  }
+}
+
+class CodeQualityGate {
+  check(code) {
+    const issues = [];
+    if (code.includes('sudo')) issues.push('Uses sudo');
+    if (code.includes('/usr/bin/') || code.includes('/bin/')) issues.push('Hardcoded paths');
+    if (!code.includes('try') && !code.includes('if') && code.includes('function')) issues.push('No error handling');
+    return { valid: issues.length === 0, issues };
+  }
+}
+
+class ActiveContextEngine {
+  constructor() {
+    this.context = { goal: '', decisions: [], blockers: [], last_action: '', turn_count: 0 };
+    this.load();
+  }
+
+  load() {
+    if (existsSync(CONTEXT_FILE)) {
+      try {
+        this.context = JSON.parse(readFileSync(CONTEXT_FILE, 'utf-8'));
+      } catch (e) {
+        this.context = { goal: '', decisions: [], blockers: [], last_action: '', turn_count: 0 };
+      }
+    }
+  }
+
+  save() {
+    writeFileSync(CONTEXT_FILE, JSON.stringify(this.context, null, 2));
+  }
+
+  update(goal, decision, blocker, action) {
+    if (goal) this.context.goal = goal;
+    if (decision) this.context.decisions.push(decision);
+    if (blocker && !this.context.blockers.includes(blocker)) this.context.blockers.push(blocker);
+    if (action) this.context.last_action = action;
+    this.context.turn_count++;
+    this.compress();
+    this.save();
+  }
+
+  compress() {
+    const maxLen = 1000;
+    const json = JSON.stringify(this.context);
+    if (json.length > maxLen) {
+      this.context.decisions = this.context.decisions.slice(-3);
+      this.context.blockers = this.context.blockers.slice(-3);
+    }
+  }
+
+  get() {
+    return this.context;
+  }
+
+  format() {
+    const c = this.context;
+    return `\nACTIVE_CONTEXT:\n  goal: ${c.goal || 'not set'}\n  decisions: ${c.decisions.length > 0 ? c.decisions.join(', ') : 'none'}\n  blockers: ${c.blockers.length > 0 ? c.blockers.join(', ') : 'none'}\n  last_action: ${c.last_action || 'none'}\n  turn: ${c.turn_count}`;
+  }
+
+  clear() {
+    this.context = { goal: '', decisions: [], blockers: [], last_action: '', turn_count: 0 };
+    if (existsSync(CONTEXT_FILE)) writeFileSync(CONTEXT_FILE, JSON.stringify(this.context, null, 2));
+  }
+}
+
+// ============================================
+// UNIFIED PIPELINE v15.0.0
+// ============================================
+
+class UnifiedPipeline {
+  constructor() {
+    // v14 preserved
+    this.coldStart = new ColdStartIntelligence();
+    this.domainMemory = new DomainMemory();
+    this.patternPreventer = new PatternPreventer(this.domainMemory);
+    this.intentLadder = new IntentLadder();
+    this.confidenceGate = new ConfidenceGating();
+    this.contextEngine = new ActiveContextEngine();
+    this.smartContext = new SmartContextCompression(this.contextEngine);
+    this.selfCritique = new SelfCritiqueLoop();
+    this.codeQualityGate = new CodeQualityGate();
+    this.autoRunLoop = new AutoRunLoop();
+    this.termuxSpecialist = new TermuxSpecialist();
+    this.parallelSplitter = new ParallelTaskSplitter();
+    this.qualityScorer = new ResponseQualityScorer();
+    this.qualityBlocker = new QualityBlocker(5);
+    this.sessionSummary = new SessionSummary();
+    
+    // v15 NEW SYSTEMS
+    this.compoundLearner = new CompoundLearner();
+    this.errorFingerprinter = new ErrorFingerprinter(this.domainMemory);
+    this.trendAnalyzer = new TrendAnalyzer();
+    this.termuxInstaller = new TermuxInstaller();
+  }
+
+  async process(userInput) {
+    // v14 Cold Start
+    if (sessionStats.queries === 0) {
+      console.log(this.coldStart.showWelcome());
+    }
+
+    // v15 NEW: Compound Learner session header
+    this.compoundLearner.showSessionHeader();
+
+    console.log('\n❄️ ICE v15.0 - Compounding Intelligence\n');
+    console.log('='.repeat(60));
+
+    // Step 0: Pattern Prevention (v14 verified)
+    console.log('🛡️  Step 0: PatternPreventer');
+    const patternResult = this.patternPreventer.preventErrors(userInput);
+    if (patternResult.warnings.length > 0) {
+      console.log('   ' + patternResult.warnings.join('\n   '));
+    } else {
+      console.log('   No patterns matched - proceeding normally');
+    }
+    const enhancedInput = patternResult.enhancedQuery;
+    console.log();
+
+    // v15 NEW: Error Fingerprinting
+    console.log('🔍 Step 0.5: ErrorFingerprinter');
+    const fingerprintResult = this.errorFingerprinter.check(userInput);
+    if (fingerprintResult.known) {
+      console.log(`   ✅ Known error detected. Applying fix: ${fingerprintResult.fix}\n`);
+      sessionStats.errorsFixed++;
+    } else {
+      console.log('   No known error fingerprint match\n');
+    }
+
+    // Step 1: Intent Analysis
+    console.log('🪜 Step 1: Intent Ladder');
+    const intent = this.intentLadder.classify(enhancedInput);
+    console.log(`   SURFACE: "${intent.surface}"`);
+    console.log(`   REAL: ${intent.real}`);
+    console.log(`   DEEP: ${intent.deep}\n`);
+
+    // Step 2: Confidence Assessment
+    console.log('🎯 Step 2: Confidence Gating');
+    const confidence = this.confidenceGate.assess(enhancedInput, { goal: intent.deep });
+    console.log(`   Confidence: ${confidence.confidence}%`);
+    console.log(`   Level: ${confidence.level}`);
+    console.log(`   Thresholds: CERTAIN≥${this.confidenceGate.thresholds.CERTAIN.min}, LIKELY≥${this.confidenceGate.thresholds.LIKELY.min}\n`);
+
+    // Step 3: Smart Context
+    console.log('📋 Step 3: Smart Context Compression');
+    this.contextEngine.update(intent.deep, null, null, enhancedInput);
+    this.smartContext.addTurn({ role: 'user', content: enhancedInput });
+    const contextBlock = this.smartContext.getCompressed();
+    console.log(`   Context turns: ${this.smartContext.turnHistory.length}`);
+    console.log(`   Token estimate: ~${Math.ceil(contextBlock.length / 4)}\n`);
+
+    // Step 4: Generate response
+    console.log('✏️  Step 4: Generate Response');
+    let response = this.generateResponse(enhancedInput, intent);
+    console.log('   Response generated\n');
+
+    // Step 5: Self-Critique
+    console.log('🔍 Step 5: Self-Critique Loop (7 questions)');
+    const critique = this.selfCritique.process(response);
+    if (critique.issues.length > 0) {
+      console.log(`   Found ${critique.issues.length} issues:`);
+      critique.issues.forEach(i => console.log(`     - ${i}`));
+      response = critique.fixed;
+      console.log('   ✅ Fixed\n');
+    } else {
+      console.log('   ✅ No issues\n');
+    }
+
+    // Step 6: Code Quality Gate
+    let codeResult = null;
+    if (response.includes('function') || response.includes('const ') || response.includes('import ')) {
+      console.log('🔒 Step 6: Code Quality Gate');
+      const quality = this.codeQualityGate.check(response);
+      if (!quality.valid) {
+        console.log(`   Found ${quality.issues.length} issues:`);
+        quality.issues.forEach(i => console.log(`     - ${i}`));
+        response = this.termuxSpecialist.apply(response);
+        console.log('   ✅ Applied Termux fixes\n');
+      } else {
+        console.log('   ✅ Code passes quality gate\n');
+      }
+    }
+
+    // Step 7: Auto-Run Loop
+    if (response.includes('```')) {
+      console.log('⚡ Step 7: Auto-Run Loop');
+      codeResult = this.autoRunLoop.exec(response);
+      if (!codeResult.success) {
+        console.log(`   ⚠️  ${codeResult.warning}`);
+        response += `\n\n${codeResult.warning}`;
+      } else if (codeResult.hasWarnings) {
+        console.log('   ✅ Code executed with warnings\n');
+      } else if (codeResult.attempt) {
+        console.log(`   ✅ Code executed (attempt ${codeResult.attempt})\n`);
+      }
+    }
+
+    // v15 NEW: TermuxInstaller - check for missing packages
+    console.log('📦 Step 7.5: TermuxInstaller');
+    if (response.includes('```')) {
+      const codeBlocks = response.match(/```[\s\S]*?```/g);
+      if (codeBlocks) {
+        for (const block of codeBlocks) {
+          await this.termuxInstaller.ensurePackages(block);
+        }
+      }
+    }
+    console.log('   Package check complete\n');
+
+    // Step 8: Domain Memory
+    console.log('💾 Step 8: Domain Memory');
+    this.domainMemory.addPattern(intent.real);
+    this.domainMemory.onResponseComplete();
+    console.log('   ✅ Pattern learned and saved\n');
+
+    // Step 9: Quality Scoring
+    console.log('📊 Step 9: Response Quality Scorer');
+    let qualityScore = this.qualityScorer.score(response, intent, critique, codeResult);
+    const avgQuality = this.qualityScorer.getAverage();
+    const trend = this.qualityScorer.getTrend();
+    console.log(`   Score: ${qualityScore}/10`);
+    console.log(`   Average: ${avgQuality || 'N/A'}/10 (${trend})`);
+
+    // v15 NEW: Trend Analyzer
+    console.log('\n📈 Step 9.5: TrendAnalyzer');
+    this.trendAnalyzer.update(qualityScore);
+    const trendStatus = this.trendAnalyzer.getTrend();
+    console.log(`   Trend status: ${trendStatus}\n`);
+
+    // v14 Quality Blocker
+    if (this.qualityBlocker.shouldBlock(qualityScore)) {
+      console.log(`\n⚠️  Quality Blocker activated`);
+      console.log(`   Score ${qualityScore}/10 is below threshold (${this.qualityBlocker.minScore}/10)`);
+      console.log('   Regenerating with quality feedback...\n');
+
+      const regenCritique = this.selfCritique.regenerateForQuality(response, qualityScore);
+      response = regenCritique.fixed;
+      console.log('   ✅ Regenerated response\n');
+
+      qualityScore = this.qualityScorer.score(response, intent, regenCritique, codeResult);
+      console.log(`   New score: ${qualityScore}/10`);
+
+      if (this.qualityBlocker.shouldBlock(qualityScore)) {
+        console.log(`\n⚠️  WARNING: Response still scores ${qualityScore}/10 after regeneration`);
+        response += `\n\n⚠️  Note: This response scored ${qualityScore}/10 on quality metrics. Please review carefully.`;
+      }
+    }
+    console.log();
+
+    // Record confidence outcome
+    const wasAccurate = critique.issues.length === 0;
+    this.confidenceGate.recordOutcome(confidence.confidence, wasAccurate);
+
+    // Track session stats
+    sessionStats.queries++;
+    if (patternResult.preAppliedFixes.length > 0) {
+      sessionStats.errorsFixed += patternResult.preAppliedFixes.length;
+    }
+    if (fingerprintResult.known) {
+      sessionStats.errorsFixed++;
+    }
+
+    console.log('='.repeat(60));
+    console.log('\n📤 Final Response:\n');
+    return response;
+  }
+
+  generateResponse(input, intent) {
+    if (input.includes('sudo')) {
+      return `To fix this on Termux, use pkg instead:\n\`\`\`bash\npkg install python\n\`\`\`\nNote: sudo is not available on Termux.`;
+    }
+    if (input.includes('function')) {
+      return `Here's the function:\n\`\`\`javascript\nfunction example() {\n  return 'Hello from Termux';\n}\n\`\`\`\nThis follows Termux best practices.`;
+    }
+    return `I understand you want to ${intent.real}. The deep goal is: ${intent.deep}.\n\nHere's how to proceed...`;
+  }
+
+  printSessionSummary() {
+    const avgQuality = this.qualityScorer.getAverage();
+    const topIntent = Object.entries(sessionStats.intentCounts)
+      .sort((a, b) => b[1] - a[1])[0]?.[0] || 'none';
+
+    const stats = {
+      queries: sessionStats.queries,
+      avgQuality: avgQuality || '0',
+      patternsLearned: sessionStats.patternsLearned,
+      errorsFixed: sessionStats.errorsFixed,
+      topIntent
+    };
+
+    // v15: Archive to sessions directory
+    this.compoundLearner.saveSessionSummary(stats);
+    
+    this.sessionSummary.printAndSave(stats);
+  }
+}
+
+// ============================================
+// CLI
+// ============================================
+
+// Only run CLI if this is the main module
+if (require.main !== module) { module.exports = { UnifiedPipeline, CompoundLearner, ErrorFingerprinter, TrendAnalyzer, TermuxInstaller }; return; }
+
+const args = process.argv.slice(2);
+const command = args[0];
+const input = args.slice(1).join(' ');
+
+function handleExit(pipeline) {
+  console.log('\n👋 Saving session summary...\n');
+  pipeline.printSessionSummary();
+  process.exit(0);
+}
+
+process.on('SIGINT', () => {
+  if (currentPipeline) {
+    handleExit(currentPipeline);
+  } else {
+    process.exit(0);
+  }
+});
+
+if (!command) {
+  console.log('❄️ ICE v15.0 - Compounding Intelligence\n');
+  console.log('NEW SYSTEMS (v15):');
+  console.log('  1. CompoundLearner - cross-session learning');
+  console.log('  2. ErrorFingerprinter - deduplicates errors');
+  console.log('  3. TrendAnalyzer - tracks quality trends');
+  console.log('  4. TermuxInstaller - auto-installs packages\n');
+  console.log('PRESERVED (v14 verified):');
+  console.log('  - ColdStartIntelligence ✅');
+  console.log('  - PatternPreventer ✅');
+  console.log('  - QualityBlocker ✅');
+  console.log('  - SessionSummary ✅\n');
+  console.log('PIPELINE:');
+  console.log('  userInput → ColdStartIntelligence → CompoundLearner → PatternPreventer');
+  console.log('            → ErrorFingerprinter → IntentLadder → ConfidenceGating');
+  console.log('            → SmartContext → Generate → SelfCritique(7)');
+  console.log('            → CodeQualityGate → AutoRunLoop → TermuxInstaller');
+  console.log('            → QualityBlocker → DomainMemory → QualityScorer');
+  console.log('            → TrendAnalyzer → SessionSummary → response\n');
+  console.log('Usage:');
+  console.log('  ice-v15 "your message"    # Run unified pipeline');
+  console.log('  ice-v15 parallel [task]   # Parallel task splitter');
+  console.log('  ice-v15 init              # Initialize config files');
+  console.log('  ice-v15 exit              # Show session summary and exit\n');
+  console.log('Termux:');
+  console.log('  PREFIX=' + TERMUX.PREFIX);
+  console.log('  HOME=' + TERMUX.HOME);
+  console.log('  No sudo | pkg manager | ARM64 only\n');
+  process.exit(0);
+}
+
+if (command === 'init') {
+  const dir = join(process.env.HOME, '.qwen');
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!existsSync(SESSIONS_DIR)) mkdirSync(SESSIONS_DIR, { recursive: true });
+
+  const files = {
+    [SESSION_FILE]: { timestamp: Date.now(), conversation: [] },
+    [CONTEXT_FILE]: { goal: '', decisions: [], blockers: [], last_action: '', turn_count: 0 },
+    [MEMORY_FILE]: { user_patterns: [], known_errors: [], project_state: {}, user_preferences: [] },
+    [CONFIDENCE_FILE]: [],
+    [QUALITY_FILE]: [],
+    [SESSION_SUMMARY_FILE]: { total_queries: 0, avg_quality: 0 },
+    [TREND_FILE]: { trends: [], alerts: [] }
+  };
+
+  Object.entries(files).forEach(([file, data]) => {
+    if (!existsSync(file)) {
+      writeFileSync(file, JSON.stringify(data, null, 2));
+      console.log(`✅ Created ${file}`);
+    }
+  });
+
+  console.log('\n✅ ICE v15.0 initialized\n');
+  process.exit(0);
+}
+
+if (command === 'exit') {
+  const pipeline = new UnifiedPipeline();
+  handleExit(pipeline);
+  process.exit(0);
+}
+
+if (command === 'parallel') {
+  const pipeline = new UnifiedPipeline();
+  const tasks = pipeline.parallelSplitter.split(input);
+  console.log(`🔀 Split into ${tasks.length} parallel tasks:\n`);
+  tasks.forEach((t, i) => console.log(`  ${i + 1}. ${t}`));
+  console.log();
+  Promise.all(tasks.map(task => pipeline.process(task))).then(() => {
+    handleExit(pipeline);
+    process.exit(0);
+  });
+  process.exit(0);
+}
+
+let currentPipeline = null;
+const pipeline = new UnifiedPipeline();
+currentPipeline = pipeline;
+pipeline.process(command + ' ' + input).then(response => {
+  console.log(response);
+});
+
+// Export for use as module
+module.exports = { UnifiedPipeline, CompoundLearner, ErrorFingerprinter, TrendAnalyzer, TermuxInstaller };
+