aiden-runtime 3.16.0

package/dist/core/memoryRecall.js

@@ -0,0 +1,140 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unifiedMemoryRecall = unifiedMemoryRecall;
+exports.buildMemoryInjection = buildMemoryInjection;
+// core/memoryRecall.ts — Sprint 21: Proactive Memory Surfacing
+//
+// Silently recalls relevant context from all memory layers before
+// every response. Injected into the system prompt so Aiden feels
+// like it knows the user — without the user having to re-explain.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const conversationMemory_1 = require("./conversationMemory");
+const semanticMemory_1 = require("./semanticMemory");
+const entityGraph_1 = require("./entityGraph");
+const knowledgeBase_1 = require("./knowledgeBase");
+// ── Durable memory confidence filtering ───────────────────────
+const MEMORY_DIR = path_1.default.join(process.cwd(), 'workspace', 'memory');
+const CONFIDENCE_FLOOR = 0.6;
+function loadDurableMemoriesFiltered() {
+    try {
+        if (!fs_1.default.existsSync(MEMORY_DIR))
+            return [];
+        const files = fs_1.default.readdirSync(MEMORY_DIR).filter(f => f.endsWith('.md') && f !== 'MEMORY_INDEX.md');
+        const all = [];
+        for (const file of files) {
+            try {
+                const content = fs_1.default.readFileSync(path_1.default.join(MEMORY_DIR, file), 'utf-8');
+                const sourceMatch = content.match(/^source:\s*(.+)$/m);
+                const confidenceMatch = content.match(/^confidence:\s*([0-9.]+)$/m);
+                const source = sourceMatch ? sourceMatch[1].trim() : 'llm_inferred';
+                const confidence = confidenceMatch ? parseFloat(confidenceMatch[1]) : 0.5;
+                // Strip frontmatter, get body text
+                const body = content.replace(/^---[\s\S]*?---\s*/m, '').trim();
+                if (body)
+                    all.push({ text: body, source, confidence });
+            }
+            catch { }
+        }
+        const passing = all.filter(m => m.confidence >= CONFIDENCE_FLOOR);
+        const skipped = all.filter(m => m.confidence < CONFIDENCE_FLOOR);
+        if (skipped.length > 0) {
+            console.log(`[Memory] Skipped ${skipped.length} low-confidence memories (confidence < ${CONFIDENCE_FLOOR})`);
+        }
+        return passing
+            .sort((a, b) => b.confidence - a.confidence)
+            .slice(0, 20);
+    }
+    catch {
+        return [];
+    }
+}
+// ── Main recall function ───────────────────────────────────────
+async function unifiedMemoryRecall(query, topK = 5) {
+    const results = [];
+    const entities = [];
+    // 1. Semantic memory — hybrid BM25 + vector search
+    try {
+        const semantic = semanticMemory_1.semanticMemory.search(query, topK);
+        for (const item of semantic.slice(0, 3)) {
+            if (item.text)
+                results.push(item.text.slice(0, 200));
+        }
+    }
+    catch { }
+    // 2. Entity graph — extract named entities from query and expand
+    try {
+        const queryEntities = query.match(/[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*/g) || [];
+        for (const entity of queryEntities.slice(0, 3)) {
+            const related = entityGraph_1.entityGraph.getRelated(entity, 2);
+            if (related.length > 0) {
+                // getRelated returns strings like "name (relation)"
+                entities.push(`${entity}: ${related.join(', ')}`);
+            }
+        }
+    }
+    catch { }
+    // 3. Knowledge base — BM25 + vector hybrid search
+    try {
+        const kb = knowledgeBase_1.knowledgeBase.search(query, 2);
+        for (const chunk of kb) {
+            if (chunk.text)
+                results.push(chunk.text.slice(0, 200));
+        }
+    }
+    catch { }
+    // 4. Recent conversation — pull relevant exchanges
+    try {
+        const recent = conversationMemory_1.conversationMemory.getRecentHistory();
+        const queryWords = new Set(query.toLowerCase().split(/\s+/).filter(w => w.length > 4));
+        const relevant = recent.filter(ex => {
+            const combined = `${ex.userMessage} ${ex.aiReply}`.toLowerCase();
+            return [...queryWords].some(w => combined.includes(w));
+        });
+        for (const ex of relevant.slice(0, 2)) {
+            if (ex.userMessage) {
+                results.push(`Previously: ${ex.userMessage.slice(0, 150)}`);
+            }
+        }
+    }
+    catch { }
+    // 5. Durable memory files — confidence-filtered .md facts
+    try {
+        const durable = loadDurableMemoriesFiltered();
+        const queryLower = query.toLowerCase();
+        const queryWords = queryLower.split(/\s+/).filter(w => w.length > 3);
+        for (const mem of durable) {
+            const textLower = mem.text.toLowerCase();
+            const relevant = queryWords.some(w => textLower.includes(w));
+            if (relevant && !results.includes(mem.text.slice(0, 200))) {
+                results.push(mem.text.slice(0, 200));
+            }
+        }
+    }
+    catch { }
+    return {
+        relevant: [...new Set(results)].slice(0, topK),
+        entities,
+        source: 'unified_recall',
+    };
+}
+// ── Prompt injection builder ───────────────────────────────────
+function buildMemoryInjection(recalled) {
+    if (recalled.relevant.length === 0 && recalled.entities.length === 0)
+        return '';
+    const parts = [];
+    if (recalled.entities.length > 0) {
+        parts.push(`Known context:\n${recalled.entities.map(e => `  - ${e}`).join('\n')}`);
+    }
+    if (recalled.relevant.length > 0) {
+        parts.push(`Relevant memory:\n${recalled.relevant.map(r => `  - ${r}`).join('\n')}`);
+    }
+    return `\n\n[MEMORY CONTEXT — use naturally, do not mention these are memories]\n${parts.join('\n')}\n`;
+}

package/dist/core/memoryStrategy.js

@@ -0,0 +1,201 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryStrategy = exports.MemoryStrategy = void 0;
+// core/memoryStrategy.ts — Goal-hashing memory layer for computer-use sessions.
+//
+// Responsibilities:
+//   • MD5-hash goals for fast lookup
+//   • Store success/failure outcomes with action history
+//   • Rank retrieved memories by keyword overlap + success rate
+//   • Clean up entries older than 30 days
+//   • Persist to workspace/computer-use-memory.json + cross-write to MemoryLayers
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const memoryLayers_1 = require("../memory/memoryLayers");
+// ── Constants ─────────────────────────────────────────────────
+const STOPWORDS = new Set([
+    'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+    'of', 'with', 'by', 'from', 'is', 'are', 'was', 'were', 'be', 'been',
+    'has', 'have', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+    'should', 'may', 'might', 'shall', 'can', 'not', 'this', 'that', 'it',
+    'its', 'my', 'your', 'our', 'their', 'we', 'i', 'you', 'he', 'she',
+    'they', 'me', 'him', 'her', 'us', 'them',
+]);
+const RETENTION_DAYS = 30;
+// ── MemoryStrategy ────────────────────────────────────────────
+class MemoryStrategy {
+    constructor() {
+        this.filePath = path.join(process.cwd(), 'workspace', 'computer-use-memory.json');
+        this.memory = [];
+        this.ensureDir();
+        this.load();
+        this.cleanup();
+    }
+    // ── Persistence ───────────────────────────────────────────
+    ensureDir() {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const raw = fs.readFileSync(this.filePath, 'utf8');
+                this.memory = JSON.parse(raw);
+            }
+        }
+        catch {
+            this.memory = [];
+        }
+    }
+    save() {
+        try {
+            fs.writeFileSync(this.filePath, JSON.stringify(this.memory, null, 2), 'utf8');
+        }
+        catch (err) {
+            console.warn(`[MemoryStrategy] save failed: ${err?.message}`);
+        }
+    }
+    // ── Hashing + keywords ─────────────────────────────────────
+    hash(goal) {
+        return crypto.createHash('md5').update(goal.trim().toLowerCase()).digest('hex');
+    }
+    extractKeywords(goal) {
+        return goal
+            .toLowerCase()
+            .replace(/[^a-z0-9\s]/g, '')
+            .split(/\s+/)
+            .filter(w => w.length > 2 && !STOPWORDS.has(w));
+    }
+    // ── Store success ─────────────────────────────────────────
+    async storeSuccess(goal, actions) {
+        const goalHash = this.hash(goal);
+        const keywords = this.extractKeywords(goal);
+        const now = new Date().toISOString();
+        const existing = this.memory.find(e => e.goalHash === goalHash);
+        if (existing) {
+            existing.successCount++;
+            existing.successRate = existing.successCount / (existing.successCount + existing.failureCount);
+            existing.lastActions = actions;
+            existing.lastUsed = now;
+            existing.keywords = keywords; // refresh keywords
+        }
+        else {
+            this.memory.push({
+                goalHash,
+                goal,
+                keywords,
+                successCount: 1,
+                failureCount: 0,
+                successRate: 1.0,
+                lastActions: actions,
+                lastUsed: now,
+                createdAt: now,
+            });
+        }
+        this.save();
+        await memoryLayers_1.memoryLayers.write(`ComputerUse memory stored (success): ${goal}`, ['computer_use', 'memory', 'success']);
+    }
+    // ── Store failure ──────────────────────────────────────────
+    async storeFailure(goal) {
+        const goalHash = this.hash(goal);
+        const existing = this.memory.find(e => e.goalHash === goalHash);
+        if (existing) {
+            existing.failureCount++;
+            existing.successRate = existing.successCount / (existing.successCount + existing.failureCount);
+            existing.lastUsed = new Date().toISOString();
+            this.save();
+        }
+        // If no existing entry, nothing to update — failure without prior success is not tracked
+    }
+    // ── Retrieve ──────────────────────────────────────────────
+    /**
+     * Retrieve best-matching memory entries for a goal.
+     * Scores by keyword overlap count, then breaks ties by successRate.
+     */
+    retrieve(goal, limit = 3) {
+        const keywords = this.extractKeywords(goal);
+        if (keywords.length === 0)
+            return [];
+        const scored = this.memory
+            .map(entry => {
+            const overlap = entry.keywords.filter(k => keywords.includes(k)).length;
+            return { entry, score: overlap + entry.successRate * 0.1 };
+        })
+            .filter(s => s.score > 0)
+            .sort((a, b) => b.score - a.score);
+        return scored.slice(0, limit).map(s => s.entry);
+    }
+    /**
+     * Return the last successful action sequence if successRate >= 0.5.
+     */
+    retrieveActions(goal) {
+        const goalHash = this.hash(goal);
+        const entry = this.memory.find(e => e.goalHash === goalHash);
+        if (!entry || entry.successRate < 0.5)
+            return null;
+        return entry.lastActions.length > 0 ? entry.lastActions : null;
+    }
+    // ── Stats ──────────────────────────────────────────────────
+    stats() {
+        const total = this.memory.length;
+        const avgSuccessRate = total
+            ? this.memory.reduce((acc, e) => acc + e.successRate, 0) / total
+            : 0;
+        const topGoals = [...this.memory]
+            .sort((a, b) => b.successRate - a.successRate || b.successCount - a.successCount)
+            .slice(0, 5)
+            .map(e => e.goal);
+        return { total, avgSuccessRate, topGoals };
+    }
+    // ── Cleanup ───────────────────────────────────────────────
+    cleanup() {
+        const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000;
+        const before = this.memory.length;
+        this.memory = this.memory.filter(e => new Date(e.lastUsed).getTime() > cutoff);
+        if (this.memory.length < before) {
+            this.save();
+        }
+    }
+}
+exports.MemoryStrategy = MemoryStrategy;
+exports.memoryStrategy = new MemoryStrategy();

