opencode-autognosis 2.0.5 → 2.3.0

package/dist/database.js

@@ -1,26 +1,66 @@
-import Database from "better-sqlite3";
 import * as path from "node:path";
 import * as fs from "node:fs";
+import { createRequire } from "node:module";
 import { tool } from "@opencode-ai/plugin";
 import { ollama, DEFAULT_EMBEDDING_MODEL } from "./services/ollama.js";
+import { mlxService } from "./services/mlx.js";
+import { tui } from "./services/tui.js";
+const require = createRequire(import.meta.url);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
 const DB_PATH = path.join(OPENCODE_DIR, "autognosis.db");
+/**
+ * Multi-Runtime SQLite Adapter
+ * Detects Bun vs Node and provides a unified interface.
+ */
+class DatabaseAdapter {
+    inner;
+    isBun;
+    constructor(path) {
+        this.isBun = !!globalThis.Bun;
+        if (this.isBun) {
+            const { Database } = require("bun:sqlite");
+            this.inner = new Database(path, { create: true });
+        }
+        else {
+            const Database = require("better-sqlite3");
+            this.inner = new Database(path);
+        }
+    }
+    exec(sql) {
+        return this.inner.exec(sql);
+    }
+    pragma(sql) {
+        if (this.isBun)
+            return this.inner.exec(`PRAGMA ${sql}`);
+        return this.inner.pragma(sql);
+    }
+    prepare(sql) {
+        const stmt = this.inner.prepare(sql);
+        // Unify APIs: Bun uses .get()/.all() on statement, Better-SQLite3 does too.
+        // However, Better-SQLite3 returns 'info' from .run(), Bun returns nothing or different.
+        return {
+            run: (...args) => stmt.run(...args),
+            get: (...args) => stmt.get(...args),
+            all: (...args) => stmt.all(...args)
+        };
+    }
+    transaction(fn) {
+        return this.inner.transaction(fn);
+    }
+}
 export class CodeGraphDB {
     db;
     workerRunning = false;
     constructor() {
-        // Ensure directory exists
         if (!fs.existsSync(OPENCODE_DIR)) {
             fs.mkdirSync(OPENCODE_DIR, { recursive: true });
         }
-        this.db = new Database(DB_PATH);
+        this.db = new DatabaseAdapter(DB_PATH);
         this.initialize();
-        // Start background worker
         this.startWorker();
     }
     initialize() {
-        // Enable WAL mode for concurrency and performance
         this.db.pragma('journal_mode = WAL');
         this.db.exec(`
       CREATE TABLE IF NOT EXISTS files (
@@ -43,7 +83,7 @@ export class CodeGraphDB {
       CREATE TABLE IF NOT EXISTS embedding_queue (
         chunk_id TEXT PRIMARY KEY,
         text_to_embed TEXT,
-        status TEXT DEFAULT 'pending', -- pending, processing, failed
+        status TEXT DEFAULT 'pending',
         retries INTEGER DEFAULT 0,
         FOREIGN KEY(chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
       );
@@ -52,7 +92,7 @@ export class CodeGraphDB {
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         chunk_id TEXT,
         name TEXT NOT NULL,
-        kind TEXT, -- 'function', 'class', 'interface', etc.
+        kind TEXT,
         FOREIGN KEY(chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
       );
 
@@ -62,12 +102,34 @@ export class CodeGraphDB {
         FOREIGN KEY(source_chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
       );
 
+      CREATE TABLE IF NOT EXISTS calls (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        caller_chunk_id TEXT,
+        callee_name TEXT,
+        line_number INTEGER,
+        FOREIGN KEY(caller_chunk_id) REFERENCES chunks(id) ON DELETE CASCADE
+      );
+
+      CREATE TABLE IF NOT EXISTS policies (
+        id TEXT PRIMARY KEY,
+        name TEXT,
+        pattern TEXT,
+        severity TEXT, -- 'error', 'warning'
+        description TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS context_access_log (
+        chunk_id TEXT,
+        plan_id TEXT,
+        accessed_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
       CREATE TABLE IF NOT EXISTS commits (
         hash TEXT PRIMARY KEY,
         author TEXT,
         date DATETIME,
         message TEXT,
-        files_touched TEXT -- JSON array of paths
+        files_touched TEXT
       );
 
       CREATE TABLE IF NOT EXISTS plan_ledger (
@@ -79,10 +141,40 @@ export class CodeGraphDB {
         timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
       );
 
+      CREATE TABLE IF NOT EXISTS blackboard (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        author TEXT,
+        message TEXT,
+        topic TEXT,
+        symbol_id TEXT, -- Optional link to a code symbol
+        embedding BLOB, -- For semantic search on the blackboard
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+      );
+
+      CREATE TABLE IF NOT EXISTS locks (
+        resource_id TEXT PRIMARY KEY, -- file path or symbol name
+        owner_agent TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        expires_at DATETIME
+      );
+
+      CREATE TABLE IF NOT EXISTS intents (
+        patch_id TEXT PRIMARY KEY,
+        reasoning TEXT,
+        plan_id TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS arch_rules (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        source_pattern TEXT,
+        target_pattern TEXT,
+        restriction TEXT DEFAULT 'forbidden'
+      );
+
       CREATE TABLE IF NOT EXISTS background_jobs (
         id TEXT PRIMARY KEY,
-        type TEXT, -- 'validation', 'setup', 'indexing'
-        status TEXT DEFAULT 'pending', -- pending, running, completed, failed
+        type TEXT,
+        status TEXT DEFAULT 'pending',
         progress INTEGER DEFAULT 0,
         result TEXT,
         error TEXT,
@@ -90,22 +182,17 @@ export class CodeGraphDB {
         updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
       );
 
-      -- Indexes for performance
       CREATE INDEX IF NOT EXISTS idx_files_path ON files(path);
       CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
       CREATE INDEX IF NOT EXISTS idx_dependencies_target ON dependencies(target_path);
       CREATE INDEX IF NOT EXISTS idx_ledger_plan ON plan_ledger(plan_id);
       CREATE INDEX IF NOT EXISTS idx_jobs_status ON background_jobs(status);
     `);
-        // Migrations
         try {
             this.db.exec("ALTER TABLE chunks ADD COLUMN embedding BLOB");
         }
         catch { }
     }
-    /**
-     * Background Job Management
-     */
     createJob(id, type, metadata) {
         this.db.prepare(`
       INSERT INTO background_jobs (id, type, status, progress, result)
@@ -144,25 +231,109 @@ export class CodeGraphDB {
         }
         return this.db.prepare("SELECT * FROM background_jobs ORDER BY created_at DESC LIMIT ?").all(limit);
     }
+    postToBlackboard(author, message, topic = 'general', symbolId) {
+        const insert = this.db.prepare(`
+      INSERT INTO blackboard (author, message, topic, symbol_id)
+      VALUES (?, ?, ?, ?)
+      RETURNING id
+    `);
+        const res = insert.get(author, message, topic, symbolId || null);
+        // Queue for embedding (blackboard search)
+        this.db.prepare(`
+      INSERT INTO embedding_queue (chunk_id, text_to_embed)
+      VALUES (?, ?)
+    `).run(`blackboard-${res.id}`, `${topic.toUpperCase()}: ${message}`);
+    }
+    readBlackboard(topic, limit = 10) {
+        if (topic) {
+            return this.db.prepare(`
+        SELECT * FROM blackboard WHERE topic = ? ORDER BY timestamp DESC LIMIT ?
+      `).all(topic, limit);
+        }
+        return this.db.prepare(`
+      SELECT * FROM blackboard ORDER BY timestamp DESC LIMIT ?
+    `).all(limit);
+    }
+    getGraffiti(symbolId) {
+        return this.db.prepare(`
+      SELECT author, message, timestamp 
+      FROM blackboard 
+      WHERE symbol_id = ? 
+      ORDER BY timestamp DESC
+    `).all(symbolId);
+    }
+    acquireLock(resourceId, agentName, ttlSeconds = 300) {
+        // Check if already locked by someone else
+        const current = this.isLocked(resourceId);
+        if (current && current.owner_agent !== agentName) {
+            throw new Error(`Resource ${resourceId} is already locked by ${current.owner_agent}`);
+        }
+        const expiresAt = new Date(Date.now() + ttlSeconds * 1000).toISOString();
+        this.db.prepare(`
+      INSERT INTO locks (resource_id, owner_agent, expires_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(resource_id) DO UPDATE SET
+        owner_agent = excluded.owner_agent,
+        expires_at = excluded.expires_at
+    `).run(resourceId, agentName, expiresAt);
+    }
+    releaseLock(resourceId, agentName) {
+        this.db.prepare(`
+      DELETE FROM locks 
+      WHERE resource_id = ? AND owner_agent = ?
+    `).run(resourceId, agentName);
+    }
+    isLocked(resourceId) {
+        // Automatically prune expired locks
+        this.db.prepare("DELETE FROM locks WHERE expires_at < CURRENT_TIMESTAMP").run();
+        return this.db.prepare("SELECT * FROM locks WHERE resource_id = ?").get(resourceId);
+    }
+    listLocks() {
+        return this.db.prepare("SELECT * FROM locks").all();
+    }
+    storeIntent(patchId, reasoning, planId) {
+        this.db.prepare(`
+      INSERT INTO intents (patch_id, reasoning, plan_id)
+      VALUES (?, ?, ?)
+      ON CONFLICT(patch_id) DO UPDATE SET
+        reasoning = excluded.reasoning,
+        plan_id = excluded.plan_id
+    `).run(patchId, reasoning, planId);
+    }
+    getIntent(patchId) {
+        return this.db.prepare("SELECT * FROM intents WHERE patch_id = ?").get(patchId);
+    }
+    addArchRule(source, target) {
+        this.db.prepare(`
+      INSERT INTO arch_rules (source_pattern, target_pattern)
+      VALUES (?, ?)
+    `).run(source, target);
+    }
+    checkArchViolation(sourcePath, targetPath) {
+        const rules = this.db.prepare("SELECT * FROM arch_rules").all();
+        for (const rule of rules) {
+            if (sourcePath.includes(rule.source_pattern) && targetPath.includes(rule.target_pattern)) {
+                return rule;
+            }
+        }
+        return null;
+    }
     async startWorker() {
         if (this.workerRunning)
             return;
         this.workerRunning = true;
-        // Run periodically
         setInterval(async () => {
             try {
                 await this.processEmbeddingQueue();
             }
-            catch (e) {
-                // Log to file if needed, but avoid console to protect TUI
-            }
-        }, 5000); // Check every 5s
+            catch (e) { }
+        }, 5000);
     }
     async processEmbeddingQueue() {
-        // Check if Ollama is ready
-        if (!(await ollama.isRunning()))
+        const useMLX = await mlxService.checkAvailability();
+        const useOllama = !useMLX && (await ollama.isRunning());
+        if (!useMLX && !useOllama)
             return;
-        // Get next task
         const task = this.db.prepare(`
       SELECT chunk_id, text_to_embed, retries 
       FROM embedding_queue 
@@ -172,24 +343,22 @@ export class CodeGraphDB {
     `).get();
         if (!task)
             return;
-        // Mark processing
         this.db.prepare("UPDATE embedding_queue SET status = 'processing' WHERE chunk_id = ?").run(task.chunk_id);
         try {
-            // Generate embedding
-            const vector = await ollama.getEmbedding(task.text_to_embed);
+            const vector = useMLX
+                ? await mlxService.getEmbedding(task.text_to_embed)
+                : await ollama.getEmbedding(task.text_to_embed);
             if (vector.length > 0) {
-                // Store blob (Float32Array to Buffer)
                 const buffer = Buffer.from(new Float32Array(vector).buffer);
                 const updateChunk = this.db.prepare("UPDATE chunks SET embedding = ? WHERE id = ?");
                 const deleteQueue = this.db.prepare("DELETE FROM embedding_queue WHERE chunk_id = ?");
-                const txn = this.db.transaction(() => {
+                this.db.transaction(() => {
                     updateChunk.run(buffer, task.chunk_id);
                     deleteQueue.run(task.chunk_id);
-                });
-                txn();
+                })();
             }
             else {
-                throw new Error("Empty vector returned");
+                throw new Error("Empty vector");
             }
         }
         catch (error) {
@@ -201,42 +370,30 @@ export class CodeGraphDB {
             }
         }
     }
-    /**
-     * Syncs a ChunkCard (JSON) into the SQLite Index.
-     */
     ingestChunkCard(card) {
         const insertFile = this.db.prepare(`
       INSERT INTO files (path, hash, last_indexed)
       VALUES (?, ?, CURRENT_TIMESTAMP)
-      ON CONFLICT(path) DO UPDATE SET
-        hash = excluded.hash,
-        last_indexed = CURRENT_TIMESTAMP
+      ON CONFLICT(path) DO UPDATE SET hash = excluded.hash, last_indexed = CURRENT_TIMESTAMP
       RETURNING id
     `);
         const insertChunk = this.db.prepare(`
       INSERT INTO chunks (id, file_id, type, complexity_score, content_summary)
       VALUES (?, ?, ?, ?, ?)
-      ON CONFLICT(id) DO UPDATE SET
-        complexity_score = excluded.complexity_score,
-        content_summary = excluded.content_summary
+      ON CONFLICT(id) DO UPDATE SET complexity_score = excluded.complexity_score, content_summary = excluded.content_summary
     `);
         const queueEmbedding = this.db.prepare(`
       INSERT INTO embedding_queue (chunk_id, text_to_embed)
       VALUES (?, ?)
-      ON CONFLICT(chunk_id) DO UPDATE SET
-        text_to_embed = excluded.text_to_embed,
-        status = 'pending',
-        retries = 0
-    `);
-        const insertSymbol = this.db.prepare(`
-      INSERT INTO symbols (chunk_id, name, kind) VALUES (?, ?, 'unknown')
-    `);
-        const insertDep = this.db.prepare(`
-      INSERT INTO dependencies (source_chunk_id, target_path) VALUES (?, ?)
+      ON CONFLICT(chunk_id) DO UPDATE SET text_to_embed = excluded.text_to_embed, status = 'pending', retries = 0
     `);
+        const insertSymbol = this.db.prepare(`INSERT INTO symbols (chunk_id, name, kind) VALUES (?, ?, 'unknown')`);
+        const insertDep = this.db.prepare(`INSERT INTO dependencies (source_chunk_id, target_path) VALUES (?, ?)`);
+        const insertCall = this.db.prepare(`INSERT INTO calls (caller_chunk_id, callee_name, line_number) VALUES (?, ?, ?)`);
         const deleteOldSymbols = this.db.prepare('DELETE FROM symbols WHERE chunk_id = ?');
         const deleteOldDeps = this.db.prepare('DELETE FROM dependencies WHERE source_chunk_id = ?');
-        const transaction = this.db.transaction(() => {
+        const deleteOldCalls = this.db.prepare('DELETE FROM calls WHERE caller_chunk_id = ?');
+        this.db.transaction(() => {
             const fileRes = insertFile.get(card.file_path, card.metadata.hash);
             const fileId = fileRes.id;
             insertChunk.run(card.id, fileId, card.chunk_type, card.metadata.complexity_score, card.content.slice(0, 500));
@@ -245,15 +402,26 @@ export class CodeGraphDB {
 ${card.content.slice(0, 2000)}`;
             queueEmbedding.run(card.id, textToEmbed);
             deleteOldSymbols.run(card.id);
-            for (const sym of card.metadata.symbols) {
+            for (const sym of card.metadata.symbols)
                 insertSymbol.run(card.id, sym);
-            }
             deleteOldDeps.run(card.id);
-            for (const dep of card.metadata.dependencies) {
+            for (const dep of card.metadata.dependencies)
                 insertDep.run(card.id, dep);
+            deleteOldCalls.run(card.id);
+            if (card.metadata.calls) {
+                for (const call of card.metadata.calls)
+                    insertCall.run(card.id, call.name, call.line);
             }
-        });
-        transaction();
+        })();
+    }
+    findCallers(functionName) {
+        return this.db.prepare(`
+      SELECT DISTINCT f.path, cl.line_number
+      FROM files f
+      JOIN chunks c ON f.id = c.file_id
+      JOIN calls cl ON c.id = cl.caller_chunk_id
+      WHERE cl.callee_name = ?
+    `).all(functionName);
     }
     deleteChunkCard(cardId) {
         this.db.prepare('DELETE FROM chunks WHERE id = ?').run(cardId);
@@ -264,57 +432,55 @@ ${card.content.slice(0, 2000)}`;
       VALUES (?, ?, ?, ?)
     `).run(planId || 'no-plan', toolName, JSON.stringify(args), isOnPlan ? 1 : 0);
     }
