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

package/scripts/ice-v13.js

@@ -0,0 +1,824 @@
+#!/usr/bin/env node
+/**
+ * ❄️ ICE v13.0.0 - Self-Improving Intelligence
+ * 
+ * BUG FIXES:
+ * 1. Auto-Run Loop: exit code 0 = success, warnings != errors
+ * 2. ConfidenceGating: now learns from history, adjusts thresholds
+ * 
+ * NEW SYSTEMS:
+ * 1. Pattern Learning Engine - proactively applies known fixes
+ * 2. Response Quality Scorer - scores 1-10 after every response
+ * 3. Smart Context Compression - keeps last 3 verbatim, compresses 4-10
+ * 
+ * PIPELINE:
+ * userInput → PatternPreventer → IntentLadder → ConfidenceGating 
+ *           → SmartContext → Generate → SelfCritique(7) → CodeQualityGate
+ *           → AutoRunLoop → DomainMemory → QualityScorer → response
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+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 MANIFEST_FILE = join(process.env.HOME, '.qwen', 'v13_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',
+  PYTHON_FLAGS: '--break-system-packages'
+};
+
+// ============================================
+// BUG FIX 1 — AUTO-RUN LOOP (exit code 0 = success)
+// ============================================
+
+class AutoRunLoop {
+  extractCode(response) {
+    const match = response.match(/```(?:bash|sh|js|javascript|python|py)?\n([\s\S]*?)\n```/);
+    return match ? match[1].trim() : null;
+  }
+
+  isWarning(line) {
+    const warningPatterns = [
+      /npm warn/i, /yarn warn/i,
+      /warning:/i, /warn:/i,
+      /deprecated/i, /pkg notice/i,
+      /apt.*warning/i, /pkg.*warning/i
+    ];
+    return warningPatterns.some(p => p.test(line));
+  }
+
+  isError(line) {
+    const errorPatterns = [
+      /error:/i, /fatal:/i, /failed/i,
+      /command not found/i, /no such file/i,
+      /permission denied/i, /exit code [1-9]/i
+    ];
+    return errorPatterns.some(p => p.test(line));
+  }
+
+  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']
+        });
+
+        // Exit code 0 = SUCCESS, even with warnings in stderr
+        console.log(`✅ Code executed successfully (exit code 0)\n`);
+        return { success: true, output, code: extractedCode, attempt };
+
+      } catch (error) {
+        const stderr = error.stderr || '';
+        const stdout = error.stdout || '';
+        const status = error.status;
+
+        // BUG FIX: exit code 0 = success, warnings are NOT failures
+        if (status === 0) {
+          console.log(`✅ Code executed with warnings (exit code 0)\n`);
+          return { 
+            success: true, 
+            output: stdout + '\nWarnings:\n' + stderr, 
+            code: extractedCode, 
+            attempt,
+            hasWarnings: true 
+          };
+        }
+
+        // Real error (exit code != 0)
+        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.`
+          };
+        }
+      }
+    }
+  }
+}
+
+// ============================================
+// BUG FIX 2 — CONFIDENCE GATING (learns from history)
+// ============================================
+
+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 };
+  }
+}
+
+// ============================================
+// NEW SYSTEM — PATTERN LEARNING ENGINE
+// ============================================
+
+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 };
+  }
+}
+
+// ============================================
+// NEW SYSTEM — RESPONSE QUALITY SCORER
+// ============================================
+
+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;
+  }
+}
+
+// ============================================
+// NEW SYSTEM — SMART CONTEXT COMPRESSION
+// ============================================
+
+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 = [];
+  }
+}
+
+// ============================================
+// EXISTING FEATURES (preserved from v12)
+// ============================================
+
+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 };
+  }
+}
+
+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();
+    }
+  }
+
+  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';
+
+    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 v13.0.0
+// ============================================
+
+class UnifiedPipeline {
+  constructor() {
+    this.domainMemory = new DomainMemory();
+    this.patternLearner = new PatternLearningEngine(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();
+  }
+
+  async process(userInput) {
+    console.log('\n❄️ ICE v13.0 - Self-Improving Intelligence\n');
+    console.log('='.repeat(60));
+
+    // STEP 0: Pattern Learning (proactive prevention)
+    console.log('🧠 Step 0: Pattern Learning Engine');
+    const patternResult = this.patternLearner.applyPatterns(userInput);
+    if (patternResult.warnings.length > 0) {
+      console.log('   ' + patternResult.warnings.join('\n   '));
+    } else {
+      console.log('   No known patterns matched');
+    }
+    const enhancedInput = patternResult.enhancedQuery;
+    console.log();
+
+    // 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`);
+      }
+    }
+
+    // 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 (NEW)
+    console.log('📊 Step 9: Response Quality Scorer');
+    const 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})`);
+    if (this.qualityScorer.shouldAudit()) {
+      console.log('   ⚠️  Average below 7 - triggering self-audit\n');
+    } else {
+      console.log();
+    }
+
+    // Record confidence outcome
+    const wasAccurate = critique.issues.length === 0;
+    this.confidenceGate.recordOutcome(confidence.confidence, wasAccurate);
+
+    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...`;
+  }
+}
+
+// ============================================
+// CLI
+// ============================================
+
+const args = process.argv.slice(2);
+const command = args[0];
+const input = args.slice(1).join(' ');
+
+if (!command) {
+  console.log('❄️ ICE v13.0 - Self-Improving Intelligence\n');
+  console.log('PIPELINE (all features wired together):');
+  console.log('  userInput → PatternPreventer → IntentLadder → ConfidenceGating');
+  console.log('            → SmartContext → Generate → SelfCritique (7 questions)');
+  console.log('            → CodeQualityGate → AutoRunLoop → DomainMemory');
+  console.log('            → QualityScorer → response\n');
+  console.log('BUG FIXES:');
+  console.log('  1. Auto-Run Loop: exit code 0 = success, warnings != errors');
+  console.log('  2. ConfidenceGating: learns from history, adjusts thresholds\n');
+  console.log('NEW SYSTEMS:');
+  console.log('  1. Pattern Learning Engine - proactively applies known fixes');
+  console.log('  2. Response Quality Scorer - scores 1-10 after every response');
+  console.log('  3. Smart Context Compression - keeps last 3 verbatim, compresses 4-10\n');
+  console.log('Usage:');
+  console.log('  ice-v13 "your message"    # Run unified pipeline');
+  console.log('  ice-v13 parallel [task]   # Parallel task splitter');
+  console.log('  ice-v13 init              # Initialize config files\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 });
+
+  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]: []
+  };
+
+  Object.entries(files).forEach(([file, data]) => {
+    if (!existsSync(file)) {
+      writeFileSync(file, JSON.stringify(data, null, 2));
+      console.log(`✅ Created ${file}`);
+    }
+  });
+
+  console.log('\n✅ ICE v13.0 initialized\n');
+  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(results => {
+    console.log('\n📊 All tasks completed\n');
+    process.exit(0);
+  });
+  process.exit(0);
+}
+
+const pipeline = new UnifiedPipeline();
+pipeline.process(command + ' ' + input).then(response => {
+  console.log(response);
+  process.exit(0);
+});