package/dist/core/messageValidator.js

@@ -0,0 +1,85 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateMessageSequence = validateMessageSequence;
+exports.validateToolSequence = validateToolSequence;
+exports.sanitizeMessages = sanitizeMessages;
+// ── validateMessageSequence ───────────────────────────────────────────────────
+/**
+ * Merge consecutive messages of the same non-system role.
+ *
+ * Providers like Hermes and many OpenAI-compat endpoints reject sequences
+ * such as [user, user] or [assistant, assistant].  When two adjacent messages
+ * share the same role, their content is joined with a blank line separator.
+ *
+ * System messages always pass through unchanged and do NOT affect the
+ * alternation check for the messages that follow them.
+ */
+function validateMessageSequence(messages) {
+    const result = [];
+    for (const msg of messages) {
+        // System messages pass through without merging
+        if (msg.role === 'system') {
+            result.push({ ...msg });
+            continue;
+        }
+        const last = result[result.length - 1];
+        if (last && last.role === msg.role && last.role !== 'system') {
+            // Merge consecutive same-role messages
+            last.content = last.content + '\n\n' + msg.content;
+        }
+        else {
+            result.push({ ...msg });
+        }
+    }
+    return result;
+}
+// ── validateToolSequence ──────────────────────────────────────────────────────
+/**
+ * Remove orphaned tool messages (role='tool') that lack a preceding
+ * assistant message with tool_calls.
+ *
+ * When a tool result exists without the assistant turn that requested it,
+ * providers return 400 errors.  This validator strips those orphaned entries
+ * so the sequence is structurally valid.
+ */
+function validateToolSequence(messages) {
+    const result = [];
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role === 'tool') {
+            const prev = result[result.length - 1];
+            const hasToolCalls = prev?.role === 'assistant' && Array.isArray(prev.tool_calls) && prev.tool_calls.length > 0;
+            if (!hasToolCalls) {
+                console.log(`[Validator] Removed orphaned tool message at position ${i}`);
+                continue;
+            }
+        }
+        result.push(msg);
+    }
+    return result;
+}
+// ── sanitizeMessages ──────────────────────────────────────────────────────────
+/**
+ * Sanitize a message array before passing it to any LLM provider.
+ *
+ * Applies tool-sequence validation first (removes orphaned tool results),
+ * then alternation enforcement (merges consecutive same-role messages).
+ * Logs a single line when the array is modified so problems are traceable.
+ *
+ * @param messages  The raw message array to sanitize (not mutated).
+ * @returns         A new array that is safe to send to any provider.
+ */
+function sanitizeMessages(messages) {
+    const before = messages.length;
+    let sanitized = validateToolSequence(messages);
+    sanitized = validateMessageSequence(sanitized);
+    const after = sanitized.length;
+    if (after !== before) {
+        console.log(`[Validator] Fixed message sequence: ${before} → ${after} messages`);
+    }
+    return sanitized;
+}