+    logAccess(chunkId, planId) {
+        this.db.prepare(`
+      INSERT INTO context_access_log (chunk_id, plan_id)
+      VALUES (?, ?)
+    `).run(chunkId, planId || 'default');
+    }
+    getLruChunks(limit = 5) {
+        return this.db.prepare(`
+      SELECT chunk_id, MAX(accessed_at) as last_seen
+      FROM context_access_log
+      GROUP BY chunk_id
+      ORDER BY last_seen ASC
+      LIMIT ?
+    `).all(limit);
+    }
     ingestCommits(commits) {
         const insert = this.db.prepare(`
       INSERT INTO commits (hash, author, date, message, files_touched)
       VALUES (?, ?, ?, ?, ?)
       ON CONFLICT(hash) DO NOTHING
     `);
-        const transaction = this.db.transaction((data) => {
-            for (const c of data) {
+        this.db.transaction((data) => {
+            for (const c of data)
                 insert.run(c.hash, c.author, c.date, c.message, JSON.stringify(c.files));
-            }
-        });
-        transaction(commits);
+        })(commits);
     }
     getHotFiles(pathPrefix = '', limit = 10) {
-        const recent = this.db.prepare(`
-      SELECT files_touched FROM commits ORDER BY date DESC LIMIT 100
-    `).all();
+        const recent = this.db.prepare(`SELECT files_touched FROM commits ORDER BY date DESC LIMIT 100`).all();
         const counts = {};
         for (const r of recent) {
             try {
                 const files = JSON.parse(r.files_touched);
-                for (const f of files) {
-                    if (f.startsWith(pathPrefix)) {
+                for (const f of files)
+                    if (f.startsWith(pathPrefix))
                         counts[f] = (counts[f] || 0) + 1;
-                    }
-                }
             }
             catch { }
         }
-        return Object.entries(counts)
-            .map(([path, count]) => ({ path, count }))
-            .sort((a, b) => b.count - a.count)
-            .slice(0, limit);
+        return Object.entries(counts).map(([path, count]) => ({ path, count })).sort((a, b) => b.count - a.count).slice(0, limit);
     }
     getPlanMetrics(planId) {
         const total = this.db.prepare("SELECT COUNT(*) as c FROM plan_ledger WHERE plan_id = ?").get(planId);
         const onPlan = this.db.prepare("SELECT COUNT(*) as c FROM plan_ledger WHERE plan_id = ? AND is_on_plan = 1").get(planId);
         const offPlan = this.db.prepare("SELECT COUNT(*) as c FROM plan_ledger WHERE plan_id = ? AND is_on_plan = 0").get(planId);
-        return {
-            total: total.c,
-            on_plan: onPlan.c,
-            off_plan: offPlan.c,
-            compliance: total.c > 0 ? Math.round((onPlan.c / total.c) * 100) : 100
-        };
+        return { total: total.c, on_plan: onPlan.c, off_plan: offPlan.c, compliance: total.c > 0 ? Math.round((onPlan.c / total.c) * 100) : 100 };
     }
     findDependents(filePath) {
         const query = this.db.prepare(`
-      SELECT DISTINCT f.path 
-      FROM files f
-      JOIN chunks c ON f.id = c.file_id
-      JOIN dependencies d ON c.id = d.source_chunk_id
+      SELECT DISTINCT f.path FROM files f JOIN chunks c ON f.id = c.file_id JOIN dependencies d ON c.id = d.source_chunk_id
       WHERE d.target_path LIKE ? OR d.target_path = ?
     `);
         const basename = path.basename(filePath);
@@ -323,32 +489,33 @@ ${card.content.slice(0, 2000)}`;
     }
     searchSymbols(query) {
         const stmt = this.db.prepare(`
-      SELECT s.name, c.type, f.path 
-      FROM symbols s
-      JOIN chunks c ON s.chunk_id = c.id
-      JOIN files f ON c.file_id = f.id
-      WHERE s.name LIKE ?
-      LIMIT 20
+      SELECT s.name, c.type, f.path FROM symbols s JOIN chunks c ON s.chunk_id = c.id JOIN files f ON c.file_id = f.id
+      WHERE s.name LIKE ? LIMIT 20
     `);
         return stmt.all(`%${query}%`);
     }
     async semanticSearch(query, limit = 10) {
-        if (!(await ollama.isRunning())) {
-            throw new Error("Ollama is not running. Please run 'autognosis_setup_ai' first.");
-        }
+        if (!(await ollama.isRunning()))
+            throw new Error("Ollama is not running.");
         const queryVec = await ollama.getEmbedding(query);
         if (queryVec.length === 0)
             return [];
         const chunks = this.db.prepare(`
-      SELECT c.id, c.content_summary, c.type, f.path, c.embedding
-      FROM chunks c
-      JOIN files f ON c.file_id = f.id
+      SELECT c.id, c.content_summary, c.type, f.path, c.embedding FROM chunks c JOIN files f ON c.file_id = f.id
       WHERE c.embedding IS NOT NULL
     `).all();
         const results = chunks.map(chunk => {
             const vector = new Float32Array(chunk.embedding.buffer, chunk.embedding.byteOffset, chunk.embedding.byteLength / 4);
-            const similarity = this.cosineSimilarity(queryVec, vector);
-            return { ...chunk, similarity, embedding: undefined };
+            const vectorSimilarity = this.cosineSimilarity(Array.from(queryVec), vector);
+            // Heuristic Reranking: Blended score with keyword overlap
+            const keywords = query.toLowerCase().split(/\s+/);
+            const text = chunk.content_summary.toLowerCase();
+            let keywordScore = 0;
+            for (const kw of keywords)
+                if (text.includes(kw))
+                    keywordScore += 0.1;
+            const similarity = (vectorSimilarity * 0.7) + (Math.min(0.3, keywordScore));
+            return { ...chunk, similarity, vectorSimilarity, keywordScore, embedding: undefined };
         });
         results.sort((a, b) => b.similarity - a.similarity);
         return results.slice(0, limit);
@@ -384,37 +551,44 @@ export function getDb() {
 export function graphTools() {
     return {
         autognosis_setup_ai: tool({
-            description: "Configure local AI capabilities (Ollama) in the background.",
-            args: { model: tool.schema.string().optional().default(DEFAULT_EMBEDDING_MODEL) },
-            async execute({ model }) {
+            description: "Configure local AI capabilities (Ollama or MLX) in the background.",
+            args: {
+                provider: tool.schema.enum(["ollama", "mlx"]).optional().default("ollama").describe("AI Provider to use"),
+                model: tool.schema.string().optional().describe("Model name (optional override)")
+            },
+            async execute({ provider, model }) {
                 const jobId = `job-setup-ai-${Date.now()}`;
-                getDb().createJob(jobId, "setup", { model });
+                getDb().createJob(jobId, "setup", { provider, model });
                 (async () => {
                     try {
                         getDb().updateJob(jobId, { status: "running", progress: 10 });
-                        if (!(await ollama.isInstalled())) {
-                            await ollama.install();
+                        await tui.showProgress("AI Setup", 10, `Initializing ${provider}...`);
+                        if (provider === "mlx") {
+                            await mlxService.setup();
+                            getDb().updateJob(jobId, { status: "completed", progress: 100, result: "MLX is ready." });
+                            await tui.showSuccess("AI Setup Complete", "MLX backend is ready.");
+                        }
+                        else {
+                            if (!(await ollama.isInstalled())) {
+                                await tui.showProgress("AI Setup", 20, "Downloading Ollama...");
+                                await ollama.install();
+                            }
+                            getDb().updateJob(jobId, { progress: 40 });
+                            await tui.showProgress("AI Setup", 40, "Starting Ollama server...");
+                            await ollama.startServer();
+                            getDb().updateJob(jobId, { progress: 60 });
+                            await tui.showProgress("AI Setup", 60, `Pulling model: ${model || DEFAULT_EMBEDDING_MODEL}...`);
+                            await ollama.pullModel(model || DEFAULT_EMBEDDING_MODEL);
+                            getDb().updateJob(jobId, { status: "completed", progress: 100, result: `Ollama (${model || DEFAULT_EMBEDDING_MODEL}) is ready.` });
+                            await tui.showSuccess("AI Setup Complete", `Ollama (${model || DEFAULT_EMBEDDING_MODEL}) is ready.`);
                         }
-                        getDb().updateJob(jobId, { progress: 40 });
-                        await ollama.startServer();
-                        getDb().updateJob(jobId, { progress: 60 });
-                        await ollama.pullModel(model);
-                        getDb().updateJob(jobId, {
-                            status: "completed",
-                            progress: 100,
-                            result: `Model ${model} is ready.`
-                        });
                     }
                     catch (error) {
                         getDb().updateJob(jobId, { status: "failed", error: error.message });
+                        await tui.showError("AI Setup Failed", error.message);
                     }
                 })();
-                return JSON.stringify({
-                    status: "STARTED",
-                    message: "AI Setup started in background.",
-                    job_id: jobId,
-                    instruction: "Use graph_background_status to check progress."
-                }, null, 2);
+                return JSON.stringify({ status: "STARTED", message: `AI Setup (${provider}) started in background.`, job_id: jobId, instruction: "Use graph_background_status to check progress." }, null, 2);
             }
         }),
         graph_semantic_search: tool({
@@ -521,9 +695,8 @@ export function graphTools() {
             },
             async execute({ job_id, type, limit }) {
                 try {
-                    if (job_id) {
+                    if (job_id)
                         return JSON.stringify({ status: "SUCCESS", job: getDb().getJob(job_id) }, null, 2);
-                    }
                     return JSON.stringify({ status: "SUCCESS", jobs: getDb().listJobs(type, limit) }, null, 2);
                 }
                 catch (error) {

package/dist/index.d.ts

@@ -1,6 +1,11 @@
-export declare const AutognosisPlugin: () => Promise<{
+export declare const AutognosisPlugin: ({ client }: any) => Promise<{
     tool: {
         [key: string]: any;
     };
+    "experimental.session.compacting": (input: {
+        sessionID: string;
+    }, output: {
+        context: string[];
+    }) => Promise<void>;
 }>;
 export default AutognosisPlugin;

package/dist/index.js

@@ -1,9 +1,40 @@
 import { unifiedTools } from "./unified-api.js";
-export const AutognosisPlugin = async () => {
+import { loadWorkingMemory, loadActiveSet } from "./activeset.js";
+import { tui } from "./services/tui.js";
+import { codeWatcher } from "./services/watcher.js";
+export const AutognosisPlugin = async ({ client }) => {
+    // Initialize TUI service for progress streaming
+    tui.setClient(client);
+    // Start live file watcher
+    codeWatcher.start();
     return {
         tool: {
             ...unifiedTools(),
         },
+        "experimental.session.compacting": async (input, output) => {
+            try {
+                const memory = await loadWorkingMemory();
+                if (memory.current_set) {
+                    const activeSet = await loadActiveSet(memory.current_set);
+                    if (activeSet) {
+                        const stateBlock = `
+[AUTOGNOSIS CONTEXT PRESERVATION]
+ActiveSet ID: ${activeSet.id}
+ActiveSet Name: ${activeSet.name}
+Priority: ${activeSet.priority}
+Loaded Chunks: ${activeSet.chunks.join(", ")}
+Metadata: ${JSON.stringify(activeSet.metadata)}
+
+The agent is currently focused on these files and symbols. Ensure the summary reflects this active working memory state.
+`;
+                        output.context.push(stateBlock);
+                    }
+                }
+            }
+            catch (error) {
+                // Fail silently during compaction to avoid breaking the core session
+            }
+        }
     };
 };
 export default AutognosisPlugin;

package/dist/performance-optimization.d.ts

@@ -1,3 +1,4 @@
 export declare function performanceTools(): {
     [key: string]: any;
 };
+export declare function indexFile(filePath: string): Promise<void>;