@anh3d0nic/qwen-code-termux-ice 14.0.0 → 16.0.0

package/core/ice-v16.js

@@ -0,0 +1,1202 @@
+#!/data/data/com.termux/files/usr/bin/node
+/**
+ * ❄️ ICE v16.0.0 — Consolidated Unified Pipeline
+ * All features from v1-v15 audited and merged
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { spawn } = require('child_process');
+
+const VERSION = '16.0.0';
+const INSTALL_DIR = '/data/data/com.termux/files/.qwen-ice';
+const CONFIG_DIR = path.join(INSTALL_DIR, 'config');
+const MEMORY_DIR = path.join(INSTALL_DIR, 'memory');
+const LOGS_DIR = path.join(INSTALL_DIR, 'logs');
+
+const API_KEYS_FILE = path.join(CONFIG_DIR, 'api-keys.json');
+const SETTINGS_FILE = path.join(CONFIG_DIR, 'settings.json');
+const SESSION_MEMORY_FILE = path.join(MEMORY_DIR, 'session_memory.json');
+const QUALITY_HISTORY_FILE = path.join(MEMORY_DIR, 'quality_history.json');
+const CONFIDENCE_HISTORY_FILE = path.join(MEMORY_DIR, 'confidence_history.json');
+const SESSION_SUMMARY_FILE = path.join(MEMORY_DIR, 'session_summary.json');
+const ERRORS_LOG = path.join(LOGS_DIR, 'errors.log');
+const YOLO_LOG = path.join(LOGS_DIR, 'yolo.log');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// UTILITY: Ensure directories exist
+// ─────────────────────────────────────────────────────────────────────────────
+function ensureDirs() {
+  [CONFIG_DIR, MEMORY_DIR, LOGS_DIR].forEach(dir => {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// UTILITY: Logger
+// ─────────────────────────────────────────────────────────────────────────────
+function logError(message, err = null) {
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] ${message}${err ? ': ' + err.stack : ''}\n`;
+  try { fs.appendFileSync(ERRORS_LOG, logLine); } catch (e) {}
+}
+
+function logYolo(message, yolo = false) {
+  if (!yolo) return;
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] ${message}\n`;
+  try { fs.appendFileSync(YOLO_LOG, logLine); } catch (e) {}
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 1: ColdStartIntelligence — Load memory + show welcome
+// ─────────────────────────────────────────────────────────────────────────────
+class ColdStartIntelligence {
+  constructor() {
+    this.sessionMemory = this.loadJson(SESSION_MEMORY_FILE, { patterns: [], known_errors: [] });
+    this.qualityHistory = this.loadJson(QUALITY_HISTORY_FILE, { scores: [] });
+    this.confidenceHistory = this.loadJson(CONFIDENCE_HISTORY_FILE, { thresholds: {} });
+    this.sessionSummary = this.loadJson(SESSION_SUMMARY_FILE, { last_session: null, total_queries: 0, total_errors: 0 });
+  }
+
+  loadJson(file, defaultVal) {
+    try {
+      if (fs.existsSync(file)) {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+      }
+    } catch (e) { logError(`Failed to load ${file}`, e); }
+    return defaultVal;
+  }
+
+  showWelcome() {
+    const patternsCount = this.sessionMemory.patterns?.length || 0;
+    const errorsCount = this.sessionMemory.known_errors?.length || 0;
+    const avgQuality = this.qualityHistory.scores.length > 0
+      ? (this.qualityHistory.scores.reduce((a, b) => a + b, 0) / this.qualityHistory.scores.length).toFixed(1)
+      : 'N/A';
+    const totalQueries = this.sessionSummary.total_queries || 0;
+
+    if (patternsCount === 0 && totalQueries === 0) {
+      return `\n❄️  Welcome to Qwen Code ICE v${VERSION}\n🔑 Run: qwen-ice api-setup to configure API keys\n`;
+    }
+
+    return `\n❄️  Qwen Code ICE v${VERSION} ready\n🧠 ${patternsCount} patterns | ⚠️ ${errorsCount} known errors | 📊 Avg quality: ${avgQuality}/10\n📈 ${totalQueries} queries total\n`;
+  }
+
+  getStats() {
+    return {
+      patternsCount: this.sessionMemory.patterns?.length || 0,
+      knownErrorsCount: this.sessionMemory.known_errors?.length || 0,
+      avgQuality: this.qualityHistory.scores.length > 0
+        ? (this.qualityHistory.scores.reduce((a, b) => a + b, 0) / this.qualityHistory.scores.length).toFixed(1)
+        : 'N/A',
+      totalQueries: this.sessionSummary.total_queries || 0
+    };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 2: PatternPreventer — Strip sudo, fix paths BEFORE generation
+// ─────────────────────────────────────────────────────────────────────────────
+class PatternPreventer {
+  constructor() {
+    this.patterns = [
+      { name: 'sudo_strip', pattern: /\bsudo\b\s*/gi, replacement: '', reason: 'Termux does not use sudo' },
+      { name: 'apt_fix', pattern: /\bapt-get\b/gi, replacement: 'pkg', reason: 'Termux uses pkg instead of apt-get' },
+      { name: 'systemctl_fix', pattern: /\bsystemctl\b/gi, replacement: '# systemctl (not available in Termux)', reason: 'Termux does not use systemd' },
+      { name: 'etc_init_fix', pattern: /\/etc\/init\.d/gi, replacement: '$PREFIX/etc/init.d', reason: 'Termux uses $PREFIX paths' },
+      { name: 'usr_bin_fix', pattern: /\/usr\/bin/gi, replacement: '$PREFIX/bin', reason: 'Termux uses $PREFIX/bin' },
+      { name: 'usr_sbin_fix', pattern: /\/usr\/sbin/gi, replacement: '$PREFIX/bin', reason: 'Termux uses $PREFIX/bin' },
+      { name: 'etc_apt_fix', pattern: /\/etc\/apt/gi, replacement: '$PREFIX/etc/apt', reason: 'Termux apt path' }
+    ];
+  }
+
+  process(input) {
+    let output = input;
+    const fixes = [];
+
+    for (const { name, pattern, replacement, reason } of this.patterns) {
+      if (pattern.test(output)) {
+        output = output.replace(pattern, replacement);
+        fixes.push({ name, reason });
+      }
+    }
+
+    return { output, fixes };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 3: IntentLadder — Surface/Real/Deep intent analysis
+// ─────────────────────────────────────────────────────────────────────────────
+class IntentLadder {
+  analyze(input) {
+    const surface = this.detectSurface(input);
+    const real = this.detectReal(input, surface);
+    const deep = this.detectDeep(input, real);
+
+    return { surface, real, deep, complexity: this.calculateComplexity(input) };
+  }
+
+  detectSurface(input) {
+    const lower = input.toLowerCase();
+    if (lower.includes('fix') || lower.includes('error') || lower.includes('bug')) return 'fix_error';
+    if (lower.includes('write') || lower.includes('create') || lower.includes('make')) return 'create_code';
+    if (lower.includes('explain') || lower.includes('what') || lower.includes('how')) return 'explain';
+    if (lower.includes('run') || lower.includes('execute') || lower.includes('test')) return 'run_code';
+    if (lower.includes('install') || lower.includes('setup') || lower.includes('configure')) return 'setup';
+    return 'general';
+  }
+
+  detectReal(input, surface) {
+    const lower = input.toLowerCase();
+    if (surface === 'fix_error' && (lower.includes('sudo') || lower.includes('permission'))) {
+      return 'fix_termux_permission';
+    }
+    if (surface === 'create_code' && lower.includes('python')) {
+      return 'create_python_script';
+    }
+    if (surface === 'setup' && lower.includes('api')) {
+      return 'setup_api_integration';
+    }
+    return surface;
+  }
+
+  detectDeep(input, real) {
+    const lower = input.toLowerCase();
+    if (lower.includes('automatically') || lower.includes('auto')) {
+      return 'wants_automation';
+    }
+    if (lower.includes('best') || lower.includes('optimal') || lower.includes('efficient')) {
+      return 'wants_best_practice';
+    }
+    if (lower.includes('quick') || lower.includes('fast') || lower.includes('simple')) {
+      return 'wants_quick_solution';
+    }
+    return 'standard_request';
+  }
+
+  calculateComplexity(input) {
+    const words = input.split(/\s+/).length;
+    if (words < 5) return 'simple';
+    if (words < 15) return 'moderate';
+    return 'complex';
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 4: ConfidenceGating — Self-adjusting thresholds
+// ─────────────────────────────────────────────────────────────────────────────
+class ConfidenceGating {
+  constructor(confidenceHistory) {
+    this.thresholds = confidenceHistory?.thresholds || {};
+    this.defaultThresholds = {
+      simple: 0.7,
+      moderate: 0.8,
+      complex: 0.9
+    };
+  }
+
+  getThreshold(complexity) {
+    return this.thresholds[complexity] || this.defaultThresholds[complexity] || 0.8;
+  }
+
+  shouldProceed(confidence, complexity) {
+    const threshold = this.getThreshold(complexity);
+    return confidence >= threshold;
+  }
+
+  recordOutcome(complexity, wasSuccessful) {
+    const current = this.thresholds[complexity] || this.defaultThresholds[complexity];
+    if (wasSuccessful) {
+      this.thresholds[complexity] = Math.max(0.5, current - 0.02);
+    } else {
+      this.thresholds[complexity] = Math.min(0.95, current + 0.05);
+    }
+  }
+
+  getThresholds() {
+    return { ...this.defaultThresholds, ...this.thresholds };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 5: SmartContext — Compress to 300 token max
+// ─────────────────────────────────────────────────────────────────────────────
+class SmartContext {
+  constructor(sessionMemory) {
+    this.knownErrors = sessionMemory?.known_errors || [];
+    this.patterns = sessionMemory?.patterns || [];
+  }
+
+  compress(conversation, maxTokens = 300) {
+    if (!conversation || conversation.length === 0) {
+      return { compressed: '', tokenCount: 0 };
+    }
+
+    const recentTurns = conversation.slice(-3);
+    const olderTurns = conversation.slice(0, -3);
+
+    let compressed = '';
+    if (olderTurns.length > 0) {
+      compressed += `[${olderTurns.length} earlier turns summarized]\n`;
+    }
+
+    for (const turn of recentTurns) {
+      compressed += `${turn.role}: ${turn.content.substring(0, 200)}${turn.content.length > 200 ? '...' : ''}\n`;
+    }
+
+    if (this.knownErrors.length > 0) {
+      compressed += `\n[Known errors: ${this.knownErrors.slice(-3).join(', ')}]\n`;
+    }
+
+    const tokenCount = Math.ceil(compressed.length / 4);
+    return { compressed, tokenCount: Math.min(tokenCount, maxTokens) };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 6: ApiRouter — Multi-provider API routing (from v15)
+// ─────────────────────────────────────────────────────────────────────────────
+class ApiRouter {
+  constructor() {
+    this.apiConfig = this.loadApiConfig();
+    this.fallbackOrder = this.apiConfig.fallback_order || ['qwen', 'gemini', 'groq', 'openai', 'dashscope'];
+    this.defaultProvider = this.apiConfig.default_provider || 'qwen';
+  }
+
+  loadApiConfig() {
+    try {
+      if (fs.existsSync(API_KEYS_FILE)) {
+        return JSON.parse(fs.readFileSync(API_KEYS_FILE, 'utf8'));
+      }
+    } catch (err) {
+      logError('Failed to load API config', err);
+    }
+    return { keys: [], fallback_order: ['qwen', 'gemini', 'groq', 'openai', 'dashscope'], default_provider: 'qwen' };
+  }
+
+  buildAttemptList() {
+    const attempts = [];
+    const keys = this.apiConfig.keys || [];
+    const keysByProvider = {};
+
+    for (const key of keys) {
+      if (!key.active) continue;
+      if (!keysByProvider[key.provider]) {
+        keysByProvider[key.provider] = [];
+      }
+      keysByProvider[key.provider].push(key);
+    }
+
+    const providersToTry = [this.defaultProvider, ...this.fallbackOrder.filter(p => p !== this.defaultProvider)];
+
+    for (const provider of providersToTry) {
+      if (keysByProvider[provider]) {
+        for (const key of keysByProvider[provider]) {
+          attempts.push({ provider, id: key.id, key: key.key, model: key.model, type: key.type });
+        }
+      }
+    }
+
+    return attempts;
+  }
+
+  async callWithFallback(messages) {
+    const attemptList = this.buildAttemptList();
+
+    if (attemptList.length === 0) {
+      throw new Error('❌ No API keys configured.\n🔑 Setup: qwen-ice api-setup');
+    }
+
+    let lastError = null;
+    for (const attempt of attemptList) {
+      try {
+        const result = await this.callProvider(attempt, messages);
+        await this.recordSuccess(attempt.provider, attempt.id);
+        return result;
+      } catch (err) {
+        lastError = err;
+        await this.recordFailure(attempt.provider, attempt.id, err);
+      }
+    }
+
+    const triedProviders = [...new Set(attemptList.map(a => a.provider))];
+    throw new Error('❌ All providers failed.\nAdd more API keys: qwen-ice api-setup\nCurrent providers tried: ' + triedProviders.join(', '));
+  }
+
+  async callProvider(attempt, messages) {
+    switch (attempt.provider) {
+      case 'qwen':
+        if (attempt.type === 'oauth') {
+          return { provider: 'qwen', type: 'oauth', content: messages[messages.length - 1]?.content || '', oauthMarker: true };
+        }
+        return await this.callQwenAPI(attempt.key, attempt.model, messages);
+      case 'gemini':
+        return await this.callGemini(attempt.key, attempt.model, messages);
+      case 'groq':
+        return await this.callGroq(attempt.key, attempt.model, messages);
+      case 'openai':
+        return await this.callOpenAI(attempt.key, attempt.model, messages);
+      case 'dashscope':
+        return await this.callDashscope(attempt.key, attempt.model, messages);
+      default:
+        throw new Error(`Unknown provider: ${attempt.provider}`);
+    }
+  }
+
+  async callQwenAPI(key, model, messages) {
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify({
+        model: model || 'qwen3-coder-plus',
+        messages: messages,
+        max_tokens: 4096
+      });
+
+      const options = {
+        hostname: 'dashscope.aliyuncs.com',
+        port: 443,
+        path: '/compatible-mode/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${key}`,
+          'Content-Length': data.length
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode >= 400) {
+            reject(new Error(`Qwen API error: ${res.statusCode} - ${responseData}`));
+          } else {
+            try {
+              const parsed = JSON.parse(responseData);
+              resolve({ provider: 'qwen', content: parsed.choices?.[0]?.message?.content || '' });
+            } catch (e) {
+              reject(new Error('Failed to parse Qwen response'));
+            }
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(60000, () => reject(new Error('Qwen API timeout')));
+      req.write(data);
+      req.end();
+    });
+  }
+
+  async callGemini(key, model, messages) {
+    return new Promise((resolve, reject) => {
+      const lastMessage = messages[messages.length - 1]?.content || '';
+      const data = JSON.stringify({
+        contents: [{ parts: [{ text: lastMessage }] }],
+        generationConfig: { maxOutputTokens: 4096 }
+      });
+
+      const options = {
+        hostname: 'generativelanguage.googleapis.com',
+        port: 443,
+        path: `/v1beta/models/${model || 'gemini-2.0-flash'}:generateContent?key=${key}`,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': data.length
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 429) {
+            reject(new Error('Gemini rate limit exceeded'));
+          } else if (res.statusCode >= 400) {
+            reject(new Error(`Gemini API error: ${res.statusCode} - ${responseData}`));
+          } else {
+            try {
+              const parsed = JSON.parse(responseData);
+              resolve({ provider: 'gemini', content: parsed.candidates?.[0]?.content?.parts?.[0]?.text || '' });
+            } catch (e) {
+              reject(new Error('Failed to parse Gemini response'));
+            }
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(60000, () => reject(new Error('Gemini API timeout')));
+      req.write(data);
+      req.end();
+    });
+  }
+
+  async callGroq(key, model, messages) {
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify({
+        model: model || 'llama-3.1-70b-versatile',
+        messages: messages,
+        max_tokens: 4096
+      });
+
+      const options = {
+        hostname: 'api.groq.com',
+        port: 443,
+        path: '/openai/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${key}`,
+          'Content-Length': data.length
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode === 429) {
+            reject(new Error('Groq rate limit exceeded'));
+          } else if (res.statusCode >= 400) {
+            reject(new Error(`Groq API error: ${res.statusCode} - ${responseData}`));
+          } else {
+            try {
+              const parsed = JSON.parse(responseData);
+              resolve({ provider: 'groq', content: parsed.choices?.[0]?.message?.content || '' });
+            } catch (e) {
+              reject(new Error('Failed to parse Groq response'));
+            }
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(60000, () => reject(new Error('Groq API timeout')));
+      req.write(data);
+      req.end();
+    });
+  }
+
+  async callOpenAI(key, model, messages) {
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify({
+        model: model || 'gpt-4o',
+        messages: messages,
+        max_tokens: 4096
+      });
+
+      const options = {
+        hostname: 'api.openai.com',
+        port: 443,
+        path: '/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${key}`,
+          'Content-Length': data.length
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode >= 400) {
+            reject(new Error(`OpenAI API error: ${res.statusCode} - ${responseData}`));
+          } else {
+            try {
+              const parsed = JSON.parse(responseData);
+              resolve({ provider: 'openai', content: parsed.choices?.[0]?.message?.content || '' });
+            } catch (e) {
+              reject(new Error('Failed to parse OpenAI response'));
+            }
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(60000, () => reject(new Error('OpenAI API timeout')));
+      req.write(data);
+      req.end();
+    });
+  }
+
+  async callDashscope(key, model, messages) {
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify({
+        model: model || 'qwen-turbo',
+        messages: messages,
+        max_tokens: 4096
+      });
+
+      const options = {
+        hostname: 'dashscope.aliyuncs.com',
+        port: 443,
+        path: '/compatible-mode/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${key}`,
+          'Content-Length': data.length
+        }
+      };
+
+      const req = https.request(options, (res) => {
+        let responseData = '';
+        res.on('data', chunk => responseData += chunk);
+        res.on('end', () => {
+          if (res.statusCode >= 400) {
+            reject(new Error(`Dashscope API error: ${res.statusCode} - ${responseData}`));
+          } else {
+            try {
+              const parsed = JSON.parse(responseData);
+              resolve({ provider: 'dashscope', content: parsed.choices?.[0]?.message?.content || '' });
+            } catch (e) {
+              reject(new Error('Failed to parse Dashscope response'));
+            }
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(60000, () => reject(new Error('Dashscope API timeout')));
+      req.write(data);
+      req.end();
+    });
+  }
+
+  async recordSuccess(provider, keyId) {
+    try {
+      const config = this.loadApiConfig();
+      const key = config.keys?.find(k => k.id === keyId);
+      if (key) {
+        key.last_used = new Date().toISOString();
+        key.call_count = (key.call_count || 0) + 1;
+        fs.writeFileSync(API_KEYS_FILE, JSON.stringify(config, null, 2));
+      }
+    } catch (err) {
+      logError(`Failed to record success for ${keyId}`, err);
+    }
+  }
+
+  async recordFailure(provider, keyId, error) {
+    try {
+      logError(`Provider ${provider} (${keyId}) failed: ${error.message}`);
+      if (error.message.includes('401') || error.message.includes('invalid')) {
+        const config = this.loadApiConfig();
+        const key = config.keys?.find(k => k.id === keyId);
+        if (key) {
+          key.active = false;
+          fs.writeFileSync(API_KEYS_FILE, JSON.stringify(config, null, 2));
+        }
+      }
+    } catch (err) {
+      logError(`Failed to record failure for ${keyId}`, err);
+    }
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 7: SelfCritiqueLoop — 7 questions to improve response
+// ─────────────────────────────────────────────────────────────────────────────
+class SelfCritiqueLoop {
+  constructor() {
+    this.questions = [
+      'Does this directly answer the user\'s query?',
+      'Is the code syntactically correct?',
+      'Are there any security issues?',
+      'Is this Termux-compatible (no sudo, correct paths)?',
+      'Could this be clearer or more concise?',
+      'Are edge cases handled?',
+      'Is the explanation sufficient?'
+    ];
+  }
+
+  async critique(response, intent) {
+    const results = [];
+    let needsFix = false;
+
+    for (let i = 0; i < this.questions.length; i++) {
+      const question = this.questions[i];
+      const answer = this.autoAnswer(question, response, intent);
+      results.push({ question, answer });
+      if (!answer.pass) needsFix = true;
+    }
+
+    return { results, needsFix, score: results.filter(r => r.answer.pass).length / this.questions.length };
+  }
+
+  autoAnswer(question, response, intent) {
+    const lower = response.toLowerCase();
+
+    if (question.includes('directly answer')) {
+      return { pass: response.length > 10, suggestion: 'Add more content' };
+    }
+    if (question.includes('syntactically correct')) {
+      const codeBlocks = response.match(/```[\s\S]*?```/g);
+      if (!codeBlocks) return { pass: true };
+      return { pass: !codeBlocks.some(block => block.includes('TODO') || block.includes('FIXME')) };
+    }
+    if (question.includes('security')) {
+      const risky = ['eval(', 'exec(', 'innerHTML', 'SELECT * FROM'];
+      return { pass: !risky.some(r => lower.includes(r.toLowerCase())) };
+    }
+    if (question.includes('Termux')) {
+      return { pass: !lower.includes('sudo') && !lower.includes('apt-get') };
+    }
+    if (question.includes('clearer')) {
+      return { pass: response.length < 2000 };
+    }
+    if (question.includes('edge cases')) {
+      return { pass: true };
+    }
+    if (question.includes('explanation')) {
+      return { pass: response.includes('```') ? response.split('```').length > 2 : true };
+    }
+
+    return { pass: true };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 8: CodeQualityGate — Validate code in response
+// ─────────────────────────────────────────────────────────────────────────────
+class CodeQualityGate {
+  check(response) {
+    const codeBlocks = response.match(/```[\s\S]*?```/g);
+    if (!codeBlocks) return { hasCode: false, issues: [] };
+
+    const issues = [];
+    for (const block of codeBlocks) {
+      const lang = block.match(/```(\w+)/)?.[1] || '';
+      const code = block.replace(/```\w*\n?/g, '').trim();
+
+      if (code.includes('sudo')) {
+        issues.push({ type: 'termux_sudo', message: 'sudo not available in Termux' });
+      }
+      if (code.includes('apt-get')) {
+        issues.push({ type: 'termux_apt', message: 'Use pkg instead of apt-get in Termux' });
+      }
+      if (code.includes('eval(')) {
+        issues.push({ type: 'security_eval', message: 'eval() is a security risk' });
+      }
+      if (code.includes('SELECT * FROM') && code.includes('+')) {
+        issues.push({ type: 'security_sqli', message: 'SQL injection risk' });
+      }
+    }
+
+    return { hasCode: true, issues, codeBlocks };
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 9: AutoRunLoop — Run code with 3 retries
+// ─────────────────────────────────────────────────────────────────────────────
+class AutoRunLoop {
+  constructor(yolo = false) {
+    this.yolo = yolo;
+    this.maxRetries = 3;
+  }
+
+  async run(code, language = 'sh') {
+    if (!this.yolo) {
+      return { skipped: true, reason: 'Not in YOLO mode' };
+    }
+
+    let lastError = null;
+    for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+      try {
+        const result = await this.execute(code, language);
+        if (result.exitCode === 0) {
+          return { success: true, output: result.output, exitCode: 0, attempts: attempt };
+        }
+        lastError = result.stderr;
+      } catch (err) {
+        lastError = err.message;
+      }
+    }
+
+    return { success: false, error: lastError, exitCode: 1, attempts: this.maxRetries };
+  }
+
+  execute(code, language) {
+    return new Promise((resolve) => {
+      let cmd, args;
+
+      if (language === 'sh' || language === 'bash') {
+        cmd = 'sh';
+        args = ['-c', code];
+      } else if (language === 'python' || language === 'py') {
+        cmd = 'python';
+        args = ['-c', code];
+      } else if (language === 'node' || language === 'js') {
+        cmd = 'node';
+        args = ['-e', code];
+      } else {
+        resolve({ output: '', stderr: `Unknown language: ${language}`, exitCode: 1 });
+        return;
+      }
+
+      const proc = spawn(cmd, args, { cwd: process.env.HOME || '/data/data/com.termux/files/home' });
+      let output = '';
+      let stderr = '';
+
+      proc.stdout.on('data', data => output += data.toString());
+      proc.stderr.on('data', data => stderr += data.toString());
+
+      proc.on('close', code => {
+        resolve({ output, stderr, exitCode: code });
+      });
+
+      proc.on('error', err => {
+        resolve({ output: '', stderr: err.message, exitCode: 1 });
+      });
+    });
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 10: QualityBlocker — Block responses < 5/10
+// ─────────────────────────────────────────────────────────────────────────────
+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';
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 11: DomainMemory — Save patterns
+// ─────────────────────────────────────────────────────────────────────────────
+class DomainMemory {
+  constructor(sessionMemoryFile) {
+    this.file = sessionMemoryFile;
+    this.data = this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.file)) {
+        return JSON.parse(fs.readFileSync(this.file, 'utf8'));
+      }
+    } catch (e) { logError('Failed to load session memory', e); }
+    return { patterns: [], known_errors: [], last_updated: new Date().toISOString() };
+  }
+
+  save() {
+    this.data.last_updated = new Date().toISOString();
+    try {
+      fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+    } catch (e) { logError('Failed to save session memory', e); }
+  }
+
+  addPattern(pattern) {
+    if (!this.data.patterns.find(p => p.input === pattern.input)) {
+      this.data.patterns.push(pattern);
+    }
+    this.save();
+  }
+
+  addKnownError(error) {
+    if (!this.data.known_errors.includes(error)) {
+      this.data.known_errors.push(error);
+    }
+    this.save();
+  }
+
+  getPatterns() {
+    return this.data.patterns;
+  }
+
+  getKnownErrors() {
+    return this.data.known_errors;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 12: QualityScorer — Score response 1-10
+// ─────────────────────────────────────────────────────────────────────────────
+class QualityScorer {
+  constructor(qualityHistoryFile) {
+    this.file = qualityHistoryFile;
+    this.history = this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.file)) {
+        return JSON.parse(fs.readFileSync(this.file, 'utf8'));
+      }
+    } catch (e) { logError('Failed to load quality history', e); }
+    return { scores: [] };
+  }
+
+  save() {
+    try {
+      fs.writeFileSync(this.file, JSON.stringify(this.history, null, 2));
+    } catch (e) { logError('Failed to save quality history', e); }
+  }
+
+  score(response, critique, codeCheck) {
+    let score = 5;
+
+    if (critique && critique.score) {
+      score += critique.score * 3;
+    }
+
+    if (codeCheck && codeCheck.issues && codeCheck.issues.length > 0) {
+      score -= Math.min(2, codeCheck.issues.length * 0.5);
+    }
+
+    if (response.length < 50) {
+      score -= 1;
+    }
+
+    score = Math.max(1, Math.min(10, Math.round(score)));
+
+    this.history.scores.push({ score, timestamp: new Date().toISOString() });
+    if (this.history.scores.length > 100) {
+      this.history.scores = this.history.scores.slice(-100);
+    }
+    this.save();
+
+    return score;
+  }
+
+  getAverage() {
+    if (this.history.scores.length === 0) return 'N/A';
+    const sum = this.history.scores.reduce((a, b) => a + b.score, 0);
+    return (sum / this.history.scores.length).toFixed(1);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 13: ConfidenceRecord — Adjust thresholds
+// ─────────────────────────────────────────────────────────────────────────────
+class ConfidenceRecord {
+  constructor(confidenceHistoryFile, confidenceGating) {
+    this.file = confidenceHistoryFile;
+    this.gating = confidenceGating;
+    this.history = this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.file)) {
+        return JSON.parse(fs.readFileSync(this.file, 'utf8'));
+      }
+    } catch (e) { logError('Failed to load confidence history', e); }
+    return { thresholds: {}, records: [] };
+  }
+
+  save() {
+    this.history.thresholds = this.gating.getThresholds();
+    try {
+      fs.writeFileSync(this.file, JSON.stringify(this.history, null, 2));
+    } catch (e) { logError('Failed to save confidence history', e); }
+  }
+
+  record(complexity, wasSuccessful) {
+    this.gating.recordOutcome(complexity, wasSuccessful);
+    this.history.records.push({
+      complexity,
+      wasSuccessful,
+      newThreshold: this.gating.getThreshold(complexity),
+      timestamp: new Date().toISOString()
+    });
+    if (this.history.records.length > 50) {
+      this.history.records = this.history.records.slice(-50);
+    }
+    this.save();
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// STEP 14: SessionSummary — Write on exit
+// ─────────────────────────────────────────────────────────────────────────────
+class SessionSummary {
+  constructor(sessionSummaryFile) {
+    this.file = sessionSummaryFile;
+    this.data = this.load();
+  }
+
+  load() {
+    try {
+      if (fs.existsSync(this.file)) {
+        return JSON.parse(fs.readFileSync(this.file, 'utf8'));
+      }
+    } catch (e) { logError('Failed to load session summary', e); }
+    return { last_session: null, total_queries: 0, total_errors: 0 };
+  }
+
+  save() {
+    this.data.last_session = new Date().toISOString();
+    try {
+      fs.writeFileSync(this.file, JSON.stringify(this.data, null, 2));
+    } catch (e) { logError('Failed to save session summary', e); }
+  }
+
+  recordQuery(hadError = false) {
+    this.data.total_queries = (this.data.total_queries || 0) + 1;
+    if (hadError) {
+      this.data.total_errors = (this.data.total_errors || 0) + 1;
+    }
+    this.save();
+  }
+
+  getSummary() {
+    return this.data;
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// UNIFIED PIPELINE — All 14 steps connected
+// ─────────────────────────────────────────────────────────────────────────────
+class IceV16 {
+  constructor(options = {}) {
+    this.yolo = options.yolo || false;
+    this.selectedModel = options.model || null;
+    this.conversation = [];
+
+    ensureDirs();
+
+    this.coldStart = new ColdStartIntelligence();
+    this.patternPreventer = new PatternPreventer();
+    this.intentLadder = new IntentLadder();
+    this.confidenceGating = new ConfidenceGating(this.coldStart.confidenceHistory);
+    this.smartContext = new SmartContext(this.coldStart.sessionMemory);
+    this.apiRouter = new ApiRouter();
+    this.selfCritique = new SelfCritiqueLoop();
+    this.codeQualityGate = new CodeQualityGate();
+    this.autoRunLoop = new AutoRunLoop(this.yolo);
+    this.qualityBlocker = new QualityBlocker();
+    this.domainMemory = new DomainMemory(SESSION_MEMORY_FILE);
+    this.qualityScorer = new QualityScorer(QUALITY_HISTORY_FILE);
+    this.confidenceRecord = new ConfidenceRecord(CONFIDENCE_HISTORY_FILE, this.confidenceGating);
+    this.sessionSummary = new SessionSummary(SESSION_SUMMARY_FILE);
+
+    logYolo('ICE v16.0.0 initialized', this.yolo);
+  }
+
+  async processQuery(query) {
+    console.log(this.coldStart.showWelcome());
+    logYolo(`Query: ${query}`, this.yolo);
+
+    const stats = this.coldStart.getStats();
+
+    // STEP 2: PatternPreventer
+    const prevented = this.patternPreventer.process(query);
+    if (prevented.fixes.length > 0) {
+      console.log(`🔧 PatternPreventer applied ${prevented.fixes.length} fixes:`);
+      prevented.fixes.forEach(f => console.log(`   - ${f.name}: ${f.reason}`));
+    }
+    const processedInput = prevented.output;
+
+    // STEP 3: IntentLadder
+    const intent = this.intentLadder.analyze(processedInput);
+    console.log(`🎯 Intent: ${intent.surface} → ${intent.real} → ${intent.deep} (${intent.complexity})`);
+
+    // STEP 4: ConfidenceGating
+    const threshold = this.confidenceGating.getThreshold(intent.complexity);
+    console.log(`📊 Confidence threshold: ${threshold}`);
+
+    // STEP 5: SmartContext
+    const context = this.smartContext.compress(this.conversation);
+    if (context.tokenCount > 0) {
+      console.log(`📝 Context: ${context.tokenCount} tokens`);
+    }
+
+    // STEP 6: Generate via ApiRouter
+    const messages = [
+      { role: 'system', content: 'You are Qwen Code ICE v16.0.0 - a consolidated AI assistant for Termux. Always provide Termux-compatible solutions (no sudo, use pkg instead of apt-get, use $PREFIX paths).' },
+      { role: 'user', content: processedInput }
+    ];
+
+    let response;
+    try {
+      const apiResult = await this.apiRouter.callWithFallback(messages);
+      response = apiResult.content;
+
+      if (apiResult.oauthMarker) {
+        return {
+          provider: 'qwen',
+          type: 'oauth',
+          content: response,
+          oauthMarker: true
+        };
+      }
+
+      console.log(`✅ Response from: ${apiResult.provider}`);
+    } catch (err) {
+      this.sessionSummary.recordQuery(true);
+      return { error: true, message: err.message };
+    }
+
+    // STEP 7: SelfCritiqueLoop
+    const critique = await this.selfCritique.critique(response, intent);
+    console.log(`🤔 Self-critique: ${Math.round(critique.score * 10)}/10`);
+
+    // STEP 8: CodeQualityGate
+    const codeCheck = this.codeQualityGate.check(response);
+    if (codeCheck.hasCode && codeCheck.issues.length > 0) {
+      console.log(`⚠️  Code issues: ${codeCheck.issues.map(i => i.message).join(', ')}`);
+    }
+
+    // STEP 9: AutoRunLoop (if code present and YOLO mode)
+    if (codeCheck.hasCode && this.yolo) {
+      for (const block of codeCheck.codeBlocks || []) {
+        const lang = block.match(/```(\w+)/)?.[1] || 'sh';
+        const code = block.replace(/```\w*\n?/g, '').trim();
+        if (lang === 'sh' || lang === 'bash' || lang === 'python' || lang === 'py' || lang === 'node' || lang === 'js') {
+          console.log(`⚡ Running code (${lang})...`);
+          const result = await this.autoRunLoop.run(code, lang);
+          if (result.success) {
+            console.log(`✅ Code executed successfully`);
+            if (result.output) {
+              console.log(`Output: ${result.output.substring(0, 200)}`);
+            }
+          } else if (!result.skipped) {
+            console.log(`❌ Code failed: ${result.error}`);
+          }
+        }
+      }
+    }
+
+    // STEP 10-14: Quality scoring and memory
+    const qualityScore = this.qualityScorer.score(response, critique, codeCheck);
+    console.log(`📊 Quality score: ${qualityScore}/10`);
+
+    if (this.qualityBlocker.shouldBlock(qualityScore)) {
+      console.log(`⚠️  Quality below threshold (${qualityScore} < ${this.qualityBlocker.minScore}), regenerating...`);
+      const retryMessages = [
+        ...messages,
+        { role: 'assistant', content: response },
+        { role: 'user', content: 'Please improve this response. Make it more accurate and helpful.' }
+      ];
+      try {
+        const retryResult = await this.apiRouter.callWithFallback(retryMessages);
+        response = retryResult.content;
+        const newScore = this.qualityScorer.score(response, critique, codeCheck);
+        console.log(`📊 New quality score: ${newScore}/10`);
+      } catch (err) {
+        console.log(`⚠️  Regeneration failed: ${err.message}`);
+      }
+    }
+
+    // STEP 11: DomainMemory
+    this.domainMemory.addPattern({
+      input: query,
+      output: response.substring(0, 500),
+      intent: intent.surface,
+      timestamp: new Date().toISOString()
+    });
+
+    // STEP 13: ConfidenceRecord
+    const wasSuccessful = qualityScore >= 5;
+    this.confidenceRecord.record(intent.complexity, wasSuccessful);
+
+    // STEP 14: SessionSummary
+    this.sessionSummary.recordQuery(!wasSuccessful);
+
+    // Store in conversation
+    this.conversation.push({ role: 'user', content: query });
+    this.conversation.push({ role: 'assistant', content: response });
+
+    return {
+      provider: this.apiRouter.apiConfig.default_provider,
+      content: response,
+      qualityScore,
+      intent,
+      critique: critique.score
+    };
+  }
+
+  getStatus() {
+    const config = this.apiRouter.loadApiConfig();
+    const stats = this.coldStart.getStats();
+
+    const apiStatus = [];
+    for (const key of config.keys || []) {
+      const status = key.active ? '✅' : '❌';
+      const label = key.type === 'oauth' ? '(OAuth)' : '';
+      const calls = key.call_count || 0;
+      const lastUsed = key.last_used ? new Date(key.last_used).toLocaleDateString() : 'never';
+      apiStatus.push({ id: key.id, provider: key.provider, status, label, calls, lastUsed });
+    }
+
+    return {
+      version: VERSION,
+      installDir: INSTALL_DIR,
+      defaultProvider: config.default_provider || 'qwen',
+      fallbackOrder: config.fallback_order || [],
+      apiKeys: apiStatus,
+      memory: stats,
+      pipeline: [
+        'ColdStartIntelligence',
+        'PatternPreventer',
+        'IntentLadder',
+        'ConfidenceGating',
+        'SmartContext',
+        'ApiRouter',
+        'SelfCritiqueLoop',
+        'CodeQualityGate',
+        'AutoRunLoop',
+        'QualityBlocker',
+        'DomainMemory',
+        'QualityScorer',
+        'ConfidenceRecord',
+        'SessionSummary'
+      ]
+    };
+  }
+
+  getVersionInfo() {
+    const config = this.apiRouter.loadApiConfig();
+    const stats = this.coldStart.getStats();
+    const providers = [...new Set((config.keys || []).map(k => k.provider))];
+
+    return {
+      version: VERSION,
+      installDir: INSTALL_DIR,
+      defaultModel: config.keys?.find(k => k.provider === config.default_provider)?.model || 'qwen3-coder-plus',
+      providersConfigured: providers,
+      fallbackOrder: config.fallback_order || [],
+      patternsCount: stats.patternsCount,
+      avgQuality: stats.avgQuality
+    };
+  }
+}
+
+module.exports = { IceV16, VERSION, INSTALL_DIR };
+
+if (require.main === module) {
+  const query = process.argv.slice(2).join(' ');
+  if (query) {
+    const ice = new IceV16({ yolo: process.argv.includes('-y') });
+    ice.processQuery(query).then(result => {
+      if (result.error) {
+        console.log(`❌ ${result.message}`);
+      } else {
+        console.log('\n' + result.content);
+      }
+    });
+  } else {
+    console.log('ICE v16.0.0 - Use: node core/ice-v16.js "your query"');
+    console.log('Or use: qwen-ice "your query"');
+  }
+}