package/dist/core/modelDiscovery.js

@@ -0,0 +1,108 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverLocalModels = discoverLocalModels;
+exports.getOllamaTimeout = getOllamaTimeout;
+// ── Known model profiles — matched by name prefix ──────────────
+const MODEL_PROFILES = {
+    'gemma4': { sizeGB: 9.6, tier: 'large', strengths: ['chat', 'reasoning'] },
+    'gemma3': { sizeGB: 5, tier: 'medium', strengths: ['chat'] },
+    'llama3.3': { sizeGB: 43, tier: 'xlarge', strengths: ['chat', 'reasoning'] },
+    'llama3.2': { sizeGB: 2, tier: 'small', strengths: ['fast', 'chat'] },
+    'llama3.1': { sizeGB: 4.7, tier: 'medium', strengths: ['chat'] },
+    'llama3': { sizeGB: 4.7, tier: 'medium', strengths: ['chat'] },
+    'mistral-nemo': { sizeGB: 7.1, tier: 'medium', strengths: ['chat', 'reasoning'] },
+    'mistral': { sizeGB: 4.4, tier: 'medium', strengths: ['chat', 'fast'] },
+    'qwen2.5-coder': { sizeGB: 9, tier: 'large', strengths: ['code'] },
+    'qwen2.5': { sizeGB: 4.7, tier: 'medium', strengths: ['chat', 'reasoning'] },
+    'deepseek-coder': { sizeGB: 9, tier: 'large', strengths: ['code'] },
+    'deepseek-r1': { sizeGB: 9, tier: 'large', strengths: ['reasoning'] },
+    'phi4': { sizeGB: 9, tier: 'large', strengths: ['reasoning', 'chat'] },
+    'phi3': { sizeGB: 2.2, tier: 'small', strengths: ['fast', 'chat'] },
+    'codellama': { sizeGB: 4.7, tier: 'medium', strengths: ['code'] },
+    'vicuna': { sizeGB: 4, tier: 'medium', strengths: ['chat'] },
+};
+// Skip these — they are embedding / vision models, not chat
+const SKIP_PATTERNS = ['embed', 'nomic', 'mxbai', 'clip', 'whisper'];
+// ── Ollama base URL ─────────────────────────────────────────────
+// Prefer OLLAMA_HOST env var, fall back to 127.0.0.1 (NOT localhost —
+// on Windows, localhost resolves to ::1 (IPv6) but Ollama only binds
+// to 127.0.0.1 (IPv4), causing ECONNREFUSED when IPv6 is tried first).
+const OLLAMA_BASE = (process.env.OLLAMA_HOST ?? 'http://127.0.0.1:11434').replace(/\/$/, '');
+// ── Main discovery function ─────────────────────────────────────
+async function discoverLocalModels(retries = 3, delayMs = 2000) {
+    let rawModels = [];
+    for (let i = 0; i < retries; i++) {
+        try {
+            const r = await fetch(`${OLLAMA_BASE}/api/tags`, {
+                signal: AbortSignal.timeout(3000),
+            });
+            if (r.ok) {
+                const data = await r.json();
+                const chat = (data.models || []).filter(m => !['embed', 'nomic', 'mxbai', 'clip'].some(skip => m.name.includes(skip)));
+                if (chat.length > 0) {
+                    rawModels = data.models;
+                    break;
+                }
+            }
+        }
+        catch { }
+        if (i < retries - 1) {
+            console.log(`[ModelDiscovery] Ollama not ready, retrying in ${delayMs}ms... (${i + 1}/${retries})`);
+            await new Promise(r => setTimeout(r, delayMs));
+        }
+    }
+    try {
+        if (rawModels.length === 0)
+            return emptyDiscovery();
+        const { models } = { models: rawModels };
+        const chatModels = models.filter(m => !SKIP_PATTERNS.some(skip => m.name.toLowerCase().includes(skip)));
+        if (chatModels.length === 0)
+            return emptyDiscovery();
+        const scored = chatModels.map(m => ({
+            name: m.name,
+            profile: getProfile(m.name),
+        }));
+        const bySize = (a, b) => b.profile.sizeGB - a.profile.sizeGB;
+        const planners = scored.filter(m => m.profile.strengths.includes('reasoning') ||
+            m.profile.tier === 'large' ||
+            m.profile.tier === 'xlarge');
+        const coders = scored.filter(m => m.profile.strengths.includes('code'));
+        const fast = scored.filter(m => m.profile.strengths.includes('fast') || m.profile.tier === 'small');
+        const bestBySize = [...scored].sort(bySize)[0]?.name || null;
+        const bestPlanner = [...planners].sort(bySize)[0]?.name || bestBySize;
+        const bestCoder = [...coders].sort(bySize)[0]?.name || bestBySize;
+        const bestFast = [...fast].sort((a, b) => a.profile.sizeGB - b.profile.sizeGB)[0]?.name || scored[scored.length - 1]?.name || null;
+        return {
+            planner: bestPlanner,
+            responder: bestBySize,
+            coder: bestCoder,
+            fast: bestFast,
+            all: chatModels.map(m => m.name),
+        };
+    }
+    catch {
+        return emptyDiscovery();
+    }
+} // end discoverLocalModels
+// ── Helpers ─────────────────────────────────────────────────────
+function getProfile(modelName) {
+    const key = Object.keys(MODEL_PROFILES).find(k => modelName.toLowerCase().startsWith(k));
+    return key ? MODEL_PROFILES[key] : { sizeGB: 4, tier: 'medium', strengths: ['chat'] };
+}
+function emptyDiscovery() {
+    return { planner: null, responder: null, coder: null, fast: null, all: [] };
+}
+// ── Timeout scaling by model size ───────────────────────────────
+// gemma4:e4b / 70b models need up to 2 min on first token generation.
+function getOllamaTimeout(modelName) {
+    const n = modelName.toLowerCase();
+    if (n.includes('70b') || n.includes('e4b') || n.includes('34b'))
+        return 120000;
+    if (n.includes('14b') || n.includes('12b') || n.includes('13b'))
+        return 60000;
+    return 30000; // 8b and smaller
+}

package/dist/core/modelRouter.js

@@ -0,0 +1,118 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelRouter = exports.ModelRouter = void 0;
+const child_process_1 = require("child_process");
+const hardwareDetector_1 = require("./hardwareDetector");
+const TASK_TYPES = ['chat', 'code', 'vision', 'reasoning', 'embedding'];
+class ModelRouter {
+    constructor() {
+        this.hardware = (0, hardwareDetector_1.detectHardware)();
+        this.models = this.buildRegistry();
+        this.syncWithOllama();
+    }
+    buildRegistry() {
+        return [
+            // Chat
+            { name: 'phi3:mini', ollamaTag: 'phi3:mini', vramGB: 2, type: 'chat', moeEnabled: false, installed: false, description: 'Lightweight fast chat, fits any GPU' },
+            { name: 'llama3.2:3b', ollamaTag: 'llama3.2:3b', vramGB: 3, type: 'chat', moeEnabled: false, installed: false, description: 'Meta Llama 3.2 — fast and capable' },
+            { name: 'mistral-nemo:12b', ollamaTag: 'mistral-nemo:12b', vramGB: 6, type: 'chat', moeEnabled: false, installed: false, description: 'Best chat quality at 6GB VRAM' },
+            // Code
+            { name: 'qwen2.5-coder:1.5b', ollamaTag: 'qwen2.5-coder:1.5b', vramGB: 2, type: 'code', moeEnabled: false, installed: false, description: 'Fast coder for simple tasks' },
+            { name: 'deepseek-coder:6.7b', ollamaTag: 'deepseek-coder:6.7b', vramGB: 5, type: 'code', moeEnabled: false, installed: false, description: 'Efficient coding model' },
+            { name: 'qwen2.5-coder:7b', ollamaTag: 'qwen2.5-coder:7b', vramGB: 6, type: 'code', moeEnabled: false, installed: false, description: 'Best local coder at 6GB VRAM' },
+            // Vision
+            { name: 'moondream', ollamaTag: 'moondream', vramGB: 2, type: 'vision', moeEnabled: false, installed: false, description: 'Tiny vision model, fast screenshots' },
+            { name: 'llava:7b', ollamaTag: 'llava:7b', vramGB: 5, type: 'vision', moeEnabled: false, installed: false, description: 'Full quality vision + text' },
+            // Reasoning
+            { name: 'phi3:medium', ollamaTag: 'phi3:medium', vramGB: 5, type: 'reasoning', moeEnabled: false, installed: false, description: 'Strong reasoning, fits 6GB' },
+            { name: 'mistral:7b', ollamaTag: 'mistral:7b', vramGB: 6, type: 'reasoning', moeEnabled: false, installed: false, description: 'Balanced reasoning model' },
+            // Embedding
+            { name: 'nomic-embed-text', ollamaTag: 'nomic-embed-text', vramGB: 1, type: 'embedding', moeEnabled: false, installed: false, description: 'Fast text embeddings' },
+            { name: 'mxbai-embed-large', ollamaTag: 'mxbai-embed-large', vramGB: 2, type: 'embedding', moeEnabled: false, installed: false, description: 'Higher quality embeddings' },
+        ];
+    }
+    syncWithOllama() {
+        try {
+            // stdio:'pipe' suppresses the Windows "not recognized" error from leaking to stderr
+            const output = (0, child_process_1.execSync)('ollama list', { timeout: 5000, stdio: 'pipe' }).toString();
+            const installedNames = output.split('\n')
+                .slice(1)
+                .map(l => l.trim().split(/\s+/)[0])
+                .filter(Boolean);
+            this.models = this.models.map(m => ({
+                ...m,
+                installed: installedNames.some(inst => inst.toLowerCase().includes(m.name.split(':')[0].toLowerCase())),
+            }));
+        }
+        catch {
+            // Ollama not installed or not on PATH — log once and continue
+            console.log('[providers] Ollama not detected — skipping local model support');
+            this.models = this.models.map(m => ({ ...m, installed: false }));
+        }
+    }
+    recommendModel(taskType) {
+        const budget = this.hardware.vramGB;
+        const candidates = this.models.filter(m => m.type === taskType && m.vramGB <= budget);
+        if (!candidates.length)
+            return 'phi3:mini';
+        // Prefer installed first, then highest VRAM
+        const installed = candidates.filter(m => m.installed);
+        const pool = installed.length ? installed : candidates;
+        return pool.sort((a, b) => b.vramGB - a.vramGB)[0].name;
+    }
+    // Alias used by index.ts (`devos models recommend`)
+    route(task) {
+        return this.recommendModel(task);
+    }
+    assessInstalledModels() {
+        const budget = this.hardware.vramGB;
+        const minVRAM = budget * 0.6;
+        const goodModels = {};
+        const missingModels = {};
+        const upgradesAvailable = {};
+        let hasGaps = false;
+        for (const task of TASK_TYPES) {
+            const compatible = this.models.filter(m => m.type === task && m.vramGB <= budget);
+            const installed = compatible.filter(m => m.installed);
+            const goodEnough = installed
+                .filter(m => m.vramGB >= minVRAM)
+                .sort((a, b) => b.vramGB - a.vramGB)[0] ?? null;
+            const best = compatible.sort((a, b) => b.vramGB - a.vramGB)[0] ?? null;
+            goodModels[task] = goodEnough;
+            if (!goodEnough) {
+                missingModels[task] = best;
+                hasGaps = true;
+            }
+            else {
+                missingModels[task] = null;
+            }
+            upgradesAvailable[task] =
+                (goodEnough && best && best.name !== goodEnough.name) ? best : null;
+        }
+        return { allGood: !hasGaps, goodModels, missingModels, hasGaps, upgradesAvailable };
+    }
+    listCompatible() {
+        return this.models
+            .filter(m => m.vramGB <= this.hardware.vramGB)
+            .sort((a, b) => b.vramGB - a.vramGB);
+    }
+    listInstalled() {
+        return this.models.filter(m => m.installed);
+    }
+    listAll() { return [...this.models]; }
+    // Alias used by existing callers (api/server.ts, index.ts)
+    listModels() { return this.listCompatible(); }
+    getHardwareInfo() { return { ...this.hardware }; }
+    // Alias used by existing callers (api/server.ts, index.ts)
+    getHardware() { return this.hardware; }
+    fits(modelName) {
+        const m = this.models.find(mod => mod.name === modelName);
+        return m ? m.vramGB <= this.hardware.vramGB : false;
+    }
+}
+exports.ModelRouter = ModelRouter;
+exports.modelRouter = new ModelRouter();